@rayspec/spec 1.5.0

package/dist/product-grammar.d.ts

@@ -0,0 +1,948 @@
+/**
+ * The Product-YAML grammar — `ProductSpec` and its sections.
+ *
+ * A Product-YAML document declares PRODUCT MEANING ONLY (Tier C — the Product-YAML
+ * program): product identity, required Tier-B capabilities, product-owned artifact kinds + response
+ * contracts, declarative TYPED PRODUCT STORES (data shape, never handlers/SQL),
+ * declarative agent EXTRACTION contracts, workflow COMPOSITION over Tier A/B primitives, grounding
+ * policy, and declarative view/read contracts. It is a DIFFERENT document family from `RaySpec`
+ * (grammar.ts): its `extractors` are extraction contracts (not backend/model/instructions wrappers),
+ * and it deliberately has NO `handlers`/`tooling`/`api` — the whole point is that NO product-owned backend
+ * code lives here (that belongs in Tier A/B). The minimal typed `stores` section below reuses the
+ * backend column vocabulary so the derived output stays a standard `StoreSpec`. The two
+ * profiles share ONE `version:'1.0'` key and are told apart by the presence of the `product:`
+ * section (the archetype discriminant) at the parse/deploy/CLI layer (`detect.ts`); the backend
+ * profile (`RaySpec`) IS the internal engine target and its shape stays byte-unchanged.
+ *
+ * ENFORCEMENT POINT: this module IS the real, fail-closed parser for the product profile — the closed
+ * grammar is enforced here (an unknown key is rejected — see below), not merely described. The product
+ * profile carries the unified production version literal `'1.0'` (the product profile of one language).
+ *
+ * FAIL-CLOSED BY CONSTRUCTION: every object level is `.strict()` (an unknown key is rejected — no
+ * silent passthrough, mirroring grammar.ts). The `contracts[]` values are INTENTIONALLY open
+ * records (they ARE JSON-Schema-like payloads) — their CLOSED vocabulary is enforced separately
+ * by `product-lint.ts`, exactly as `RaySpec` validates a tool's `parameters` via ajv in lint
+ * rather than by strict-key rejection.
+ *
+ * BRIDGE ALIGNMENT: the `workflows`/`extractors` shapes here are FIELD-COMPATIBLE
+ * with `ProductYamlBridgeInput` (`@rayspec/product-yaml-workflow-bridge`) — same key names (workflows:
+ * id/trigger{capability,event,scope}/steps[]{id,type,use,inputs,outputs,depends_on,on_error,retry}; and
+ * the extractor extraction contract) — so a validated `ProductSpec` feeds the real bridge compiler unchanged.
+ *
+ * REPRESENTABLE: only string/literal/enum/array/record/object/boolean/number types are used, so
+ * `z.toJSONSchema` (export.ts `exportProductJsonSchema`) exports it without throwing.
+ */
+import { z } from 'zod';
+export declare const ProductIdentity: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    owners: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+export type ProductIdentity = z.infer<typeof ProductIdentity>;
+export declare const RequiresSpec: z.ZodObject<{
+    capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type RequiresSpec = z.infer<typeof RequiresSpec>;
+/** Reusable Tier B capability references are tier `B` (the draft's only allowed tier). */
+export declare const CapabilityTier: z.ZodEnum<{
+    B: "B";
+}>;
+export type CapabilityTier = z.infer<typeof CapabilityTier>;
+/**
+ * A capability's runtime availability. All three statuses are shape-valid: `available`
+ * declares the capability is runtime-backed; `reserved`/`not_yet_runtime` declare a future
+ * dependency. WIREDNESS is enforced at the deploy composition, not here — a MOUNT rejects any
+ * capability that is not `available` + actually runtime-backed (fail-closed, section named), while
+ * `doctor`/`plan` (validate-only) accept all three (the frozen legacy fixture stays valid).
+ */
+export declare const CapabilityStatus: z.ZodEnum<{
+    reserved: "reserved";
+    not_yet_runtime: "not_yet_runtime";
+    available: "available";
+}>;
+export type CapabilityStatus = z.infer<typeof CapabilityStatus>;
+/**
+ * Narrow, DECLARATIVE provider policy (draft): provider/model SELECTION by policy — NOT a
+ * provider-native request/response blob. Allowed ONLY here (on a capability) and in
+ * `deployment_overrides`; product-lint rejects provider policy that leaks into `workflows`/`extractors`.
+ */
+export declare const ProviderPolicy: z.ZodObject<{
+    default_provider: z.ZodOptional<z.ZodString>;
+    default_model: z.ZodOptional<z.ZodString>;
+    adapter_visibility: z.ZodOptional<z.ZodEnum<{
+        internal: "internal";
+        public: "public";
+    }>>;
+}, z.core.$strict>;
+export type ProviderPolicy = z.infer<typeof ProviderPolicy>;
+/**
+ * OPTIONAL declarative INPUT-NORMALIZE step for a submit-ingress capability (default OFF). When
+ * declared, a submitted record is transformed by the named agent AFTER shape-validation and BEFORE
+ * persist — the NORMALIZED value is what is re-validated, stored, and emitted. ABSENT ⇒ behaviour is
+ * byte-identical to today (a capability that does not declare it is completely unaffected). The agent
+ * runs through the platform's neutral agent-invocation path (the deployment wires a normalizer for the
+ * declared `agent` id — the config-side wiring precedent); the model output must conform to
+ * `output_contract`. Fail-closed: a normalize failure REJECTS the submit and persists nothing.
+ */
+export declare const CapabilityInputNormalize: z.ZodObject<{
+    agent: z.ZodString;
+    output_contract: z.ZodString;
+}, z.core.$strict>;
+export type CapabilityInputNormalize = z.infer<typeof CapabilityInputNormalize>;
+export declare const CapabilitySpec: z.ZodObject<{
+    id: z.ZodString;
+    tier: z.ZodEnum<{
+        B: "B";
+    }>;
+    status: z.ZodEnum<{
+        reserved: "reserved";
+        not_yet_runtime: "not_yet_runtime";
+        available: "available";
+    }>;
+    contracts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    provider_policy: z.ZodOptional<z.ZodObject<{
+        default_provider: z.ZodOptional<z.ZodString>;
+        default_model: z.ZodOptional<z.ZodString>;
+        adapter_visibility: z.ZodOptional<z.ZodEnum<{
+            internal: "internal";
+            public: "public";
+        }>>;
+    }, z.core.$strict>>;
+    runtime_notes: z.ZodOptional<z.ZodString>;
+    input_normalize: z.ZodOptional<z.ZodObject<{
+        agent: z.ZodString;
+        output_contract: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CapabilitySpec = z.infer<typeof CapabilitySpec>;
+export declare const ArtifactProvenance: z.ZodObject<{
+    source: z.ZodOptional<z.ZodString>;
+    evidence_field: z.ZodOptional<z.ZodString>;
+    quote_field: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ArtifactProvenance = z.infer<typeof ArtifactProvenance>;
+export declare const ArtifactLifecycle: z.ZodObject<{
+    persist: z.ZodOptional<z.ZodBoolean>;
+    preserve_human_edits: z.ZodOptional<z.ZodBoolean>;
+    reconcile_stale_rows: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ArtifactLifecycle = z.infer<typeof ArtifactLifecycle>;
+export declare const ArtifactSpec: z.ZodObject<{
+    kind: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    contract: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+    collection: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        evidence_field: z.ZodOptional<z.ZodString>;
+        quote_field: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    lifecycle: z.ZodOptional<z.ZodObject<{
+        persist: z.ZodOptional<z.ZodBoolean>;
+        preserve_human_edits: z.ZodOptional<z.ZodBoolean>;
+        reconcile_stale_rows: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ArtifactSpec = z.infer<typeof ArtifactSpec>;
+/**
+ * `contracts` maps a contract id to a JSON-Schema-like payload. INTENTIONALLY an OPEN record at the
+ * grammar level (like a `RaySpec` tool's `parameters` — a free-form schema slot): its CLOSED
+ * declarative vocabulary (allowed keys: type/description/properties/items/required/enum/
+ * additional_properties/nullable/ref; allowed types: object/array/string/number/integer/boolean/null;
+ * FORBIDDEN: functions/transforms/computed expressions/provider-native shapes) is enforced by
+ * `product-lint.ts` (`invalid_contract`), which walks each contract schema against the allowlist.
+ */
+export declare const ContractsSpec: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+export type ContractsSpec = z.infer<typeof ContractsSpec>;
+export declare const AgentArtifactInput: z.ZodObject<{
+    name: z.ZodString;
+    ref: z.ZodString;
+    kind: z.ZodString;
+    required: z.ZodOptional<z.ZodBoolean>;
+    source_step_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AgentArtifactInput = z.infer<typeof AgentArtifactInput>;
+export declare const AgentArtifactOutput: z.ZodObject<{
+    name: z.ZodString;
+    ref: z.ZodString;
+    kind: z.ZodString;
+    schema_ref: z.ZodOptional<z.ZodString>;
+    materialization_target: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AgentArtifactOutput = z.infer<typeof AgentArtifactOutput>;
+export declare const RequiredOutputShape: z.ZodObject<{
+    schema_ref: z.ZodString;
+    required_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    additional_properties: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type RequiredOutputShape = z.infer<typeof RequiredOutputShape>;
+export declare const AcceptanceBoundary: z.ZodObject<{
+    type: z.ZodLiteral<"validation_node">;
+    requires: z.ZodArray<z.ZodString>;
+    closed_source_artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type AcceptanceBoundary = z.infer<typeof AcceptanceBoundary>;
+export declare const ArtifactMaterialization: z.ZodObject<{
+    target: z.ZodLiteral<"typed_artifact_ref">;
+    persist_via: z.ZodOptional<z.ZodString>;
+    handle_ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ArtifactMaterialization = z.infer<typeof ArtifactMaterialization>;
+export declare const AgentExtraction: z.ZodObject<{
+    intent: z.ZodString;
+    input_artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ref: z.ZodString;
+        kind: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        source_step_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    output_artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ref: z.ZodString;
+        kind: z.ZodString;
+        schema_ref: z.ZodOptional<z.ZodString>;
+        materialization_target: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    required_output_shape: z.ZodObject<{
+        schema_ref: z.ZodString;
+        required_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        additional_properties: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    acceptance_boundary: z.ZodObject<{
+        type: z.ZodLiteral<"validation_node">;
+        requires: z.ZodArray<z.ZodString>;
+        closed_source_artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    materialization: z.ZodObject<{
+        target: z.ZodLiteral<"typed_artifact_ref">;
+        persist_via: z.ZodOptional<z.ZodString>;
+        handle_ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentExtraction = z.infer<typeof AgentExtraction>;
+export declare const ExtractorSpec: z.ZodObject<{
+    id: z.ZodString;
+    purpose: z.ZodString;
+    extraction: z.ZodObject<{
+        intent: z.ZodString;
+        input_artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            ref: z.ZodString;
+            kind: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            source_step_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        output_artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            ref: z.ZodString;
+            kind: z.ZodString;
+            schema_ref: z.ZodOptional<z.ZodString>;
+            materialization_target: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        required_output_shape: z.ZodObject<{
+            schema_ref: z.ZodString;
+            required_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            additional_properties: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        acceptance_boundary: z.ZodObject<{
+            type: z.ZodLiteral<"validation_node">;
+            requires: z.ZodArray<z.ZodString>;
+            closed_source_artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        materialization: z.ZodObject<{
+            target: z.ZodLiteral<"typed_artifact_ref">;
+            persist_via: z.ZodOptional<z.ZodString>;
+            handle_ref: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    extraction_constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ExtractorSpec = z.infer<typeof ExtractorSpec>;
+/**
+ * A declared product store: the MINIMAL typed data declaration the store_read/store_write step
+ * runtime targets, and the backing for store-sourced views. DESIGN LAWS:
+ *  - the columns are EXACTLY the backend `StoreColumn` vocabulary (imported from grammar.ts, which stays
+ *    byte-stable), so the DERIVED output (`deriveProductStores`) is a standard `StoreSpec` and the
+ *    whole existing store machinery — `generateProductSql` (tenancy/GDPR injection), `diffProductStores`,
+ *    drift/classify, the update seam, `eraseTenant` — consumes declared stores UNCHANGED;
+ *  - authors declare BUSINESS columns only; the tenancy/GDPR columns (`id`/`tenant_id`/`created_at`/
+ *    `deleted_at`/`retention_days`/`region`) are INJECTED downstream exactly like collection stores get
+ *    them (declaring one is rejected by lint, `reserved_column_name`);
+ *  - `key` is the REQUIRED conflict/idempotency identity: the durable engine's at-least-once law
+ *    re-executes a mid-crash node, so EVERY store_write is an UPSERT on this declared key (single-flight — never
+ *    insert-and-recover; an in-tx unique-violation would poison the whole run transaction). It lives on
+ *    the STORE (not the write step) because row identity is a property of the DATA — two write paths to
+ *    one store must agree on one identity — and because the derivation must materialize the backing
+ *    UNIQUE index (the key column derives `unique: true`). v1 admits EXACTLY ONE key column (the backend
+ *    `StoreSpec` family has per-column uniques only — no composite/table-level unique vocabulary; a
+ *    composite identity is composed into one column, the platform's `artifact_ref`/`track_ref` idiom);
+ *  - deliberately NOT supported in v1 (honest scope): product-to-product foreign keys, composite keys,
+ *    per-column defaults (the backend `StoreColumn` vocabulary carries none), non-tenant stores.
+ */
+export declare const ProductStoreSpec: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    columns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            boolean: "boolean";
+            text: "text";
+            uuid: "uuid";
+            timestamp: "timestamp";
+            integer: "integer";
+            jsonb: "jsonb";
+        }>;
+        nullable: z.ZodDefault<z.ZodBoolean>;
+        unique: z.ZodDefault<z.ZodBoolean>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    key: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type ProductStoreSpec = z.infer<typeof ProductStoreSpec>;
+/** A value read from the TRIGGER EVENT payload (`payload[<event>]` — a scalar, fail-closed at run). */
+export declare const StoreEventValue: z.ZodObject<{
+    event: z.ZodString;
+}, z.core.$strict>;
+export type StoreEventValue = z.infer<typeof StoreEventValue>;
+/**
+ * A literal scalar. The FILTER variant excludes null (SQL equality on NULL never matches a row).
+ *
+ * ⚠ KNOWN LIMITATION (GLI-1 — INTENDED; do NOT "fix" by narrowing the guard): a `{const:}` literal
+ * lives inside the `workflows` graph subtree, so the graph NEUTRALITY guardrails
+ * (`scanProductGuardrails` — provider names, code-like tokens, handler/module paths,
+ * production-/prompt-execution claims) scan it like every other graph string. A BUSINESS constant
+ * that happens to contain such a token (e.g. a status text naming a provider, or `llm call`) is
+ * therefore OVER-REJECTED fail-closed. This is the deliberate posture: the guard is trust-boundary-adjacent
+ * and MUST NOT be weakened for literal convenience — rephrase the constant, or carry the value as
+ * DATA through an `{event:}` / `{artifact:}` source instead of YAML meaning. Pinned by a lint test
+ * (product-stores.test.ts GLI-1) so an accidental narrowing of the guard goes red.
+ */
+export declare const StoreFilterConstValue: z.ZodObject<{
+    const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, z.core.$strict>;
+export type StoreFilterConstValue = z.infer<typeof StoreFilterConstValue>;
+/** The write-variant literal (incl. null). The GLI-1 over-rejection note above applies here too. */
+export declare const StoreWriteConstValue: z.ZodObject<{
+    const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>;
+export type StoreWriteConstValue = z.infer<typeof StoreWriteConstValue>;
+/**
+ * An UPSTREAM ARTIFACT value by its declared contract ref (last producer wins — the same resolution
+ * every other node uses). Write-values only: it feeds a step's produced data (e.g. a store_read's
+ * rows) into a written column; a whole artifact is not an equality-filter scalar.
+ */
+export declare const StoreArtifactValue: z.ZodObject<{
+    artifact: z.ZodString;
+}, z.core.$strict>;
+export type StoreArtifactValue = z.infer<typeof StoreArtifactValue>;
+/** store_read filter sources: event payload key or a non-null literal (EQUALITY-ONLY, see below). */
+export declare const StoreFilterValue: z.ZodUnion<readonly [z.ZodObject<{
+    event: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, z.core.$strict>]>;
+export type StoreFilterValue = z.infer<typeof StoreFilterValue>;
+/** store_write value sources: event payload key, literal (incl. null), or an upstream artifact. */
+export declare const StoreWriteValue: z.ZodUnion<readonly [z.ZodObject<{
+    event: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>, z.ZodObject<{
+    artifact: z.ZodString;
+}, z.core.$strict>]>;
+export type StoreWriteValue = z.infer<typeof StoreWriteValue>;
+/**
+ * The store_read row cap: `limit` may not exceed this (shape-level), the node clamps to it
+ * (defense-in-depth), and an omitted limit defaults to `STORE_READ_DEFAULT_LIMIT`. A step read is a
+ * BOUNDED reference lookup feeding a workflow node — unbounded reads belong to paged views.
+ */
+export declare const STORE_READ_MAX_LIMIT = 1000;
+export declare const STORE_READ_DEFAULT_LIMIT = 100;
+/**
+ * The closed set of workflow step types. `capability`/`agent`/`validation`/`artifact_persist`/
+ * `artifact_read` are what the bridge compiles today; `store_read`/`store_write` are draft Tier-A
+ * node types (validated statically here, compiled by later stages). An unknown/typo'd `type` is
+ * fail-closed-rejected by this enum (the fail-open lesson: never silently drop a step; reject loudly).
+ */
+export declare const WorkflowStepType: z.ZodEnum<{
+    agent: "agent";
+    capability: "capability";
+    validation: "validation";
+    artifact_persist: "artifact_persist";
+    artifact_read: "artifact_read";
+    store_read: "store_read";
+    store_write: "store_write";
+}>;
+export type WorkflowStepType = z.infer<typeof WorkflowStepType>;
+/** Bounded failure policy a step may select (Tier A runtime executes it). */
+export declare const WorkflowOnError: z.ZodEnum<{
+    fail: "fail";
+    retry: "retry";
+    drop: "drop";
+    quarantine: "quarantine";
+}>;
+export type WorkflowOnError = z.infer<typeof WorkflowOnError>;
+/** A BOUNDED retry policy — a positive attempt cap (no unbounded loops). */
+export declare const WorkflowRetry: z.ZodObject<{
+    max_attempts: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkflowRetry = z.infer<typeof WorkflowRetry>;
+export declare const WorkflowStep: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        agent: "agent";
+        capability: "capability";
+        validation: "validation";
+        artifact_persist: "artifact_persist";
+        artifact_read: "artifact_read";
+        store_read: "store_read";
+        store_write: "store_write";
+    }>;
+    use: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    on_error: z.ZodOptional<z.ZodEnum<{
+        fail: "fail";
+        retry: "retry";
+        drop: "drop";
+        quarantine: "quarantine";
+    }>>;
+    retry: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+    }, z.core.$strict>>;
+    store: z.ZodOptional<z.ZodString>;
+    filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        event: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>]>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        event: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>, z.ZodObject<{
+        artifact: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>;
+export type WorkflowStep = z.infer<typeof WorkflowStep>;
+export declare const WorkflowTrigger: z.ZodObject<{
+    capability: z.ZodString;
+    event: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WorkflowTrigger = z.infer<typeof WorkflowTrigger>;
+export declare const ProductWorkflowSpec: z.ZodObject<{
+    id: z.ZodString;
+    trigger: z.ZodObject<{
+        capability: z.ZodString;
+        event: z.ZodString;
+        scope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            agent: "agent";
+            capability: "capability";
+            validation: "validation";
+            artifact_persist: "artifact_persist";
+            artifact_read: "artifact_read";
+            store_read: "store_read";
+            store_write: "store_write";
+        }>;
+        use: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        on_error: z.ZodOptional<z.ZodEnum<{
+            fail: "fail";
+            retry: "retry";
+            drop: "drop";
+            quarantine: "quarantine";
+        }>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            max_attempts: z.ZodNumber;
+        }, z.core.$strict>>;
+        store: z.ZodOptional<z.ZodString>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            event: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>]>>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            event: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+        }, z.core.$strict>, z.ZodObject<{
+            artifact: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ProductWorkflowSpec = z.infer<typeof ProductWorkflowSpec>;
+export declare const AttributionPolicy: z.ZodObject<{
+    tracks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+export type AttributionPolicy = z.infer<typeof AttributionPolicy>;
+export declare const GroundingSpec: z.ZodObject<{
+    require_source_spans: z.ZodOptional<z.ZodBoolean>;
+    source_span_contract: z.ZodOptional<z.ZodString>;
+    on_invalid_citation: z.ZodOptional<z.ZodEnum<{
+        fail: "fail";
+        drop: "drop";
+        prune: "prune";
+        repair: "repair";
+    }>>;
+    on_empty_evidence: z.ZodOptional<z.ZodEnum<{
+        fail: "fail";
+        drop: "drop";
+        prune: "prune";
+        keep: "keep";
+    }>>;
+    on_unquoted_claim: z.ZodOptional<z.ZodEnum<{
+        fail: "fail";
+        drop: "drop";
+        prune: "prune";
+        ignore: "ignore";
+    }>>;
+    validation_capability: z.ZodOptional<z.ZodString>;
+    attribution_policy: z.ZodOptional<z.ZodObject<{
+        tracks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GroundingSpec = z.infer<typeof GroundingSpec>;
+/** Views are reads plus a playback-token command — GET/POST only (a mutating verb implies a handler). */
+export declare const ViewMethod: z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+}>;
+export type ViewMethod = z.infer<typeof ViewMethod>;
+export declare const ViewRoute: z.ZodObject<{
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+    }>;
+    path: z.ZodString;
+}, z.core.$strict>;
+export type ViewRoute = z.infer<typeof ViewRoute>;
+export declare const ViewSource: z.ZodObject<{
+    kind: z.ZodEnum<{
+        store: "store";
+        capability: "capability";
+        artifact_query: "artifact_query";
+    }>;
+    ref: z.ZodString;
+}, z.core.$strict>;
+export type ViewSource = z.infer<typeof ViewSource>;
+export declare const ViewPagination: z.ZodObject<{
+    limit_param: z.ZodOptional<z.ZodString>;
+    offset_param: z.ZodOptional<z.ZodString>;
+    max_limit: z.ZodOptional<z.ZodNumber>;
+    default_limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ViewPagination = z.infer<typeof ViewPagination>;
+/**
+ * Response behavior for processing/absent data. The draft BANS `processing_200`; this enum omits it, so
+ * it is fail-closed-rejected by construction (a bad-enum `schema_violation`). `not_ready_409` preserves
+ * the playback-token readiness contract; `empty_200` is the empty-read-model shape.
+ */
+export declare const ViewAbsentState: z.ZodEnum<{
+    empty_200: "empty_200";
+    not_ready_409: "not_ready_409";
+}>;
+export type ViewAbsentState = z.infer<typeof ViewAbsentState>;
+/**
+ * VERSION-DISCIPLINE NOTE: the view read+projection vocabulary below (`params`/`read`/
+ * `conditional_read` + `pagination.default_limit`) is a STRICTLY ADDITIVE, ALL-OPTIONAL extension of
+ * the product profile, so it needs no version bump: every previously-valid product document parses
+ * byte-identically (the `version` literal + `product:` discriminant select document PROFILES, not
+ * additive vocabulary), and `.strict()` still rejects unknown keys fail-closed. The committed
+ * schema and the fixtures are regenerated/updated DELIBERATELY with this change (never silently).
+ *
+ * SEMANTIC SPLIT: `source` (+ `read`) declare the BACKING DATA and are validated
+ * kind-aware (store name / declared artifact / capability contract — a contract id NEVER satisfies a
+ * source); `response_contract` (+ `read.shape`) declare the DTO and are validated by the separate
+ * shape⊆contract conformance pass. See product-views.ts + product-views-lint.ts.
+ */
+export declare const ProductViewSpec: z.ZodObject<{
+    id: z.ZodString;
+    route: z.ZodObject<{
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+        }>;
+        path: z.ZodString;
+    }, z.core.$strict>;
+    auth: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        in: z.ZodEnum<{
+            path: "path";
+            query: "query";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        shape: z.ZodEnum<{
+            string: "string";
+            safe_id: "safe_id";
+            positive_int: "positive_int";
+            nonnegative_int: "nonnegative_int";
+        }>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    source: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            store: "store";
+            capability: "capability";
+            artifact_query: "artifact_query";
+        }>;
+        ref: z.ZodString;
+    }, z.core.$strict>>;
+    read: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            list: "list";
+            single: "single";
+            collect: "collect";
+        }>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            param: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            const: 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.ZodObject<{}, z.core.$strict>]>;
+        }, z.core.$strict>]>>>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            equals: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodNull]>;
+        }, z.core.$strict>>>;
+        order_by: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            dir: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>>>;
+        shape: z.ZodType<import("./product-views.js").ViewObjectShape, unknown, z.core.$ZodTypeInternals<import("./product-views.js").ViewObjectShape, unknown>>;
+        absent: z.ZodOptional<z.ZodObject<{
+            fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"param">;
+                param: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"const">;
+                value: 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.ZodObject<{}, z.core.$strict>]>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    pagination: z.ZodOptional<z.ZodObject<{
+        limit_param: z.ZodOptional<z.ZodString>;
+        offset_param: z.ZodOptional<z.ZodString>;
+        max_limit: z.ZodOptional<z.ZodNumber>;
+        default_limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    absent_state: z.ZodOptional<z.ZodEnum<{
+        empty_200: "empty_200";
+        not_ready_409: "not_ready_409";
+    }>>;
+    conditional_read: z.ZodOptional<z.ZodEnum<{
+        etag: "etag";
+    }>>;
+    response_contract: z.ZodString;
+}, z.core.$strict>;
+export type ProductViewSpec = z.infer<typeof ProductViewSpec>;
+export declare const ProviderOverride: z.ZodObject<{
+    default_model: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ProviderOverride = z.infer<typeof ProviderOverride>;
+export declare const DeploymentOverrides: z.ZodObject<{
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        default_model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type DeploymentOverrides = z.infer<typeof DeploymentOverrides>;
+/**
+ * The full Product-YAML document (the product profile of the unified `version:'1.0'` language). Its
+ * top-level key is `version` (`z.literal('1.0')`) — checked FIRST by the two-phase `parseProductSpec`
+ * (product-parse.ts) so an unsupported version yields a clean `unsupported_version` instead of a wall
+ * of strict errors. The required `product:` section is the archetype discriminant that tells this
+ * profile apart from the backend profile (which never carries `product:` — see detect.ts). `.strict()`
+ * rejects any unknown top-level section. Only `product` is required; every other section defaults
+ * ([]/{}), so a minimal doc (just `version` + `product`) is valid and a product need not declare every
+ * section. The grammar is a single `z.literal(SPEC_VERSION)` — the parse boundary (product-parse.ts)
+ * accepts exactly `version:'1.0'` and rejects any other version fail-closed.
+ */
+export declare const ProductSpec: z.ZodObject<{
+    version: z.ZodLiteral<"1.0">;
+    product: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        owners: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>;
+    requires: z.ZodDefault<z.ZodObject<{
+        capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    capabilities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tier: z.ZodEnum<{
+            B: "B";
+        }>;
+        status: z.ZodEnum<{
+            reserved: "reserved";
+            not_yet_runtime: "not_yet_runtime";
+            available: "available";
+        }>;
+        contracts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        provider_policy: z.ZodOptional<z.ZodObject<{
+            default_provider: z.ZodOptional<z.ZodString>;
+            default_model: z.ZodOptional<z.ZodString>;
+            adapter_visibility: z.ZodOptional<z.ZodEnum<{
+                internal: "internal";
+                public: "public";
+            }>>;
+        }, z.core.$strict>>;
+        runtime_notes: z.ZodOptional<z.ZodString>;
+        input_normalize: z.ZodOptional<z.ZodObject<{
+            agent: z.ZodString;
+            output_contract: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        contract: z.ZodString;
+        scope: z.ZodOptional<z.ZodString>;
+        collection: z.ZodOptional<z.ZodString>;
+        provenance: z.ZodOptional<z.ZodObject<{
+            source: z.ZodOptional<z.ZodString>;
+            evidence_field: z.ZodOptional<z.ZodString>;
+            quote_field: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        lifecycle: z.ZodOptional<z.ZodObject<{
+            persist: z.ZodOptional<z.ZodBoolean>;
+            preserve_human_edits: z.ZodOptional<z.ZodBoolean>;
+            reconcile_stale_rows: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    stores: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        columns: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                boolean: "boolean";
+                text: "text";
+                uuid: "uuid";
+                timestamp: "timestamp";
+                integer: "integer";
+                jsonb: "jsonb";
+            }>;
+            nullable: z.ZodDefault<z.ZodBoolean>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        key: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    contracts: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    extractors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        purpose: z.ZodString;
+        extraction: z.ZodObject<{
+            intent: z.ZodString;
+            input_artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                ref: z.ZodString;
+                kind: z.ZodString;
+                required: z.ZodOptional<z.ZodBoolean>;
+                source_step_id: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            output_artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                ref: z.ZodString;
+                kind: z.ZodString;
+                schema_ref: z.ZodOptional<z.ZodString>;
+                materialization_target: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            required_output_shape: z.ZodObject<{
+                schema_ref: z.ZodString;
+                required_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                additional_properties: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+            acceptance_boundary: z.ZodObject<{
+                type: z.ZodLiteral<"validation_node">;
+                requires: z.ZodArray<z.ZodString>;
+                closed_source_artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>;
+            materialization: z.ZodObject<{
+                target: z.ZodLiteral<"typed_artifact_ref">;
+                persist_via: z.ZodOptional<z.ZodString>;
+                handle_ref: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        extraction_constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    workflows: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        trigger: z.ZodObject<{
+            capability: z.ZodString;
+            event: z.ZodString;
+            scope: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                agent: "agent";
+                capability: "capability";
+                validation: "validation";
+                artifact_persist: "artifact_persist";
+                artifact_read: "artifact_read";
+                store_read: "store_read";
+                store_write: "store_write";
+            }>;
+            use: z.ZodString;
+            inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            on_error: z.ZodOptional<z.ZodEnum<{
+                fail: "fail";
+                retry: "retry";
+                drop: "drop";
+                quarantine: "quarantine";
+            }>>;
+            retry: z.ZodOptional<z.ZodObject<{
+                max_attempts: z.ZodNumber;
+            }, z.core.$strict>>;
+            store: z.ZodOptional<z.ZodString>;
+            filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                event: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>]>>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                event: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            }, z.core.$strict>, z.ZodObject<{
+                artifact: z.ZodString;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    grounding: z.ZodOptional<z.ZodObject<{
+        require_source_spans: z.ZodOptional<z.ZodBoolean>;
+        source_span_contract: z.ZodOptional<z.ZodString>;
+        on_invalid_citation: z.ZodOptional<z.ZodEnum<{
+            fail: "fail";
+            drop: "drop";
+            prune: "prune";
+            repair: "repair";
+        }>>;
+        on_empty_evidence: z.ZodOptional<z.ZodEnum<{
+            fail: "fail";
+            drop: "drop";
+            prune: "prune";
+            keep: "keep";
+        }>>;
+        on_unquoted_claim: z.ZodOptional<z.ZodEnum<{
+            fail: "fail";
+            drop: "drop";
+            prune: "prune";
+            ignore: "ignore";
+        }>>;
+        validation_capability: z.ZodOptional<z.ZodString>;
+        attribution_policy: z.ZodOptional<z.ZodObject<{
+            tracks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    views: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        route: z.ZodObject<{
+            method: z.ZodEnum<{
+                GET: "GET";
+                POST: "POST";
+            }>;
+            path: z.ZodString;
+        }, z.core.$strict>;
+        auth: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            in: z.ZodEnum<{
+                path: "path";
+                query: "query";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            shape: z.ZodEnum<{
+                string: "string";
+                safe_id: "safe_id";
+                positive_int: "positive_int";
+                nonnegative_int: "nonnegative_int";
+            }>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+        source: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                store: "store";
+                capability: "capability";
+                artifact_query: "artifact_query";
+            }>;
+            ref: z.ZodString;
+        }, z.core.$strict>>;
+        read: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                list: "list";
+                single: "single";
+                collect: "collect";
+            }>;
+            filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                param: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                const: 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.ZodObject<{}, z.core.$strict>]>;
+            }, z.core.$strict>]>>>;
+            exclude: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                column: z.ZodString;
+                equals: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodNull]>;
+            }, z.core.$strict>>>;
+            order_by: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                column: z.ZodString;
+                dir: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strict>>>;
+            shape: z.ZodType<import("./product-views.js").ViewObjectShape, unknown, z.core.$ZodTypeInternals<import("./product-views.js").ViewObjectShape, unknown>>;
+            absent: z.ZodOptional<z.ZodObject<{
+                fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"param">;
+                    param: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"const">;
+                    value: 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.ZodObject<{}, z.core.$strict>]>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        pagination: z.ZodOptional<z.ZodObject<{
+            limit_param: z.ZodOptional<z.ZodString>;
+            offset_param: z.ZodOptional<z.ZodString>;
+            max_limit: z.ZodOptional<z.ZodNumber>;
+            default_limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        absent_state: z.ZodOptional<z.ZodEnum<{
+            empty_200: "empty_200";
+            not_ready_409: "not_ready_409";
+        }>>;
+        conditional_read: z.ZodOptional<z.ZodEnum<{
+            etag: "etag";
+        }>>;
+        response_contract: z.ZodString;
+    }, z.core.$strict>>>;
+    deployment_overrides: z.ZodOptional<z.ZodObject<{
+        providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            default_model: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ProductSpec = z.infer<typeof ProductSpec>;
+//# sourceMappingURL=product-grammar.d.ts.map