import type { Executor } from "./executors.js";
import { type Conversation, type ConversationStatus } from "./protocol.js";
import type { TerminalControlRef, TerminalDurableCompletionRequest, TerminalRuntimeIdentity } from "./terminal-agent-adapter.js";
import type { TerminalAgentBridge, TerminalBridgeStatus } from "./terminal-agent-bridge.js";
import { type TerminalInteractionProjection } from "./terminal-interaction-protocol.js";
import type { TerminalBridgeSubmissionMutation } from "./terminal-dispatch-receipt.js";
import type { MonitorApprovalCallbackRecord, MonitorApprovalNotificationResult, MonitorInteractionNotificationResult, MonitorPollResult, MonitorSubmissionReconciliation, TerminalMonitorPresentation } from "./terminal-monitor-application-service.js";
import { type UnknownRecord } from "./value-guards.js";
type Release = () => void;
type EventRecord = {
    event: string;
    [key: string]: unknown;
};
export declare function terminalMonitorStoreOperationTimeout(error: unknown): {
    code: string;
    lockKind: string;
} | undefined;
export declare function terminalMonitorStoreLeaseTimeout(error: unknown): {
    code: string;
    lockKind: string;
} | undefined;
export interface PreparedMonitorRecoveryPorts {
    acquireTerminal(control: TerminalControlRef): Release;
    withWriter<T>(use: () => Promise<T>): Promise<T>;
    acquireState(): Release;
    loadConversation(): Conversation;
    loadLedger(control: TerminalControlRef): UnknownRecord | undefined;
    saveLedger(control: TerminalControlRef, ledger: UnknownRecord): void;
    saveConversation(conversation: Conversation): void;
    submission(conversation: Conversation): UnknownRecord | undefined;
    applySubmission(mutation: TerminalBridgeSubmissionMutation): Conversation;
    requestFingerprint(requestText: string): string | undefined;
    now(): Date;
    appendEvent(event: EventRecord): void;
    stallCollateral(input: {
        terminalControl: TerminalControlRef;
        currentConversationId: string;
        uncertainMessageId: string;
    }): void;
}
export interface RecoverPreparedMonitorInput {
    conversation: Conversation;
    statePath: string;
    logPath: string;
    terminalControl: TerminalControlRef;
    currentMessageId: string;
    dispatcherPid: number;
    ports: PreparedMonitorRecoveryPorts;
}
export interface LaggingAcceptedMonitorAuthorityRepairPorts {
    acquireTerminal(control: TerminalControlRef): Release;
    withWriter<T>(use: () => Promise<T>): Promise<T>;
    acquireState(): Release;
    loadConversation(): Conversation;
    loadLedger(control: TerminalControlRef): UnknownRecord | undefined;
    reconcileLedger(control: TerminalControlRef, ledger?: UnknownRecord): UnknownRecord | undefined;
    submission(conversation: Conversation): UnknownRecord | undefined;
}
/**
 * Repair the one legacy migration window that otherwise reaches acceptance
 * observation first: an enter-dispatched Turn without route authority and an
 * accepted ledger that already owns the canonical authority. The existing
 * lagging-dispatch recovery performs all identity/evidence validation while
 * these locks prevent either durable image from changing underneath it.
 */
export declare function repairLaggingAcceptedMonitorAuthority(input: {
    conversation: Conversation;
    terminalControl: TerminalControlRef;
    currentMessageId: string;
    ports: LaggingAcceptedMonitorAuthorityRepairPorts;
}): Promise<Conversation>;
/** Recover one abandoned prepared receipt while the CLI owns all raw locks. */
export declare function recoverPreparedMonitorSubmission(input: RecoverPreparedMonitorInput): Promise<Conversation>;
export interface MonitorPollAdapterPorts {
    acquireTerminal(control: TerminalControlRef): Release;
    withWriter<T>(use: () => Promise<T>): Promise<T>;
    acquireState(): Release;
    reconcileLedger(control: TerminalControlRef, ledger?: UnknownRecord): UnknownRecord | undefined;
    loadLedger(control: TerminalControlRef): UnknownRecord | undefined;
    saveLedger(control: TerminalControlRef, ledger: UnknownRecord): void;
    submission(conversation: Conversation): UnknownRecord | undefined;
    loadConversation(): Conversation;
    terminalControl(conversation: Conversation): TerminalControlRef | undefined;
    sameIncarnation(left: TerminalControlRef, right: TerminalControlRef): boolean;
    runtime(conversation: Conversation, control: TerminalControlRef): TerminalRuntimeIdentity;
    durableRequest(conversation: Conversation, control: TerminalControlRef): TerminalDurableCompletionRequest;
    appendEvent(event: EventRecord): void;
    now(): Date;
}
export declare function reconcileMonitorAcceptance(input: {
    terminalControl: TerminalControlRef;
    acquireTerminal(control: TerminalControlRef): Release;
    reconcile(): Promise<MonitorSubmissionReconciliation>;
    apply(reconciliation: MonitorSubmissionReconciliation): "continue" | "finished" | "pending";
    recover(error: unknown): "continue" | "finished";
}): Promise<"continue" | "finished" | "pending">;
export declare function pollTerminalMonitor(input: {
    conversation: Conversation;
    terminalControl: TerminalControlRef;
    currentMessageId?: string;
    executor: Executor;
    screenChangedSinceSend: boolean;
    scrollbackLines: number;
    terminalBridge: TerminalAgentBridge;
    onFenced(ledgerStatus?: string): void;
    ports: MonitorPollAdapterPorts;
}): Promise<MonitorPollResult>;
export interface ApprovalNotificationAdapterPorts {
    record(input: {
        terminalControl: TerminalControlRef;
        terminalStatus: TerminalBridgeStatus;
        fingerprint?: string;
        expectedConversation: {
            conversationId: string;
            status: ConversationStatus;
            updatedAt: string;
            messageId?: string;
        };
        onRecorded(conversation: Conversation, context?: {
            recoverMissingOutbox?: boolean;
        }): MonitorApprovalCallbackRecord;
    }): MonitorApprovalNotificationResult;
    prepare(input: {
        conversation: Conversation;
        actor: Executor["actor"];
        type: "question" | "blocked";
        body: string;
        metadata: UnknownRecord;
        recoverMissingOutbox: boolean;
    }): MonitorApprovalCallbackRecord;
    approvalInstructions(input: {
        conversation: Conversation;
        terminalControl: TerminalControlRef;
        terminalStatus: TerminalBridgeStatus;
    }): string;
    approvalCandidate(input: {
        executorKind: Executor["kind"];
        terminalControl: TerminalControlRef;
        terminalStatus: TerminalBridgeStatus;
        fingerprint?: string;
    }): UnknownRecord | undefined;
}
export declare function recordMonitorApprovalNotification(input: {
    conversation: Conversation;
    executor: Executor;
    terminalControl: TerminalControlRef;
    terminalStatus: TerminalBridgeStatus;
    currentMessageId?: string;
    fingerprint?: string;
    kind: "question" | "error";
    reason?: string;
    ports: ApprovalNotificationAdapterPorts;
}): MonitorApprovalNotificationResult;
export interface InteractionNotificationAdapterPorts {
    record(input: {
        terminalControl: TerminalControlRef;
        terminalStatus: TerminalBridgeStatus;
        interactionId: string;
        questionId: string;
        fingerprint: string;
        surfaceId: string;
        expectedConversation: {
            conversationId: string;
            status: ConversationStatus;
            updatedAt: string;
            messageId?: string;
        };
        onRecorded(conversation: Conversation, context?: {
            recoverMissingOutbox?: boolean;
        }): MonitorApprovalCallbackRecord;
    }): MonitorInteractionNotificationResult;
    prepare(input: {
        conversation: Conversation;
        actor: Executor["actor"];
        body: string;
        metadata: UnknownRecord;
        requiresResponse: boolean;
        recoverMissingOutbox: boolean;
    }): MonitorApprovalCallbackRecord;
}
export declare function recordMonitorInteractionNotification(input: {
    conversation: Conversation;
    executor: Executor;
    terminalControl: TerminalControlRef;
    terminalStatus: TerminalBridgeStatus;
    currentMessageId?: string;
    interactionId: string;
    questionId: string;
    fingerprint: string;
    surfaceId: string;
    ports: InteractionNotificationAdapterPorts;
}): MonitorInteractionNotificationResult;
export declare function validMonitorInteractionProjection(value: unknown): TerminalInteractionProjection | undefined;
export declare function presentTerminalMonitor(result: TerminalMonitorPresentation, write: (value: UnknownRecord) => void): void;
export {};