/**
 * @license
 * Copyright 2026 Qwen Team
 * SPDX-License-Identifier: Apache-2.0
 */
export type DebugConnectionKind = 'main' | 'monitor' | 'search' | 'visual' | 'notification';
export type DebugArchiveDirection = 'out' | 'in' | 'local';
export interface DebugConnectionInfo {
    kind: DebugConnectionKind;
    id?: string;
    taskId?: string;
    callEpoch?: string | number;
    endpoint?: string;
    model?: string;
    voice?: string;
    [key: string]: unknown;
}
export interface DebugArchiveWarning {
    code: string;
    message: string;
    at: string;
    path: string;
    globalSeq?: number;
    connectionId?: string;
}
export interface DebugArchiveOptions {
    /** Dedicated, private archive root. Each instance creates a unique run below it. */
    directory: string;
    sessionId?: string;
    metadata?: Record<string, unknown>;
    secrets?: readonly string[];
    onWarning?: (warning: DebugArchiveWarning) => void;
    /** Includes manifest and its atomic-write reserve; minimum 32 KiB. */
    maxBytes?: number;
    maxQueuedBytes?: number;
    /** Completed runs retained, in addition to runs whose owners are still active. */
    retainRuns?: number;
}
export interface DebugArchiveMediaRef {
    $media: string;
    byteOffset: number;
    bytes: number;
    sha256: string;
    encoding: 'base64' | 'uint8array';
    kind: 'audio' | 'image' | 'binary';
}
export interface DebugArchiveEventEnvelope {
    globalSeq: number;
    connectionSeq: number;
    wallTime: string;
    wallTimeMs: number;
    monotonicNs: string;
    direction: DebugArchiveDirection;
    connectionId: string;
    kind: DebugConnectionKind | 'runtime';
    redacted: boolean;
    event: unknown;
}
export interface DebugArchiveRecorder {
    readonly id: string;
    readonly path: string;
    record(direction: DebugArchiveDirection, event: unknown): void;
    close(reason?: unknown): void;
}
/**
 * Construct only for debug runs. Recording never throws into the application.
 * All event/media writes share one FIFO; closing drains accepted writes even
 * after a capacity failure. No send success or missing media is fabricated.
 */
export declare class DebugArchive {
    private readonly options;
    readonly path: string;
    private readonly root;
    private readonly runId;
    private readonly createdAt;
    private readonly monotonicStart;
    private readonly secrets;
    private readonly maxBytes;
    private readonly maxQueuedBytes;
    private readonly retainRuns;
    private readonly warnings;
    private readonly warned;
    private readonly recorders;
    private readonly offsets;
    private readonly imageFiles;
    private readonly audioFiles;
    private rootIdentity?;
    private runIdentity?;
    private mediaIdentity?;
    private eventIdentity?;
    private events?;
    private initialized;
    private stopped;
    private ioFailed;
    private closing;
    private incomplete;
    private closedAt?;
    private tail;
    private closingPromise?;
    private connectionCount;
    private runtimeSeq;
    private globalSeq;
    private writtenEvents;
    private droppedEvents;
    private dataBytes;
    private reservedBytes;
    private queuedBytes;
    private queuedHighWater;
    private lastManifestAt;
    private redactedValues;
    private invalidMediaValues;
    constructor(options: DebugArchiveOptions);
    get isIncomplete(): boolean;
    beginConnection(info: DebugConnectionInfo): DebugArchiveRecorder;
    recordRuntime(type: string, payload: unknown): void;
    /** Flush everything accepted before this call, without waiting for future traffic. */
    flush(): Promise<void>;
    close(): Promise<void>;
    private initialize;
    private capture;
    private cleanString;
    private prepare;
    private checkDirectories;
    private writeMedia;
    private fail;
    private enqueueControl;
    private persistManifest;
    private prune;
}