@sanity/ailf 0.1.0

package/dist/_vendor/ailf-core/schemas/pipeline.js

@@ -0,0 +1,318 @@
+/**
+ * @sanity/ailf-core — Pipeline schemas
+ *
+ * Zod schemas for runtime validation of task YAML files and related configs.
+ * These schemas are the single source of truth for what constitutes a valid
+ * task definition — the TypeScript interfaces in types.ts are derived from
+ * (or should match) these schemas.
+ *
+ * Extracted from packages/eval/src/pipeline/schemas.ts (Phase 0d).
+ */
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Rubric template schemas — validates config/rubrics.yaml
+// ---------------------------------------------------------------------------
+/**
+ * Schema for a single rubric template (e.g., task-completion, code-correctness).
+ *
+ * The optional `dimension` field tags which scoring dimension this template
+ * belongs to. When present, it propagates into assertion metadata so the
+ * scoring engine can classify rubrics structurally instead of heuristically.
+ * See docs/design-docs/structured-dimensions.md.
+ */
+export const RubricTemplateSchema = z.object({
+    criteria_label: z
+        .string()
+        .min(1, "criteria_label must be a non-empty string")
+        .nullish(),
+    dimension: z.string().min(1).optional(),
+    header: z.string().min(1, "header must be a non-empty string"),
+    scale: z
+        .array(z.string().min(1))
+        .min(1, "scale must have at least one entry"),
+});
+/**
+ * Schema for the full config/rubrics.yaml config file.
+ *
+ * Each dimension is scored on a uniform 0–100 scale. The `weights` section
+ * defines how dimensions are combined into a composite score (must sum to 1.0).
+ */
+export const RubricConfigSchema = z.object({
+    footer: z.string().min(1, "footer must be a non-empty string"),
+    templates: z
+        .record(z.string(), RubricTemplateSchema)
+        .refine((t) => Object.keys(t).length > 0, {
+        message: "templates must have at least one entry",
+    }),
+    weights: z.record(z.string(), z.number().min(0).max(1)).refine((w) => {
+        const sum = Object.values(w).reduce((s, v) => s + v, 0);
+        return Math.abs(sum - 1.0) < 0.001;
+    }, { message: "weights must sum to 1.0" }),
+});
+// ---------------------------------------------------------------------------
+// Feature registry schema — validates config/features.yaml (Phase 3c)
+// ---------------------------------------------------------------------------
+/**
+ * Schema for a single product feature in the feature registry.
+ */
+export const FeatureSchema = z.object({
+    area: z.string().min(1).optional(),
+    id: z
+        .string()
+        .min(1)
+        .regex(/^[a-z0-9][a-z0-9-]*$/, "id must be lowercase alphanumeric with hyphens"),
+    name: z.string().min(1),
+    priority: z.enum(["critical", "high", "medium", "low"]),
+    sections: z.array(z.string().min(1)).min(1),
+    status: z.enum(["covered", "uncovered", "planned", "out-of-scope"]),
+    taskCount: z.number().int().min(0).optional(),
+});
+/**
+ * Schema for the full config/features.yaml config file.
+ */
+export const FeatureRegistrySchema = z.object({
+    features: z.array(FeatureSchema).min(1),
+});
+// ---------------------------------------------------------------------------
+// Assertion schemas — one per Promptfoo assertion type
+// ---------------------------------------------------------------------------
+/**
+ * Templated llm-rubric assertion — references a rubric template by key
+ * and provides task-specific criteria.
+ */
+const TemplatedLlmRubricAssertSchema = z.object({
+    criteria: z
+        .array(z.string().min(1))
+        .min(1, "criteria must have at least one entry"),
+    template: z.string().min(1, "template must be a non-empty string"),
+    type: z.literal("llm-rubric"),
+    weight: z.number().optional(),
+});
+const ContainsAssertSchema = z.object({
+    type: z.literal("contains"),
+    value: z.string().min(1, "contains must have a non-empty value"),
+    weight: z.number().optional(),
+});
+const ContainsAnyAssertSchema = z.object({
+    type: z.literal("contains-any"),
+    value: z
+        .array(z.string().min(1))
+        .min(1, "contains-any must have at least one value"),
+    weight: z.number().optional(),
+});
+const NotContainsAssertSchema = z.object({
+    type: z.literal("not-contains"),
+    value: z.string().min(1, "not-contains must have a non-empty value"),
+    weight: z.number().optional(),
+});
+const JavascriptAssertSchema = z.object({
+    type: z.literal("javascript"),
+    value: z.string().min(1, "javascript must have a non-empty value"),
+    weight: z.number().optional(),
+});
+/**
+ * Union of all supported Promptfoo assertion types.
+ *
+ * llm-rubric assertions use the templated format (template + criteria).
+ * Other assertion types use their standard value-based format.
+ *
+ * Note: we use z.union instead of z.discriminatedUnion because multiple
+ * schemas share the "llm-rubric" type literal (the old value-based format
+ * is gone, but union is more flexible for future additions).
+ */
+export const AssertionSchema = z.union([
+    TemplatedLlmRubricAssertSchema,
+    ContainsAssertSchema,
+    ContainsAnyAssertSchema,
+    NotContainsAssertSchema,
+    JavascriptAssertSchema,
+]);
+// ---------------------------------------------------------------------------
+// Task variable schemas
+// ---------------------------------------------------------------------------
+const TaskVarsSchema = z
+    .object({
+    docs: z.string({
+        message: "vars.docs must be a string (use empty string for baseline)",
+    }),
+    task: z.string().min(1, "vars.task must be a non-empty string"),
+})
+    .passthrough();
+// ---------------------------------------------------------------------------
+// Canonical doc mapping schema (inline in task files)
+// ---------------------------------------------------------------------------
+/**
+ * Polymorphic canonical doc reference — discriminated by key presence.
+ *
+ * Exactly one resolution key must be present: slug, path, id, or perspective.
+ * All carry an optional reason. The union uses Zod discriminatedUnion-like
+ * semantics but keyed on field presence rather than a literal discriminator.
+ *
+ * @see docs/design-docs/canonical-doc-resolution.md
+ */
+const SlugDocRefSchema = z.object({
+    reason: z.string().optional().default(""),
+    slug: z.string().min(1, "slug must be a non-empty string"),
+});
+const PathDocRefSchema = z.object({
+    path: z.string().min(1, "path must be a non-empty string"),
+    reason: z.string().optional().default(""),
+});
+const IdDocRefSchema = z.object({
+    id: z.string().min(1, "id must be a non-empty string"),
+    reason: z.string().optional().default(""),
+});
+const PerspectiveDocRefSchema = z.object({
+    perspective: z.string().min(1, "perspective must be a non-empty string"),
+    reason: z.string().optional().default(""),
+});
+const CanonicalDocSchema = z.union([
+    SlugDocRefSchema,
+    PathDocRefSchema,
+    IdDocRefSchema,
+    PerspectiveDocRefSchema,
+]);
+// ---------------------------------------------------------------------------
+// Baseline options schema
+// ---------------------------------------------------------------------------
+const BaselineOptionsSchema = z.object({
+    enabled: z.boolean().optional(),
+    rubric: z.enum(["abbreviated", "full", "none"]).optional(),
+});
+// ---------------------------------------------------------------------------
+// Task entry schemas — new (single-definition) and legacy formats
+// ---------------------------------------------------------------------------
+/**
+ * Schema for the new single-definition task format.
+ * Each task is defined once with an id field; the pipeline auto-generates
+ * gold + baseline variants.
+ */
+export const SingleTaskSchema = z.object({
+    assert: z
+        .array(AssertionSchema)
+        .min(1, "assert must have at least one entry"),
+    baseline: BaselineOptionsSchema.optional(),
+    /** Canonical docs — which documentation articles are gold-standard for this task. */
+    canonical_docs: z
+        .array(CanonicalDocSchema)
+        .min(1, "canonical_docs must have at least one entry"),
+    description: z.string().min(1, "description must be a non-empty string"),
+    /** Opt-in: auto-generate a documentation coverage rubric for the gold variant. */
+    doc_coverage: z.boolean().optional(),
+    id: z
+        .string()
+        .min(1, "id must be a non-empty string")
+        .regex(/^[a-z0-9][a-z0-9-]*$/, "id must be lowercase alphanumeric with hyphens (e.g., 'groq-blog-queries')"),
+    /** Path to the reference solution file, relative to canonical/. */
+    reference_solution: z
+        .string()
+        .min(1, "reference_solution must be a non-empty path"),
+    vars: TaskVarsSchema,
+});
+/**
+ * Schema for legacy task entries (the old paired gold/baseline format).
+ * These have description and vars but no id field.
+ */
+export const LegacyTaskSchema = z.object({
+    assert: z.array(AssertionSchema).optional(),
+    description: z.string().min(1, "description must be a non-empty string"),
+    transform: z.string().optional(),
+    vars: z
+        .object({
+        task: z.string().min(1, "vars.task must be a non-empty string"),
+    })
+        .passthrough(),
+});
+// ---------------------------------------------------------------------------
+// Task entry — union of both formats
+// ---------------------------------------------------------------------------
+/**
+ * A single task entry that can be either format.
+ * Entries with an id field are validated as SingleTask;
+ * entries without are validated as LegacyTask.
+ */
+export const TaskEntrySchema = z.union([SingleTaskSchema, LegacyTaskSchema]);
+// ---------------------------------------------------------------------------
+// Task file schema — the top-level array
+// ---------------------------------------------------------------------------
+/**
+ * Schema for an entire task YAML file: an array of task entries.
+ */
+export const TaskFileSchema = z
+    .array(TaskEntrySchema)
+    .min(1, "Task file must contain at least one task entry");
+// ---------------------------------------------------------------------------
+// Threshold config schemas — validates config/thresholds.yaml (Phase 5a)
+// ---------------------------------------------------------------------------
+/**
+ * Schema for per-dimension threshold values.
+ * Keys use kebab-case to match YAML convention; the threshold engine
+ * normalizes to camelCase for comparison against FeatureScore fields.
+ */
+export const ThresholdDimensionsSchema = z.object({
+    "code-correctness": z.number().min(0).max(100).optional(),
+    "doc-coverage": z.number().min(0).max(100).optional(),
+    "task-completion": z.number().min(0).max(100).optional(),
+});
+/**
+ * Schema for threshold defaults (and per-area overrides).
+ * All fields are optional in per-area overrides; defaults must have composite.
+ */
+export const ThresholdDefaultsSchema = z.object({
+    ceiling: z.number().min(0).max(100).optional(),
+    composite: z.number().min(0).max(100),
+    dimensions: ThresholdDimensionsSchema.optional(),
+    "doc-lift": z.number().optional(),
+});
+/**
+ * Schema for regression thresholds (all values should be negative or zero).
+ */
+export const RegressionThresholdsSchema = z.object({
+    composite: z.number().max(0),
+    "per-area": z.number().max(0),
+    "per-dimension": z.number().max(0),
+});
+/**
+ * Schema for severity classification rules.
+ */
+export const SeverityConfigSchema = z.object({
+    critical: z
+        .object({
+        "composite-below": z.number().min(0).max(100).optional(),
+        "negative-doc-lift": z.boolean().optional(),
+    })
+        .optional(),
+    info: z
+        .object({
+        "composite-below": z.number().min(0).max(100).optional(),
+    })
+        .optional(),
+    warning: z
+        .object({
+        "composite-below": z.number().min(0).max(100).optional(),
+        "regression-exceeds": z.number().optional(),
+    })
+        .optional(),
+});
+/**
+ * Schema for the complete config/thresholds.yaml file.
+ */
+export const ThresholdConfigSchema = z.object({
+    areas: z.record(z.string(), ThresholdDefaultsSchema.partial()).optional(),
+    defaults: ThresholdDefaultsSchema,
+    regression: RegressionThresholdsSchema.optional(),
+    severity: SeverityConfigSchema.optional(),
+});
+// ---------------------------------------------------------------------------
+// Error formatting
+// ---------------------------------------------------------------------------
+/**
+ * Format a Zod error into human-readable lines suitable for CLI output.
+ * Each line includes the path (e.g., "[2].vars.task") and the error message.
+ */
+export function formatZodErrors(error) {
+    return error.issues.map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return "  [" + path + "]: " + issue.message;
+    });
+}

package/dist/_vendor/ailf-core/schemas/schedules.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @sanity/ailf-core — Schedule schemas
+ *
+ * Zod schemas for runtime validation of config/schedules.yaml — the
+ * configuration file for scheduled evaluation runs and digests.
+ *
+ * Each schedule defines a recurring pipeline run with source, mode,
+ * area/task filters, and publishing options. The digest section controls
+ * periodic summary notifications.
+ *
+ * @see docs/design-docs/report-store/implementation.md — Phase 5
+ */
+import { z } from "zod";
+/** Schema for a single scheduled evaluation run. */
+export declare const ScheduleEntrySchema: z.ZodObject<{
+    areas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    compare: z.ZodDefault<z.ZodBoolean>;
+    cron: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        agentic: "agentic";
+        baseline: "baseline";
+        full: "full";
+        observed: "observed";
+    }>>;
+    name: z.ZodString;
+    publish: z.ZodDefault<z.ZodBoolean>;
+    source: z.ZodDefault<z.ZodString>;
+    tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** Inferred TypeScript type for a schedule entry. */
+export type ScheduleEntry = z.infer<typeof ScheduleEntrySchema>;
+/** Schema for the weekly digest section. */
+export declare const DigestConfigSchema: z.ZodObject<{
+    cron: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    lookbackDays: z.ZodDefault<z.ZodNumber>;
+    slackWebhookUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Inferred TypeScript type for the digest config. */
+export type DigestConfig = z.infer<typeof DigestConfigSchema>;
+/** Schema for the complete config/schedules.yaml file. */
+export declare const SchedulesFileSchema: z.ZodObject<{
+    digest: z.ZodOptional<z.ZodObject<{
+        cron: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        lookbackDays: z.ZodDefault<z.ZodNumber>;
+        slackWebhookUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        areas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        compare: z.ZodDefault<z.ZodBoolean>;
+        cron: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            agentic: "agentic";
+            baseline: "baseline";
+            full: "full";
+            observed: "observed";
+        }>>;
+        name: z.ZodString;
+        publish: z.ZodDefault<z.ZodBoolean>;
+        source: z.ZodDefault<z.ZodString>;
+        tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** Inferred TypeScript type for the full schedules config file. */
+export type SchedulesFile = z.infer<typeof SchedulesFileSchema>;

package/dist/_vendor/ailf-core/schemas/schedules.js

@@ -0,0 +1,74 @@
+/**
+ * @sanity/ailf-core — Schedule schemas
+ *
+ * Zod schemas for runtime validation of config/schedules.yaml — the
+ * configuration file for scheduled evaluation runs and digests.
+ *
+ * Each schedule defines a recurring pipeline run with source, mode,
+ * area/task filters, and publishing options. The digest section controls
+ * periodic summary notifications.
+ *
+ * @see docs/design-docs/report-store/implementation.md — Phase 5
+ */
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Cron expression validation
+// ---------------------------------------------------------------------------
+/**
+ * Validates a basic cron expression (5 fields: min hour dom month dow).
+ * Accepts standard GitHub Actions cron syntax.
+ */
+const CronSchema = z
+    .string()
+    .regex(/^[\d*,/-]+\s+[\d*,/-]+\s+[\d*,/-]+\s+[\d*,/-]+\s+[\d*,/-]+$/, "Invalid cron expression — expected 5 space-separated fields");
+// ---------------------------------------------------------------------------
+// Schedule entry
+// ---------------------------------------------------------------------------
+/** Schema for a single scheduled evaluation run. */
+export const ScheduleEntrySchema = z.object({
+    /** Feature areas to evaluate (blank = all areas) */
+    areas: z.array(z.string()).optional(),
+    /** Whether to auto-compare against the most recent baseline */
+    compare: z.boolean().default(false),
+    /** Cron expression (UTC) for when this schedule runs */
+    cron: CronSchema,
+    /** Whether this schedule is active */
+    enabled: z.boolean().default(true),
+    /** Evaluation mode */
+    mode: z.enum(["agentic", "baseline", "full", "observed"]).default("baseline"),
+    /** Human-readable schedule name (used as report tag) */
+    name: z
+        .string()
+        .min(1)
+        .regex(/^[a-z][a-z0-9-]*$/, "Schedule name must be lowercase kebab-case"),
+    /** Whether to publish the report to the Sanity store + sinks */
+    publish: z.boolean().default(true),
+    /** Documentation source to evaluate */
+    source: z.string().default("production"),
+    /** Specific task IDs to evaluate (blank = all tasks) */
+    tasks: z.array(z.string()).optional(),
+});
+// ---------------------------------------------------------------------------
+// Digest configuration
+// ---------------------------------------------------------------------------
+/** Schema for the weekly digest section. */
+export const DigestConfigSchema = z.object({
+    /** Cron expression for when the digest is sent */
+    cron: CronSchema.optional(),
+    /** Whether the digest is enabled */
+    enabled: z.boolean().default(false),
+    /** How many days of reports to include in the digest */
+    lookbackDays: z.number().int().min(1).max(90).default(7),
+    /** Slack webhook URL (supports env var interpolation) */
+    slackWebhookUrl: z.string().optional(),
+});
+// ---------------------------------------------------------------------------
+// Top-level file schema (config/schedules.yaml)
+// ---------------------------------------------------------------------------
+/** Schema for the complete config/schedules.yaml file. */
+export const SchedulesFileSchema = z.object({
+    /** Digest aggregation settings */
+    digest: DigestConfigSchema.optional(),
+    /** Scheduled evaluation runs */
+    schedules: z.array(ScheduleEntrySchema).default([]),
+});

package/dist/_vendor/ailf-core/schemas/sinks.d.ts

@@ -0,0 +1,207 @@
+/**
+ * @sanity/ailf-core — Sink schemas
+ *
+ * Zod schemas for runtime validation of config/sinks.yaml — the configuration
+ * file for report delivery sinks.
+ *
+ * Each sink type has its own config schema, and the top-level SinksFileSchema
+ * validates the complete YAML structure. The discriminated union on `type`
+ * ensures type-safe parsing with clear error messages for unknown sink types.
+ *
+ * Usage:
+ *   import { SinksFileSchema } from "./schema.js"
+ *   const parsed = SinksFileSchema.parse(rawYaml)
+ *
+ * @see docs/design-docs/report-store/sink-architecture.md
+ */
+import { z } from "zod";
+/** All supported sink types as a Zod union. */
+export declare const SinkTypeSchema: z.ZodEnum<{
+    webhook: "webhook";
+    bigquery: "bigquery";
+    "github-comment": "github-comment";
+    slack: "slack";
+}>;
+/** Supported sink type string literal union. */
+export type SinkType = z.infer<typeof SinkTypeSchema>;
+/**
+ * Schema for sink routing rules.
+ * Controls which messages are delivered based on severity and type.
+ * When omitted, the sink receives all reports (backward compatible).
+ */
+export declare const SinkRoutingSchema: z.ZodObject<{
+    critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+}, z.core.$strip>;
+/** Inferred TypeScript type for sink routing rules. */
+/** Config schema for a generic webhook sink. */
+export declare const WebhookSinkConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    routing: z.ZodOptional<z.ZodObject<{
+        critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"webhook">;
+    url: z.ZodString;
+}, z.core.$strip>;
+export type SinkRouting = z.infer<typeof SinkRoutingSchema>;
+/** Config schema for a Slack notification sink. */
+export declare const SlackSinkConfigSchema: z.ZodObject<{
+    channel: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    routing: z.ZodOptional<z.ZodObject<{
+        critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"slack">;
+    webhookUrl: z.ZodString;
+}, z.core.$strip>;
+/** Config schema for a GitHub PR comment sink. */
+export declare const GitHubCommentSinkConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    routing: z.ZodOptional<z.ZodObject<{
+        critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    }, z.core.$strip>>;
+    token: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"github-comment">;
+}, z.core.$strip>;
+/** Config schema for a BigQuery sink. */
+export declare const BigQuerySinkConfigSchema: z.ZodObject<{
+    credentials: z.ZodOptional<z.ZodString>;
+    dataset: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    project: z.ZodString;
+    routing: z.ZodOptional<z.ZodObject<{
+        critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"bigquery">;
+}, z.core.$strip>;
+/**
+ * A single sink configuration — discriminated on the `type` field.
+ *
+ * Zod v4 discriminatedUnion provides clear errors when the `type` value
+ * doesn't match any known sink.
+ */
+export declare const SinkConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    credentials: z.ZodOptional<z.ZodString>;
+    dataset: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    project: z.ZodString;
+    routing: z.ZodOptional<z.ZodObject<{
+        critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"bigquery">;
+}, z.core.$strip>, z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    routing: z.ZodOptional<z.ZodObject<{
+        critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    }, z.core.$strip>>;
+    token: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"github-comment">;
+}, z.core.$strip>, z.ZodObject<{
+    channel: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    routing: z.ZodOptional<z.ZodObject<{
+        critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"slack">;
+    webhookUrl: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    routing: z.ZodOptional<z.ZodObject<{
+        critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"webhook">;
+    url: z.ZodString;
+}, z.core.$strip>], "type">;
+/** Inferred TypeScript type for a single sink config. */
+export type SinkConfig = z.infer<typeof SinkConfigSchema>;
+/** Schema for the complete config/sinks.yaml file. */
+export declare const SinksFileSchema: z.ZodObject<{
+    sinks: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        credentials: z.ZodOptional<z.ZodString>;
+        dataset: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        project: z.ZodString;
+        routing: z.ZodOptional<z.ZodObject<{
+            critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"bigquery">;
+    }, z.core.$strip>, z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        routing: z.ZodOptional<z.ZodObject<{
+            critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        }, z.core.$strip>>;
+        token: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"github-comment">;
+    }, z.core.$strip>, z.ZodObject<{
+        channel: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        routing: z.ZodOptional<z.ZodObject<{
+            critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"slack">;
+        webhookUrl: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        routing: z.ZodOptional<z.ZodObject<{
+            critical: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            digest: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            info: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            regression: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            warning: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"webhook">;
+        url: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+/** Inferred TypeScript type for the full sinks config file. */
+export type SinksFile = z.infer<typeof SinksFileSchema>;