import type { ConversationStatus } from "./protocol.js";
import { type ManagedSessionState } from "./managed-session.js";
import { type CanonicalMutationLockPorts, type CanonicalMutationResources, type CanonicalMutationScopes } from "./mutation-transaction.js";
import { type ManagedBindingConflictKind } from "./native-thread-transition-policy.js";
import type { ExecutorKind } from "./executors.js";
import type { TerminalControlRef } from "./terminal-control-ref.js";
import type { TerminalNativeIdentity } from "./terminal-binding-authority.js";
export interface BindingReconciliationTerminalFacts {
    readonly conversationId: string;
    readonly agent: ExecutorKind;
    readonly pid: number;
    readonly terminalControl: TerminalControlRef;
}
export interface BindingReconciliationStatusFacts {
    readonly reachable: boolean;
    readonly activity_state: string;
    readonly activity_reason: string;
    readonly approval_state: Readonly<{
        blocked: boolean;
    }>;
}
type Identity = TerminalNativeIdentity | undefined;
type ScopeArgs = [CanonicalMutationScopes, CanonicalMutationResources];
type Scoped<Args extends unknown[], Result> = (...args: [...ScopeArgs, ...Args]) => Result;
type TurnBlocker = Readonly<{
    turnId: string;
    status: ConversationStatus;
}>;
export type BindingReconciliationRequest<Terminal extends BindingReconciliationTerminalFacts = BindingReconciliationTerminalFacts> = Readonly<{
    initialTerminal: Terminal;
    conflictingSessionId: string;
    expectedSessionRevision: number;
    expectedBindingToken: string;
    expectedTerminalToken: string;
}>;
export type BindingReconciliationResult<Terminal extends BindingReconciliationTerminalFacts = BindingReconciliationTerminalFacts> = Readonly<{
    terminal: Terminal;
    detached: ManagedSessionState;
    conflictKind: ManagedBindingConflictKind;
}>;
type BindingTransactionPort<Terminal extends BindingReconciliationTerminalFacts> = Readonly<{
    locks: CanonicalMutationLockPorts;
    recover: Scoped<[Terminal], Promise<void>>;
    loadSession: Scoped<[string], ManagedSessionState>;
    saveSession: Scoped<[
        ManagedSessionState,
        {
            expectedRevision: number;
        }
    ], ManagedSessionState>;
}>;
type BindingTerminalPort<Terminal extends BindingReconciliationTerminalFacts, Status extends BindingReconciliationStatusFacts> = Readonly<{
    resolve: () => Promise<Terminal>;
    sameIncarnation: (left: unknown, right: unknown) => boolean;
    identity: (terminal: Terminal) => Promise<Identity>;
    prepareStatus: () => (terminal: Terminal) => Promise<Status>;
    assertReady: (terminal: Terminal, status: Status) => void;
}>;
type BindingAuthorityPort<Terminal extends BindingReconciliationTerminalFacts> = Readonly<{
    dispatchIsFree: (control: Terminal["terminalControl"]) => boolean;
    sessionClaimsTerminal: (session: ManagedSessionState, terminal: Terminal) => boolean;
    terminalTokenMatches: (terminal: Terminal, identity: Identity, token: string) => boolean;
    hasUnresolvedTransition: (session: ManagedSessionState) => boolean;
    blockingTurn: (sessionId: string) => TurnBlocker | undefined;
    conflictKind: (session: ManagedSessionState, terminal: Terminal, identity: Identity) => ManagedBindingConflictKind | undefined;
}>;
export type BindingReconciliationPorts<Terminal extends BindingReconciliationTerminalFacts = BindingReconciliationTerminalFacts, Status extends BindingReconciliationStatusFacts = BindingReconciliationStatusFacts> = Readonly<{
    transaction: BindingTransactionPort<Terminal>;
    terminal: BindingTerminalPort<Terminal, Status>;
    authority: BindingAuthorityPort<Terminal>;
    now: () => string;
    present: (result: BindingReconciliationResult<Terminal>) => void;
}>;
export declare function reconcileTerminalBinding<Terminal extends BindingReconciliationTerminalFacts, Status extends BindingReconciliationStatusFacts>(request: BindingReconciliationRequest<Terminal>, ports: BindingReconciliationPorts<Terminal, Status>): Promise<void>;
export {};