import type { EventAdapterIdV3 } from "../events/v3/adapter-id.js";
import type { EventV3 } from "../events/v3/contract.js";
import { type SessionFinalizationRequestV3 } from "./session-finalization-state-v3.js";
export { listSessionFinalizationRequestsV3, type SessionFinalizationRequestV3, type SessionFinalizationTriggerV3, } from "./session-finalization-state-v3.js";
export interface SessionArchiveObservationV3 {
    adapter: EventAdapterIdV3;
    native_session_id: string;
    archived: boolean;
    observed_at: string;
}
export interface ReconcileSessionFinalizationOptionsV3 {
    now?: Date;
    archive_observations?: readonly SessionArchiveObservationV3[];
}
export interface ReconcileSessionFinalizationResultV3 {
    observed: number;
    cancelled: number;
    finalized: number;
    already_terminal: number;
    pending: number;
    diagnostics: string[];
}
export interface EndSessionExplicitV3Input {
    coordRoot: string;
    instance_id: `inst_${string}`;
    generation_id: `gen_${string}`;
    outcome?: SessionFinalizationRequestV3["outcome"];
    observed_at?: string;
    coordination_finalized: boolean;
}
export interface RequestSessionEndExplicitV3Input extends EndSessionExplicitV3Input {
}
export type RequestSessionEndExplicitV3Result = ReturnType<typeof endSessionExplicitV3> | {
    state: "busy";
} | {
    state: "generation_unavailable";
} | {
    state: "delegated_work_open";
    count: number;
} | {
    state: "queued";
    request: SessionFinalizationRequestV3;
} | {
    state: "already_requested";
    request: SessionFinalizationRequestV3;
    /** What the pending request is still waiting on, so a repeated explicit end reports its exact blocker instead of a bare refusal. */
    blocker: {
        open_span_ids: `span_${string}`[];
        current_turn_open: boolean;
        pending_age_ms: number;
    };
};
export interface ObserveHostDisappearedV3Input {
    coordRoot: string;
    instance_id: `inst_${string}`;
    generation_id: `gen_${string}`;
    observed_at?: string;
}
export declare function endSessionExplicitV3(input: EndSessionExplicitV3Input): {
    state: "gate_closed";
    reason: string;
} | {
    state: "generation_unavailable";
    reason: string;
} | {
    state: "already_ended";
    event_id?: `evt_${string}`;
} | {
    state: "recorded";
    event: EventV3;
    durability: import("../events/v3/writer.js").WriteEventV3Result;
    recovered: boolean;
} | {
    state: "unavailable";
    reason: string;
};
/**
 * Request an explicit end without weakening the terminal writer's open-work
 * guard. When invoked from inside an adapter turn, the request is committed
 * first and the stop hook reconciles it after that exact turn has closed.
 */
export declare function requestSessionEndExplicitV3(input: RequestSessionEndExplicitV3Input): RequestSessionEndExplicitV3Result;
export declare function hasPendingExplicitSessionEndV3(coordRoot: string): boolean;
/** Accept a host supervisor's observation without granting it terminal authority. */
export declare function observeHostDisappearedV3(input: ObserveHostDisappearedV3Input): {
    state: "unavailable";
    reason: string;
    request?: undefined;
} | {
    state: "busy";
    readonly reason?: undefined;
    request?: undefined;
} | {
    state: "generation_unavailable";
    readonly reason?: undefined;
    request?: undefined;
} | {
    state: "observed";
    request: SessionFinalizationRequestV3;
    readonly reason?: undefined;
} | {
    state: "already_observed";
    readonly reason?: undefined;
    request?: undefined;
};
export declare function reconcileSessionFinalizationV3(coordRoot: string, options?: ReconcileSessionFinalizationOptionsV3): ReconcileSessionFinalizationResultV3;
//# sourceMappingURL=session-finalizer-v3.d.ts.map