@vibeorm/dsl 2.0.0 → 2.1.0

package/dist/model.d.ts

@@ -27,7 +27,7 @@ import type { CreateModelConfig, IndexBuilder, IndexDef, ModelDef, SchemaDefinit
  *   i.on(["content"], { type: "Gist" }),
  * ]
  */
-export declare function createIndexBuilder<T extends string = string>(): IndexBuilder<T>;
+export declare function createIndexBuilder<T extends string = string, TSchema extends SchemaDefinition = SchemaDefinition>(): IndexBuilder<T, TSchema>;
 /**
  * Creates a model definition. `indexes` and `primaryKey` are constrained to
  * the model's own column names.

package/dist/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,KAAK,EAIV,iBAAiB,EACjB,YAAY,EAEZ,QAAQ,EAGR,QAAQ,EAER,gBAAgB,EAEjB,MAAM,YAAY,CAAC;AAkBpB;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,KAAK,YAAY,CAAC,CAAC,CAAC,CAsE/E;AAyCD;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,CAAC,OAAO,SAAS,gBAAgB,EAC3D,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACjC,QAAQ,CAAC,OAAO,CAAC,CAoBnB;AAID,yDAAyD;AACzD,wBAAgB,cAAc,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,EAAE,CAEpE;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,GAAG,QAAQ,EAAE,CAMvE"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,OAAO,KAAK,EAKV,iBAAiB,EAEjB,YAAY,EAEZ,QAAQ,EAGR,QAAQ,EAIR,gBAAgB,EAEjB,MAAM,YAAY,CAAC;AAkBpB;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,SAAS,MAAM,GAAG,MAAM,EACzB,OAAO,SAAS,gBAAgB,GAAG,gBAAgB,KAChD,YAAY,CAAC,CAAC,EAAE,OAAO,CAAC,CAkG5B;AAyCD;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,CAAC,OAAO,SAAS,gBAAgB,EAC3D,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACjC,QAAQ,CAAC,OAAO,CAAC,CAwBnB;AAID,yDAAyD;AACzD,wBAAgB,cAAc,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,EAAE,CAEpE;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,GAAG,QAAQ,EAAE,CAMvE"}

package/dist/predicate.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The typed predicate builder — the `c` handed to a model's `checks` callback
+ * and to an index's `.where()`.
+ *
+ * Every combinator returns plain {@link PredicateIR}: serializable data, never
+ * a JavaScript callback. Nothing downstream evaluates a function, and a
+ * predicate survives JSON unchanged. The SQL text is produced exactly once, by
+ * `renderPredicate` in @vibeorm/sql, when the schema is compiled and the
+ * dialect is finally known.
+ *
+ * The builder is structural at RUNTIME — it only records names and values — so
+ * one instance serves every model. The type parameters on
+ * {@link PredicateBuilder} are what bind it to a particular model's columns.
+ */
+import type { ExclusionIR, CheckIR, EnumIR, FieldIR, PredicateIR } from "@vibeorm/schema";
+import type { SqlDialect } from "@vibeorm/sql";
+import type { ModelDef, ChecksCallback, ModelCheckConfig, PredicateBuilder, SchemaDefinition } from "./types.ts";
+/**
+ * One predicate builder instance. Stateless and structural — the type
+ * parameters, not the value, bind it to a model.
+ */
+export declare function createPredicateBuilder<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition>(): PredicateBuilder<TColumns, TSchema>;
+/** A model's CHECKs, still un-rendered: raw text stays raw, typed stays typed. */
+export type EvaluatedCheck = {
+    readonly kind: "raw";
+    readonly name: string;
+    readonly expression: string;
+} | {
+    readonly kind: "typed";
+    readonly name: string;
+    readonly predicate: PredicateIR;
+};
+/**
+ * Run a model's `checks` declaration, whichever form it took.
+ *
+ * The raw array form and the typed callback form produce the same shape of
+ * answer, so every consumer downstream handles ONE list — and raw text is
+ * carried through untouched rather than parsed into a predicate.
+ */
+export declare function evaluateChecks(params: {
+    checks: readonly ModelCheckConfig[] | ChecksCallback | undefined;
+    model: string;
+}): readonly EvaluatedCheck[];
+/** What a predicate needs to know about the model it belongs to. */
+export type PredicateModel = {
+    readonly name: string;
+    readonly fields: readonly FieldIR[];
+};
+/**
+ * A model's CHECKs as IR, with every typed expression compiled to SQL ONCE.
+ *
+ * `CheckIR.expression` always carries the AUTHORED text — what the schema says,
+ * not what a database deparsed back — because that is the currency EPIC 1's
+ * differ, desired-state records and DDL renderers all read. The predicate rides
+ * alongside as the structured source, so editing a typed expression changes the
+ * text and produces a real migration, while re-rendering an unchanged one
+ * produces byte-identical text and cannot churn.
+ */
+/** Compile exclusions beside CHECKs and index predicates at the schema boundary. */
+export declare function compileExclusions(params: {
+    exclusions: ModelDef["__exclusions"];
+    model: PredicateModel;
+    dialect: SqlDialect;
+}): readonly ExclusionIR[];
+export declare function compileChecks(params: {
+    checks: readonly ModelCheckConfig[] | ChecksCallback | undefined;
+    model: PredicateModel;
+    dialect: SqlDialect;
+    enums: readonly EnumIR[];
+}): readonly CheckIR[];
+/**
+ * An index's partial predicate as IR: the raw string verbatim, or a typed
+ * expression compiled to SQL text plus its structured source.
+ */
+export declare function compileIndexPredicate(params: {
+    where: string | undefined;
+    wherePredicate: PredicateIR | undefined;
+    columns: readonly string[];
+    model: PredicateModel;
+    dialect: SqlDialect;
+    enums: readonly EnumIR[];
+}): {
+    readonly where: string;
+    readonly wherePredicate?: PredicateIR;
+} | undefined;
+//# sourceMappingURL=predicate.d.ts.map

package/dist/predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../src/predicate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAkB,MAAM,iBAAiB,CAAC;AAE1G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EACd,gBAAgB,EAEhB,gBAAgB,EAEhB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAyEpB;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,OAAO,SAAS,gBAAgB,GAAG,gBAAgB,KAChD,gBAAgB,CAAC,QAAQ,EAAE,OAAO,CAAC,CA8DvC;AAID,kFAAkF;AAClF,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC5E;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAA;CAAE,CAAC;AAEvF;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACrC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,cAAc,GAAG,SAAS,CAAC;IACjE,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,SAAS,cAAc,EAAE,CAmB5B;AAID,oEAAoE;AACpE,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;CACrC,CAAC;AAEF;;;;;;;;;GASG;AACH,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC;IAAC,KAAK,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAE,GAAG,SAAS,WAAW,EAAE,CAGtJ;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE;IACpC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,cAAc,GAAG,SAAS,CAAC;IACjE,KAAK,EAAE,cAAc,CAAC;IACtB,OAAO,EAAE,UAAU,CAAC;IACpB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B,GAAG,SAAS,OAAO,EAAE,CAkBrB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,cAAc,EAAE,WAAW,GAAG,SAAS,CAAC;IACxC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,cAAc,CAAC;IACtB,OAAO,EAAE,UAAU,CAAC;IACpB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,WAAW,CAAA;CAAE,GAAG,SAAS,CAwBhF"}

package/dist/relation-plan.d.ts

@@ -20,7 +20,7 @@
  *    parent) use the `@relation` alias when there is one, else the source model
  *    name, suffixed on collision.
  */
-import type { CascadeAction, RelationType } from "@vibeorm/schema";
+import type { CascadeAction, PredicateIR, RelationType } from "@vibeorm/schema";
 import type { IndexType, ModelDef, RelationsMap, SchemaDef } from "./types.ts";
 /**
  * Structural role of a planned relation field:
@@ -43,7 +43,11 @@ export type PlannedRelation = {
     readonly isOptional: boolean;
     /** `@relation("Name")` — the DSL's `alias`. */
     readonly relationName?: string;
+    /** Physical FOREIGN KEY name — the DSL's `constraintName`, never the alias. */
+    readonly constraintName?: string;
+    /** FK columns on this model, in declared order; member `i` pairs with `references[i]`. */
     readonly fields?: readonly string[];
+    /** Referenced columns on the target model, in declared order. */
     readonly references?: readonly string[];
     readonly onDelete?: CascadeAction;
     readonly onUpdate?: CascadeAction;
@@ -56,6 +60,8 @@ export type PlannedIndex = {
     readonly indexType?: IndexType;
     /** Partial-index predicate (raw SQL) — postgres/pglite/sqlite only. */
     readonly where?: string;
+    /** Partial-index predicate as a typed expression, rendered when the dialect is known. */
+    readonly wherePredicate?: PredicateIR;
     /** `UNIQUE NULLS NOT DISTINCT` — unique indexes on postgres/pglite (15+) only. */
     readonly nullsNotDistinct?: boolean;
     /** Client selector name for a compound unique (Prisma `@@unique(..., name:)`). */
@@ -74,6 +80,8 @@ export type MergedOneToOneSide = {
     /** Merged referential actions — the FK owner's win. */
     readonly onDelete?: CascadeAction;
     readonly onUpdate?: CascadeAction;
+    /** Merged physical FK name — the FK owner's wins; either side may declare it. */
+    readonly constraintName?: string;
 };
 /**
  * Finds pairs of `r.one` relations that describe the same 1:1 relationship

package/dist/relation-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relation-plan.d.ts","sourceRoot":"","sources":["../src/relation-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGnE,OAAO,KAAK,EACV,SAAS,EACT,QAAQ,EACR,YAAY,EACZ,SAAS,EAEV,MAAM,YAAY,CAAC;AAIpB;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;AAEjE,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC;CACnC,CAAC;AAEF,4EAA4E;AAC5E,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,uEAAuE;IACvE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC,kFAAkF;IAClF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,8DAA8D;AAC9D,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC,CAAC;IACpE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC,CAAC;CAChE,CAAC;AAIF,+DAA+D;AAC/D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,uDAAuD;IACvD,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC;CACnC,CAAC;AAQF;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACvC,GAAG,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAmElC;AA4QD,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GAAG,UAAU,CA8BpE;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,QAAQ,EAAE,eAAe,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;CAClB,GAAG,YAAY,CAgBf"}
+{"version":3,"file":"relation-plan.d.ts","sourceRoot":"","sources":["../src/relation-plan.ts"],"names":[],"mappings":"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"}

package/dist/relations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../src/relations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAGV,QAAQ,EACR,eAAe,EAEf,gBAAgB,EAChB,YAAY,EACZ,eAAe,EAGhB,MAAM,YAAY,CAAC;AAgIpB;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,OAAO,SAAS,YAAY,EAC1G,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,CAAC,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAK,OAAO,GAAG,eAAe,CAAC,OAAO,CAAC,GAC7E,OAAO,CAGT;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,OAAO,SAAS,YAAY,EAC9G,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,CAAC,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,GACtF,OAAO,CAGT;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,KAAK,CAAC,MAAM,SAAS,SAAS,YAAY,EAAE,EAAE,GAAG,KAAK,EAAE,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,CAWtH"}
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../src/relations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAKV,QAAQ,EACR,eAAe,EAGf,gBAAgB,EAChB,YAAY,EACZ,eAAe,EAGhB,MAAM,YAAY,CAAC;AAmMpB;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,OAAO,SAAS,YAAY,EAC1G,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,CAAC,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAK,OAAO,GAAG,eAAe,CAAC,OAAO,CAAC,GAC7E,OAAO,CAGT;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,OAAO,SAAS,YAAY,EAC9G,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,CAAC,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,GACtF,OAAO,CAGT;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,KAAK,CAAC,MAAM,SAAS,SAAS,YAAY,EAAE,EAAE,GAAG,KAAK,EAAE,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,CAWtH"}

package/dist/to-ir.d.ts

@@ -26,12 +26,25 @@
  * - `.collation()` / `{ collation }` → `FieldIR.collation`.
  * - relation types are derived structurally by `resolveRelationType`.
  */
-import type { DefaultValueIR, ExtensionRegistry, Provider, SchemaIR } from "@vibeorm/schema";
+import type { DefaultValueIR, ExtensionRegistry, FieldIR, Provider, SchemaIR } from "@vibeorm/schema";
 import type { ColumnDef, SchemaDef } from "./types.ts";
 /** Compile a column default once for both DSL output paths. */
 export declare function fieldDefault(params: {
     column: ColumnDef;
 }): DefaultValueIR | undefined;
+/**
+ * One column as `FieldIR`.
+ *
+ * Exported so the `.prisma` printer compiles typed CHECK and partial-index
+ * expressions against exactly the same physical names and scalar types the IR
+ * path uses — a second mapping is how the two would drift apart.
+ */
+export declare function buildField(params: {
+    name: string;
+    column: ColumnDef;
+    /** Native type resolved by an extension field-type lowering, when present. */
+    extensionNativeType?: string;
+}): FieldIR;
 /**
  * Compiles a composed DSL schema to the canonical `SchemaIR`, then validates it.
  *

package/dist/to-ir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-ir.d.ts","sourceRoot":"","sources":["../src/to-ir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAWH,OAAO,KAAK,EACV,cAAc,EAGd,iBAAiB,EAMjB,QAAQ,EAER,QAAQ,EAET,MAAM,iBAAiB,CAAC;AAGzB,OAAO,KAAK,EACV,SAAS,EAKT,SAAS,EAEV,MAAM,YAAY,CAAC;AAwDpB,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GAAG,cAAc,GAAG,SAAS,CAyCtF;AA+RD;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE;IAC3B,MAAM,EAAE,SAAS,CAAC;IAClB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC,GAAG,QAAQ,CA+CX"}
+{"version":3,"file":"to-ir.d.ts","sourceRoot":"","sources":["../src/to-ir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAYH,OAAO,KAAK,EACV,cAAc,EAGd,iBAAiB,EACjB,OAAO,EAKP,QAAQ,EAER,QAAQ,EAET,MAAM,iBAAiB,CAAC;AAQzB,OAAO,KAAK,EACV,SAAS,EAKT,SAAS,EAEV,MAAM,YAAY,CAAC;AA6BpB,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GAAG,cAAc,GAAG,SAAS,CAyCtF;AA6CD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,CAAC;IAClB,8EAA8E;IAC9E,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B,GAAG,OAAO,CA8BV;AA0OD;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE;IAC3B,MAAM,EAAE,SAAS,CAAC;IAClB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC,GAAG,QAAQ,CAmDX"}

package/dist/types.d.ts

@@ -5,7 +5,7 @@
  * through `defineRelations` (Drizzle-style), which keeps column references
  * type-safe without inference-heavy model types.
  */
-import type { CascadeAction, EnumStorage, ExtensionAttributeValue, RlsContextIR, RlsContextRefIR, RlsPolicyIR } from "@vibeorm/schema";
+import type { ExclusionSpec, ExclusionEndpoint, CascadeAction, EnumStorage, ExtensionAttributeValue, PredicateIR, Provider, RlsContextIR, RlsContextRefIR, RlsPolicyIR } from "@vibeorm/schema";
 import type { ChainableEnumColumn } from "./column.ts";
 /** Referential actions, re-exported from the IR so both sources agree. */
 export type { CascadeAction };
@@ -175,11 +175,59 @@ export type ChildrenDef = {
 export type ChildrenBuilder = {
     children(config: ChildrenRelationConfig): ChildrenDef;
 };
-/** A named CHECK constraint (raw SQL expression) on a model. */
+/**
+ * A named CHECK constraint written as a RAW SQL expression.
+ *
+ * This is the documented escape hatch for anything the typed expression
+ * language cannot say (database-specific functions, operators VibeORM does not
+ * model). The text is carried through VERBATIM: never parsed, never
+ * re-rendered, never checked against the model — so physical column names and
+ * dialect-specific syntax are the author's responsibility here.
+ */
+/** Range operands are restricted to the schema's matching scalar columns. */
+export type ExclusionConfig<TSchema extends SchemaDefinition> = Omit<ExclusionSpec<SchemaColumnNames<TSchema>>, "range"> & {
+    readonly range: ({
+        readonly type: "int8range";
+        readonly lower: ExclusionEndpoint<ExclusionColumns<TSchema, "bigint">>;
+        readonly upper: ExclusionEndpoint<ExclusionColumns<TSchema, "bigint">>;
+    } | {
+        readonly type: "tsrange" | "tstzrange";
+        readonly lower: ExclusionEndpoint<ExclusionColumns<TSchema, "datetime">>;
+        readonly upper: ExclusionEndpoint<ExclusionColumns<TSchema, "datetime">>;
+    }) & {
+        readonly bounds: "[)" | "[]" | "()" | "(]";
+    };
+};
+type ExclusionColumns<TSchema extends SchemaDefinition, TType extends ColumnType> = {
+    [K in keyof TSchema]: TSchema[K] extends ColumnDef<TType> ? K : never;
+}[keyof TSchema] & string;
+/** Predicate callback for a model's exclusion declarations. */
+export type ExclusionsCallback<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = (c: PredicateBuilder<TColumns, TSchema>) => readonly ExclusionSpec<TColumns>[];
 export type ModelCheckConfig = {
     readonly name: string;
     readonly expression: string;
 };
+/**
+ * A named CHECK constraint built from a TYPED expression (`c.named(...)`).
+ *
+ * The predicate is serializable data compiled to SQL once, when the schema
+ * becomes IR or `.prisma` text — never a JavaScript callback carried
+ * downstream.
+ */
+export type NamedCheckDef = {
+    readonly __type: "check";
+    readonly name: string;
+    readonly predicate: PredicateIR;
+};
+/**
+ * The `c` handed to a model's `checks` callback, returning named typed CHECKs.
+ *
+ * @example
+ * checks: (c) => [
+ *   c.named("dispatch_clock", c.gt(c.field("deadlineAt"), c.field("startedAt"))),
+ * ]
+ */
+export type ChecksCallback<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = (c: PredicateBuilder<TColumns, TSchema>) => NamedCheckDef[];
 /**
  * Application-level row-scoping policy — the DSL twin of
  * `@@policy([field], context: "key")`. The runtime fails closed on policied
@@ -200,8 +248,18 @@ export type IndexDef = {
     readonly __type: "index" | "unique";
     readonly __columns: readonly string[];
     readonly __indexType?: IndexType;
-    /** Partial-index predicate (raw SQL) — postgres/pglite/sqlite only. */
+    /**
+     * Partial-index predicate as RAW SQL — postgres/pglite/sqlite only. Carried
+     * verbatim, exactly like a raw CHECK: the escape hatch for predicates the
+     * typed expression language cannot say.
+     */
     readonly __where?: string;
+    /**
+     * Partial-index predicate as a TYPED expression (`.where((c) => …)`),
+     * compiled to SQL once when the schema becomes IR or `.prisma` text. Refused
+     * alongside `__where` — one index has one predicate.
+     */
+    readonly __wherePredicate?: PredicateIR;
     /** `UNIQUE NULLS NOT DISTINCT` — unique indexes on postgres/pglite (15+) only. */
     readonly __nullsNotDistinct?: boolean;
     /** Client selector name for a compound unique (Prisma `@@unique(..., name:)`). */
@@ -230,20 +288,116 @@ export type UniqueIndexOptions = {
      */
     name?: string;
 };
+/**
+ * An index that can still be narrowed by a TYPED partial predicate.
+ *
+ * `.where()` is terminal — it returns the plain {@link IndexDef} — so an index
+ * carries at most one predicate and the chain cannot be reopened.
+ *
+ * @example
+ * i.index("deadlineAt").where((c) => c.isNull("cancelledAt"))
+ */
+export type PartialIndexDef<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = IndexDef & {
+    where(predicate: (c: PredicateBuilder<TColumns, TSchema>) => PredicateIR): IndexDef;
+};
 /** Index builder; column names are constrained to the model's own columns. */
-export type IndexBuilder<TColumns extends string = string> = {
-    on<T extends TColumns>(...columns: T[]): IndexDef;
-    on<T extends TColumns>(columns: T[], options: IndexOptions): IndexDef;
+export type IndexBuilder<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = {
+    on<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
+    on<T extends TColumns>(columns: T[], options: IndexOptions): PartialIndexDef<TColumns, TSchema>;
     /** Alias of `on(...)` — reads better next to `unique(...)`. */
-    index<T extends TColumns>(...columns: T[]): IndexDef;
-    unique<T extends TColumns>(...columns: T[]): IndexDef;
-    unique<T extends TColumns>(columns: T[], options: UniqueIndexOptions): IndexDef;
-    gin<T extends TColumns>(...columns: T[]): IndexDef;
-    gist<T extends TColumns>(...columns: T[]): IndexDef;
-    hash<T extends TColumns>(...columns: T[]): IndexDef;
-    brin<T extends TColumns>(...columns: T[]): IndexDef;
-};
-export type IndexCallback<TColumns extends string = string> = (i: IndexBuilder<TColumns>) => IndexDef[];
+    index<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
+    unique<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
+    unique<T extends TColumns>(columns: T[], options: UniqueIndexOptions): PartialIndexDef<TColumns, TSchema>;
+    gin<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
+    gist<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
+    hash<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
+    brin<T extends TColumns>(...columns: T[]): PartialIndexDef<TColumns, TSchema>;
+};
+export type IndexCallback<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = (i: IndexBuilder<TColumns, TSchema>) => IndexDef[];
+/**
+ * The JavaScript literal a column of each pairing tag admits.
+ *
+ * `DateTime` is deliberately `never`: the same instant is spelled three
+ * different ways across postgres, mysql and sqlite, and guessing wrong is a
+ * silent data bug rather than an error — so a fixed instant goes through the
+ * raw-expression escape hatch, while "end after start" is a column-to-column
+ * comparison that needs no literal at all. `Json`, `Bytes` and `Unsupported`
+ * are `never` because VibeORM does not model their operators.
+ *
+ * `Decimal` takes exact decimal TEXT (`"19.99"`) for the reason column defaults
+ * do: a JS number cannot carry an exact decimal.
+ */
+type PredicateLiteralByRefKind = {
+    readonly String: string;
+    readonly Boolean: boolean;
+    readonly Int: number;
+    readonly BigInt: bigint | number;
+    readonly Float: number;
+    readonly Decimal: string;
+    readonly DateTime: never;
+    readonly Json: never;
+    readonly Bytes: never;
+    readonly Enum: string;
+    readonly Id: string | number;
+    readonly Unsupported: never;
+};
+/**
+ * A reference to one of the model's own fields inside a predicate.
+ *
+ * Structurally a `PredicateFieldRef` (`{ kind: "field", name }`) plus the
+ * pairing tag comparisons are checked against. The tag carries no value and is
+ * stripped when the builder writes the IR, so nothing `__kind`-shaped is ever
+ * serialized.
+ */
+export type PredicateFieldExpr<TColumn extends string = string, TKind extends ColumnRefKind = ColumnRefKind> = {
+    readonly kind: "field";
+    readonly name: TColumn;
+    readonly __kind: TKind;
+};
+/**
+ * What may sit opposite a field of a given tag: a literal of its own scalar, or
+ * another field whose scalar can be compared with it.
+ *
+ * Column pairing reads {@link PairableRefKind} — the SAME table foreign keys
+ * use — because a foreign key and a comparison ask one question: are these two
+ * columns the same scalar family?
+ */
+type ComparisonOperand<TKind extends ColumnRefKind> = PredicateLiteralByRefKind[TKind] | PredicateFieldExpr<string, PairableRefKind[TKind]>;
+/**
+ * The `c` handed to `checks` and to an index's `.where()`.
+ *
+ * Every combinator returns serializable {@link PredicateIR} — never a callback
+ * — and the SQL text is produced once, when the schema is compiled and the
+ * dialect is known.
+ *
+ * SQL three-valued logic applies unchanged: a comparison against NULL is
+ * UNKNOWN, and a CHECK passes on TRUE **or** UNKNOWN, so a comparison alone
+ * never rejects a NULL row. Nothing here adds a hidden null guard — write
+ * all-or-none out with {@link PredicateBuilder.isNull} / `isNotNull`.
+ */
+export type PredicateBuilder<TColumns extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> = {
+    /** Reference one of the model's own fields, by LOGICAL name. */
+    field<C extends TColumns>(name: C): PredicateFieldExpr<C, SchemaColumnRefKind<TSchema, C>>;
+    eq<TKind extends ColumnRefKind>(left: PredicateFieldExpr<string, TKind>, right: ComparisonOperand<TKind>): PredicateIR;
+    ne<TKind extends ColumnRefKind>(left: PredicateFieldExpr<string, TKind>, right: ComparisonOperand<TKind>): PredicateIR;
+    gt<TKind extends ColumnRefKind>(left: PredicateFieldExpr<string, TKind>, right: ComparisonOperand<TKind>): PredicateIR;
+    gte<TKind extends ColumnRefKind>(left: PredicateFieldExpr<string, TKind>, right: ComparisonOperand<TKind>): PredicateIR;
+    lt<TKind extends ColumnRefKind>(left: PredicateFieldExpr<string, TKind>, right: ComparisonOperand<TKind>): PredicateIR;
+    lte<TKind extends ColumnRefKind>(left: PredicateFieldExpr<string, TKind>, right: ComparisonOperand<TKind>): PredicateIR;
+    /** `col IN (…)`. Membership, not a set operation — every value is a literal. */
+    inList<TKind extends ColumnRefKind>(field: PredicateFieldExpr<string, TKind>, values: readonly PredicateLiteralByRefKind[TKind][]): PredicateIR;
+    /** `col NOT IN (…)`. NULL in the column stays UNKNOWN, as SQL defines it. */
+    notInList<TKind extends ColumnRefKind>(field: PredicateFieldExpr<string, TKind>, values: readonly PredicateLiteralByRefKind[TKind][]): PredicateIR;
+    /** `col IS NULL` — the EXPLICIT null test; a comparison never implies one. */
+    isNull<C extends TColumns>(name: C): PredicateIR;
+    /** `col IS NOT NULL`. */
+    isNotNull<C extends TColumns>(name: C): PredicateIR;
+    and(...operands: PredicateIR[]): PredicateIR;
+    or(...operands: PredicateIR[]): PredicateIR;
+    not(operand: PredicateIR): PredicateIR;
+    /** Name a predicate as a CHECK constraint. The name keys the migration diff. */
+    named(name: string, predicate: PredicateIR): NamedCheckDef;
+};
 /** A model. `TSchema` is preserved so relations can reference real columns. */
 export type ModelDef<TSchema extends SchemaDefinition = SchemaDefinition> = {
     readonly __type: "model";
@@ -256,8 +410,12 @@ export type ModelDef<TSchema extends SchemaDefinition = SchemaDefinition> = {
     readonly __map?: string;
     /** `@@id([...])` — compound primary key. */
     readonly __primaryKey?: readonly string[];
-    /** Named CHECK constraints (`@@check`-equivalent). */
-    readonly __checks?: readonly ModelCheckConfig[];
+    /**
+     * Named CHECK constraints (`@@check`-equivalent): the raw-SQL array form, or
+     * the typed-expression callback. Evaluated once, where the dialect is known.
+     */
+    readonly __exclusions?: readonly ExclusionSpec[] | ExclusionsCallback;
+    readonly __checks?: readonly ModelCheckConfig[] | ChecksCallback;
     /** Extension attributes declared on the model (`@@search`-style). */
     readonly __extensions?: readonly ExtensionAttributeUse[];
     /** `@@policy([field], context: "key")` — application-level row scoping. */
@@ -275,13 +433,23 @@ export type SchemaColumnNames<T> = Extract<ColumnKeys<T>, string>;
 export type CreateModelConfig<TSchema extends SchemaDefinition = SchemaDefinition> = {
     name: string;
     schema: TSchema | ((s: ChildrenBuilder) => TSchema);
-    indexes?: IndexCallback<SchemaColumnNames<TSchema>>;
+    indexes?: IndexCallback<SchemaColumnNames<TSchema>, TSchema>;
     /** `@@map("table_name")` — database table name when it differs. */
     map?: string;
     /** `@@id([...])` — compound primary key columns. */
     primaryKey?: SchemaColumnNames<TSchema>[];
-    /** Named CHECK constraints — raw SQL expressions, name-keyed in migrations. */
-    checks?: readonly ModelCheckConfig[];
+    /**
+     * Named CHECK constraints, name-keyed in migrations. Either the TYPED
+     * expression callback (checked against this model's fields) or the raw-SQL
+     * array form, which is carried verbatim as the escape hatch.
+     *
+     * @example
+     * checks: (c) => [c.named("qty_nonnegative", c.gte(c.field("qty"), 0))]
+     * @example
+     * checks: [{ name: "qty_nonnegative", expression: '"qty" >= 0' }]
+     */
+    exclusions?: readonly ExclusionConfig<TSchema>[] | ((c: PredicateBuilder<SchemaColumnNames<TSchema>, TSchema>) => readonly ExclusionConfig<TSchema>[]);
+    checks?: readonly ModelCheckConfig[] | ChecksCallback<SchemaColumnNames<TSchema>, TSchema>;
     /** Extension model attributes (`@@search`-style declarations). */
     extensions?: readonly ExtensionAttributeUse[];
     /**
@@ -292,11 +460,61 @@ export type CreateModelConfig<TSchema extends SchemaDefinition = SchemaDefinitio
     /** Model doc comment — emitted as `///` lines above the model, kept as `ModelIR.documentation`. */
     comment?: string;
 };
+/**
+ * The scalar identity relation pairing compares.
+ *
+ * Deliberately coarser than `FieldType`: `dsl.id()` carries the single tag
+ * `"Id"` because the DSL type does not record whether an id is String-backed or
+ * `autoincrement`, and an enum column carries `"Enum"` without its name. The
+ * type level rejects the pairs no id strategy and no enum could ever make legal
+ * (String↔Int, DateTime↔String); relation planning compares the real
+ * `FieldType` — id strategy and enum name included — when it builds the IR.
+ */
+export type ColumnRefKind = "String" | "Boolean" | "Int" | "BigInt" | "Float" | "Decimal" | "DateTime" | "Json" | "Bytes" | "Enum" | "Id" | "Unsupported";
+/** `ColumnType` → `ColumnRefKind`, as a table: one indexed access, never a conditional chain. */
+type RefKindByColumnType = {
+    readonly string: "String";
+    readonly int: "Int";
+    readonly bigint: "BigInt";
+    readonly float: "Float";
+    readonly decimal: "Decimal";
+    readonly boolean: "Boolean";
+    readonly datetime: "DateTime";
+    readonly json: "Json";
+    readonly bytes: "Bytes";
+    readonly id: "Id";
+    readonly enum: "Enum";
+    readonly unsupported: "Unsupported";
+};
+/** The pairing tag of a column kind. */
+export type ColumnRefKindOf<TColumn extends ColumnType> = RefKindByColumnType[TColumn];
+/**
+ * Which tags may sit OPPOSITE a given tag in a relation pair. Symmetric, and
+ * `"Id"` pairs with both scalars an id column can be backed by. `Json` and an
+ * `Unsupported` column can never be a foreign key on any dialect here, so they
+ * pair with nothing.
+ */
+type PairableRefKind = {
+    readonly String: "String" | "Id";
+    readonly Boolean: "Boolean";
+    readonly Int: "Int" | "Id";
+    readonly BigInt: "BigInt";
+    readonly Float: "Float";
+    readonly Decimal: "Decimal";
+    readonly DateTime: "DateTime";
+    readonly Json: never;
+    readonly Bytes: "Bytes";
+    readonly Enum: "Enum";
+    readonly Id: "Id" | "String" | "Int";
+    readonly Unsupported: never;
+};
 /** A reference to `Model.column`, used for relation `from` / `to`. */
-export type ColumnRef<TModel extends string = string, TColumn extends string = string> = {
+export type ColumnRef<TModel extends string = string, TColumn extends string = string, TKind extends ColumnRefKind = ColumnRefKind> = {
     readonly __type: "columnRef";
     readonly __model: TModel;
     readonly __column: TColumn;
+    /** Pairing tag; carries no value, only the scalar identity `to` is checked against. */
+    readonly __kind: TKind;
     through<TJunction extends string, TJunctionCol extends string>(junction: ColumnRef<TJunction, TJunctionCol>): ThroughRef<TModel, TColumn, TJunction, TJunctionCol>;
 };
 /** A column reference routed through a junction model (many-to-many). */
@@ -307,24 +525,48 @@ export type ThroughRef<TModel extends string = string, TColumn extends string =
     readonly __junction: TJunction;
     readonly __junctionColumn: TJunctionCol;
 };
+/**
+ * One end of a relation reference: a single column (today's syntax) or an
+ * ordered tuple of columns from ONE model (a composite key).
+ */
+export type RelationRefInput = ColumnRef | ThroughRef | readonly ColumnRef[];
+/** The `to` partner a single `from` column admits. */
+type PairedColumnRef<TRef> = TRef extends ColumnRef<string, string, infer TKind extends ColumnRefKind> ? ColumnRef<string, string, PairableRefKind[TKind]> : never;
+/**
+ * The `to` a given `from` admits: the same arity, each position restricted to
+ * the scalar tags its partner can pair with. Mapping over a tuple keeps its
+ * length, so a `to` of the wrong size is a type error at the `to:` property.
+ */
+export type RelationTarget<TFrom extends RelationRefInput> = TFrom extends readonly ColumnRef[] ? {
+    readonly [TIndex in keyof TFrom]: PairedColumnRef<TFrom[TIndex]>;
+} : TFrom extends ColumnRef ? PairedColumnRef<TFrom> | ThroughRef : ColumnRef | ThroughRef;
 /** Config for `r.one.Model({ from, to })`. */
-export type OneRelationDefConfig<TFrom extends ColumnRef | ThroughRef = ColumnRef, TTo extends ColumnRef | ThroughRef = ColumnRef> = {
+export type OneRelationDefConfig<TFrom extends RelationRefInput = ColumnRef> = {
     /** Explicitly identifies the foreign-key side of a one-to-one pair. */
     ownsForeignKey?: boolean;
     from: TFrom;
-    to: TTo;
+    to: RelationTarget<TFrom>;
     optional?: boolean;
     /** `@relation("Name")` — disambiguates multiple relations between a pair. */
     alias?: string;
+    /**
+     * Physical FOREIGN KEY constraint name (`@relation(map: "…")` in .prisma).
+     * Independent of `alias` and of the relation key: those name the client
+     * field, this names the database object. Set it to adopt an existing
+     * constraint under the name the database already gave it.
+     */
+    constraintName?: string;
     onDelete?: CascadeAction;
     onUpdate?: CascadeAction;
 };
 /** Config for `r.many.Model({ from, to })`. */
-export type ManyRelationDefConfig<TFrom extends ColumnRef | ThroughRef = ColumnRef | ThroughRef, TTo extends ColumnRef | ThroughRef = ColumnRef | ThroughRef> = {
+export type ManyRelationDefConfig<TFrom extends RelationRefInput = ColumnRef | ThroughRef> = {
     from: TFrom;
-    to: TTo;
+    to: RelationTarget<TFrom>;
     optional?: boolean;
     alias?: string;
+    /** Physical FOREIGN KEY constraint name; see `OneRelationDefConfig.constraintName`. */
+    constraintName?: string;
     onDelete?: CascadeAction;
     onUpdate?: CascadeAction;
 };
@@ -334,14 +576,22 @@ export type StoredRelationDef<TKind extends "one" | "many" = "one" | "many", TTa
     readonly __relationType: TKind;
     readonly __targetModel: TTarget;
     readonly __fromModel: string;
+    /** First `from` member — `__fromColumns[0]`. The tuple is authoritative. */
     readonly __fromColumn: string;
+    /** Every `from` member, in declared order. Length 1 for a single-column relation. */
+    readonly __fromColumns: readonly string[];
     readonly __toModel: string;
+    /** First `to` member — `__toColumns[0]`. The tuple is authoritative. */
     readonly __toColumn: string;
+    /** Every `to` member, in declared order; member `i` pairs with `__fromColumns[i]`. */
+    readonly __toColumns: readonly string[];
     readonly __throughJunction?: string;
     readonly __throughFromCol?: string;
     readonly __throughToCol?: string;
     readonly __optional: boolean;
     readonly __alias?: string;
+    /** Physical FOREIGN KEY constraint name, independent of `__alias`. */
+    readonly __constraintName?: string;
     readonly __ownsForeignKey?: boolean;
     readonly __onDelete?: CascadeAction;
     readonly __onUpdate?: CascadeAction;
@@ -350,17 +600,19 @@ export type StoredRelationDef<TKind extends "one" | "many" = "one" | "many", TTa
 export type RelationsMap = Record<string, Record<string, StoredRelationDef>>;
 /** Column names of a `ModelDef`, extracted from its schema type. */
 export type ExtractModelColumns<T> = T extends ModelDef<infer TSchema> ? Extract<keyof TSchema, string> : never;
+/** The pairing tag of one column of a model schema. */
+type SchemaColumnRefKind<TSchema, TColumn extends PropertyKey> = TColumn extends keyof TSchema ? (TSchema[TColumn] extends ColumnDef<infer TColumnType> ? ColumnRefKindOf<TColumnType> : ColumnRefKind) : ColumnRefKind;
 /** `r.User.id`, `r.User.email`, … */
-export type ModelColumnRefs<TModelName extends string, TModel extends ModelDef> = {
-    [C in ExtractModelColumns<TModel>]: ColumnRef<TModelName, C>;
-};
+export type ModelColumnRefs<TModelName extends string, TModel extends ModelDef> = TModel extends ModelDef<infer TSchema> ? {
+    [C in Extract<keyof TSchema, string>]: ColumnRef<TModelName, C, SchemaColumnRefKind<TSchema, C>>;
+} : Record<string, ColumnRef<TModelName>>;
 /** The `r` handed to a `defineRelations` callback. */
 export type RelationsBuilder<TSchema extends Record<string, ModelDef>> = {
     one: {
-        [K in keyof TSchema & string]: <TFrom extends ColumnRef | ThroughRef, TTo extends ColumnRef | ThroughRef>(config: OneRelationDefConfig<TFrom, TTo>) => StoredRelationDef<"one", K>;
+        [K in keyof TSchema & string]: <const TFrom extends RelationRefInput>(config: OneRelationDefConfig<TFrom>) => StoredRelationDef<"one", K>;
     };
     many: {
-        [K in keyof TSchema & string]: <TFrom extends ColumnRef | ThroughRef, TTo extends ColumnRef | ThroughRef>(config: ManyRelationDefConfig<TFrom, TTo>) => StoredRelationDef<"many", K>;
+        [K in keyof TSchema & string]: <const TFrom extends RelationRefInput>(config: ManyRelationDefConfig<TFrom>) => StoredRelationDef<"many", K>;
     };
 } & {
     [K in keyof TSchema & string]: ModelColumnRefs<K, TSchema[K]>;
@@ -432,6 +684,13 @@ export type SchemaDef = {
 };
 export type PrismaGeneratorConfig = {
     output?: string;
+    /**
+     * Datasource provider the printed schema targets. Only typed CHECK and
+     * partial-index expressions read it — they become SQL text while printing,
+     * and identifier quoting and literal spelling are dialect decisions. Defaults
+     * to `"postgresql"`, matching `toIR`.
+     */
+    provider?: Provider;
 };
 export type GeneratorOutput = {
     prisma?: string;