@iris-eval/mcp-server 0.8.1 → 0.9.0

package/dist/eval/response-schema.d.ts

@@ -0,0 +1,652 @@
+import { z } from 'zod';
+export declare const intervalSchema: z.ZodObject<{
+    point: z.ZodNumber;
+    lo: z.ZodNumber;
+    hi: z.ZodNumber;
+}, z.core.$loose>;
+export declare const uncertaintySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    basis: z.ZodLiteral<"published_accuracy">;
+    fired: z.ZodBoolean;
+    ppv: z.ZodOptional<z.ZodObject<{
+        point: z.ZodNumber;
+        lo: z.ZodNumber;
+        hi: z.ZodNumber;
+    }, z.core.$loose>>;
+    missRate: z.ZodOptional<z.ZodObject<{
+        point: z.ZodNumber;
+        lo: z.ZodNumber;
+        hi: z.ZodNumber;
+    }, z.core.$loose>>;
+    prior: z.ZodObject<{
+        pi: z.ZodNumber;
+        source: z.ZodEnum<{
+            default: "default";
+            config: "config";
+            estimated: "estimated";
+        }>;
+    }, z.core.$loose>;
+    corpus: z.ZodObject<{
+        n: z.ZodNumber;
+        tp: z.ZodNumber;
+        fp: z.ZodNumber;
+        fn: z.ZodNumber;
+        tn: z.ZodNumber;
+        version: z.ZodString;
+        release: z.ZodString;
+        labelling: z.ZodEnum<{
+            "same-model": "same-model";
+            "human-verified": "human-verified";
+        }>;
+    }, z.core.$loose>;
+}, z.core.$loose>, z.ZodObject<{
+    basis: z.ZodLiteral<"definition">;
+    conformance: z.ZodObject<{
+        n: z.ZodNumber;
+        matched: z.ZodNumber;
+    }, z.core.$loose>;
+}, z.core.$loose>, z.ZodObject<{
+    basis: z.ZodLiteral<"self_consistency">;
+    samples: z.ZodNumber;
+    voteFraction: z.ZodNumber;
+    scoreSd: z.ZodNumber;
+}, z.core.$loose>, z.ZodObject<{
+    basis: z.ZodLiteral<"local_labels">;
+    precision: z.ZodObject<{
+        point: z.ZodNumber;
+        lo: z.ZodNumber;
+        hi: z.ZodNumber;
+    }, z.core.$loose>;
+    n: z.ZodNumber;
+}, z.core.$loose>, z.ZodObject<{
+    basis: z.ZodLiteral<"policy">;
+}, z.core.$loose>, z.ZodObject<{
+    basis: z.ZodLiteral<"unmeasured">;
+    why: z.ZodString;
+}, z.core.$loose>], "basis">;
+export declare const evidenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"span">;
+    source: z.ZodString;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    label: z.ZodString;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"pattern">;
+    name: z.ZodString;
+    count: z.ZodNumber;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"toolCall">;
+    index: z.ZodNumber;
+    toolName: z.ZodString;
+    label: z.ZodString;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"citation">;
+    url: z.ZodString;
+    status: z.ZodEnum<{
+        resolved: "resolved";
+        dead: "dead";
+        unverifiable: "unverifiable";
+        supported: "supported";
+        unsupported: "unsupported";
+    }>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"count">;
+    stat: z.ZodString;
+    unit: z.ZodString;
+    value: z.ZodNumber;
+    threshold: z.ZodOptional<z.ZodNumber>;
+    thresholdSource: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        config: "config";
+        call: "call";
+        rule: "rule";
+    }>>;
+}, z.core.$loose>], "type">;
+export declare const measuredValueSchema: z.ZodObject<{
+    stat: z.ZodString;
+    unit: z.ZodString;
+    value: z.ZodNumber;
+}, z.core.$loose>;
+export declare const claimKindSchema: z.ZodEnum<{
+    measurement: "measurement";
+    detection: "detection";
+    inference: "inference";
+    judgment: "judgment";
+    policy: "policy";
+    verification: "verification";
+}>;
+export declare const roleSchema: z.ZodEnum<{
+    gate: "gate";
+    veto: "veto";
+    risk: "risk";
+    advisory: "advisory";
+    term: "term";
+}>;
+export declare const skipClassSchema: z.ZodEnum<{
+    not_applicable: "not_applicable";
+    defeated: "defeated";
+    config_invalid: "config_invalid";
+}>;
+export declare const needSchema: z.ZodEnum<{
+    cost: "cost";
+    output: "output";
+    input: "input";
+    expected: "expected";
+    tool_calls: "tool_calls";
+    tool_outputs: "tool_outputs";
+    tools_catalogue: "tools_catalogue";
+    tokens: "tokens";
+    citations: "citations";
+}>;
+export declare const questionIdSchema: z.ZodEnum<{
+    safe_output: "safe_output";
+    grounded: "grounded";
+    complete: "complete";
+    relevant: "relevant";
+    task_completed: "task_completed";
+    tool_use_correct: "tool_use_correct";
+    within_budget: "within_budget";
+}>;
+export declare const evalRuleResultSchema: z.ZodObject<{
+    ruleName: z.ZodString;
+    ruleId: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodEnum<{
+        completeness: "completeness";
+        relevance: "relevance";
+        safety: "safety";
+        cost: "cost";
+        custom: "custom";
+    }>>;
+    critical: z.ZodOptional<z.ZodBoolean>;
+    criticalSource: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        config: "config";
+    }>>;
+    passed: z.ZodBoolean;
+    score: z.ZodNumber;
+    message: z.ZodString;
+    skipped: z.ZodOptional<z.ZodBoolean>;
+    skipReason: z.ZodOptional<z.ZodString>;
+    configInvalid: z.ZodOptional<z.ZodBoolean>;
+    budgetExceeded: z.ZodOptional<z.ZodBoolean>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        measurement: "measurement";
+        detection: "detection";
+        inference: "inference";
+        judgment: "judgment";
+        policy: "policy";
+        verification: "verification";
+    }>>;
+    role: z.ZodOptional<z.ZodEnum<{
+        gate: "gate";
+        veto: "veto";
+        risk: "risk";
+        advisory: "advisory";
+        term: "term";
+    }>>;
+    question: z.ZodOptional<z.ZodEnum<{
+        safe_output: "safe_output";
+        grounded: "grounded";
+        complete: "complete";
+        relevant: "relevant";
+        task_completed: "task_completed";
+        tool_use_correct: "tool_use_correct";
+        within_budget: "within_budget";
+    }>>;
+    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ruleVersion: z.ZodOptional<z.ZodNumber>;
+    saw: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        cost: "cost";
+        output: "output";
+        input: "input";
+        expected: "expected";
+        tool_calls: "tool_calls";
+        tool_outputs: "tool_outputs";
+        tools_catalogue: "tools_catalogue";
+        tokens: "tokens";
+        citations: "citations";
+    }>>>;
+    skipClass: z.ZodOptional<z.ZodEnum<{
+        not_applicable: "not_applicable";
+        defeated: "defeated";
+        config_invalid: "config_invalid";
+    }>>;
+    uncertainty: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        basis: z.ZodLiteral<"published_accuracy">;
+        fired: z.ZodBoolean;
+        ppv: z.ZodOptional<z.ZodObject<{
+            point: z.ZodNumber;
+            lo: z.ZodNumber;
+            hi: z.ZodNumber;
+        }, z.core.$loose>>;
+        missRate: z.ZodOptional<z.ZodObject<{
+            point: z.ZodNumber;
+            lo: z.ZodNumber;
+            hi: z.ZodNumber;
+        }, z.core.$loose>>;
+        prior: z.ZodObject<{
+            pi: z.ZodNumber;
+            source: z.ZodEnum<{
+                default: "default";
+                config: "config";
+                estimated: "estimated";
+            }>;
+        }, z.core.$loose>;
+        corpus: z.ZodObject<{
+            n: z.ZodNumber;
+            tp: z.ZodNumber;
+            fp: z.ZodNumber;
+            fn: z.ZodNumber;
+            tn: z.ZodNumber;
+            version: z.ZodString;
+            release: z.ZodString;
+            labelling: z.ZodEnum<{
+                "same-model": "same-model";
+                "human-verified": "human-verified";
+            }>;
+        }, z.core.$loose>;
+    }, z.core.$loose>, z.ZodObject<{
+        basis: z.ZodLiteral<"definition">;
+        conformance: z.ZodObject<{
+            n: z.ZodNumber;
+            matched: z.ZodNumber;
+        }, z.core.$loose>;
+    }, z.core.$loose>, z.ZodObject<{
+        basis: z.ZodLiteral<"self_consistency">;
+        samples: z.ZodNumber;
+        voteFraction: z.ZodNumber;
+        scoreSd: z.ZodNumber;
+    }, z.core.$loose>, z.ZodObject<{
+        basis: z.ZodLiteral<"local_labels">;
+        precision: z.ZodObject<{
+            point: z.ZodNumber;
+            lo: z.ZodNumber;
+            hi: z.ZodNumber;
+        }, z.core.$loose>;
+        n: z.ZodNumber;
+    }, z.core.$loose>, z.ZodObject<{
+        basis: z.ZodLiteral<"policy">;
+    }, z.core.$loose>, z.ZodObject<{
+        basis: z.ZodLiteral<"unmeasured">;
+        why: z.ZodString;
+    }, z.core.$loose>], "basis">>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"span">;
+        source: z.ZodString;
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+        label: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"pattern">;
+        name: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"toolCall">;
+        index: z.ZodNumber;
+        toolName: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"citation">;
+        url: z.ZodString;
+        status: z.ZodEnum<{
+            resolved: "resolved";
+            dead: "dead";
+            unverifiable: "unverifiable";
+            supported: "supported";
+            unsupported: "unsupported";
+        }>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"count">;
+        stat: z.ZodString;
+        unit: z.ZodString;
+        value: z.ZodNumber;
+        threshold: z.ZodOptional<z.ZodNumber>;
+        thresholdSource: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            config: "config";
+            call: "call";
+            rule: "rule";
+        }>>;
+    }, z.core.$loose>], "type">>>;
+    value: z.ZodOptional<z.ZodObject<{
+        stat: z.ZodString;
+        unit: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const evalCategoryResultSchema: z.ZodObject<{
+    score: z.ZodNullable<z.ZodNumber>;
+    passed: z.ZodNullable<z.ZodBoolean>;
+    rules_evaluated: z.ZodNumber;
+    rules_skipped: z.ZodNumber;
+    insufficient_data: z.ZodBoolean;
+    critical_failures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    critical_skipped: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export declare const coverageSchema: z.ZodObject<{
+    inputs: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            safe_output: "safe_output";
+            grounded: "grounded";
+            complete: "complete";
+            relevant: "relevant";
+            task_completed: "task_completed";
+            tool_use_correct: "tool_use_correct";
+            within_budget: "within_budget";
+        }>;
+        status: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            judged: "judged";
+            unjudged: "unjudged";
+        }>;
+        why: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    dormant: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        name: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare const verdictSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        unknown: "unknown";
+    }>;
+    passed: z.ZodBoolean;
+    basis: z.ZodEnum<{
+        policy_gate: "policy_gate";
+        detector_veto: "detector_veto";
+        critical_unknown: "critical_unknown";
+        required_evidence_missing: "required_evidence_missing";
+        risk_over_loss: "risk_over_loss";
+        score_below_threshold: "score_below_threshold";
+        clean: "clean";
+        no_rules: "no_rules";
+    }>;
+    by: z.ZodArray<z.ZodString>;
+    risk: z.ZodNullable<z.ZodObject<{
+        pBad: z.ZodNumber;
+        lo: z.ZodNumber;
+        hi: z.ZodNumber;
+    }, z.core.$loose>>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        decisive: "decisive";
+        marginal: "marginal";
+    }>>;
+}, z.core.$loose>;
+export declare const provenanceSchema: z.ZodObject<{
+    irisVersion: z.ZodString;
+    rulesetHash: z.ZodString;
+    configHash: z.ZodString;
+    thresholds: z.ZodObject<{
+        default: z.ZodNumber;
+        perRule: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>;
+    corpusVersion: z.ZodString;
+    judgedAt: z.ZodString;
+}, z.core.$loose>;
+/** The `evaluate_output` response — the same object the engine returns plus the tool's own fields. */
+export declare const evaluateOutputResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    trace_id: z.ZodOptional<z.ZodString>;
+    verdict: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            unknown: "unknown";
+        }>;
+        passed: z.ZodBoolean;
+        basis: z.ZodEnum<{
+            policy_gate: "policy_gate";
+            detector_veto: "detector_veto";
+            critical_unknown: "critical_unknown";
+            required_evidence_missing: "required_evidence_missing";
+            risk_over_loss: "risk_over_loss";
+            score_below_threshold: "score_below_threshold";
+            clean: "clean";
+            no_rules: "no_rules";
+        }>;
+        by: z.ZodArray<z.ZodString>;
+        risk: z.ZodNullable<z.ZodObject<{
+            pBad: z.ZodNumber;
+            lo: z.ZodNumber;
+            hi: z.ZodNumber;
+        }, z.core.$loose>>;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            decisive: "decisive";
+            marginal: "marginal";
+        }>>;
+    }, z.core.$loose>>;
+    coverage: z.ZodOptional<z.ZodObject<{
+        inputs: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+        questions: z.ZodArray<z.ZodObject<{
+            id: z.ZodEnum<{
+                safe_output: "safe_output";
+                grounded: "grounded";
+                complete: "complete";
+                relevant: "relevant";
+                task_completed: "task_completed";
+                tool_use_correct: "tool_use_correct";
+                within_budget: "within_budget";
+            }>;
+            status: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                judged: "judged";
+                unjudged: "unjudged";
+            }>;
+            why: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        dormant: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+            name: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        irisVersion: z.ZodString;
+        rulesetHash: z.ZodString;
+        configHash: z.ZodString;
+        thresholds: z.ZodObject<{
+            default: z.ZodNumber;
+            perRule: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>;
+        corpusVersion: z.ZodString;
+        judgedAt: z.ZodString;
+    }, z.core.$loose>>;
+    erased_at: z.ZodOptional<z.ZodString>;
+    eval_type: z.ZodEnum<{
+        completeness: "completeness";
+        relevance: "relevance";
+        safety: "safety";
+        cost: "cost";
+        custom: "custom";
+        all: "all";
+    }>;
+    score: z.ZodNumber;
+    passed: z.ZodBoolean;
+    rule_results: z.ZodArray<z.ZodObject<{
+        ruleName: z.ZodString;
+        ruleId: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodEnum<{
+            completeness: "completeness";
+            relevance: "relevance";
+            safety: "safety";
+            cost: "cost";
+            custom: "custom";
+        }>>;
+        critical: z.ZodOptional<z.ZodBoolean>;
+        criticalSource: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            config: "config";
+        }>>;
+        passed: z.ZodBoolean;
+        score: z.ZodNumber;
+        message: z.ZodString;
+        skipped: z.ZodOptional<z.ZodBoolean>;
+        skipReason: z.ZodOptional<z.ZodString>;
+        configInvalid: z.ZodOptional<z.ZodBoolean>;
+        budgetExceeded: z.ZodOptional<z.ZodBoolean>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            measurement: "measurement";
+            detection: "detection";
+            inference: "inference";
+            judgment: "judgment";
+            policy: "policy";
+            verification: "verification";
+        }>>;
+        role: z.ZodOptional<z.ZodEnum<{
+            gate: "gate";
+            veto: "veto";
+            risk: "risk";
+            advisory: "advisory";
+            term: "term";
+        }>>;
+        question: z.ZodOptional<z.ZodEnum<{
+            safe_output: "safe_output";
+            grounded: "grounded";
+            complete: "complete";
+            relevant: "relevant";
+            task_completed: "task_completed";
+            tool_use_correct: "tool_use_correct";
+            within_budget: "within_budget";
+        }>>;
+        classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        ruleVersion: z.ZodOptional<z.ZodNumber>;
+        saw: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            cost: "cost";
+            output: "output";
+            input: "input";
+            expected: "expected";
+            tool_calls: "tool_calls";
+            tool_outputs: "tool_outputs";
+            tools_catalogue: "tools_catalogue";
+            tokens: "tokens";
+            citations: "citations";
+        }>>>;
+        skipClass: z.ZodOptional<z.ZodEnum<{
+            not_applicable: "not_applicable";
+            defeated: "defeated";
+            config_invalid: "config_invalid";
+        }>>;
+        uncertainty: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            basis: z.ZodLiteral<"published_accuracy">;
+            fired: z.ZodBoolean;
+            ppv: z.ZodOptional<z.ZodObject<{
+                point: z.ZodNumber;
+                lo: z.ZodNumber;
+                hi: z.ZodNumber;
+            }, z.core.$loose>>;
+            missRate: z.ZodOptional<z.ZodObject<{
+                point: z.ZodNumber;
+                lo: z.ZodNumber;
+                hi: z.ZodNumber;
+            }, z.core.$loose>>;
+            prior: z.ZodObject<{
+                pi: z.ZodNumber;
+                source: z.ZodEnum<{
+                    default: "default";
+                    config: "config";
+                    estimated: "estimated";
+                }>;
+            }, z.core.$loose>;
+            corpus: z.ZodObject<{
+                n: z.ZodNumber;
+                tp: z.ZodNumber;
+                fp: z.ZodNumber;
+                fn: z.ZodNumber;
+                tn: z.ZodNumber;
+                version: z.ZodString;
+                release: z.ZodString;
+                labelling: z.ZodEnum<{
+                    "same-model": "same-model";
+                    "human-verified": "human-verified";
+                }>;
+            }, z.core.$loose>;
+        }, z.core.$loose>, z.ZodObject<{
+            basis: z.ZodLiteral<"definition">;
+            conformance: z.ZodObject<{
+                n: z.ZodNumber;
+                matched: z.ZodNumber;
+            }, z.core.$loose>;
+        }, z.core.$loose>, z.ZodObject<{
+            basis: z.ZodLiteral<"self_consistency">;
+            samples: z.ZodNumber;
+            voteFraction: z.ZodNumber;
+            scoreSd: z.ZodNumber;
+        }, z.core.$loose>, z.ZodObject<{
+            basis: z.ZodLiteral<"local_labels">;
+            precision: z.ZodObject<{
+                point: z.ZodNumber;
+                lo: z.ZodNumber;
+                hi: z.ZodNumber;
+            }, z.core.$loose>;
+            n: z.ZodNumber;
+        }, z.core.$loose>, z.ZodObject<{
+            basis: z.ZodLiteral<"policy">;
+        }, z.core.$loose>, z.ZodObject<{
+            basis: z.ZodLiteral<"unmeasured">;
+            why: z.ZodString;
+        }, z.core.$loose>], "basis">>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"span">;
+            source: z.ZodString;
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+            label: z.ZodString;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"pattern">;
+            name: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"toolCall">;
+            index: z.ZodNumber;
+            toolName: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"citation">;
+            url: z.ZodString;
+            status: z.ZodEnum<{
+                resolved: "resolved";
+                dead: "dead";
+                unverifiable: "unverifiable";
+                supported: "supported";
+                unsupported: "unsupported";
+            }>;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"count">;
+            stat: z.ZodString;
+            unit: z.ZodString;
+            value: z.ZodNumber;
+            threshold: z.ZodOptional<z.ZodNumber>;
+            thresholdSource: z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                config: "config";
+                call: "call";
+                rule: "rule";
+            }>>;
+        }, z.core.$loose>], "type">>>;
+        value: z.ZodOptional<z.ZodObject<{
+            stat: z.ZodString;
+            unit: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    suggestions: z.ZodArray<z.ZodString>;
+    rules_evaluated: z.ZodNumber;
+    rules_skipped: z.ZodNumber;
+    insufficient_data: z.ZodBoolean;
+    critical_failures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    critical_skipped: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        score: z.ZodNullable<z.ZodNumber>;
+        passed: z.ZodNullable<z.ZodBoolean>;
+        rules_evaluated: z.ZodNumber;
+        rules_skipped: z.ZodNumber;
+        insufficient_data: z.ZodBoolean;
+        critical_failures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        critical_skipped: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type EvaluateOutputResponse = z.infer<typeof evaluateOutputResponseSchema>;