export declare const FAILURE_CATEGORIES: readonly ["transient-provider", "transient-tool", "timeout", "output-contract", "implementation-defect", "configuration", "missing-dependency", "invalid-topology", "wrong-decomposition", "budget", "authorization", "policy", "side-effect", "unknown"];
export type FailureCategory = typeof FAILURE_CATEGORIES[number];
export declare const RECOVERY_LEVELS: readonly ["retry", "repair", "replan"];
export type RecoveryLevel = typeof RECOVERY_LEVELS[number];
export declare const CONTRACT_VIOLATIONS: readonly ["missing-input", "missing-output", "invalid-output", "validator-rejected", "artifact-mismatch"];
export type ContractViolation = typeof CONTRACT_VIOLATIONS[number];
export type RecoveryStatus = "active" | "waiting-diagnosis" | "waiting-configuration" | "waiting-authorization" | "waiting-policy" | "waiting-side-effect-review" | "waiting-successor-artifact" | "waiting-successor-approval" | "ready-successor-activation" | "released" | "failed";
export type RecoveryTopology = "preserve" | "successor";
export type RecoveryAction = RecoveryLevel | "pause" | "fail";
export type RecoveryReason = "transient-failure" | "local-defect" | "structural-defect" | "diagnosis-required" | "unknown-after-diagnosis" | "configuration-change-required" | "human-authorization-required" | "policy-change-required" | "side-effect-review-required" | "global-budget-exhausted" | "retry-exhausted" | "repair-exhausted" | "replan-exhausted" | "recovery-level-consumed" | "recovery-level-skipped";
export interface FailureEvidence {
    version: 1;
    runId: string;
    nodeId: string;
    category: FailureCategory;
    nodeKind: string;
    graphVersion: string;
    graphDigest: string;
    planVersion: number;
    planHash: string;
    attempt: number;
    failureLineageId: string;
    contractViolation?: ContractViolation;
    contractId?: string;
    artifactHashes: readonly string[];
}
export interface RecoveryBudgets {
    retry: number;
    repair: number;
    replan: number;
}
export interface RecoveryState {
    version: 1;
    status: RecoveryStatus;
    genesisHash: string;
    fingerprint: string;
    budgetKey: string;
    observedCategory: FailureCategory;
    consumed: readonly RecoveryLevel[];
    remaining: Readonly<RecoveryBudgets>;
    sourcePlanVersion: number;
    sourcePlanHash: string;
    approvedPlanVersion: number;
    approvedPlanHash: string;
    planVersionCeiling: number;
    successor?: Readonly<RecoverySuccessorState>;
}
export interface RecoverySuccessorState {
    status: "intent-recorded" | "artifact-durable" | "approved" | "activated";
    sourcePlanVersion: number;
    targetPlanVersion: number;
    graphHash?: string;
    planHash?: string;
    graphRef?: string;
    planRef?: string;
    approvalHash?: string;
    approvalRef?: string;
}
export interface RecoveryDirective {
    version: 1;
    failureFingerprint: string;
    rootCauseCategory: FailureCategory;
    confidence: "low" | "medium" | "high";
    diagnosisRef: string;
    diagnosisHash: string;
    evidenceRefs: readonly string[];
    repairScope: readonly string[];
    validationRequirements: readonly string[];
    topologyAssessment: "preserve" | "structural";
}
export interface RecoveryDecision {
    version: 1;
    failureFingerprint: string;
    observedCategory: FailureCategory;
    effectiveCategory: FailureCategory;
    action: RecoveryAction;
    reason: RecoveryReason;
    topology: RecoveryTopology;
    sourcePlanVersion: number;
    sourcePlanHash: string;
    targetPlanVersion: number;
    remainingBefore: Readonly<RecoveryBudgets>;
    remainingAfter: Readonly<RecoveryBudgets>;
    directiveHash?: string;
}
export interface RecoveryLimits {
    maxEntries: number;
    maxPlanVersions: number;
    budgets: Readonly<RecoveryBudgets>;
}
export interface RecoveryAuthority {
    version: 1;
    runId: string;
    graphDigest: string;
    activePlanVersion: number;
    activePlanHash: string;
    limits: Readonly<RecoveryLimits>;
}
export interface RecoveryLedgerGenesis extends RecoveryAuthority {
    limitsHash: string;
    genesisHash: string;
}
interface RecoveryLedgerRecordBase {
    sequence: number;
    previousHash: string;
    hash: string;
}
export interface RecoveryRegistrationRecord extends RecoveryLedgerRecordBase {
    kind: "registration";
    failure: FailureEvidence;
    state: RecoveryState;
}
export interface RecoveryDecisionRecord extends RecoveryLedgerRecordBase {
    kind: "decision";
    fingerprint: string;
    directive?: RecoveryDirective;
    decision: RecoveryDecision;
    state: RecoveryState;
}
export interface RecoverySuccessorRecord extends RecoveryLedgerRecordBase {
    kind: "successor";
    fingerprint: string;
    event: RecoverySuccessorEvent;
    state: RecoveryState;
}
export interface RecoveryReleaseRecord extends RecoveryLedgerRecordBase {
    kind: "release";
    fingerprint: string;
    release: RecoveryRelease;
    state: RecoveryState;
}
export type RecoveryLedgerRecord = RecoveryRegistrationRecord | RecoveryDecisionRecord | RecoverySuccessorRecord | RecoveryReleaseRecord;
export interface RecoveryLedger {
    version: 1;
    genesis: Readonly<RecoveryLedgerGenesis>;
    records: readonly Readonly<RecoveryLedgerRecord>[];
    headHash: string;
}
export type RecoverySuccessorEvent = RecoverySuccessorArtifactEvent | RecoverySuccessorApprovalEvent | RecoverySuccessorActivationEvent;
export interface RecoverySuccessorArtifactEvent {
    version: 1;
    phase: "artifact-durable";
    failureFingerprint: string;
    sourcePlanVersion: number;
    targetPlanVersion: number;
    graphHash: string;
    planHash: string;
    graphRef: string;
    planRef: string;
}
export interface RecoverySuccessorApprovalEvent extends Omit<RecoverySuccessorArtifactEvent, "phase"> {
    phase: "approved";
    approvalHash: string;
    approvalRef: string;
}
export interface RecoverySuccessorActivationEvent extends Omit<RecoverySuccessorApprovalEvent, "phase"> {
    phase: "activated";
}
export interface RecoveryRelease {
    version: 1;
    failureFingerprint: string;
    reason: "configuration-changed" | "authorization-granted" | "policy-changed" | "side-effect-reviewed";
    evidenceRef: string;
    evidenceHash: string;
}
export type RecoveryRankingTuple = readonly [
    active: number,
    effectiveBudget: number,
    availableLevels: number,
    successorSteps: number,
    planVersionCapacity: number
];
export declare function validateFailureEvidence(value: unknown): FailureEvidence;
export declare function fingerprintFailure(value: FailureEvidence): string;
export declare function recoveryBudgetKey(value: FailureEvidence): string;
export declare function createRecoveryLedger(authorityValue: RecoveryAuthority): RecoveryLedger;
export declare function validateRecoveryAuthority(value: unknown): RecoveryAuthority;
export declare function validateRecoveryLedger(value: unknown, authorityValue: RecoveryAuthority): RecoveryLedger;
export declare function registerRecovery(ledgerValue: RecoveryLedger, authorityValue: RecoveryAuthority, failure: FailureEvidence): RecoveryLedger;
export declare function resumeRecoveryState(ledgerValue: RecoveryLedger, authorityValue: RecoveryAuthority, fingerprintValue: string): RecoveryState;
export declare function applyRecoveryDecisionToLedger(ledgerValue: RecoveryLedger, authorityValue: RecoveryAuthority, fingerprintValue: string, directiveValue?: RecoveryDirective): RecoveryLedger;
export declare function validateRecoveryState(value: unknown): RecoveryState;
export declare function validateRecoveryDirective(value: unknown): RecoveryDirective;
export declare function recoveryDirectiveDigest(value: RecoveryDirective): string;
export declare function validateRecoveryDecision(value: unknown): RecoveryDecision;
export declare function classifyFailure(failureValue: FailureEvidence, stateValue: RecoveryState, directiveValue?: RecoveryDirective): RecoveryDecision;
export declare function applyRecoveryDecision(stateValue: RecoveryState, decisionValue: RecoveryDecision): RecoveryState;
export declare function applyRecoverySuccessorEventToLedger(ledgerValue: RecoveryLedger, authorityValue: RecoveryAuthority, eventValue: RecoverySuccessorEvent): RecoveryLedger;
export declare function applyRecoveryReleaseToLedger(ledgerValue: RecoveryLedger, authorityValue: RecoveryAuthority, releaseValue: RecoveryRelease): RecoveryLedger;
export declare function validateRecoverySuccessorEvent(value: unknown): RecoverySuccessorEvent;
export declare function validateRecoveryRelease(value: unknown): RecoveryRelease;
export declare function recoveryRankingTuple(stateValue: RecoveryState): RecoveryRankingTuple;
export {};