import { type DeferredForegroundTransfer } from "./deferred-foreground-transfer.js";
import { type Conversation } from "./protocol.js";
import type { TerminalControlRef } from "./terminal-agent-adapter.js";
import type { TerminalAgentBridge } from "./terminal-agent-bridge.js";
import { type TerminalSubmissionRetryRecord } from "./terminal-submission-retry-service.js";
import type { CanonicalMutationResources, CanonicalMutationScopes, CanonicalStateMutationResources, CanonicalStateMutationScopes } from "./mutation-transaction.js";
import { type TerminalDispatchLedgerDocument } from "./terminal-dispatch-ledger-codec.js";
import type { DeferredCodexForegroundBindingBoundary, TerminalDispatchTerminal } from "./terminal-dispatch-composition.js";
import type { DeferredForegroundApplicationScope } from "./deferred-foreground-boundary.js";
import { type TerminalDispatchExecutionService } from "./terminal-dispatch-execution.js";
import type { TerminalCommandCliOptions, TerminalDispatchRecord } from "./terminal-command-cli-ports.js";
import type { TerminalSubmissionRetryReconciliationPorts } from "./terminal-submission-retry-ports.js";
export interface TerminalSubmissionRetryDeferredContext {
    scope: DeferredForegroundApplicationScope;
    transfer: DeferredForegroundTransfer;
    boundary: DeferredCodexForegroundBindingBoundary;
}
export interface TerminalSubmissionRetryInvocation {
    options: TerminalCommandCliOptions;
    exactTurnId: string;
    statePath: string;
    logPath: string;
    storeDir: string;
    bridge: TerminalAgentBridge;
    live: TerminalDispatchTerminal;
    terminalControl: TerminalControlRef;
}
export interface TerminalSubmissionRetryLockedAuthority {
    conversation: Conversation;
    takeover?: Record<string, unknown>;
    submission: TerminalDispatchRecord;
    ledger: TerminalDispatchLedgerDocument;
    attempt?: TerminalSubmissionRetryRecord;
    currentMessageId: string;
    originalMessageId: string;
    requestText: string;
    requestHash: string;
    deferredTransferId?: string;
    lifecycleSettled: boolean;
}
export interface TerminalSubmissionRetryFlowState {
    conversation: Conversation;
    submission: TerminalDispatchRecord;
    ledger: TerminalDispatchLedgerDocument;
    attempt?: TerminalSubmissionRetryRecord;
}
export interface TerminalSubmissionRetryFlowContext {
    invocation: TerminalSubmissionRetryInvocation;
    scopes: CanonicalStateMutationScopes;
    resources: CanonicalStateMutationResources;
    execution: TerminalDispatchExecutionService;
    deferred?: TerminalSubmissionRetryDeferredContext;
    takeover?: Record<string, unknown>;
    currentMessageId: string;
    originalMessageId: string;
    requestText: string;
    requestHash: string;
}
export declare class TerminalSubmissionRetryReconciliation {
    private readonly ports;
    constructor(ports: TerminalSubmissionRetryReconciliationPorts);
    terminalSubmissionRetryBaseRecord(input: {
        mode: "exact_draft_enter" | "replacement_send";
        state: TerminalSubmissionRetryRecord["state"];
        attemptId: string;
        storeDir: string;
        statePath: string;
        conversation: Conversation;
        originalMessageId: string;
        activeMessageId: string;
        requestHash: string;
        terminalControl: TerminalControlRef;
        at: string;
        deferredTransferId?: string;
    }): TerminalSubmissionRetryRecord;
    assertTerminalSubmissionRetryAttemptIdentity(input: {
        attempt?: TerminalSubmissionRetryRecord;
        conversation: Conversation;
        storeDir: string;
        statePath: string;
        originalMessageId: string;
        requestHash: string;
        terminalControl: TerminalControlRef;
        deferredTransferId?: string;
    }): void;
    terminalSubmissionRetryMessageType(submission: TerminalDispatchRecord): "task" | "answer";
    withDeferredTransferSubmissionAuthority(conversation: Conversation, messageId: string, transferId: string): Conversation;
    terminalSubmissionRetryUnstalled(conversation: Conversation): Conversation;
    withTerminalSubmissionRetryMonitorEpoch(conversation: Conversation, at: string): Conversation;
    terminalSubmissionRetryAccepted(input: {
        conversation: Conversation;
        submission: TerminalDispatchRecord;
        ledger: TerminalDispatchLedgerDocument;
        evidence: NonNullable<Awaited<ReturnType<TerminalDispatchExecutionService["detectAcceptance"]>>>;
        requestText: string;
        at: string;
        statePath: string;
        logPath: string;
        scopes: CanonicalMutationScopes;
        resources: CanonicalMutationResources;
        attempt?: TerminalSubmissionRetryRecord;
        terminalInputSent: boolean;
    }): {
        conversation: Conversation;
        attempt?: TerminalSubmissionRetryRecord;
    };
    terminalSubmissionRetryTerminalOutcome(input: {
        conversation: Conversation;
        submission: TerminalDispatchRecord;
        ledger: TerminalDispatchLedgerDocument;
        requestText: string;
        reason: string;
        at: string;
        statePath: string;
        logPath: string;
        scopes: CanonicalMutationScopes;
        resources: CanonicalMutationResources;
        attempt: TerminalSubmissionRetryRecord;
        outcome: "not_accepted" | "uncertain";
    }): Conversation;
    finalizeDeferredTerminalSubmissionRetryAccepted(input: {
        statePath: string;
        scopes: CanonicalMutationScopes;
        resources: CanonicalMutationResources;
        attempt?: TerminalSubmissionRetryRecord;
    }): {
        conversation: Conversation;
        attempt?: TerminalSubmissionRetryRecord;
    };
    reconcileTerminalSubmissionRetryPending(input: {
        conversation: Conversation;
        submission: TerminalDispatchRecord;
        ledger: TerminalDispatchLedgerDocument;
        attempt: TerminalSubmissionRetryRecord;
        requestText: string;
        statePath: string;
        logPath: string;
        scopes: CanonicalMutationScopes;
        resources: CanonicalMutationResources;
        deferred?: TerminalSubmissionRetryDeferredContext;
    }): Conversation;
    assertTerminalSubmissionRetryDeferredMirror(input: {
        attempt: TerminalSubmissionRetryRecord;
        transfer: DeferredForegroundTransfer;
        submission: TerminalDispatchRecord;
    }): void;
    assertTerminalSubmissionRetryDeferredMirrorCanReconcile(input: {
        attempt: TerminalSubmissionRetryRecord;
        transfer: DeferredForegroundTransfer;
        submission: TerminalDispatchRecord;
    }): void;
    terminalSubmissionRetryTransportRank(attempt: TerminalSubmissionRetryRecord): number;
    reconcileTerminalSubmissionRetryLedgerPrefix(input: {
        attempt: TerminalSubmissionRetryRecord;
        ledger: TerminalDispatchLedgerDocument;
    }): {
        ledger: TerminalDispatchLedgerDocument;
        changed: boolean;
    };
    terminalSubmissionRetryLedgerStates(attempt: TerminalSubmissionRetryRecord): {
        previous?: TerminalSubmissionRetryRecord["state"];
    };
    terminalSubmissionRetryLedgerFieldsAtState(attempt: TerminalSubmissionRetryRecord, state: TerminalSubmissionRetryRecord["state"], revision: number): Record<string, unknown>;
    printTerminalSubmissionRetryOutcome(input: {
        conversation: Conversation;
        terminalControl: TerminalControlRef;
        attempt?: TerminalSubmissionRetryRecord;
        outcome: "agent_accepted" | "enter_dispatched" | "not_accepted" | "refused";
        terminalInputSent: boolean;
        reason: string;
    }): void;
    loadExactTerminalSubmissionRetryTurn(input: {
        statePath: string;
        exactTurnId: string;
    }): Conversation;
    assertTerminalSubmissionRetryTurnOpen(input: {
        statePath: string;
        exactTurnId: string;
    }): Conversation;
    saveTerminalSubmissionRetryForOpenTurn(statePath: string, candidate: TerminalSubmissionRetryRecord, expectedRevision: number | null): TerminalSubmissionRetryRecord;
    loadTerminalSubmissionRetryLockedAuthority(input: {
        invocation: TerminalSubmissionRetryInvocation;
        scopes: CanonicalStateMutationScopes;
        resources: CanonicalStateMutationResources;
    }): TerminalSubmissionRetryLockedAuthority;
    assertTerminalSubmissionRetryLedgerAuthority(input: {
        ledger?: TerminalDispatchLedgerDocument;
        conversation: Conversation;
        exactTurnId: string;
        currentMessageId: string;
        messageType: "task" | "answer";
        messageBodyHash: string;
        requestHash: string;
        storeDir: string;
        statePath: string;
        terminalControl: TerminalControlRef;
    }): asserts input is typeof input & {
        ledger: TerminalDispatchLedgerDocument;
    };
    exactTerminalSubmissionRetryDeferredTransferId(input: {
        takeover?: Record<string, unknown>;
        submission: TerminalDispatchRecord;
        ledger: TerminalDispatchLedgerDocument;
    }): string | undefined;
    assertTerminalSubmissionRetryGeneration(input: {
        attempt?: TerminalSubmissionRetryRecord;
        takeover?: Record<string, unknown>;
        currentMessageId: string;
        originalMessageId: string;
    }): void;
    reconcileTerminalSubmissionRetryDeferredTransfer(input: {
        invocation: TerminalSubmissionRetryInvocation;
        scope: DeferredForegroundApplicationScope;
        boundary: DeferredCodexForegroundBindingBoundary;
        transfer: DeferredForegroundTransfer;
        attempt?: TerminalSubmissionRetryRecord;
        submission: TerminalDispatchRecord;
    }): DeferredForegroundTransfer;
    prepareTerminalSubmissionRetryDeferredContext(input: {
        invocation: TerminalSubmissionRetryInvocation;
        authority: TerminalSubmissionRetryLockedAuthority;
        scopes: CanonicalStateMutationScopes;
        resources: CanonicalStateMutationResources;
    }): {
        deferred?: TerminalSubmissionRetryDeferredContext;
        ledger: TerminalDispatchLedgerDocument;
    };
    assertTerminalSubmissionRetryDeferredTransferAuthority(input: {
        invocation: TerminalSubmissionRetryInvocation;
        authority: TerminalSubmissionRetryLockedAuthority;
        transfer: DeferredForegroundTransfer;
        attempt?: TerminalSubmissionRetryRecord;
    }): void;
    reconcileTerminalSubmissionRetryDeferredPending(context: TerminalSubmissionRetryFlowContext, state: TerminalSubmissionRetryFlowState): boolean;
    recoverPartialTerminalSubmissionRetryAcceptance(context: TerminalSubmissionRetryFlowContext, state: TerminalSubmissionRetryFlowState): Promise<boolean>;
}