import type http from 'node:http';
import { WebSocket } from 'ws';
import { type CodexAppServerJsonRpcMessage } from '../core/codex-app-server-host.js';
import { ensureThread, type CodexCompletedTurnItem } from '../core/store.js';
import { CodexDeviceControl } from '../core/codex-device-control.js';
export type CodexBridgeHost = {
    deviceControl: CodexDeviceControl;
    ensureInitialized(input: {
        cwd: string;
    }): Promise<void>;
    clientInitializationResult(): Record<string, unknown> | null;
    subscribeNotifications(listener: (message: CodexAppServerJsonRpcMessage) => void): () => void;
    subscribeServerRequests(listener: (message: CodexAppServerJsonRpcMessage) => void): () => void;
    request(method: string, params?: Record<string, unknown> | null): Promise<CodexAppServerJsonRpcMessage>;
    respondToServerRequest(id: string | number, response: {
        result?: Record<string, unknown>;
        error?: Record<string, unknown>;
    }): boolean;
    close?(): void;
};
/**
 * A transport-only adapter for official Codex clients. Codex remains the
 * authority: this class tees every native JSON-RPC notification to connected
 * clients and Supen streams. It only synthesizes a missing terminal event after
 * a native final-answer item, matching Codex's own completed-turn semantics.
 */
export declare class CodexAppServerBridge {
    private readonly clients;
    private readonly serverRequests;
    private readonly host;
    private readonly trusted;
    private readonly rememberWorkspace;
    private readonly ensureThreadRecord;
    private readonly recordCompletedItem;
    private readonly completedItemsForThread;
    private readonly mirroredHistoryForThread;
    private readonly finalAnswerTerminalGraceMs;
    private readonly finalAnswerTimers;
    private readonly turnThreads;
    private readonly controlledThreadIds;
    private readonly pendingWriterReleaseThreadIds;
    private readonly writerReleasePromises;
    private readonly readOnlyThreads;
    private unsubscribeNotifications;
    private unsubscribeServerRequests;
    private subscribed;
    private controlSubscription;
    private readonly takeoverTickets;
    private controlTimer;
    constructor(host?: CodexBridgeHost, options?: {
        trusted?: () => boolean;
        rememberWorkspace?: (threadId: string, workspace: string) => void;
        ensureThread?: (record: Parameters<typeof ensureThread>[0]) => void;
        recordCompletedItem?: (threadId: string, item: CodexCompletedTurnItem) => void;
        completedItemsForThread?: (threadId: string) => CodexCompletedTurnItem[];
        mirroredHistoryForThread?: (threadId: string, limit: number) => Promise<Record<string, unknown> | null>;
        finalAnswerTerminalGraceMs?: number;
    });
    start(): void;
    stop(): void;
    connect(ws: WebSocket, req: http.IncomingMessage): Promise<void>;
    private enqueueClientMessage;
    private closeClient;
    private hasWriterClient;
    private hasActiveTurn;
    private releaseWriterWhenUnused;
    private isThreadLoaded;
    private controlStatus;
    private controlRequest;
    private resumeWithAvailableCliControl;
    private handleClientMessage;
    private handleNotification;
    private scheduleMissingTerminal;
    private clearFinalAnswerTimer;
    private clearFinalAnswerTimersForThread;
    private handleServerRequest;
}
/** Start the one native event fan-out for every Supen and remote Codex turn. */
export declare function startCodexAppServerBridge(): void;
export declare function isCodexAppServerBridgeSocket(pathname: string): boolean;
export declare function handleCodexAppServerBridgeConnection(ws: WebSocket, req: http.IncomingMessage): void;
//# sourceMappingURL=codex-app-server-bridge.d.ts.map