import { type Logger } from 'pino';
import { PGMBEventBatcher } from './batcher.ts';
import type { PgClientLike } from './query-types.ts';
import type { GetWebhookInfoFn, IEphemeralListener, IEventData, IEventHandler, IFindEventsFn, IReadEvent, IReadNextEventsFn, ISplitFn, Pgmb2ClientOpts, registerReliableHandlerParams, RegisterSubscriptionParams, WebhookInfo } from './types.ts';
type IReliableListener<T extends IEventData, E> = {
    type: 'reliable';
    handler: IEventHandler<T, E>;
    removeOnEmpty?: boolean;
    extra?: unknown;
    splitBy?: ISplitFn<T>;
    queue: {
        item: IReadEvent<T>;
        checkpoint: Checkpoint;
    }[];
};
type IFireAndForgetListener<T extends IEventData> = {
    type: 'fire-and-forget';
    stream: IEphemeralListener<T>;
};
type IListener<T extends IEventData, E> = IFireAndForgetListener<T> | IReliableListener<T, E>;
type Checkpoint = {
    activeTasks: number;
    nextCursor: string;
    cancelled?: boolean;
};
export type IListenerStore<T extends IEventData, E> = {
    values: {
        [id: string]: IListener<T, E>;
    };
};
export declare class PgmbClient<T extends IEventData = IEventData, W = {}> extends PGMBEventBatcher<T> {
    #private;
    readonly client: PgClientLike;
    readonly logger: Logger;
    readonly groupId: string;
    readonly readEventsIntervalMs: number;
    readonly pollEventsIntervalMs: number;
    readonly readChunkSize: number;
    readonly subscriptionMaintenanceMs: number;
    readonly tableMaintenanceMs: number;
    readonly maxActiveCheckpoints: number;
    readonly readNextEvents: IReadNextEventsFn;
    readonly findEvents?: IFindEventsFn;
    readonly getWebhookInfo: GetWebhookInfoFn<W>;
    readonly webhookHandler: IEventHandler<T, WebhookInfo<W>>;
    readonly listeners: {
        [subId: string]: IListenerStore<T, unknown>;
    };
    constructor({ client, groupId, logger, readEventsIntervalMs, readChunkSize, maxActiveCheckpoints, pollEventsIntervalMs, subscriptionMaintenanceMs, tableMaintainanceMs, webhookHandlerOpts: { splitBy: whSplitBy, ...whHandlerOpts }, getWebhookInfo, readNextEvents, findEvents, ...batcherOpts }: Pgmb2ClientOpts<T, W>);
    init(): Promise<void>;
    end(): Promise<void>;
    publish(events: T[], client?: PgClientLike): Promise<import("./queries.ts").IWriteEventsResult[]>;
    assertSubscription(opts: RegisterSubscriptionParams, client?: PgClientLike): Promise<import("./queries.ts").IAssertSubscriptionResult>;
    /**
     * Registers a fire-and-forget handler, returning an async iterator
     * that yields events as they arrive. The client does not wait for event
     * processing acknowledgements. Useful for cases where data is eventually
     * consistent, or when event delivery isn't critical
     * (eg. http SSE, websockets).
     */
    registerFireAndForgetHandler(opts: RegisterSubscriptionParams): Promise<IEphemeralListener<T>>;
    /**
     * Registers a reliable handler for the given subscription params.
     * If the handler throws an error, client will rollback to the last known
     * good cursor, and re-deliver events.
     * To avoid a full redelivery of a batch, a retry strategy can be provided
     * to retry failed events by the handler itself, allowing for delayed retries
     * with backoff, and without disrupting the overall event flow.
     */
    registerReliableHandler({ retryOpts, name, splitBy, ...opts }: registerReliableHandlerParams<T>, handler: IEventHandler<T, unknown>): Promise<{
        subscriptionId: string;
        cancel: () => void;
    }>;
    removeSubscription(subId: string): Promise<void>;
    readChanges(): Promise<number>;
}
export {};