/**
 * 🏅 THE TRUSTWORTHY DISCOVERY CERTIFICATE (TDC) — the moat: one signed verdict no competitor can match.
 *
 * Every other optimizer hands you a "best recipe" and stops. Melete already proves, separately, that a result
 * is REAL (not noise), CAUSAL (not confounded), and ROBUST (survives wobble). The TDC FUSES all of them into a
 * SINGLE Ed25519-signed certificate an auditor / regulator / insurer verifies OFFLINE — and it tells you which
 * gate failed when a result is NOT trustworthy:
 *   • SIGNAL  (NULL ENGINE)   — is there a real effect at all, or just luck?            [permutation test]
 *   • CAUSAL  (CAUSAL ENGINE) — does it CAUSE the outcome, or is it confounded?         [randomized intervention]
 *   • ROBUST  (AEGIS)         — does the optimum survive real-world wobble, or is it a fragile spike?
 * TRUSTWORTHY ⟺ every gate passes. One failing gate ⇒ NOT-TRUSTWORTHY, with the reason named.
 *
 * Why it is a MOAT (not just a feature): a competitor can copy any one algorithm, but the value here is the
 * COMPOSITION into a single, signed, offline-verifiable trust artifact — the format an auditor learns to
 * accept. (DIAKRISIS: that ADOPTION is a market outcome, not code; what this module builds is the verifiable
 * substrate of such a standard. The gauntlet proves the substrate: it stamps a genuinely good discovery
 * TRUSTWORTHY, and correctly refuses — naming the failed gate — a noisy / confounded / fragile one, ≥97.5%,
 * with a certificate that verifies offline and breaks on tamper.)
 */
import { type Space, type Experiment } from "./space.js";
import { type Goal, type Observation } from "./engine.js";
import { type KeyObject } from "node:crypto";
export interface TrustGate {
    name: string;
    pass: boolean;
    assessed: boolean;
    detail: string;
}
export interface TrustCertificate {
    standard: "melete-trust-certificate/v1";
    verdict: "TRUSTWORTHY" | "NOT-TRUSTWORTHY";
    gates: TrustGate[];
    failedGates: string[];
    best: Observation;
    goal: Goal;
    payloadHash: string;
    signature: string;
    publicKeyPem: string;
    algo: "ed25519+sha256";
}
/**
 * Issue a Trustworthy Discovery Certificate. Runs the SIGNAL (null), ROBUST (aegis) gates on the oracle, and —
 * if you supply historical `observations` — the CAUSAL gate (confounding check). Composes them into one signed
 * verdict. Deterministic per seed.
 */
export declare function issueTrustCertificate(opts: {
    space: Space;
    oracle: (e: Experiment) => number;
    observations?: ReadonlyArray<Observation>;
    goal?: Goal;
    seed?: number;
    robustMin?: number;
    keys?: {
        publicKey: KeyObject;
        privateKey: KeyObject;
    };
}): TrustCertificate;
/** Verify a Trustworthy Discovery Certificate offline (signature + embedded public key). */
export declare function verifyTrustCertificate(c: TrustCertificate): {
    ok: boolean;
    reason: string;
};
export declare function trustCertGauntlet(): {
    score: 0 | 100;
    checks: Array<{
        name: string;
        pass: boolean;
        detail: string;
    }>;
};
//# sourceMappingURL=trustcert.d.ts.map