/**
 * OperatorConfirmGate — R2 of the Sealed Handoff (secure agent-to-agent secret
 * transfer). Enforces, in code, the rule that the agent REQUESTING a secret can
 * never be the party that AUTHORIZES the transfer: authorization is an explicit,
 * out-of-band operator act bound to the HOLDER (the agent that will send the
 * secret). A relayed "the operator said go" is not an authorization — only a
 * record the operator created is.
 *
 * This is the structural backstop behind the peer's behavioral gate (the holder
 * also refuses to act until the operator tells it directly, off-relay). Both
 * layers are required — neither substitutes for the other.
 *
 * Earned from: 2026-06-01, a parallel session moved a credential via Secret Drop
 * URLs and the peer (Dawn) flagged credential requests an "Echo" had no record of
 * initiating — exactly the requester-self-authorizes / unattributed-request hole
 * this gate closes.
 *
 * Pure decision logic — no I/O. The caller supplies the authorization record it
 * holds (from durable operator-confirm storage) and the gate returns allow/block.
 */
/** An operator's explicit, out-of-band authorization for one sealed handoff. */
export interface OperatorAuthorization {
    /** Fingerprint of the HOLDER — the agent authorized to SEND the secret. */
    holderFingerprint: string;
    /** Identity of the operator who confirmed (NOT an agent fingerprint). */
    authorizedBy: string;
    /** The specific request this authorization is scoped to (one-time). */
    requestId: string;
    /** ISO-8601 timestamp of the confirmation. */
    confirmedAt: string;
}
export interface OperatorConfirmInput {
    /** Fingerprint of the agent that REQUESTED the secret (the receiver). */
    requesterFingerprint: string;
    /** Fingerprint of the agent submitting the secret (the holder/sender). */
    holderFingerprint: string;
    /** The request id being completed. */
    requestId: string;
    /** The operator-authorization record on file for this request, or null. */
    authorization: OperatorAuthorization | null;
}
export interface OperatorConfirmDecision {
    allow: boolean;
    reason: string;
}
/**
 * Decide whether a sealed-handoff transfer may complete. Blocks unless ALL hold:
 *  1. an operator-authorization record exists,
 *  2. it is scoped to THIS request id,
 *  3. it authorizes THIS holder (not some other agent),
 *  4. the requester is not the authorizer (an agent cannot self-authorize, nor
 *     impersonate the operator).
 */
export declare function evaluateOperatorConfirm(input: OperatorConfirmInput): OperatorConfirmDecision;
/** Peer trust ladder (ascending), mirrors AgentTrustManager's TRUST_ORDER. */
export type PeerTrustLevel = 'untrusted' | 'verified' | 'trusted' | 'autonomous';
/** Operation-autonomy ladder (ascending), mirrors AdaptiveTrust's TRUST_ORDER. */
export type OperationAutonomyLevel = 'blocked' | 'approve-always' | 'approve-first' | 'log' | 'autonomous';
/** High-trust thresholds — confirmed by Justin 2026-06-01. */
export declare const PEER_TRUST_HIGH: PeerTrustLevel;
export declare const OP_AUTONOMY_HIGH: OperationAutonomyLevel;
export interface TransferTrustContext {
    /** The agent's trust of the peer (from AgentTrustManager). */
    peerTrust: PeerTrustLevel;
    /** The user's granted autonomy for this credential-transfer operation. */
    opAutonomy: OperationAutonomyLevel;
}
/**
 * True when BOTH trust axes are at/above their high-trust thresholds, so the
 * transfer needs no operator approval. Unknown level strings are treated as the
 * lowest rung (fail-closed: an unrecognized trust value never clears the bar).
 */
export declare function isHighTrustTransfer(ctx: TransferTrustContext): boolean;
export interface TransferAuthorizationInput extends OperatorConfirmInput {
    /** The two trust levels gating whether operator approval is required. */
    trust: TransferTrustContext;
}
export interface TransferAuthorizationDecision {
    allow: boolean;
    reason: string;
    /** How it was (or wasn't) authorized — for the audit trail. */
    path: 'high-trust' | 'operator-confirm' | 'blocked';
}
/**
 * Trust-gated R2 decision. High trust on both axes → authorized with no operator
 * approval. Otherwise → the explicit operator-confirm gate decides (and a missing
 * authorization blocks). Pure logic; the caller resolves the two trust levels
 * (peer from AgentTrustManager, op-autonomy from AdaptiveTrust) and the
 * authorization record from durable storage.
 */
export declare function evaluateTransferAuthorization(input: TransferAuthorizationInput): TransferAuthorizationDecision;
//# sourceMappingURL=OperatorConfirmGate.d.ts.map