import { DurableLogConfig } from "./config/durableLogConfig";
import { ConsultationStorageStatus, ReplayBatch, ReplayPlan, SessionManifest } from "./domain/types";
import { TranscriptMergeResult } from "./transcript/TranscriptMerger";
export declare const CONSULTATION_DB_TTL_MS: number;
export interface DurableAudioSessionManagerOptions {
    sessionId?: string;
    config?: Partial<DurableLogConfig>;
    persistenceGranted?: boolean;
    onDiagnostic?: (detail: Record<string, unknown>) => void;
}
export interface ConsultationStorageStatusOptions {
    initializeIfMissing?: boolean;
}
export declare class DurableAudioSessionManager {
    private readonly options;
    private db;
    private readonly config;
    private readonly sessionId;
    private manifestRepo;
    private segmentRepo;
    private checkpointRepo;
    private payloadStore;
    private readonly segmentBuilder;
    private readonly replayEdgeRing;
    private readonly coverageTracker;
    private readonly recoveryPlanner;
    private readonly transcriptMerger;
    private retentionManager;
    private archiveBuilder;
    private diagnostics;
    private manifest;
    private nextSegmentId;
    private capturedTimelineMs;
    private lastFlushAt;
    private appendChain;
    private persistenceQueue;
    private manifestPersistInFlight;
    private manifestPersistRequested;
    private flushInFlight;
    constructor(options?: DurableAudioSessionManagerOptions);
    startSession(now?: number): Promise<void>;
    appendCaptureChunk(payload: ArrayBuffer, durationMs: number, now?: number): Promise<number>;
    private appendCaptureChunkInternal;
    flush(reason: "threshold" | "timer" | "stop" | "recovery", now?: number): Promise<void>;
    private flushInternal;
    onTranscriptMessage(message: unknown, now?: number): Promise<void>;
    mergeTranscriptMessage(message: {
        is_partial?: boolean;
        data?: {
            text?: string;
        };
    }): TranscriptMergeResult;
    markLiveSentThroughSeq(seq: number, now?: number): Promise<void>;
    incrementReconnectCount(now?: number): Promise<void>;
    prepareReplayPlan(): Promise<ReplayPlan | null>;
    getReplayBatch(fromSeq: number): Promise<ReplayBatch>;
    completeReplayCycle(now?: number): Promise<void>;
    finalizeSession(now?: number): Promise<SessionManifest>;
    buildFinalUpload(format?: "pcm" | "wav"): Promise<Blob | ReadableStream<Uint8Array>>;
    markArchiveCommitted(uploadId: string, now?: number): Promise<void>;
    compactIfEligible(): Promise<number>;
    getConsultationStorageStatus(options?: ConsultationStorageStatusOptions): Promise<ConsultationStorageStatus | null>;
    getDiagnostics(): Promise<Record<string, unknown>>;
    getSessionId(): string;
    getCoverageState(): import("./domain/types").CoverageState;
    scheduleStorageDropAfterStop(ttlMs?: number): void;
    private createDiagnostics;
    private refreshStorageBindings;
    private ensureSession;
    private resetConsultationStorage;
    private logConsultationStorageReset;
    private enqueuePersistenceTask;
    private runPersistenceTaskWithRecovery;
    private persistManifest;
    private applyBackpressureIfNeeded;
    private estimateBacklogBytes;
    private isDatabaseClosedError;
}
//# sourceMappingURL=DurableAudioSessionManager.d.ts.map