import type { CodexConversionConfig } from "../../adapter/activation/config.ts";
import type { CodexVoiceAuth } from "../auth.ts";
import type { AssistantMessage } from "@earendil-works/pi-ai";
import type { RealtimeInitialMessageItem } from "../context.ts";
import type { RealtimeVoiceTurn } from "../turns.ts";
import type { RealtimePiInputBehavior } from "./handoff.ts";
import type { CodexRealtimePeer } from "./peer.ts";
import { type RealtimeVoiceEventDetails } from "./wire.ts";
import type { PreparedVoiceTask } from "./end-call.ts";
export interface CodexConversationCallbacks {
    onError(error: Error): void;
    onDrop(error: Error): void;
    onStatus(status: string): void;
    onTurn(turn: RealtimeVoiceTurn): void;
    rewriteDelegation?(turn: RealtimeVoiceTurn, signal: AbortSignal): Promise<PreparedVoiceTask>;
    onEndCall?(finalOutputObserved?: boolean, resultDelegationId?: string): void;
    onDelegationError?(error: Error): void;
    onUserTranscript(transcript: string): void;
    onTranscriptTail(transcriptDelta: string): void;
    onEvent?(event: RealtimeVoiceEventDetails): void;
}
export declare class CodexRealtimeConversation {
    private readonly callbacks;
    private readonly setup;
    private readonly peer;
    private readonly turns;
    private state;
    private closePromise;
    private inputMuted;
    finishingAcceptedWork: boolean;
    private ending;
    private endAfterResult;
    private completedOutputs;
    private endingOutput;
    private readonly closing;
    private established;
    private inputChanged;
    constructor(callbacks: CodexConversationCallbacks, peer: CodexRealtimePeer, publicRealtime?: boolean);
    start(auth: CodexVoiceAuth, config: CodexConversionConfig, instructions: string, initialItems?: RealtimeInitialMessageItem[], inputMuted?: boolean): Promise<void>;
    markEstablished(): void;
    greet(contextual: boolean, arrival?: boolean): void;
    announcePrompt(prompt: string): void;
    announceContextTransition(reason: "threshold" | "overflow" | "rollover"): void;
    private appendSpeakableContext;
    activateDelegation(id: string): void;
    agentStarted(): void;
    piInput(input: unknown, streamingBehavior?: RealtimePiInputBehavior): boolean;
    piUserMessage(message: unknown): boolean;
    get microphoneMuted(): boolean;
    setInputMuted(muted: boolean): void;
    streamAgentDelta(delta: string): void;
    resumeAgentWork(): void;
    agentProgress(content: string, reasoningSummary?: string): void;
    agentResult(content: string, stopReason: AssistantMessage["stopReason"]): void;
    settleAgentTurn(): void;
    private failDeferredEnding;
    private beginEnding;
    get isEndingCall(): boolean;
    /** Require the closing response observed since delegation, not an initially idle call. */
    waitForFinalPlayback(): Promise<void>;
    /** Quiet peer activity is best-effort: the helper has no speaker-drain acknowledgement. */
    waitForPlaybackEnd(signal: AbortSignal, minimumOutputs?: number): Promise<void>;
    close(finishAcceptedWork?: boolean): Promise<void>;
    waitForInput(signal: AbortSignal): Promise<void>;
    private closeSession;
    private handlePeerEvent;
    private handleHelperState;
    private fail;
    private drop;
    private finishFailure;
}