import { type SegmentDurability, type SegmentUploaderConfig } from "../chunk-uploader/segment-uploader.js";
import type { ChunkDropDetail, ChunkDropReason } from "../chunk-uploader/chunk-uploader.js";
import { type AssessmentReplayChunk, type AssessmentReplayPhase, type AssessmentReplayRecorderOptions, type ReplayRecordStart } from "./assessment-replay-recorder.js";
export type AssessmentReplayEndReason = "completed" | "navigation" | "pagehide" | "superseded" | "startup-failed" | "capture-failed";
export interface ReplayControllerStore extends SegmentDurability {
    open(): Promise<void>;
    close(): Promise<void>;
}
export interface ReplayControllerUploader {
    upload(sequence: number, blob: Blob, timingHeaders?: Record<string, string>): void;
    drain(timeoutMs?: number): Promise<void>;
    stop(): void;
}
export interface ReplayControllerRecorder {
    start(): boolean;
    flush(): Promise<void>;
    stop(): Promise<void>;
    setPhase(phase: AssessmentReplayPhase): Promise<void>;
}
type ReplayUploaderOptions = Omit<SegmentUploaderConfig, "durability"> & {
    durability: ReplayControllerStore;
};
type ReplayRecorderOptions = AssessmentReplayRecorderOptions & {
    onChunk: (chunk: AssessmentReplayChunk) => void;
    onDropped: (sequence: number, reason: "memory-pressure") => void;
    onFailure: (error: Error) => void;
};
export interface AssessmentReplayControllerOptions {
    sessionId: string;
    ingestUrl: string;
    appId?: string;
    fingerprintId?: string;
    runId?: string;
    initialPhase?: AssessmentReplayPhase;
    drainTimeoutMs?: number;
    now?: () => number;
    loadRecord?: () => Promise<ReplayRecordStart>;
    createStore?: () => ReplayControllerStore;
    createUploader?: (options: ReplayUploaderOptions) => ReplayControllerUploader;
    createRecorder?: (options: ReplayRecorderOptions) => ReplayControllerRecorder;
    onStarted?: (startedAt: number) => void;
    onUploaded?: (sequence: number, byteSize: number) => void;
    onDropped?: (sequence: number, reason: "memory-pressure" | ChunkDropReason, detail?: ChunkDropDetail) => void;
    onFailure?: (error: Error) => void;
    registerRun?: (input: {
        sessionId: string;
        runId: string;
        phase: AssessmentReplayPhase;
        fingerprintId?: string;
        startedAt: number;
    }) => Promise<void>;
    closeRun?: (input: {
        sessionId: string;
        runId: string;
        initialPhase: AssessmentReplayPhase;
        startedAt: number;
        endedAt: number;
        endReason: AssessmentReplayEndReason;
        keepalive: boolean;
    }) => Promise<void>;
}
/** Owns the always-on DOM replay capture, durable queue, and direct upload. */
export declare class AssessmentReplayController {
    private readonly options;
    private store;
    private uploader;
    private recorder;
    private startedAt;
    private startPromise;
    private stopPromise;
    private captureFailed;
    readonly runId: string;
    private readonly initialPhase;
    private readonly registerRun;
    private readonly closeRun;
    private readonly drainTimeoutMs;
    constructor(options: AssessmentReplayControllerOptions);
    start(): Promise<boolean>;
    flush(): Promise<void>;
    setPhase(phase: AssessmentReplayPhase): Promise<void>;
    stop(endReason?: AssessmentReplayEndReason, options?: {
        keepalive?: boolean;
    }): Promise<void>;
    private startInternal;
    private uploadChunk;
    private stopInternal;
    private postRun;
}
export declare function loadRrwebRecord(): Promise<ReplayRecordStart>;
export {};
//# sourceMappingURL=assessment-replay-controller.d.ts.map