@ogygie/generate 0.0.0-stage → 0.20.0

package/dist/generation-block.schema.d.ts

@@ -0,0 +1,1279 @@
+/**
+ * @intent Zod schema AND parser of the `# Génération` block of a spec
+ * (DECISIONS.md D18, D28, D30, D32): ONE fenced YAML block, four keys —
+ * `contracts`, `operations`, `motifs`, `holes` — nothing else. The shape is
+ * validated field by field, then every cross-reference is checked (an
+ * operation that uses an unknown motif or method, a hole nobody carries, two
+ * operations on one route, a method that does not fit the kind, a keyed write
+ * whose `by` is not the contracts key, a slot or a reference nobody declared,
+ * a `respondsWith` that is not a read of the block, a view reading an unknown
+ * table…) and each violation names its path: the refusal is
+ * `OGYGIE_GENERATION_BLOCK_INVALID`, with `details.path` dot-joined
+ * (`operations.3.uses`) so an agent fixes the right line without guessing.
+ *
+ * The YAML is read by the `yaml` package — a real parser, carried by this
+ * package alone (D11) — never by the core's restricted frontmatter reader,
+ * which would misread a nested object as a string without a sound.
+ * What the block cannot check without the schemas module (does
+ * `CreateRateInputSchema` exist? are `reads` fields of the input?) is
+ * `schema-checks.ts` (D19): this module says so instead of pretending.
+ */
+import { z } from "zod";
+import { type OgygieError } from "@ogygie/core/errors";
+import { type HttpOperationKind } from "./motif-catalog.js";
+export declare const GENERATION_BLOCK_INVALID = "OGYGIE_GENERATION_BLOCK_INVALID";
+export declare const GENERATION_BLOCK_KEYS: readonly ["contracts", "operations", "motifs", "holes"];
+/** SQL types a `columns` override may name — what Zod cannot express alone. */
+export declare const SqlTypeSchema: z.ZodString;
+export declare const TableNameSchema: z.ZodString;
+/** A route under /api/, lowercase segments, `:camelCase` parameters (the key and the slot key of a keyed write). */
+export declare const RoutePathSchema: z.ZodString;
+/** A cache root the mutation stales, as the manifest-derived client reads them. */
+export declare const CacheRootSchema: z.ZodString;
+/** A path into an output: `canManage`, `grades[].holderCount`. */
+export declare const OutputPathSchema: z.ZodString;
+export declare const HoleEffectSchema: z.ZodEnum<{
+    clock: "clock";
+    db: "db";
+}>;
+export declare const TransformSourceSchema: z.ZodEnum<{
+    "text/csv": "text/csv";
+}>;
+export declare const HttpMethodSchema: z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PATCH: "PATCH";
+    PUT: "PUT";
+    DELETE: "DELETE";
+}>;
+export declare const SUCCESS_STATUS_BY_KIND: Readonly<Record<HttpOperationKind, number>>;
+/** The one method each kind answers to (D22, D28). */
+export declare const METHOD_BY_KIND: Readonly<Record<HttpOperationKind, z.infer<typeof HttpMethodSchema>>>;
+/** D36: a constraint name as the database knows it — raw: the one thing of an adopted table the target does not render. */
+export declare const ConstraintNameSchema: z.ZodString;
+/** D36: one column of an adopted table — its logical name (camelCase, rendered in the target's casing) and its SQL type (the `columns` vocabulary, rendered by the target). */
+export declare const AdoptedColumnSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+}, z.core.$strict>;
+export type AdoptedColumn = z.infer<typeof AdoptedColumnSchema>;
+/** D36: the CLOSED list of what the generator may ALTER on an adopted table — each step replayable, everything else written by hand. */
+export declare const AlterStepSchema: z.ZodUnion<readonly [z.ZodObject<{
+    drop: z.ZodLiteral<"check">;
+    name: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    add: z.ZodLiteral<"check">;
+    name: z.ZodString;
+    column: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    add: z.ZodLiteral<"foreignKey">;
+    name: z.ZodString;
+    columns: z.ZodArray<z.ZodString>;
+    references: z.ZodObject<{
+        table: z.ZodString;
+        columns: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    onDelete: z.ZodEnum<{
+        cascade: "cascade";
+        restrict: "restrict";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    add: z.ZodLiteral<"column">;
+    field: z.ZodString;
+}, z.core.$strict>]>;
+export type AlterStep = z.infer<typeof AlterStepSchema>;
+/**
+ * D36: a table by its declared shape. `owned` (the default of a bare name): the generator creates it. `adopted`: the table
+ * exists in the product; `columns` declares every field the generator touches, `key` its primary key (composite allowed),
+ * `id: none` that there is no identity column, `alter` what the migration may change about it.
+ */
+export declare const TableRefSchema: z.ZodObject<{
+    name: z.ZodString;
+    mode: z.ZodEnum<{
+        owned: "owned";
+        adopted: "adopted";
+    }>;
+    id: z.ZodOptional<z.ZodLiteral<"none">>;
+    key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strict>>>;
+    alter: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        drop: z.ZodLiteral<"check">;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        add: z.ZodLiteral<"check">;
+        name: z.ZodString;
+        column: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        add: z.ZodLiteral<"foreignKey">;
+        name: z.ZodString;
+        columns: z.ZodArray<z.ZodString>;
+        references: z.ZodObject<{
+            table: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        onDelete: z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        add: z.ZodLiteral<"column">;
+        field: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>;
+export type TableRef = z.infer<typeof TableRefSchema>;
+/** A table of the block: its snake_case name alone (owned), or its TableRef. */
+export declare const TableDeclarationSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    mode: z.ZodEnum<{
+        owned: "owned";
+        adopted: "adopted";
+    }>;
+    id: z.ZodOptional<z.ZodLiteral<"none">>;
+    key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strict>>>;
+    alter: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        drop: z.ZodLiteral<"check">;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        add: z.ZodLiteral<"check">;
+        name: z.ZodString;
+        column: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        add: z.ZodLiteral<"foreignKey">;
+        name: z.ZodString;
+        columns: z.ZodArray<z.ZodString>;
+        references: z.ZodObject<{
+            table: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        onDelete: z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        add: z.ZodLiteral<"column">;
+        field: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>]>;
+export type TableDeclaration = z.infer<typeof TableDeclarationSchema>;
+export declare function tableNameOf(table: TableDeclaration): string;
+/** The declared shape of a table, a bare name being an owned table with an id. */
+export declare function tableRefOf(table: TableDeclaration): TableRef;
+/** The field of a slot or reference row that carries the resource key: `GradeSchema` + `code` → `gradeCode` (D28). */
+export declare function parentKeyFieldOf(resourceSchema: string, key: string): string;
+/** D28: a detail table of values by composite key (resource key, slot key), FK ON DELETE CASCADE. */
+export declare const SlotSchema: z.ZodObject<{
+    table: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        mode: z.ZodEnum<{
+            owned: "owned";
+            adopted: "adopted";
+        }>;
+        id: z.ZodOptional<z.ZodLiteral<"none">>;
+        key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$strict>>>;
+        alter: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            drop: z.ZodLiteral<"check">;
+            name: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            add: z.ZodLiteral<"check">;
+            name: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            add: z.ZodLiteral<"foreignKey">;
+            name: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+            references: z.ZodObject<{
+                table: z.ZodString;
+                columns: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            onDelete: z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            add: z.ZodLiteral<"column">;
+            field: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>]>;
+    key: z.ZodString;
+    value: z.ZodString;
+    schema: z.ZodString;
+    field: z.ZodString;
+}, z.core.$strict>;
+export type Slot = z.infer<typeof SlotSchema>;
+/** D28: a table that POINTS at the resource — counted by refuseWhenReferenced, exposed by countField. */
+export declare const ReferenceSchema: z.ZodObject<{
+    table: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        mode: z.ZodEnum<{
+            owned: "owned";
+            adopted: "adopted";
+        }>;
+        id: z.ZodOptional<z.ZodLiteral<"none">>;
+        key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$strict>>>;
+        alter: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            drop: z.ZodLiteral<"check">;
+            name: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            add: z.ZodLiteral<"check">;
+            name: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            add: z.ZodLiteral<"foreignKey">;
+            name: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+            references: z.ZodObject<{
+                table: z.ZodString;
+                columns: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            onDelete: z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            add: z.ZodLiteral<"column">;
+            field: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>]>;
+    column: z.ZodString;
+    schema: z.ZodOptional<z.ZodString>;
+    countField: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type Reference = z.infer<typeof ReferenceSchema>;
+export declare const ContractsSchema: z.ZodObject<{
+    module: z.ZodString;
+    resource: z.ZodOptional<z.ZodString>;
+    table: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        mode: z.ZodEnum<{
+            owned: "owned";
+            adopted: "adopted";
+        }>;
+        id: z.ZodOptional<z.ZodLiteral<"none">>;
+        key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$strict>>>;
+        alter: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            drop: z.ZodLiteral<"check">;
+            name: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            add: z.ZodLiteral<"check">;
+            name: z.ZodString;
+            column: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            add: z.ZodLiteral<"foreignKey">;
+            name: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+            references: z.ZodObject<{
+                table: z.ZodString;
+                columns: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            onDelete: z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            add: z.ZodLiteral<"column">;
+            field: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>]>>;
+    columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    indexes: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+    key: z.ZodOptional<z.ZodString>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        table: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            mode: z.ZodEnum<{
+                owned: "owned";
+                adopted: "adopted";
+            }>;
+            id: z.ZodOptional<z.ZodLiteral<"none">>;
+            key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+            }, z.core.$strict>>>;
+            alter: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                drop: z.ZodLiteral<"check">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                add: z.ZodLiteral<"check">;
+                name: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                add: z.ZodLiteral<"foreignKey">;
+                name: z.ZodString;
+                columns: z.ZodArray<z.ZodString>;
+                references: z.ZodObject<{
+                    table: z.ZodString;
+                    columns: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                onDelete: z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                add: z.ZodLiteral<"column">;
+                field: z.ZodString;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>]>;
+        key: z.ZodString;
+        value: z.ZodString;
+        schema: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strict>>>;
+    references: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        table: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            mode: z.ZodEnum<{
+                owned: "owned";
+                adopted: "adopted";
+            }>;
+            id: z.ZodOptional<z.ZodLiteral<"none">>;
+            key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+            }, z.core.$strict>>>;
+            alter: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                drop: z.ZodLiteral<"check">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                add: z.ZodLiteral<"check">;
+                name: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                add: z.ZodLiteral<"foreignKey">;
+                name: z.ZodString;
+                columns: z.ZodArray<z.ZodString>;
+                references: z.ZodObject<{
+                    table: z.ZodString;
+                    columns: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                onDelete: z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                add: z.ZodLiteral<"column">;
+                field: z.ZodString;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>]>;
+        column: z.ZodString;
+        schema: z.ZodOptional<z.ZodString>;
+        countField: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    sharedTables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const OrderBySchema: z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>], null>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>], null>>]>;
+export declare const ReadOperationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"read">;
+    orderBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>], null>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>], null>>]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    range: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const CreateOperationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"create">;
+    respondsWith: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const ImportOperationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"import">;
+    respondsWith: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const UpdateOperationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"update">;
+    by: z.ZodString;
+    notFound: z.ZodString;
+    respondsWith: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const SetOrClearOperationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"setOrClear">;
+    slot: z.ZodString;
+    by: z.ZodString;
+    notFound: z.ZodString;
+    respondsWith: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const DeleteOperationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"delete">;
+    by: z.ZodString;
+    notFound: z.ZodString;
+    respondsWith: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/** A non-HTTP operation — the generator specifies itself with these (D20). */
+export declare const CommandOperationSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"command">;
+    input: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodString>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const OperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"read">;
+    orderBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>], null>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>], null>>]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    range: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"create">;
+    respondsWith: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"import">;
+    respondsWith: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"update">;
+    by: z.ZodString;
+    notFound: z.ZodString;
+    respondsWith: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"setOrClear">;
+    slot: z.ZodString;
+    by: z.ZodString;
+    notFound: z.ZodString;
+    respondsWith: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"delete">;
+    by: z.ZodString;
+    notFound: z.ZodString;
+    respondsWith: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PATCH: "PATCH";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    guard: z.ZodString;
+    guardDeniedCode: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    output: z.ZodString;
+    uses: z.ZodOptional<z.ZodString>;
+    holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"command">;
+    input: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodString>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>], "kind">;
+export type Operation = z.infer<typeof OperationSchema>;
+export type HttpOperation = Exclude<Operation, {
+    kind: "command";
+}>;
+export type CommandOperation = Extract<Operation, {
+    kind: "command";
+}>;
+export type ReadOperation = Extract<Operation, {
+    kind: "read";
+}>;
+export type WriteOperation = Exclude<HttpOperation, {
+    kind: "read";
+}>;
+export type KeyedOperation = Extract<Operation, {
+    kind: "update" | "setOrClear" | "delete";
+}>;
+export declare function isHttpOperation(operation: Operation): operation is HttpOperation;
+export declare function isWriteOperation(operation: Operation): operation is WriteOperation;
+export declare function isKeyedOperation(operation: Operation): operation is KeyedOperation;
+export declare const ValidateHoleSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"validate">;
+    reads: z.ZodArray<z.ZodString>;
+    error: z.ZodString;
+    effects: z.ZodArray<z.ZodEnum<{
+        clock: "clock";
+        db: "db";
+    }>>;
+    suggestedFix: z.ZodOptional<z.ZodBoolean>;
+    examples: z.ZodObject<{
+        accept: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+        reject: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const TransformHoleSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"transform">;
+    from: z.ZodEnum<{
+        "text/csv": "text/csv";
+    }>;
+    columns: z.ZodArray<z.ZodString>;
+    effects: z.ZodArray<z.ZodEnum<{
+        clock: "clock";
+        db: "db";
+    }>>;
+    error: z.ZodOptional<z.ZodString>;
+    motifCandidate: z.ZodOptional<z.ZodBoolean>;
+    examples: z.ZodObject<{
+        accept: z.ZodObject<{
+            input: z.ZodUnknown;
+            output: z.ZodUnknown;
+        }, z.core.$strict>;
+        reject: z.ZodObject<{
+            input: z.ZodUnknown;
+            line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** D32: computes ONE resource field from the input before persistence; `error` is the operation's 400 when the derivation is empty. */
+export declare const DeriveHoleSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"derive">;
+    reads: z.ZodArray<z.ZodString>;
+    writes: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+    effects: z.ZodArray<z.ZodEnum<{
+        clock: "clock";
+        db: "db";
+    }>>;
+    examples: z.ZodObject<{
+        accept: z.ZodArray<z.ZodObject<{
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            output: z.ZodUnknown;
+        }, z.core.$strict>>;
+        reject: z.ZodOptional<z.ZodObject<{
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** D32: shapes the output of a read by caller — receives the guard's context (without its db) and the computed output. */
+export declare const ProjectHoleSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"project">;
+    reads: z.ZodArray<z.ZodString>;
+    writes: z.ZodArray<z.ZodString>;
+    examples: z.ZodObject<{
+        accept: z.ZodArray<z.ZodObject<{
+            context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            input: z.ZodUnknown;
+            output: z.ZodUnknown;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** D32: a computation the DATABASE does — its body is SQL in the migration, between markers; the repository reads the view. */
+export declare const ViewHoleSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"view">;
+    name: z.ZodString;
+    from: z.ZodArray<z.ZodString>;
+    writes: z.ZodString;
+    examples: z.ZodObject<{
+        rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        value: z.ZodUnknown;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const HoleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"validate">;
+    reads: z.ZodArray<z.ZodString>;
+    error: z.ZodString;
+    effects: z.ZodArray<z.ZodEnum<{
+        clock: "clock";
+        db: "db";
+    }>>;
+    suggestedFix: z.ZodOptional<z.ZodBoolean>;
+    examples: z.ZodObject<{
+        accept: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+        reject: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"transform">;
+    from: z.ZodEnum<{
+        "text/csv": "text/csv";
+    }>;
+    columns: z.ZodArray<z.ZodString>;
+    effects: z.ZodArray<z.ZodEnum<{
+        clock: "clock";
+        db: "db";
+    }>>;
+    error: z.ZodOptional<z.ZodString>;
+    motifCandidate: z.ZodOptional<z.ZodBoolean>;
+    examples: z.ZodObject<{
+        accept: z.ZodObject<{
+            input: z.ZodUnknown;
+            output: z.ZodUnknown;
+        }, z.core.$strict>;
+        reject: z.ZodObject<{
+            input: z.ZodUnknown;
+            line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"derive">;
+    reads: z.ZodArray<z.ZodString>;
+    writes: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+    effects: z.ZodArray<z.ZodEnum<{
+        clock: "clock";
+        db: "db";
+    }>>;
+    examples: z.ZodObject<{
+        accept: z.ZodArray<z.ZodObject<{
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            output: z.ZodUnknown;
+        }, z.core.$strict>>;
+        reject: z.ZodOptional<z.ZodObject<{
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"project">;
+    reads: z.ZodArray<z.ZodString>;
+    writes: z.ZodArray<z.ZodString>;
+    examples: z.ZodObject<{
+        accept: z.ZodArray<z.ZodObject<{
+            context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            input: z.ZodUnknown;
+            output: z.ZodUnknown;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"view">;
+    name: z.ZodString;
+    from: z.ZodArray<z.ZodString>;
+    writes: z.ZodString;
+    examples: z.ZodObject<{
+        rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        value: z.ZodUnknown;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;
+export type Hole = z.infer<typeof HoleSchema>;
+export type ValidateHole = Extract<Hole, {
+    kind: "validate";
+}>;
+export type TransformHole = Extract<Hole, {
+    kind: "transform";
+}>;
+export type DeriveHole = Extract<Hole, {
+    kind: "derive";
+}>;
+export type ProjectHole = Extract<Hole, {
+    kind: "project";
+}>;
+export type ViewHole = Extract<Hole, {
+    kind: "view";
+}>;
+/** The accept examples of a validate hole, always as a list (first = the valid input overlay). */
+export declare function acceptExamplesOf(hole: ValidateHole): Record<string, unknown>[];
+/** The kinds of operation each kind of hole may serve (D22, D32). */
+export declare const HOLE_KIND_SERVES: Readonly<Record<Hole["kind"], readonly HttpOperationKind[]>>;
+/** `/api/grades/:code/targets/:criterionCode` → ["code", "criterionCode"]. */
+export declare function pathParametersOf(path: string): string[];
+export declare const GenerationBlockSchema: z.ZodObject<{
+    contracts: z.ZodObject<{
+        module: z.ZodString;
+        resource: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            mode: z.ZodEnum<{
+                owned: "owned";
+                adopted: "adopted";
+            }>;
+            id: z.ZodOptional<z.ZodLiteral<"none">>;
+            key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+            }, z.core.$strict>>>;
+            alter: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                drop: z.ZodLiteral<"check">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                add: z.ZodLiteral<"check">;
+                name: z.ZodString;
+                column: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                add: z.ZodLiteral<"foreignKey">;
+                name: z.ZodString;
+                columns: z.ZodArray<z.ZodString>;
+                references: z.ZodObject<{
+                    table: z.ZodString;
+                    columns: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                onDelete: z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                add: z.ZodLiteral<"column">;
+                field: z.ZodString;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>]>>;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        indexes: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+        key: z.ZodOptional<z.ZodString>;
+        slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            table: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                name: z.ZodString;
+                mode: z.ZodEnum<{
+                    owned: "owned";
+                    adopted: "adopted";
+                }>;
+                id: z.ZodOptional<z.ZodLiteral<"none">>;
+                key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                }, z.core.$strict>>>;
+                alter: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    drop: z.ZodLiteral<"check">;
+                    name: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    add: z.ZodLiteral<"check">;
+                    name: z.ZodString;
+                    column: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    add: z.ZodLiteral<"foreignKey">;
+                    name: z.ZodString;
+                    columns: z.ZodArray<z.ZodString>;
+                    references: z.ZodObject<{
+                        table: z.ZodString;
+                        columns: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>;
+                    onDelete: z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    add: z.ZodLiteral<"column">;
+                    field: z.ZodString;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>]>;
+            key: z.ZodString;
+            value: z.ZodString;
+            schema: z.ZodString;
+            field: z.ZodString;
+        }, z.core.$strict>>>;
+        references: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            table: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                name: z.ZodString;
+                mode: z.ZodEnum<{
+                    owned: "owned";
+                    adopted: "adopted";
+                }>;
+                id: z.ZodOptional<z.ZodLiteral<"none">>;
+                key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                }, z.core.$strict>>>;
+                alter: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    drop: z.ZodLiteral<"check">;
+                    name: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    add: z.ZodLiteral<"check">;
+                    name: z.ZodString;
+                    column: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    add: z.ZodLiteral<"foreignKey">;
+                    name: z.ZodString;
+                    columns: z.ZodArray<z.ZodString>;
+                    references: z.ZodObject<{
+                        table: z.ZodString;
+                        columns: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>;
+                    onDelete: z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    add: z.ZodLiteral<"column">;
+                    field: z.ZodString;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>]>;
+            column: z.ZodString;
+            schema: z.ZodOptional<z.ZodString>;
+            countField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        sharedTables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"read">;
+        orderBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>], null>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>], null>>]>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        range: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PATCH: "PATCH";
+            PUT: "PUT";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        guard: z.ZodString;
+        guardDeniedCode: z.ZodOptional<z.ZodString>;
+        input: z.ZodString;
+        output: z.ZodString;
+        uses: z.ZodOptional<z.ZodString>;
+        holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"create">;
+        respondsWith: z.ZodOptional<z.ZodString>;
+        invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        id: z.ZodString;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PATCH: "PATCH";
+            PUT: "PUT";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        guard: z.ZodString;
+        guardDeniedCode: z.ZodOptional<z.ZodString>;
+        input: z.ZodString;
+        output: z.ZodString;
+        uses: z.ZodOptional<z.ZodString>;
+        holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"import">;
+        respondsWith: z.ZodOptional<z.ZodString>;
+        invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        id: z.ZodString;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PATCH: "PATCH";
+            PUT: "PUT";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        guard: z.ZodString;
+        guardDeniedCode: z.ZodOptional<z.ZodString>;
+        input: z.ZodString;
+        output: z.ZodString;
+        uses: z.ZodOptional<z.ZodString>;
+        holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"update">;
+        by: z.ZodString;
+        notFound: z.ZodString;
+        respondsWith: z.ZodOptional<z.ZodString>;
+        invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        id: z.ZodString;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PATCH: "PATCH";
+            PUT: "PUT";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        guard: z.ZodString;
+        guardDeniedCode: z.ZodOptional<z.ZodString>;
+        input: z.ZodString;
+        output: z.ZodString;
+        uses: z.ZodOptional<z.ZodString>;
+        holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"setOrClear">;
+        slot: z.ZodString;
+        by: z.ZodString;
+        notFound: z.ZodString;
+        respondsWith: z.ZodOptional<z.ZodString>;
+        invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        id: z.ZodString;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PATCH: "PATCH";
+            PUT: "PUT";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        guard: z.ZodString;
+        guardDeniedCode: z.ZodOptional<z.ZodString>;
+        input: z.ZodString;
+        output: z.ZodString;
+        uses: z.ZodOptional<z.ZodString>;
+        holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"delete">;
+        by: z.ZodString;
+        notFound: z.ZodString;
+        respondsWith: z.ZodOptional<z.ZodString>;
+        invalidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        id: z.ZodString;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PATCH: "PATCH";
+            PUT: "PUT";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        guard: z.ZodString;
+        guardDeniedCode: z.ZodOptional<z.ZodString>;
+        input: z.ZodString;
+        output: z.ZodString;
+        uses: z.ZodOptional<z.ZodString>;
+        holes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"command">;
+        input: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodString>;
+        errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>], "kind">>;
+    motifs: z.ZodDefault<z.ZodObject<{
+        appendOnlySupersedes: z.ZodOptional<z.ZodObject<{
+            key: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+            errors: z.ZodObject<{
+                duplicate: z.ZodString;
+                mismatch: z.ZodString;
+                alreadySuperseded: z.ZodString;
+                notFound: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        allOrNothingImport: z.ZodOptional<z.ZodObject<{
+            rowSchema: z.ZodString;
+            applies: z.ZodString;
+            maxBytes: z.ZodNumber;
+            error: z.ZodString;
+        }, z.core.$strict>>;
+        uniqueKey: z.ZodOptional<z.ZodObject<{
+            key: z.ZodArray<z.ZodString>;
+            error: z.ZodString;
+        }, z.core.$strict>>;
+        refuseWhenReferenced: z.ZodOptional<z.ZodObject<{
+            reference: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strict>>;
+        idempotentSetOrClear: z.ZodOptional<z.ZodObject<{
+            slot: z.ZodString;
+        }, z.core.$strict>>;
+        signedWrite: z.ZodOptional<z.ZodObject<{
+            by: z.ZodString;
+            at: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    holes: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"validate">;
+        reads: z.ZodArray<z.ZodString>;
+        error: z.ZodString;
+        effects: z.ZodArray<z.ZodEnum<{
+            clock: "clock";
+            db: "db";
+        }>>;
+        suggestedFix: z.ZodOptional<z.ZodBoolean>;
+        examples: z.ZodObject<{
+            accept: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+            reject: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"transform">;
+        from: z.ZodEnum<{
+            "text/csv": "text/csv";
+        }>;
+        columns: z.ZodArray<z.ZodString>;
+        effects: z.ZodArray<z.ZodEnum<{
+            clock: "clock";
+            db: "db";
+        }>>;
+        error: z.ZodOptional<z.ZodString>;
+        motifCandidate: z.ZodOptional<z.ZodBoolean>;
+        examples: z.ZodObject<{
+            accept: z.ZodObject<{
+                input: z.ZodUnknown;
+                output: z.ZodUnknown;
+            }, z.core.$strict>;
+            reject: z.ZodObject<{
+                input: z.ZodUnknown;
+                line: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"derive">;
+        reads: z.ZodArray<z.ZodString>;
+        writes: z.ZodString;
+        error: z.ZodOptional<z.ZodString>;
+        effects: z.ZodArray<z.ZodEnum<{
+            clock: "clock";
+            db: "db";
+        }>>;
+        examples: z.ZodObject<{
+            accept: z.ZodArray<z.ZodObject<{
+                input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                output: z.ZodUnknown;
+            }, z.core.$strict>>;
+            reject: z.ZodOptional<z.ZodObject<{
+                input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"project">;
+        reads: z.ZodArray<z.ZodString>;
+        writes: z.ZodArray<z.ZodString>;
+        examples: z.ZodObject<{
+            accept: z.ZodArray<z.ZodObject<{
+                context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                input: z.ZodUnknown;
+                output: z.ZodUnknown;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"view">;
+        name: z.ZodString;
+        from: z.ZodArray<z.ZodString>;
+        writes: z.ZodString;
+        examples: z.ZodObject<{
+            rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            value: z.ZodUnknown;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>;
+export type GenerationBlock = z.infer<typeof GenerationBlockSchema>;
+export interface BlockLocation {
+    /** Spec path, relative to the repo root — the `file` of every refusal. */
+    file: string;
+    /** 1-based line of the first YAML line in the spec file. */
+    line: number;
+}
+export type GenerationBlockParse = {
+    ok: true;
+    block: GenerationBlock;
+} | {
+    ok: false;
+    problems: OgygieError[];
+};
+/** Validates an already-parsed block value (what the YAML reader produced). */
+export declare function validateGenerationBlock(raw: unknown, location: BlockLocation): GenerationBlockParse;
+/** A refusal of a block at its path — shared with the screen block (D41), which refuses the same way. */
+export declare function blockProblemOf(location: BlockLocation, cause: string, suggestedFix: string, details: Record<string, unknown>): OgygieError;
+export type YamlBlockRead = {
+    ok: true;
+    raw: unknown;
+} | {
+    ok: false;
+    problems: OgygieError[];
+};
+/** Reads the YAML text of a `# Génération` block into a raw value — one refusal per YAML error, at its line. */
+export declare function readYamlBlock(yamlText: string, location: BlockLocation): YamlBlockRead;
+/** D41: a raw block is a SCREEN block when it carries `consumes` — a feature block carries `contracts`; `check` refuses a block that carries both or neither. */
+export declare function blockKindOf(raw: unknown): "feature" | "screen" | "both" | "neither";
+/** Reads the YAML text of the block, then validates it. */
+export declare function parseGenerationBlock(yamlText: string, location: BlockLocation): GenerationBlockParse;