ppef 1.2.0 → 1.3.0

package/dist/cli/evaluator-schemas.d.ts

@@ -0,0 +1,395 @@
+/**
+ * Evaluator Configuration Zod Schemas
+ *
+ * Runtime-validated schemas for all evaluator config types.
+ * Existing interfaces in types/evaluator.ts remain for class implementations;
+ * these schemas are used by the CLI for config validation and JSON schema generation.
+ */
+import { z } from "zod";
+/**
+ * Built-in evaluation types.
+ */
+export declare const EvaluationTypeSchema: z.ZodEnum<{
+    metrics: "metrics";
+    claims: "claims";
+    robustness: "robustness";
+    exploratory: "exploratory";
+    custom: "custom";
+}>;
+export type EvaluationTypeSchema = z.infer<typeof EvaluationTypeSchema>;
+/**
+ * Direction of comparison for claims.
+ */
+export declare const ComparisonDirectionSchema: z.ZodEnum<{
+    greater: "greater";
+    less: "less";
+    equal: "equal";
+}>;
+export type ComparisonDirectionSchema = z.infer<typeof ComparisonDirectionSchema>;
+/**
+ * Scope of claim validity.
+ */
+export declare const ValidityScopeSchema: z.ZodEnum<{
+    global: "global";
+    caseClass: "caseClass";
+    parameterRange: "parameterRange";
+    localStructure: "localStructure";
+}>;
+export type ValidityScopeSchema = z.infer<typeof ValidityScopeSchema>;
+/**
+ * Metric direction for ranking interpretation.
+ */
+export declare const MetricDirectionSchema: z.ZodEnum<{
+    "higher-better": "higher-better";
+    "lower-better": "lower-better";
+}>;
+export type MetricDirectionSchema = z.infer<typeof MetricDirectionSchema>;
+/**
+ * Criterion type for metrics evaluation.
+ */
+export declare const MetricsCriterionTypeSchema: z.ZodEnum<{
+    baseline: "baseline";
+    threshold: "threshold";
+    "target-range": "target-range";
+}>;
+export type MetricsCriterionTypeSchema = z.infer<typeof MetricsCriterionTypeSchema>;
+/**
+ * Threshold comparison operator.
+ */
+export declare const ThresholdOperatorSchema: z.ZodEnum<{
+    gt: "gt";
+    gte: "gte";
+    lt: "lt";
+    lte: "lte";
+    eq: "eq";
+}>;
+export type ThresholdOperatorSchema = z.infer<typeof ThresholdOperatorSchema>;
+/**
+ * Base configuration shared by all evaluators.
+ */
+export declare const EvaluatorConfigBase: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * A single evaluation claim (hypothesis).
+ */
+export declare const EvaluationClaimSchema: z.ZodObject<{
+    claimId: z.ZodString;
+    description: z.ZodString;
+    sut: z.ZodString;
+    baseline: z.ZodString;
+    metric: z.ZodString;
+    direction: z.ZodEnum<{
+        greater: "greater";
+        less: "less";
+        equal: "equal";
+    }>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+    scope: z.ZodEnum<{
+        global: "global";
+        caseClass: "caseClass";
+        parameterRange: "parameterRange";
+        localStructure: "localStructure";
+    }>;
+    scopeConstraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+    significanceLevel: z.ZodOptional<z.ZodNumber>;
+    minEffectSize: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    citation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EvaluationClaimSchema = z.infer<typeof EvaluationClaimSchema>;
+/**
+ * Claims evaluator configuration.
+ */
+export declare const ClaimsEvaluatorConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    claims: z.ZodArray<z.ZodObject<{
+        claimId: z.ZodString;
+        description: z.ZodString;
+        sut: z.ZodString;
+        baseline: z.ZodString;
+        metric: z.ZodString;
+        direction: z.ZodEnum<{
+            greater: "greater";
+            less: "less";
+            equal: "equal";
+        }>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+        scope: z.ZodEnum<{
+            global: "global";
+            caseClass: "caseClass";
+            parameterRange: "parameterRange";
+            localStructure: "localStructure";
+        }>;
+        scopeConstraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+        significanceLevel: z.ZodOptional<z.ZodNumber>;
+        minEffectSize: z.ZodOptional<z.ZodNumber>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        citation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    significanceLevel: z.ZodOptional<z.ZodNumber>;
+    minEffectSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ClaimsEvaluatorConfigSchema = z.infer<typeof ClaimsEvaluatorConfigSchema>;
+/**
+ * A single metrics evaluation criterion.
+ *
+ * Uses superRefine to enforce that the correct sub-fields are present
+ * for each criterion type (threshold requires threshold field, etc.).
+ */
+export declare const MetricsCriterionSchema: z.ZodObject<{
+    criterionId: z.ZodString;
+    description: z.ZodString;
+    type: z.ZodEnum<{
+        baseline: "baseline";
+        threshold: "threshold";
+        "target-range": "target-range";
+    }>;
+    metric: z.ZodString;
+    sut: z.ZodString;
+    threshold: z.ZodOptional<z.ZodObject<{
+        operator: z.ZodEnum<{
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            eq: "eq";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>>;
+    baseline: z.ZodOptional<z.ZodObject<{
+        sut: z.ZodString;
+        operator: z.ZodEnum<{
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            eq: "eq";
+        }>;
+    }, z.core.$strip>>;
+    targetRange: z.ZodOptional<z.ZodObject<{
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        minInclusive: z.ZodOptional<z.ZodBoolean>;
+        maxInclusive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    scopeConstraints: z.ZodOptional<z.ZodObject<{
+        caseClass: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type MetricsCriterionSchema = z.infer<typeof MetricsCriterionSchema>;
+/**
+ * Metrics evaluator configuration.
+ */
+export declare const MetricsEvaluatorConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    criteria: z.ZodArray<z.ZodObject<{
+        criterionId: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<{
+            baseline: "baseline";
+            threshold: "threshold";
+            "target-range": "target-range";
+        }>;
+        metric: z.ZodString;
+        sut: z.ZodString;
+        threshold: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                gt: "gt";
+                gte: "gte";
+                lt: "lt";
+                lte: "lte";
+                eq: "eq";
+            }>;
+            value: z.ZodNumber;
+        }, z.core.$strip>>;
+        baseline: z.ZodOptional<z.ZodObject<{
+            sut: z.ZodString;
+            operator: z.ZodEnum<{
+                gt: "gt";
+                gte: "gte";
+                lt: "lt";
+                lte: "lte";
+                eq: "eq";
+            }>;
+        }, z.core.$strip>>;
+        targetRange: z.ZodOptional<z.ZodObject<{
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            minInclusive: z.ZodOptional<z.ZodBoolean>;
+            maxInclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        scopeConstraints: z.ZodOptional<z.ZodObject<{
+            caseClass: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MetricsEvaluatorConfigSchema = z.infer<typeof MetricsEvaluatorConfigSchema>;
+/**
+ * Robustness evaluator configuration.
+ */
+export declare const RobustnessEvaluatorConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metrics: z.ZodArray<z.ZodString>;
+    perturbations: z.ZodArray<z.ZodString>;
+    intensityLevels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    runsPerLevel: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RobustnessEvaluatorConfigSchema = z.infer<typeof RobustnessEvaluatorConfigSchema>;
+/**
+ * Exploratory evaluator configuration.
+ */
+export declare const ExploratoryEvaluatorConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    suts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metricDirections: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        "higher-better": "higher-better";
+        "lower-better": "lower-better";
+    }>>>;
+    significanceLevel: z.ZodOptional<z.ZodNumber>;
+    minEffectSize: z.ZodOptional<z.ZodNumber>;
+    computeCorrelations: z.ZodOptional<z.ZodBoolean>;
+    analyzeCaseClassEffects: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ExploratoryEvaluatorConfigSchema = z.infer<typeof ExploratoryEvaluatorConfigSchema>;
+/**
+ * Custom evaluator configuration.
+ * Uses catchall to allow arbitrary additional properties.
+ */
+export declare const CustomEvaluatorConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    customType: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type CustomEvaluatorConfigSchema = z.infer<typeof CustomEvaluatorConfigSchema>;
+/**
+ * A single evaluator entry combining type discriminant with config.
+ */
+export declare const EvaluatorEntrySchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        metrics: "metrics";
+        claims: "claims";
+        robustness: "robustness";
+        exploratory: "exploratory";
+        custom: "custom";
+    }>;
+    config: z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        claims: z.ZodArray<z.ZodObject<{
+            claimId: z.ZodString;
+            description: z.ZodString;
+            sut: z.ZodString;
+            baseline: z.ZodString;
+            metric: z.ZodString;
+            direction: z.ZodEnum<{
+                greater: "greater";
+                less: "less";
+                equal: "equal";
+            }>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+            scope: z.ZodEnum<{
+                global: "global";
+                caseClass: "caseClass";
+                parameterRange: "parameterRange";
+                localStructure: "localStructure";
+            }>;
+            scopeConstraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+            significanceLevel: z.ZodOptional<z.ZodNumber>;
+            minEffectSize: z.ZodOptional<z.ZodNumber>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            citation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        significanceLevel: z.ZodOptional<z.ZodNumber>;
+        minEffectSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        criteria: z.ZodArray<z.ZodObject<{
+            criterionId: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodEnum<{
+                baseline: "baseline";
+                threshold: "threshold";
+                "target-range": "target-range";
+            }>;
+            metric: z.ZodString;
+            sut: z.ZodString;
+            threshold: z.ZodOptional<z.ZodObject<{
+                operator: z.ZodEnum<{
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    eq: "eq";
+                }>;
+                value: z.ZodNumber;
+            }, z.core.$strip>>;
+            baseline: z.ZodOptional<z.ZodObject<{
+                sut: z.ZodString;
+                operator: z.ZodEnum<{
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    eq: "eq";
+                }>;
+            }, z.core.$strip>>;
+            targetRange: z.ZodOptional<z.ZodObject<{
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                minInclusive: z.ZodOptional<z.ZodBoolean>;
+                maxInclusive: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            scopeConstraints: z.ZodOptional<z.ZodObject<{
+                caseClass: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        metrics: z.ZodArray<z.ZodString>;
+        perturbations: z.ZodArray<z.ZodString>;
+        intensityLevels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        runsPerLevel: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        metrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        suts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        metricDirections: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            "higher-better": "higher-better";
+            "lower-better": "lower-better";
+        }>>>;
+        significanceLevel: z.ZodOptional<z.ZodNumber>;
+        minEffectSize: z.ZodOptional<z.ZodNumber>;
+        computeCorrelations: z.ZodOptional<z.ZodBoolean>;
+        analyzeCaseClassEffects: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        customType: z.ZodString;
+    }, z.core.$catchall<z.ZodUnknown>>]>;
+}, z.core.$strip>;
+export type EvaluatorEntrySchema = z.infer<typeof EvaluatorEntrySchema>;
+//# sourceMappingURL=evaluator-schemas.d.ts.map

package/dist/cli/evaluator-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator-schemas.d.ts","sourceRoot":"","sources":["../../src/cli/evaluator-schemas.ts"],"names":[],"mappings":"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"}

package/dist/cli/evaluator-schemas.js

@@ -0,0 +1,285 @@
+/**
+ * Evaluator Configuration Zod Schemas
+ *
+ * Runtime-validated schemas for all evaluator config types.
+ * Existing interfaces in types/evaluator.ts remain for class implementations;
+ * these schemas are used by the CLI for config validation and JSON schema generation.
+ */
+import { z } from "zod";
+// ============================================================================
+// Shared Enums
+// ============================================================================
+/**
+ * Built-in evaluation types.
+ */
+export const EvaluationTypeSchema = z
+    .enum(["claims", "robustness", "metrics", "exploratory", "custom"])
+    .describe("Evaluation type");
+/**
+ * Direction of comparison for claims.
+ */
+export const ComparisonDirectionSchema = z
+    .enum(["greater", "less", "equal"])
+    .describe("Expected direction of difference");
+/**
+ * Scope of claim validity.
+ */
+export const ValidityScopeSchema = z
+    .enum(["global", "caseClass", "parameterRange", "localStructure"])
+    .describe("Scope of claim validity");
+/**
+ * Metric direction for ranking interpretation.
+ */
+export const MetricDirectionSchema = z
+    .enum(["higher-better", "lower-better"])
+    .describe("Metric direction for ranking");
+/**
+ * Criterion type for metrics evaluation.
+ */
+export const MetricsCriterionTypeSchema = z
+    .enum(["threshold", "baseline", "target-range"])
+    .describe("Type of metrics criterion");
+/**
+ * Threshold comparison operator.
+ */
+export const ThresholdOperatorSchema = z
+    .enum(["gt", "gte", "lt", "lte", "eq"])
+    .describe("Comparison operator");
+// ============================================================================
+// Base Config
+// ============================================================================
+/**
+ * Base configuration shared by all evaluators.
+ */
+export const EvaluatorConfigBase = z.object({
+    name: z.string().optional().describe("Human-readable evaluator name"),
+    description: z.string().optional().describe("Evaluator description"),
+    options: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("Additional evaluator-specific options"),
+});
+// ============================================================================
+// Claims Evaluator
+// ============================================================================
+/**
+ * Primitive value type for scope constraints.
+ */
+const PrimitiveSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+/**
+ * A single evaluation claim (hypothesis).
+ */
+export const EvaluationClaimSchema = z
+    .object({
+    claimId: z.string().min(1).describe("Unique claim identifier"),
+    description: z.string().min(1).describe("Human-readable claim description"),
+    sut: z.string().min(1).describe("Primary SUT being evaluated"),
+    baseline: z.string().min(1).describe("Baseline SUT for comparison"),
+    metric: z.string().min(1).describe("Metric being compared"),
+    direction: ComparisonDirectionSchema,
+    threshold: z.number().optional().describe("Optional threshold for the difference"),
+    scope: ValidityScopeSchema,
+    scopeConstraints: z
+        .record(z.string(), z.union([PrimitiveSchema, z.array(PrimitiveSchema)]))
+        .optional()
+        .describe("Scope constraints"),
+    significanceLevel: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("Required significance level (default: 0.05)"),
+    minEffectSize: z.number().min(0).optional().describe("Minimum effect size (Cohen's d)"),
+    tags: z.array(z.string()).optional().describe("Tags for filtering"),
+    citation: z.string().optional().describe("Citation/reference for the claim"),
+})
+    .meta({ title: "EvaluationClaim", description: "An evaluation claim (hypothesis)" });
+/**
+ * Claims evaluator configuration.
+ */
+export const ClaimsEvaluatorConfigSchema = EvaluatorConfigBase.extend({
+    claims: z.array(EvaluationClaimSchema).min(1).describe("Claims to evaluate"),
+    significanceLevel: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("Global significance level override"),
+    minEffectSize: z.number().min(0).optional().describe("Global minimum effect size override"),
+}).meta({
+    title: "ClaimsEvaluatorConfig",
+    description: "Configuration for the claims evaluator",
+});
+// ============================================================================
+// Metrics Evaluator
+// ============================================================================
+/**
+ * A single metrics evaluation criterion.
+ *
+ * Uses superRefine to enforce that the correct sub-fields are present
+ * for each criterion type (threshold requires threshold field, etc.).
+ */
+export const MetricsCriterionSchema = z
+    .object({
+    criterionId: z.string().min(1).describe("Unique criterion identifier"),
+    description: z.string().min(1).describe("Human-readable description"),
+    type: MetricsCriterionTypeSchema,
+    metric: z.string().min(1).describe("Metric to evaluate"),
+    sut: z.string().min(1).describe('SUT to evaluate (or "*" for all SUTs)'),
+    threshold: z
+        .object({
+        operator: ThresholdOperatorSchema,
+        value: z.number().describe("Threshold value"),
+    })
+        .optional()
+        .describe("Threshold operator and value (required when type is threshold)"),
+    baseline: z
+        .object({
+        sut: z.string().min(1).describe("Baseline SUT identifier"),
+        operator: ThresholdOperatorSchema,
+    })
+        .optional()
+        .describe("Baseline comparison (required when type is baseline)"),
+    targetRange: z
+        .object({
+        min: z.number().optional().describe("Minimum value"),
+        max: z.number().optional().describe("Maximum value"),
+        minInclusive: z.boolean().optional().describe("Whether min is inclusive"),
+        maxInclusive: z.boolean().optional().describe("Whether max is inclusive"),
+    })
+        .optional()
+        .describe("Target range (required when type is target-range)"),
+    scopeConstraints: z
+        .object({
+        caseClass: z
+            .union([z.string(), z.array(z.string())])
+            .optional()
+            .describe("Case class filter"),
+    })
+        .optional()
+        .describe("Optional scope constraints"),
+    tags: z.array(z.string()).optional().describe("Tags for filtering"),
+})
+    .superRefine((data, ctx) => {
+    if (data.type === "threshold" && !data.threshold) {
+        ctx.addIssue({
+            code: "custom",
+            message: 'Criterion type "threshold" requires the "threshold" field',
+            path: ["threshold"],
+        });
+    }
+    if (data.type === "baseline" && !data.baseline) {
+        ctx.addIssue({
+            code: "custom",
+            message: 'Criterion type "baseline" requires the "baseline" field',
+            path: ["baseline"],
+        });
+    }
+    if (data.type === "target-range" && !data.targetRange) {
+        ctx.addIssue({
+            code: "custom",
+            message: 'Criterion type "target-range" requires the "targetRange" field',
+            path: ["targetRange"],
+        });
+    }
+})
+    .meta({ title: "MetricsCriterion", description: "A metrics evaluation criterion" });
+/**
+ * Metrics evaluator configuration.
+ */
+export const MetricsEvaluatorConfigSchema = EvaluatorConfigBase.extend({
+    criteria: z.array(MetricsCriterionSchema).min(1).describe("Criteria to evaluate"),
+}).meta({
+    title: "MetricsEvaluatorConfig",
+    description: "Configuration for the metrics evaluator",
+});
+// ============================================================================
+// Robustness Evaluator
+// ============================================================================
+/**
+ * Robustness evaluator configuration.
+ */
+export const RobustnessEvaluatorConfigSchema = EvaluatorConfigBase.extend({
+    metrics: z.array(z.string().min(1)).min(1).describe("Metrics to analyze"),
+    perturbations: z.array(z.string().min(1)).min(1).describe("Perturbations applied"),
+    intensityLevels: z.array(z.number()).optional().describe("Intensity levels tested"),
+    runsPerLevel: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Number of runs per perturbation level"),
+}).meta({
+    title: "RobustnessEvaluatorConfig",
+    description: "Configuration for the robustness evaluator",
+});
+// ============================================================================
+// Exploratory Evaluator
+// ============================================================================
+/**
+ * Exploratory evaluator configuration.
+ */
+export const ExploratoryEvaluatorConfigSchema = EvaluatorConfigBase.extend({
+    metrics: z
+        .array(z.string().min(1))
+        .optional()
+        .describe("Metrics to analyze (all if not specified)"),
+    suts: z.array(z.string().min(1)).optional().describe("SUTs to include (all if not specified)"),
+    metricDirections: z
+        .record(z.string(), MetricDirectionSchema)
+        .optional()
+        .describe("Metric directions for ranking interpretation"),
+    significanceLevel: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("Significance level for statistical tests (default: 0.05)"),
+    minEffectSize: z
+        .number()
+        .min(0)
+        .optional()
+        .describe("Minimum effect size to consider meaningful"),
+    computeCorrelations: z.boolean().optional().describe("Whether to compute metric correlations"),
+    analyzeCaseClassEffects: z.boolean().optional().describe("Whether to analyze case-class effects"),
+}).meta({
+    title: "ExploratoryEvaluatorConfig",
+    description: "Configuration for the exploratory evaluator",
+});
+// ============================================================================
+// Custom Evaluator
+// ============================================================================
+/**
+ * Custom evaluator configuration.
+ * Uses catchall to allow arbitrary additional properties.
+ */
+export const CustomEvaluatorConfigSchema = EvaluatorConfigBase.extend({
+    customType: z.string().min(1).describe("Custom evaluator type name"),
+})
+    .catchall(z.unknown())
+    .meta({
+    title: "CustomEvaluatorConfig",
+    description: "Configuration for a custom evaluator",
+});
+// ============================================================================
+// Evaluator Entry (for ExperimentConfig.evaluators array)
+// ============================================================================
+/**
+ * A single evaluator entry combining type discriminant with config.
+ */
+export const EvaluatorEntrySchema = z
+    .object({
+    type: EvaluationTypeSchema,
+    config: z.union([
+        ClaimsEvaluatorConfigSchema,
+        MetricsEvaluatorConfigSchema,
+        RobustnessEvaluatorConfigSchema,
+        ExploratoryEvaluatorConfigSchema,
+        CustomEvaluatorConfigSchema,
+    ]),
+})
+    .meta({
+    title: "EvaluatorEntry",
+    description: "An evaluator configuration entry",
+});
+//# sourceMappingURL=evaluator-schemas.js.map