import { type InstanceAiEvent } from '@n8n/api-types';
import { Logger } from '@n8n/backend-common';
import type { StoredEvent } from '@n8n/instance-ai';
import { DurableLogMetrics } from './durable-log-metrics';
import { InstanceAiEventLogRepository } from '../repositories/instance-ai-event-log.repository';
export interface DrainedEvent {
    id?: number;
    event: InstanceAiEvent;
    live: boolean;
}
export interface OpenSegment {
    runId: string;
    agentId: string;
    responseId?: string;
    kind: 'text' | 'reasoning';
    text: string;
}
type EmitFn = (drained: DrainedEvent) => void;
export declare class DurableEventLog {
    private readonly logger;
    private readonly repo;
    private readonly metrics;
    private readonly pendingByThread;
    private readonly draining;
    private readonly lastSeq;
    private readonly buffers;
    private readonly emitters;
    private readonly lifecycles;
    private readonly idleFlushTimers;
    idleFlushMs: number;
    constructor(logger: Logger, repo: InstanceAiEventLogRepository, metrics: DurableLogMetrics);
    publish(threadId: string, event: InstanceAiEvent, emit: EmitFn): void;
    private scheduleIdleFlush;
    getEventsAfter(threadId: string, afterSeq: number): Promise<StoredEvent[]>;
    getEventsForRuns(threadId: string, runIds: string[]): Promise<InstanceAiEvent[]>;
    getOpenSegments(threadId: string): OpenSegment[];
    getNextEventId(threadId: string): Promise<number>;
    clearThread(threadId: string): void;
    clear(): void;
    private resolvePendingFlushes;
    flush(threadId: string): Promise<void>;
    flushAll(): Promise<void>;
    private ensureDraining;
    private drainBatch;
    private currentLifecycle;
    private takeAllOpenBlocks;
    private persistWithRetry;
    private didBatchCommit;
    private bufferDelta;
    private markBufferedPartsEmitted;
    private flushBlocks;
    private rollSegmentOnResponseChange;
    private takeBlock;
    private currentSeq;
    private getOrCreateBuffer;
    private takePending;
}
export {};