import type { ScopeOfClaim } from '../accountability/types/base.js';
import type { CoSignerEntry, CoSignerRole, HumanOversightSlots, BreakGlass, CoSignerKeyResolution, SharesRoot } from './types.js';
import type { HumanOversightDescriptor, CoSignatureFact, ApprovalScheme, BreakGlassFact } from './descriptor.js';
export * from './types.js';
export * from './descriptor.js';
/**
 * The bytes a co-signer signs: canonical(receipt minus the co_signer
 * slot and minus the version marker). Every co-signer signs the SAME
 * string, exactly the discipline in bilateral-receipt.ts:101-102. The
 * approval_reference and break_glass slots ARE part of the signed body
 * (a human signs over the approval they reference and the override they
 * declare); only co_signer and the version marker are removed so the
 * signatures do not sign over each other.
 */
export declare function canonicalCoSignBody(receipt: Record<string, unknown>): string;
/**
 * Produce a co_signer entry by signing the canonical co-sign body of a
 * receipt. The receipt passed in MUST already carry whatever
 * approval_reference / break_glass slots are to be covered; pass the
 * receipt WITHOUT a co_signer slot (or with the prior entries; they are
 * stripped before signing so order does not matter).
 */
export declare function signAsCoSigner(opts: {
    receipt: Record<string, unknown>;
    role: CoSignerRole;
    keyClass: string;
    privateKey: string;
    publicKey: string;
    did?: string;
    signedAt?: string;
}): CoSignerEntry;
/**
 * Attach a co-signer entry to a receipt's co_signer slot, stamping the
 * versioned marker. Additive and pure: returns a new object. A receipt
 * with an empty/absent co_signer slot is byte-identical to its pre-slot
 * form for canonicalization purposes; only adding an entry changes it.
 */
export declare function attachCoSigner(receipt: Record<string, unknown>, entry: CoSignerEntry): Record<string, unknown> & HumanOversightSlots;
/**
 * Validate a break_glass declaration as a format. Returns the mechanical
 * facts a verifier records: well formed, in force, class allowed, and the
 * rejection reasons. `forbiddenClasses` is the relying party's list of
 * action classes that may NOT be overridden by break-glass; a declaration
 * whose action_class is in that list is rejected.
 *
 * This does not run a workflow. It does not notify or escalate. It reads
 * the declaration and reports whether it is acceptable.
 */
export declare function validateBreakGlass(bg: BreakGlass, opts?: {
    forbiddenClasses?: string[];
    now?: Date;
}): BreakGlassFact;
/** Classify which existing request-id scheme an approval reference uses.
 *  'approval-<hex>' (commerce) or 'approval_<uuid12>' (charter). No third
 *  scheme is recognized; an unrecognized id is reported as such, not
 *  coined. */
export declare function classifyApprovalScheme(requestId: string): ApprovalScheme;
/**
 * Verify each co_signer entry over the canonical co-sign body and return
 * a Belnap-valued fact per signer. A key resolution may be supplied per
 * entry (by index) to verify against a DID-resolved key instead of the
 * entry's self-declared publicKey; absent that, the entry's own publicKey
 * is used. When no key is available, the status is 'unknown' (Belnap),
 * never silently 'pass'.
 */
export declare function verifyCoSignatures(receipt: Record<string, unknown>, resolutions?: (CoSignerKeyResolution | undefined)[]): CoSignatureFact[];
/**
 * Derive the full human-oversight descriptor from a receipt's slots. This
 * is the verifier OUTPUT: a SET of mechanical facts. The single advisory
 * scalar on top is a relying-party-policy output, computed here, never
 * read from the receipt.
 */
export declare function deriveOversightDescriptor(receipt: Record<string, unknown>, opts?: {
    resolutions?: (CoSignerKeyResolution | undefined)[];
    sharesRoot?: SharesRoot;
    forbiddenBreakGlassClasses?: string[];
    now?: Date;
}): HumanOversightDescriptor;
/**
 * Return a ScopeOfClaim mirroring this module's PROOF BOX, for callers
 * that emit an accountability receipt over the oversight check. The
 * capture_mode and self_attested fields reflect the descriptor: when a
 * verified human signature is independent of the agent, the oversight is
 * not self-attested; otherwise it is.
 */
export declare function buildOversightScopeOfClaim(descriptor?: HumanOversightDescriptor): ScopeOfClaim;
//# sourceMappingURL=index.d.ts.map