import type { CommonPermissions } from '../config.js';
import type { ConversationEventV1, ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
import type { CodexAppServerTransportFactory } from './codex-app-server-transport.js';
import type { AgentSession, ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnResult } from './types.js';
type JsonObject = Record<string, unknown>;
export interface CodexAppServerSessionOptions {
    name: string;
    argv: string[];
    cwd: string;
    env: Record<string, string>;
    stateDir: string;
    mode: 'fresh' | 'resume';
    permissions: CommonPermissions;
    permissionMode: NonNullable<SessionSnapshot['permissionMode']>;
    model?: string | null;
    effort?: string;
    approvalPolicy: string;
    sandbox: string;
    config?: Record<string, unknown>;
    addDirs?: string[];
    log(line: string): void;
    permissionTimeoutMs?: number;
    controllerGraceMs?: number;
    interruptSettleMs?: number;
    interruptTerminateGraceMs?: number;
    terminalReconcileQuietMs?: number;
    terminalReconcileRequestTimeoutMs?: number;
}
/** Server-generated application provenance for authenticated browser prompts only. */
export declare function nativePromptAdditionalContext(origin: PromptOrigin | undefined): JsonObject | undefined;
/** Native Codex session implementing Fleet's provider-neutral live-session contract. */
export declare class CodexAppServerSession implements AgentSession {
    private readonly options;
    readonly backend: "codex-app-server";
    readonly capabilities: import("./types.js").AgentSessionCapabilities;
    readonly pid: number;
    private readonly events;
    private readonly conversation;
    private readonly conversationStartCursor?;
    private readonly sessionGeneration;
    private readonly threadFile;
    private readonly pendingPermissions;
    private readonly activeTools;
    private readonly activeItems;
    private readonly itemPhases;
    private readonly itemText;
    private transport;
    private threadId?;
    private readiness;
    private runtimeModel?;
    private reasoningEffort?;
    private lastUpdateAt?;
    private lastError?;
    private exit;
    private queueDepth;
    private promptTail;
    private activeTurn?;
    private controllerCount;
    private controllerGrace?;
    private interruptForceKill?;
    private terminalReconcile?;
    private terminalReconcileInFlight;
    private finalAnswerObserved;
    private closing;
    private constructor();
    static start(options: CodexAppServerSessionOptions, transportFactory?: CodexAppServerTransportFactory): Promise<CodexAppServerSession>;
    isAlive(): boolean;
    snapshot(): SessionSnapshot;
    queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
    submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
    interrupt(source?: TurnCancellationSource): Promise<InterruptOutcome>;
    respondPermission(permissionId: string, optionId: string): boolean;
    respondPermissionV2(permissionId: string, optionId: string, sessionGeneration: string): 'accepted' | 'stale';
    eventsSince(seq: number): SessionEvent[];
    subscribe(listener: (event: SessionEvent) => void): () => void;
    setControllerAttached(attached: boolean): void;
    exitResult(): ExitRecord | null;
    close(): Promise<void>;
    conversationPage(request?: {
        after?: string;
        limit?: number;
    }): ConversationHandlePage;
    conversationSnapshot(): ConversationSnapshot;
    subscribeConversation(listener: (event: ConversationEventV1) => void): () => void;
    submitPromptBrowser(command: SubmitPromptCommand): Promise<PromptReceipt>;
    private initialize;
    private recoverOpenPrompts;
    private admit;
    private runPrompt;
    private steer;
    private notification;
    private itemStarted;
    private itemCompleted;
    private messageDelta;
    private emitMessage;
    private thoughtDelta;
    private planUpdated;
    private recordTool;
    private finishTurn;
    /**
     * Some supported Codex versions can persist a completed turn without
     * emitting `turn/completed`. Reconcile only an exact, quiescent final-answer
     * candidate against the app-server's authoritative thread snapshot.
     */
    private scheduleTerminalReconciliation;
    private terminalCandidate;
    private reconcileTerminal;
    private cancelTerminalReconciliation;
    private clearInterruptForceKill;
    private terminateFailedTransport;
    private serverRequest;
    private requestPermission;
    private serverRequestResolved;
    private autoResolvePermission;
    private resolvePermission;
    private currentEvent;
    private isActiveNotification;
    private permissionResponse;
    private transportExited;
    private fail;
}
export {};