import * as plugins from './plugins.js';
import type { IControllerCodexAccount, IControllerCodexActivity, IControllerCodexActivitySummary, IControllerCodexCollaborationMode, IControllerCodexModelChoice, IControllerCodexModelOption, IControllerEvent, IControllerMessagePage, IControllerMessageBundle, IControllerPermission, IControllerQuestion, IControllerSession, TControllerCodexCollaborationMode } from '../dist_ts_interfaces/index.js';
import { CodexSupervisor } from './classes.codexsupervisor.js';
interface ICodexNativeCollaborationMode {
    mode: TControllerCodexCollaborationMode;
    settings: {
        model: string;
        reasoning_effort: string | null;
        developer_instructions: null;
    };
}
export interface ICodexPreparedCollaborationMode {
    native: ICodexNativeCollaborationMode;
    public: IControllerCodexCollaborationMode;
}
export interface ICodexEventClock {
    streamEpoch: number;
    revision: number;
}
/** A dispatched mode mutation completed without exact native settings evidence. */
export declare class CodexCollaborationModeOutcomeUnknownError extends Error {
    constructor(optionsArg?: ErrorOptions);
}
/** Native app-server projection. Only explicitly admitted AGL threads may subscribe or answer requests. */
export declare class CodexClientAdapter {
    readonly supervisor: CodexSupervisor;
    private readonly emit;
    private readonly clock;
    private readonly identity?;
    private readonly scopes;
    private readonly loaded;
    private readonly emptyThreads;
    private readonly loading;
    private readonly liveItems;
    private readonly pending;
    private readonly turns;
    private readonly activities;
    private readonly interruptibleTurns;
    private readonly steeredInputs;
    private readonly modeWaiters;
    private readonly modeUpdates;
    private readonly modeAuthorities;
    private readonly released;
    private liveBytes;
    constructor(supervisor: CodexSupervisor, emit: (eventArg: IControllerEvent) => void, clock?: ICodexEventClock, identity?: {
        profileId: string;
        legacyThreadIds: ReadonlySet<string>;
    } | undefined);
    get profileId(): string | undefined;
    rawThreadId(publicIdArg: string): string;
    private publicThreadId;
    private publicThread;
    get streamEpoch(): number;
    get cursor(): {
        streamEpoch: number;
        revision: number;
    };
    activity(threadIdArg: string): IControllerCodexActivity;
    activitySummary(threadIdArg: string): IControllerCodexActivitySummary;
    /** Prove an exact active turn only through this connected app-server. */
    refreshActivity(threadIdArg: string, signalArg?: AbortSignal): Promise<IControllerCodexActivitySummary>;
    /**
     * The conversation's in-progress turn, as the app-server itself states it. A thread has at most
     * one such turn and it is always the newest, so one turn read answers it — without loading the
     * turn's items, without depending on the notifications AGL may have missed, and regardless of
     * which client owns the turn.
     *
     * The read is auxiliary: it refines a page AGL can already render, so a request that fails, is
     * aborted, or answers with something that is not a turn identity leaves the active turn unknown
     * instead of failing the page. Reading a conversation must not depend on it.
     */
    private readActiveTurn;
    /**
     * Records the thread's model and reasoning effort as the native app-server reports them. They
     * are what the conversation subheading states answered last, so they are tracked from every
     * source that can change them: a resumed thread, a turn AGL started, and a native settings
     * change or reroute made outside AGL.
     */
    observeSettings(threadIdArg: string, resultArg: Record<string, unknown>): void;
    canDispatchModeDependent(threadIdArg: string, explicitModeArg?: boolean): boolean;
    private assertModeDependentDispatchAllowed;
    private parseCollaborationMode;
    prepareCollaborationMode(modeArg: TControllerCodexCollaborationMode, modelArg: IControllerCodexModelChoice, signalArg?: AbortSignal): Promise<ICodexPreparedCollaborationMode>;
    setCollaborationMode(threadIdArg: string, modeArg: TControllerCodexCollaborationMode, modelArg: IControllerCodexModelChoice, signalArg?: AbortSignal, beforeDispatchArg?: () => void): Promise<IControllerCodexCollaborationMode>;
    account(signalArg?: AbortSignal): Promise<IControllerCodexAccount>;
    request(methodArg: string, paramsArg: Record<string, unknown>, signalArg?: AbortSignal): Promise<Record<string, unknown>>;
    register(projectIdArg: string, directoryArg: string, sessionArg: IControllerSession): IControllerSession;
    private applySessionSnapshot;
    private scope;
    readSession(directoryArg: string, threadIdArg: string, signalArg?: AbortSignal): Promise<IControllerSession>;
    private listThreadState;
    listSessions(directoryArg: string, signalArg?: AbortSignal): Promise<IControllerSession[]>;
    listModels(signalArg?: AbortSignal): Promise<IControllerCodexModelOption[]>;
    validateModel(modelArg: IControllerCodexModelChoice, signalArg?: AbortSignal): Promise<void>;
    ensureLoaded(threadIdArg: string, signalArg?: AbortSignal): Promise<void>;
    markCreatedLoaded(threadIdArg: string): void;
    markForkedLoaded(threadIdArg: string): void;
    listMessagePage(threadIdArg: string, optionsArg?: {
        limit?: number;
        before?: string;
    }, signalArg?: AbortSignal): Promise<IControllerMessagePage>;
    getMessage(threadIdArg: string, itemIdArg: string, signalArg?: AbortSignal): Promise<IControllerMessageBundle>;
    pendingPermissionScopes(): Array<{
        projectId: string;
        sessionId: IControllerSession['id'];
    }>;
    attention(threadIdArg: string): {
        permissions: IControllerPermission[];
        questions: IControllerQuestion[];
    };
    startTurn(threadIdArg: string, textArg: string, clientMessageIdArg: string, modelArg: IControllerCodexModelChoice | undefined, beforeDispatchArg: () => Promise<void>, completeArg: () => void, signalArg?: AbortSignal, onUserMessageArg?: (idArg: string) => void, cancelUndispatchedArg?: () => Promise<void>, collaborationModeArg?: ICodexPreparedCollaborationMode): Promise<() => void>;
    /** Starts the native inline review operation and owns only the exact turn returned by Codex. */
    startReview(threadIdArg: string, instructionsArg: string | undefined, admissionIdArg: string, beforeDispatchArg: () => Promise<void>, completeArg: () => void, signalArg?: AbortSignal, cancelUndispatchedArg?: () => Promise<void>): Promise<() => void>;
    private completeTurn;
    /** Observe only the exact dispatched input after its caller has fenced the unknown outcome. */
    observeSubmissionOutcomeUnknown(threadIdArg: string, clientMessageIdArg: string): void;
    private armSteeredInput;
    /** Uses the exact acknowledged active turn. A lost response is never retried. */
    steer(threadIdArg: string, textArg: string, clientMessageIdArg: string, onUserMessageArg: (idArg: string) => void, completeArg: () => void, expectedTurnIdArg?: string, signalArg?: AbortSignal): Promise<() => void>;
    /** Native validation errors are returned before Codex enqueues the steering input. */
    private isDefinitiveSteerRejection;
    releaseWriter(threadIdArg: string, signalArg?: AbortSignal): Promise<void>;
    resumeWriter(threadIdArg: string, signalArg?: AbortSignal): Promise<void>;
    /**
     * Marks one live entry settled once the rollout has proven it settled. The entry keeps its place
     * so the existing capacity eviction releases it in insertion order, and the completion guard in
     * `updateItem` stops a later replay from reopening it.
     */
    private settleLiveItem;
    /**
     * Drops the live entries of a conversation whose notification stream AGL has left for good. A
     * conversation AGL created is served from that snapshot alone until its rollout becomes readable;
     * once the snapshot is gone the rollout is by definition its only remaining source, so the thread
     * stops being treated as empty here rather than serving a blank transcript.
     */
    private dropLiveItems;
    private completeTurnItems;
    abort(threadIdArg: string, expectedTurnIdArg?: string, signalArg?: AbortSignal): Promise<{
        turnId: string;
        writer: 'agl' | 'external';
    }>;
    waitForTurnTerminal(threadIdArg: string, turnIdArg: string, signalArg: AbortSignal): Promise<void>;
    waitForIdle(threadIdArg: string, signalArg: AbortSignal): Promise<void>;
    rename(threadIdArg: string, titleArg: string, signalArg?: AbortSignal): Promise<void>;
    readIfPresent(directoryArg: string, threadIdArg: string, signalArg?: AbortSignal): Promise<IControllerSession | undefined>;
    forget(threadIdArg: string): void;
    deleteThread(directoryArg: string, threadIdArg: string, signalArg?: AbortSignal): Promise<void>;
    archive(threadIdArg: string, signalArg?: AbortSignal): Promise<IControllerSession>;
    onNotification(notificationArg: plugins.crossharness.ICodexAppServerNotification): void;
    private updateItem;
    onServerRequest(requestArg: plugins.crossharness.ICodexAppServerRequest): void;
    replyPermission(threadIdArg: string, idArg: string, replyArg: 'once' | 'reject'): void;
    replyQuestion(threadIdArg: string, idArg: string, answersArg: string[][] | null): void;
    private changed;
}
export {};