import { type IControllerDraftAttachment, type IControllerRuntimeId, type IControllerSessionDraft, type IControllerSessionDraftUpdate, type TControllerModelChoice, type TControllerSessionHarnessId } from '../dist_ts_interfaces/interfaces.js';
import type { IFlexModelChoice } from './interfaces.flexipc.js';
export declare class ControllerHarnessOperationConflictError extends Error {
    constructor(messageArg: string);
}
export declare class ControllerHarnessOperationLimitError extends Error {
    constructor(messageArg: string);
}
export type TControllerHarnessOperationKind = 'send' | 'slash';
export type TControllerHarnessOperationDelivery = 'ordinary' | 'steer';
type TControllerHarnessOperationState = 'submitting' | 'queued' | 'accepted' | 'outcomeUnknown' | 'cancelled';
interface IControllerHarnessOperationReservationBase {
    operationId: string;
    createdAt: number;
    kind: TControllerHarnessOperationKind;
    readonly delivery: TControllerHarnessOperationDelivery;
    projectId: string;
    sessionId: IControllerRuntimeId;
    /** Native user-message identity when the harness accepts a caller-selected ID. */
    messageId?: IControllerRuntimeId;
}
export interface IControllerDraftHarnessOperationReservation extends IControllerHarnessOperationReservationBase {
    source: 'draft';
    draft: IControllerSessionDraft;
    promptSuffix: string;
    uploadDirectory?: string;
}
export interface IControllerDirectHarnessOperationReservation extends IControllerHarnessOperationReservationBase {
    source: 'direct';
    kind: 'send';
    direct: Readonly<{
        text: string;
        model?: Readonly<TControllerModelChoice>;
        providerConnectionId?: string;
    }>;
    promptSuffix?: never;
    uploadDirectory?: never;
}
export type TControllerHarnessOperationReservation = IControllerDraftHarnessOperationReservation | IControllerDirectHarnessOperationReservation;
export interface IControllerHarnessOperationSnapshot {
    reservation: TControllerHarnessOperationReservation;
    state: TControllerHarnessOperationState;
    inputAccepted: boolean;
    flexQueueId?: string;
    flexRunId?: string;
    flexModel?: IFlexModelChoice;
}
export interface IControllerHarnessOperationBarrier {
    token: string;
    harnessId?: 'opencode' | 'flex' | 'codex';
    operationIds: string[];
    sessions: Array<{
        projectId: string;
        sessionId: IControllerRuntimeId;
    }>;
}
export interface IControllerHarnessOperationManagerOptions {
    onDraftChanged: (projectIdArg: string, sessionIdArg: IControllerRuntimeId, updateArg: IControllerSessionDraftUpdate) => void;
    onQueuedOperationCancelled?: (reservationArg: TControllerHarnessOperationReservation) => void;
    onOperationReleased?: (reservationArg: TControllerHarnessOperationReservation) => void;
    cleanupTimeoutMs?: number;
}
export declare class ControllerHarnessOperationManager {
    private readonly options;
    private readonly drafts;
    private readonly uploads;
    private readonly operationsBySession;
    private readonly operationsByOpenCodeMessage;
    private readonly operationsByFlexQueue;
    private readonly pendingUploadCleanups;
    private readonly harnessAdmissionGenerations;
    private readonly sealedHarnessAdmissions;
    private activeOperationCount;
    private operationBarrier?;
    private closed;
    private closePromise?;
    private readonly cleanupTimeoutMs;
    constructor(options: IControllerHarnessOperationManagerOptions);
    getDraft(projectIdArg: string, sessionIdArg: IControllerRuntimeId): IControllerSessionDraft;
    updateDraft(projectIdArg: string, sessionIdArg: IControllerRuntimeId, expectedRevisionArg: number, patchArg: {
        text?: string;
        attachments?: readonly IControllerDraftAttachment[];
    }): IControllerSessionDraft;
    reserve(kindArg: TControllerHarnessOperationKind, projectIdArg: string, sessionIdArg: IControllerRuntimeId, draftRevisionArg: number, optionsArg: {
        allowAttachments: boolean;
        delivery?: TControllerHarnessOperationDelivery;
    }): Promise<IControllerDraftHarnessOperationReservation>;
    reserveDirect(projectIdArg: string, sessionIdArg: IControllerRuntimeId, textArg: string, modelArg?: TControllerModelChoice, providerConnectionIdArg?: string): Promise<IControllerDirectHarnessOperationReservation>;
    accept(reservationArg: IControllerDraftHarnessOperationReservation): IControllerSessionDraft;
    accept(reservationArg: IControllerDirectHarnessOperationReservation): undefined;
    accept(reservationArg: TControllerHarnessOperationReservation): IControllerSessionDraft | undefined;
    queueOpenCodeIfBlocked(reservationArg: TControllerHarnessOperationReservation): boolean;
    queuePromptIfBlocked(reservationArg: TControllerHarnessOperationReservation): boolean;
    /** Called only after the adapter proves that no provider frame was dispatched. */
    returnUndispatchedToQueue(reservationArg: TControllerHarnessOperationReservation): void;
    adoptQueuedHarnessGeneration(harnessIdArg: TControllerSessionHarnessId, generationArg: number): void;
    acceptQueued(reservationArg: IControllerDraftHarnessOperationReservation): IControllerSessionDraft;
    acceptQueued(reservationArg: IControllerDirectHarnessOperationReservation): undefined;
    acceptQueued(reservationArg: TControllerHarnessOperationReservation): IControllerSessionDraft | undefined;
    beginQueuedSubmission(reservationArg: TControllerHarnessOperationReservation): void;
    bindOpenCodeMessage(reservationArg: TControllerHarnessOperationReservation, messageIdArg: IControllerRuntimeId): void;
    bindCodexMessage(reservationArg: TControllerHarnessOperationReservation, messageIdArg: IControllerRuntimeId): void;
    private clearReservationDraft;
    markOutcomeUnknown(reservationArg: TControllerHarnessOperationReservation): boolean;
    fail(reservationArg: TControllerHarnessOperationReservation): Promise<void>;
    complete(reservationArg: TControllerHarnessOperationReservation): Promise<void>;
    bindFlex(reservationArg: TControllerHarnessOperationReservation, queueIdArg: string, runIdArg: string, modelArg: Readonly<IFlexModelChoice>): void;
    bindFlexRun(projectIdArg: string, sessionIdArg: IControllerRuntimeId, queueIdArg: string, runIdArg: string): boolean;
    completeFlex(projectIdArg: string, sessionIdArg: IControllerRuntimeId, queueIdArg: string, runIdArg?: string): Promise<boolean>;
    ownsFlexRun(projectIdArg: string, sessionIdArg: IControllerRuntimeId, queueIdArg: string, runIdArg: string): boolean;
    getFlexRunModel(projectIdArg: string, sessionIdArg: IControllerRuntimeId, queueIdArg: string, runIdArg: string): IFlexModelChoice | undefined;
    completeOpenCodeMessage(projectIdArg: string, sessionIdArg: IControllerRuntimeId, messageIdArg: IControllerRuntimeId): Promise<boolean>;
    getActive(projectIdArg: string, sessionIdArg: IControllerRuntimeId): IControllerHarnessOperationSnapshot | undefined;
    getOperation(reservationArg: TControllerHarnessOperationReservation): IControllerHarnessOperationSnapshot | undefined;
    listSessionActive(projectIdArg: string, sessionIdArg: IControllerRuntimeId): IControllerHarnessOperationSnapshot[];
    bindFlexMessage(projectIdArg: string, sessionIdArg: IControllerRuntimeId, queueIdArg: string, runIdArg: string, messageIdArg: IControllerRuntimeId): boolean;
    listProjectActive(projectIdArg: string): IControllerHarnessOperationSnapshot[];
    listHarnessActive(harnessIdArg: 'opencode' | 'flex' | 'codex'): IControllerHarnessOperationSnapshot[];
    assertExclusive(reservationArg: TControllerHarnessOperationReservation): void;
    sealHarnessAdmission(harnessIdArg: TControllerSessionHarnessId): number;
    reopenHarnessAdmission(harnessIdArg: TControllerSessionHarnessId, generationArg: number): boolean;
    assertCurrentHarnessAdmission(reservationArg: TControllerHarnessOperationReservation): void;
    beginOperationBarrier(harnessIdArg?: 'opencode' | 'flex' | 'codex', maximumSessionsArg?: number): IControllerHarnessOperationBarrier;
    beginUpgradeBarrier(maximumSessionsArg?: number): IControllerHarnessOperationBarrier;
    waitForOperationBarrier(barrierArg: IControllerHarnessOperationBarrier, timeoutMsArg: number, signalArg?: AbortSignal): Promise<boolean>;
    waitForUpgradeBarrier(barrierArg: IControllerHarnessOperationBarrier, timeoutMsArg: number, signalArg?: AbortSignal): Promise<boolean>;
    endOperationBarrier(barrierArg: IControllerHarnessOperationBarrier): void;
    endUpgradeBarrier(barrierArg: IControllerHarnessOperationBarrier): void;
    purgeSession(projectIdArg: string, sessionIdArg: IControllerRuntimeId): Promise<void>;
    releaseSession(projectIdArg: string, sessionIdArg: IControllerRuntimeId): Promise<void>;
    purgeProject(projectIdArg: string): Promise<void>;
    releaseHarness(harnessIdArg: 'opencode' | 'flex' | 'codex', preserveQueuedArg?: boolean): Promise<void>;
    close(): Promise<void>;
    private sessionKey;
    private assertOperationBarrier;
    private currentHarnessAdmissionGeneration;
    private assertHarnessAdmission;
    private assertHarnessGeneration;
    private flexQueueKey;
    private openCodeMessageKey;
    private findActive;
    private requireActive;
    private releaseActive;
    private waitForCleanup;
    private finalizeRelease;
    private cleanupUpload;
    private retryPendingUploadCleanup;
    private retryPendingUploadCleanups;
}
export {};