/**
 * VerdictLedger — temporal, assumption-bound conjecture verdicts ("knowledge is fluid").
 *
 * A conjecture verdict is NEVER eternal. It is always "as of timestamp T, under
 * assumptions A." When an assumption the verdict depended on is later overturned, the
 * verdict must be RE-OPENED — and crucially, a falsified/rejected claim re-opens to
 * `undecided`, NOT to `survived`: overturning the reason a claim was rejected does not
 * make it true, it makes it open again (it must be re-tested). This is the Wegener
 * mechanism: a theory that consensus rejected without a counterexample stays re-openable;
 * a theory rejected *under a now-overturned assumption* returns to the open set.
 *
 * The ledger is append-only — every transition is preserved, so the history reads
 * "falsified at T1 under assumption A → re-opened at T2 when A was overturned." That
 * audit trail IS the fluid-knowledge record. Generalizes the documented impossibility
 * UPGRADE pattern (W.056: a rating moving DOESN'T_HELP → PARTIALLY after reframing) to
 * the conjecture-engine verdict ladder.
 *
 * Reject ONLY on a counterexample (`falsified`) or untestability (`out-of-scope`); never
 * on consensus. Consensus rejection without a counterexample is `undecided`, and stays
 * re-openable forever (D.060 epistemics — anti-authority, pro-evidence).
 *
 * Deterministic entry keys via the shared `buildConjectureStableKey` primitive. No edits
 * to ConjectureEngine.ts — this is a higher-level meta-layer over conjecture receipts.
 */
import { type ConjectureReceipt, type ConjectureStatus } from './ConjectureEngine';
export declare const VERDICT_LEDGER_V1: "conjecture.verdict-ledger.v1";
export type VerdictLedgerSolverType = typeof VERDICT_LEDGER_V1;
/**
 * The full verdict ladder (D.060 / W.536): intake gate → resolution → novelty.
 * `out-of-scope` (unfalsifiable) and `undecided` (falsifiable, unresolved) are distinct;
 * `falsified` requires an actual counterexample; consensus rejection is NEVER `falsified`.
 */
export type VerdictStatus = 'out-of-scope' | 'undecided' | 'falsified' | 'survived' | 'rediscovered';
export interface VerdictEntry {
    claimId: string;
    status: VerdictStatus;
    /** What this verdict is conditional on. Overturning one of these re-opens the verdict. */
    assumptions: ReadonlyArray<string>;
    /** ISO timestamp — the verdict holds "as of" this moment, not eternally. */
    timestamp: string;
    /** Optional link to the underlying conjecture receipt that produced this status. */
    receiptKey: string | null;
    /** The prior entry this revises (append-only chain). Null for the first entry. */
    supersedesKey: string | null;
    /** Which assumption was overturned to trigger this revision (null for the first entry). */
    reopenedBecause: string | null;
    /** Deterministic hash of this entry's content. */
    entryKey: string;
}
export interface VerdictLedger {
    claimId: string;
    solverType: VerdictLedgerSolverType;
    entries: ReadonlyArray<VerdictEntry>;
    /** The latest entry — authoritative *for now*, never eternal. */
    current: VerdictEntry;
}
export interface RecordVerdictInput {
    claimId: string;
    status: VerdictStatus;
    assumptions?: ReadonlyArray<string>;
    timestamp: string;
    receiptKey?: string | null;
}
/** Open a ledger with the first verdict for a claim. */
export declare function recordVerdict(input: RecordVerdictInput): VerdictLedger;
export interface ReopenVerdictInput {
    /** The assumption being overturned — MUST be one the current verdict depended on. */
    overturnedAssumption: string;
    /** Human-readable reason / evidence for the overturn. */
    reason: string;
    timestamp: string;
    /**
     * The status after re-opening. Defaults to `undecided` — overturning the reason a
     * claim was rejected re-opens it, it does NOT make it true. A caller may pass a
     * status explicitly (e.g. after a fresh run), but `falsified`/`survived` should come
     * from an actual re-test, not from the overturn alone.
     */
    newStatus?: VerdictStatus;
    /** Assumptions for the re-opened verdict (the overturned one is dropped by default). */
    assumptions?: ReadonlyArray<string>;
    receiptKey?: string | null;
}
/**
 * Re-open a verdict because one of its assumptions was overturned. Appends a new entry
 * superseding the current one. Guard: you can only overturn an assumption the current
 * verdict actually depended on (no rewriting history with an unrelated assumption).
 * Default re-opened status is `undecided` (re-test required) — the Wegener mechanism.
 */
export declare function reopenVerdict(ledger: VerdictLedger, input: ReopenVerdictInput): VerdictLedger;
/**
 * Map a Conjecture Engine receipt status onto the verdict ladder. The unions currently
 * coincide (out-of-scope | undecided | survived | falsified | rediscovered), so this is
 * a 1:1 pass-through — but the exhaustive switch makes any future ConjectureStatus
 * divergence a compile error rather than a silent miscategorization.
 */
export declare function conjectureStatusToVerdict(status: ConjectureStatus): VerdictStatus;
/**
 * The real consumer: open a verdict ledger directly from a Conjecture Engine receipt.
 * The verdict inherits the claim's assumptions (so overturning one re-opens it) and
 * links the receipt that produced it. `timestamp` is when the verdict is recorded
 * (receipts are deterministic/timeless; the verdict is the time-bound interpretation).
 */
export declare function verdictFromConjectureReceipt(receipt: ConjectureReceipt, timestamp: string): VerdictLedger;
/** The authoritative-for-now verdict. Never treat as eternal. */
export declare function currentVerdict(ledger: VerdictLedger): VerdictEntry;
/** Whether a claim's verdict has ever been revised (knowledge moved). */
export declare function hasBeenReopened(ledger: VerdictLedger): boolean;
/** The full transition history as a readable chain of "status @ time (because …)". */
export declare function verdictHistory(ledger: VerdictLedger): ReadonlyArray<string>;
//# sourceMappingURL=VerdictLedger.d.ts.map