import { z } from 'zod';
/**
 * The body of a tool verdict, WITHOUT `evalId`. This is what a per-eval
 * grader fragment carries (`EvalFragment.tool` in eval-fragment.ts) — the
 * fragment already carries `evalId` at its top level, so repeating it inside
 * the `tool` body would be redundant data that could drift from the
 * fragment's own `evalId`. {@link ToolVerdictSchema} re-adds `evalId` for the
 * merged, per-eval-keyed `tool-eval.json` report where there is no
 * surrounding fragment to source it from.
 */
export declare const ToolVerdictBodySchema: z.ZodObject<{
    mustRun: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        ran: z.ZodBoolean;
        evidence: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }, {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }>, "many">>;
    mustNotRun: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        ran: z.ZodBoolean;
        evidence: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }, {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }>, "many">>;
    mustSucceed: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        succeeded: z.ZodBoolean;
        evidence: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        name: string;
        succeeded: boolean;
        evidence?: string | undefined;
    }, {
        name: string;
        succeeded: boolean;
        evidence?: string | undefined;
    }>, "many">>;
    sequence: z.ZodOptional<z.ZodArray<z.ZodObject<{
        steps: z.ZodArray<z.ZodString, "many">;
        satisfied: z.ZodBoolean;
        evidence: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        steps: string[];
        satisfied: boolean;
        evidence?: string | undefined;
    }, {
        steps: string[];
        satisfied: boolean;
        evidence?: string | undefined;
    }>, "many">>;
    /**
     * The grader's self-reported overall verdict (mustRun all ran AND mustNotRun
     * none ran AND mustSucceed all succeeded AND sequence all satisfied). vat NEVER
     * trusts this field alone — it is RECOMPUTED from the sub-checks by
     * {@link computeToolPassed} and a grader whose `passed` disagrees with its own
     * sub-checks is rejected as a malfunction (see eval-grader.ts), mirroring
     * `reconcileGrading`'s summary/expectations reconciliation.
     */
    passed: z.ZodBoolean;
}, "strict", z.ZodTypeAny, {
    passed: boolean;
    mustRun?: {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    mustNotRun?: {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    mustSucceed?: {
        name: string;
        succeeded: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    sequence?: {
        steps: string[];
        satisfied: boolean;
        evidence?: string | undefined;
    }[] | undefined;
}, {
    passed: boolean;
    mustRun?: {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    mustNotRun?: {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    mustSucceed?: {
        name: string;
        succeeded: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    sequence?: {
        steps: string[];
        satisfied: boolean;
        evidence?: string | undefined;
    }[] | undefined;
}>;
export type ToolVerdictBody = z.infer<typeof ToolVerdictBodySchema>;
/**
 * Recompute a tool verdict's overall pass from its sub-checks — the
 * authoritative value vat uses instead of the grader's self-reported `passed`
 * (fail-open fix #3). Pure: every declared `mustRun` ran, every `mustNotRun`
 * did NOT run, every `mustSucceed` succeeded, and every `sequence` was
 * satisfied. An absent or empty sub-array is vacuously true (nothing declared
 * in that channel cannot make the verdict fail).
 */
export declare function computeToolPassed(body: ToolVerdictBody): boolean;
/** A single eval's tool verdict, keyed by `evalId` — one entry in {@link ToolEvalReportSchema}. */
export declare const ToolVerdictSchema: z.ZodObject<{
    mustRun: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        ran: z.ZodBoolean;
        evidence: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }, {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }>, "many">>;
    mustNotRun: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        ran: z.ZodBoolean;
        evidence: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }, {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }>, "many">>;
    mustSucceed: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        succeeded: z.ZodBoolean;
        evidence: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        name: string;
        succeeded: boolean;
        evidence?: string | undefined;
    }, {
        name: string;
        succeeded: boolean;
        evidence?: string | undefined;
    }>, "many">>;
    sequence: z.ZodOptional<z.ZodArray<z.ZodObject<{
        steps: z.ZodArray<z.ZodString, "many">;
        satisfied: z.ZodBoolean;
        evidence: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        steps: string[];
        satisfied: boolean;
        evidence?: string | undefined;
    }, {
        steps: string[];
        satisfied: boolean;
        evidence?: string | undefined;
    }>, "many">>;
    /**
     * The grader's self-reported overall verdict (mustRun all ran AND mustNotRun
     * none ran AND mustSucceed all succeeded AND sequence all satisfied). vat NEVER
     * trusts this field alone — it is RECOMPUTED from the sub-checks by
     * {@link computeToolPassed} and a grader whose `passed` disagrees with its own
     * sub-checks is rejected as a malfunction (see eval-grader.ts), mirroring
     * `reconcileGrading`'s summary/expectations reconciliation.
     */
    passed: z.ZodBoolean;
} & {
    evalId: z.ZodString;
}, "strict", z.ZodTypeAny, {
    passed: boolean;
    evalId: string;
    mustRun?: {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    mustNotRun?: {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    mustSucceed?: {
        name: string;
        succeeded: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    sequence?: {
        steps: string[];
        satisfied: boolean;
        evidence?: string | undefined;
    }[] | undefined;
}, {
    passed: boolean;
    evalId: string;
    mustRun?: {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    mustNotRun?: {
        name: string;
        ran: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    mustSucceed?: {
        name: string;
        succeeded: boolean;
        evidence?: string | undefined;
    }[] | undefined;
    sequence?: {
        steps: string[];
        satisfied: boolean;
        evidence?: string | undefined;
    }[] | undefined;
}>;
export type ToolVerdict = z.infer<typeof ToolVerdictSchema>;
/** vat-owned strict tool-eval report — vat's `tool-eval.json` output artifact. */
export declare const ToolEvalReportSchema: z.ZodObject<{
    evals: z.ZodArray<z.ZodObject<{
        mustRun: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            ran: z.ZodBoolean;
            evidence: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }, {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }>, "many">>;
        mustNotRun: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            ran: z.ZodBoolean;
            evidence: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }, {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }>, "many">>;
        mustSucceed: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            succeeded: z.ZodBoolean;
            evidence: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            name: string;
            succeeded: boolean;
            evidence?: string | undefined;
        }, {
            name: string;
            succeeded: boolean;
            evidence?: string | undefined;
        }>, "many">>;
        sequence: z.ZodOptional<z.ZodArray<z.ZodObject<{
            steps: z.ZodArray<z.ZodString, "many">;
            satisfied: z.ZodBoolean;
            evidence: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            steps: string[];
            satisfied: boolean;
            evidence?: string | undefined;
        }, {
            steps: string[];
            satisfied: boolean;
            evidence?: string | undefined;
        }>, "many">>;
        /**
         * The grader's self-reported overall verdict (mustRun all ran AND mustNotRun
         * none ran AND mustSucceed all succeeded AND sequence all satisfied). vat NEVER
         * trusts this field alone — it is RECOMPUTED from the sub-checks by
         * {@link computeToolPassed} and a grader whose `passed` disagrees with its own
         * sub-checks is rejected as a malfunction (see eval-grader.ts), mirroring
         * `reconcileGrading`'s summary/expectations reconciliation.
         */
        passed: z.ZodBoolean;
    } & {
        evalId: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        passed: boolean;
        evalId: string;
        mustRun?: {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        mustNotRun?: {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        mustSucceed?: {
            name: string;
            succeeded: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        sequence?: {
            steps: string[];
            satisfied: boolean;
            evidence?: string | undefined;
        }[] | undefined;
    }, {
        passed: boolean;
        evalId: string;
        mustRun?: {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        mustNotRun?: {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        mustSucceed?: {
            name: string;
            succeeded: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        sequence?: {
            steps: string[];
            satisfied: boolean;
            evidence?: string | undefined;
        }[] | undefined;
    }>, "many">;
}, "strict", z.ZodTypeAny, {
    evals: {
        passed: boolean;
        evalId: string;
        mustRun?: {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        mustNotRun?: {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        mustSucceed?: {
            name: string;
            succeeded: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        sequence?: {
            steps: string[];
            satisfied: boolean;
            evidence?: string | undefined;
        }[] | undefined;
    }[];
}, {
    evals: {
        passed: boolean;
        evalId: string;
        mustRun?: {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        mustNotRun?: {
            name: string;
            ran: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        mustSucceed?: {
            name: string;
            succeeded: boolean;
            evidence?: string | undefined;
        }[] | undefined;
        sequence?: {
            steps: string[];
            satisfied: boolean;
            evidence?: string | undefined;
        }[] | undefined;
    }[];
}>;
export type ToolEvalReport = z.infer<typeof ToolEvalReportSchema>;
export declare const ToolEvalReportJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
    $schema?: string | undefined;
    definitions?: {
        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
    } | undefined;
};
//# sourceMappingURL=tool-eval-schema.d.ts.map