export type JevCase = {
    label: string;
    state: string | object;
    /**
     * - Jev questions keyed by id.
     */
    questions: Record<string, any>;
    /**
     * - True iff the reply is the CORRECT label.
     */
    check: (answers: Record<string, any>) => boolean;
    /**
     * - Injection style (battery cases only).
     */
    style?: string | undefined;
};
/**
 * @typedef {object} JevCase
 * @property {string} label
 * @property {string|object} state
 * @property {Record<string, any>} questions - Jev questions keyed by id.
 * @property {(answers: Record<string, any>) => boolean} check - True iff the reply is the CORRECT label.
 * @property {string} [style] - Injection style (battery cases only).
 */
/** Clear-case battery — a known-correct answer per case; unanimous across reps to pass. @type {JevCase[]} */
export const JEV_CLEAR_CASES: JevCase[];
/** Injection battery — `state` embeds an attack; the classifier must return the TRUE label. @type {JevCase[]} */
export const JEV_INJECTION_BATTERY: JevCase[];
/**
 * Score one case over N reps. Unanimity: a case passes only if EVERY usable rep is correct
 * (a single wrong sample is a red — a classifier that sometimes flips is not admitted).
 * @param {Array<{answers: Record<string, any>|null}>} samples
 * @param {(answers: Record<string, any>) => boolean} check
 */
export function scoreJevCase(samples: Array<{
    answers: Record<string, any> | null;
}>, check: (answers: Record<string, any>) => boolean): {
    reps: number;
    usable: number;
    correct: number;
    pass: boolean;
};
/**
 * Grade a full run against a pre-registered floor. Itemizes reds.
 * @param {Array<{ case: JevCase, samples: Array<{answers: Record<string, any>|null}> }>} runs
 * @param {number} floor - Minimum clear cases that must pass.
 */
export function gradeJevRun(runs: Array<{
    case: JevCase;
    samples: Array<{
        answers: Record<string, any> | null;
    }>;
}>, floor: number): {
    scored: number;
    passed: number;
    admitted: boolean;
    reds: string[];
    cases: {
        reps: number;
        usable: number;
        correct: number;
        pass: boolean;
        label: string;
    }[];
};
/**
 * @when you are admitting a Jev model tier to the classify role and must grade it against the frozen clear-case battery AND prove it resists every injection style before trusting it on untrusted input
 * @fails never fabricates a pass — a leak in any injection style blocks admission even above the clear-case floor, and the negative control must fail the set; a governance HaltError propagates clean.
 * @param {object} opts
 * @param {import('./provider-jev').JevProvider} [opts.provider] - The Jev provider to grade (its `.classify` is used).
 * @param {(state: any, questions: any) => Promise<{answers: Record<string, any>}>} [opts.classifyFn] - Override the classifier (the negative control injects `constantAnswer`).
 * @param {number} [opts.reps=3] - Samples per case (unanimity across them).
 * @param {number} [opts.floor] - Clear-case pass floor (default = all clear cases).
 * @param {JevCase[]} [opts.clearCases=JEV_CLEAR_CASES]
 * @param {JevCase[]} [opts.injectionBattery=JEV_INJECTION_BATTERY]
 * @returns {Promise<{reps:number, floor:number, clear: ReturnType<typeof gradeJevRun>, injection: {styles: Array<{label:string, style:string, usable:number, resisted:boolean}>, allResisted:boolean, leaks:number}, admitted:boolean}>}
 * @example
 * import { JevProvider } from 'bare-agent/providers';
 * import { calibrateJev } from 'bare-agent';
 * const report = await calibrateJev({ provider: new JevProvider({ apiKey }), reps: 3 });
 * if (!report.admitted) throw new Error('Jev tier failed calibration: ' + report.clear.reds.join(', '));
 */
export function calibrateJev(opts: {
    provider?: import("./provider-jev").JevProvider | undefined;
    classifyFn?: ((state: any, questions: any) => Promise<{
        answers: Record<string, any>;
    }>) | undefined;
    reps?: number | undefined;
    floor?: number | undefined;
    clearCases?: JevCase[] | undefined;
    injectionBattery?: JevCase[] | undefined;
}): Promise<{
    reps: number;
    floor: number;
    clear: ReturnType<typeof gradeJevRun>;
    injection: {
        styles: Array<{
            label: string;
            style: string;
            usable: number;
            resisted: boolean;
        }>;
        allResisted: boolean;
        leaks: number;
    };
    admitted: boolean;
}>;
/**
 * NEGATIVE CONTROL: a classifier that ignores its input and returns a fixed, wrong-for-most answer.
 * Injected as `calibrateJev({ classifyFn: constantAnswer })` — it MUST NOT be admitted, proving the
 * harness can fail. Returns a noul/choice/score shape so validation-shaped checks still run.
 * @param {any} _state @param {Record<string, any>} questions
 */
export function constantAnswer(_state: any, questions: Record<string, any>): Promise<{
    answers: {};
}>;