/**
 * SOVEREIGN — the ecosystem spine. Melete is "The Sovereign Verifiable AI Analyst & Optimizer": you bring a
 * system you can MEASURE (an ML pipeline, an infra/DB/network config, a process, a simulation), and in ONE
 * call Melete plays four roles end-to-end and hands back a single, signed, offline-verifiable verdict:
 *
 *   ① DISCOVER  — find the best setting in the fewest experiments
 *   ② DECIDE    — the Φ brain's safety-first verdict + AEGIS's ROBUST (survives-the-real-world) answer
 *   ③ DIAGNOSE  — the analyst's plain-language read: which knobs matter, where the cliffs are, the shape,
 *                 the achievable ceiling, the family of equally-good recipes
 *   ④ CERTIFY   — an Ed25519-signed PROVENANCE certificate: a tamper-evident record of WHAT was tested and
 *                 the result reached, verifiable offline with the embedded public key, no Melete needed
 *
 * This is the product face (one call, one verdict — usable) AND the moat (sovereign + a signed, vendor-
 * neutral verdict FORMAT others must speak to audit it). It runs entirely on the caller's machine.
 *
 * Honest by construction (DIAKRISIS): "verifiable" means PROVENANCE + REPRODUCIBILITY — the certificate
 * proves, offline, exactly what was measured and the result found, and that the signed payload wasn't
 * altered. It is NOT a proof that the customer's code is bug-free or exploit-free (that is undecidable in
 * general and we refuse to fake it). Every facet of the verdict comes from an independently-tested engine.
 */
import { type KeyObject } from "node:crypto";
import { type Space } from "./space.js";
import { type Observation, type Goal } from "./engine.js";
export interface SovereignCertificate {
    standard: "melete-sovereign-verdict/v1";
    payloadHash: string;
    signature: string;
    publicKeyPem: string;
    algo: "ed25519+sha256";
    issuedAtMs: number;
}
export interface SovereignVerdict {
    product: "Melete — The Sovereign Verifiable AI Analyst & Optimizer";
    discover: {
        best: Observation | null;
        evaluations: number;
        goal: Goal;
    };
    decide: {
        processIQ: number;
        grade: string;
        decision: string;
        briefing: string;
    };
    diagnose: {
        shape: unknown;
        cliffs: unknown;
        sloppiness: unknown;
        achievability: unknown;
        options: unknown;
    };
    certify: SovereignCertificate;
    verdict: string;
}
/** Run the full Sovereign analysis on a finished (or in-progress) run and sign the verdict. */
export declare function sovereignAnalyze(obs: ReadonlyArray<Observation>, space: Space, goal?: Goal, opts?: {
    target?: number;
    keys?: {
        privateKey: KeyObject;
        publicKey: KeyObject;
    };
    issuedAtMs?: number;
}): SovereignVerdict;
/** Re-verify a Sovereign Verdict OFFLINE: recompute the payload hash + check the Ed25519 signature. */
export declare function verifySovereign(v: SovereignVerdict): {
    ok: boolean;
    reason: string;
};
export declare function sovereignGauntlet(): {
    score: 0 | 100;
    checks: Array<{
        name: string;
        pass: boolean;
        detail: string;
    }>;
};
//# sourceMappingURL=sovereign.d.ts.map