import type { Tracer } from '@opentelemetry/api';
import { type IViewLocker, type IEventLocker, type IProjection, type ILogger, type IExtendableLogger, type IEvent, type IObservable, type IEventStorageReader } from './interfaces/index.ts';
export type AbstractProjectionParams<T> = {
    /**
     * The default view associated with the projection.
     * Can optionally implement IViewLocker and/or IEventLocker.
     */
    view?: T;
    /**
     * Manages view restoration state to prevent early access to an inconsistent view
     * or conflicts from concurrent restoration by other processes.
     */
    viewLocker?: IViewLocker;
    /**
     * Tracks event processing state to prevent concurrent handling by multiple processes.
     */
    eventLocker?: IEventLocker;
    logger?: ILogger | IExtendableLogger;
    tracerFactory?: (name: string) => Tracer;
};
/**
 * Base class for Projection definition
 */
export declare abstract class AbstractProjection<TView = any> implements IProjection<TView> {
    #private;
    /**
     * List of event types handled by the projection. Can be overridden in the projection implementation.
     * If not overridden, event types will be inferred from handler methods defined on the Projection class.
     */
    static get handles(): string[];
    protected _logger?: ILogger;
    /**
     * The default view associated with the projection.
     * Can optionally implement IViewLocker and/or IEventLocker.
     */
    get view(): TView;
    protected set view(value: TView);
    /**
     * Manages view restoration state to prevent early access to an inconsistent view
     * or conflicts from concurrent restoration by other processes.
     */
    protected get _viewLocker(): IViewLocker | null;
    protected set _viewLocker(value: IViewLocker | undefined | null);
    /**
     * Tracks event processing state to prevent concurrent handling by multiple processes.
     */
    protected get _eventLocker(): IEventLocker | null;
    protected set _eventLocker(value: IEventLocker | undefined | null);
    constructor({ view, viewLocker, eventLocker, tracerFactory, logger }?: AbstractProjectionParams<TView>);
    /**
     * Subscribe to event store
     * and restore view state from not yet projected events
     */
    subscribe(eventStore: IObservable): void;
    /** Pass event to projection event handler */
    project(event: IEvent, meta?: Record<string, any>): Promise<void>;
    /**
     * Determines whether an event should be recorded as the last projected event (restore checkpoint).
     * Override in derived classes to control checkpoint behavior based on event metadata.
     */
    protected shouldRecordLastEvent(_event: IEvent, _meta?: Record<string, any>): boolean;
    /** Pass event to projection event handler, without awaiting for restore operation to complete */
    protected _project(event: IEvent, meta?: Record<string, any>): Promise<void>;
    /**
     * Restore view state from not-yet-projected events.
     *
     * Lock the view to ensure same restoring procedure
     * won't be performed by another projection instance.
     * */
    restore(eventStore: IEventStorageReader): Promise<void>;
    /** Restore view state from not-yet-projected events */
    protected _restore(eventStore: IEventStorageReader): Promise<void>;
    /**
     * Handle error on restoring.
     *
     * Logs and throws error by default
     */
    protected _onRestoringError(error: unknown, event: IEvent): void;
}