@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20

package/dist/{types-YStFFkKs-D9UAmnON.d.mts → types-CuCxAQat-Dz8P4xyt.d.mts}

@@ -1,9 +1,9 @@
-import { r as SqlObjectNaming } from "./naming-CV9j2pXl-KARaDReS.mjs";
+import { r as SqlObjectNaming } from "./naming-BcD36g9T-Mfe_xGGL.mjs";
 import { IRNodeBase } from "@prisma/orm-framework/components/ir";
+import { CodecRef, DataType, DataTypeParams, DataTypeValue } from "@prisma/orm-framework/components/codec";
 import { ColumnDefault } from "@prisma/orm-framework/contract/types";
-import { CodecRef } from "@prisma/orm-framework/components/codec";
-import { DiffSubjectGranularity, DiffableNode, SchemaNodeRef } from "@prisma/orm-framework/components/control";
-//#region ../../../2-sql/1-core/schema-ir/dist/types-YStFFkKs.d.mts
+import { DiffSubjectGranularity, DiffableNode, MismatchExplanation, SchemaNodeRef } from "@prisma/orm-framework/components/control";
+//#region ../../../2-sql-family/1-core/schema-ir/dist/types-CuCxAQat.d.mts
 //#region src/ir/sql-schema-ir-node.d.ts
 /**
  * SQL Schema IR node base. Carries the family-level
@@ -175,17 +175,30 @@ declare class SqlCheckConstraintIR extends SqlSchemaIRNode implements DiffableNo
   isEqualTo(other: DiffableNode): boolean;
 }
 //#endregion
+//#region src/ir/sql-default-value.d.ts
+/**
+ * A literal default as a value of its column's data type: one value, or for a list column its elements, with `null` for an element that is SQL NULL. ADR 254.
+ */
+type SqlDefaultValue = DataTypeValue | readonly (DataTypeValue | null)[];
+/** Whether two defaults are one value: the same type, parameters and value, element by element for a list. */
+declare function sqlDefaultValuesEqual(a: SqlDefaultValue, b: SqlDefaultValue): boolean;
+//#endregion
 //#region src/ir/sql-column-default-ir.d.ts
+/** The `sql` literal that writes a SQL text, or `undefined` when no literal reads back as that text. */
+type SqlExpressionLiteralFor = (text: string) => string | undefined;
 interface SqlColumnDefaultIRInput {
-  /** Structured resolved default (contract-declared or normalizer-parsed). */
+  /** Structured default: the contract's, or what introspection read from the database. */
   readonly resolved?: ColumnDefault;
   /** Raw database default expression, when known (introspected side). */
   readonly raw?: string;
-  /**
-   * Native-type context for temporal literal normalization — the owning
-   * column's resolved native type.
-   */
-  readonly nativeTypeContext?: string;
+  /** See {@link import('./sql-column-ir').SqlColumnIRInput.authoredDefault}. */
+  readonly authored?: ColumnDefault;
+  /** See {@link import('./sql-column-ir').SqlColumnIRInput.defaultValue}. */
+  readonly value?: SqlDefaultValue;
+  /** See {@link import('./sql-column-ir').SqlColumnIRInput.defaultUnreadable}. */
+  readonly unreadable?: string;
+  /** See {@link import('./sql-column-ir').SqlColumnIRInput.defaultExpressionValue}. */
+  readonly expressionValue?: SqlDefaultValue;
   /**
    * The owning column's array-ness, threaded through so the planner's
    * set-default op-builder can render an array-literal default (e.g.
@@ -193,6 +206,14 @@ interface SqlColumnDefaultIRInput {
    * {@link import('./sql-column-ir').SqlColumnIRInput.many}.
    */
   readonly many?: boolean;
+  /**
+   * The owning column's codec identity, threaded through so the set-default op-builder renders a
+   * list default's cast to the column type the way the column's DDL writes it. See
+   * {@link import('./sql-column-ir').SqlColumnIRInput.codecRef}.
+   */
+  readonly codecRef?: CodecRef;
+  /** See {@link import('./sql-column-ir').SqlColumnIRInput.sqlExpressionLiteralFor}. */
+  readonly sqlExpressionLiteralFor?: SqlExpressionLiteralFor;
 }
 /**
  * Schema-diff node for a column's default value. The default is the one
@@ -211,21 +232,41 @@ declare class SqlColumnDefaultIR extends SqlSchemaIRNode implements DiffableNode
   readonly nodeKind: "sql-column-default";
   readonly resolved?: ColumnDefault;
   readonly raw?: string;
-  readonly nativeTypeContext?: string;
+  /** See {@link SqlColumnDefaultIRInput.authored}. Non-enumerable, same reason as {@link many}. */
+  readonly authored?: ColumnDefault;
+  /** See {@link SqlColumnDefaultIRInput.value}. Non-enumerable, same reason as {@link many}. */
+  readonly value?: SqlDefaultValue;
+  /** See {@link SqlColumnDefaultIRInput.unreadable}. Non-enumerable, same reason as {@link many}. */
+  readonly unreadable?: string;
+  /** See {@link SqlColumnDefaultIRInput.expressionValue}. Non-enumerable, same reason as {@link many}. */
+  readonly expressionValue?: SqlDefaultValue;
   /** See {@link SqlColumnDefaultIRInput.many}. Non-enumerable so it stays out of JSON and structural equality. */
   readonly many?: boolean;
+  /** See {@link SqlColumnDefaultIRInput.codecRef}. Non-enumerable, same reason as {@link many}. */
+  readonly codecRef?: CodecRef;
+  /** See {@link SqlColumnDefaultIRInput.sqlExpressionLiteralFor}. Non-enumerable, same reason as {@link many}. */
+  readonly sqlExpressionLiteralFor?: SqlExpressionLiteralFor;
   constructor(input: SqlColumnDefaultIRInput);
   get id(): string;
   children(): readonly DiffableNode[];
   static is(node: SqlSchemaIRNode): node is SqlColumnDefaultIR;
   /**
-   * Structured comparison with `this` as the expected side: both sides
-   * resolved compare per the relational walk's `columnDefaultsEqual`
-   * semantics; a declared expected default against an unparseable actual
-   * (raw present, no resolved parse) is a mismatch; two raw-only nodes fall
-   * back to raw string equality.
+   * Compares with `this` as the expected side. Two literals compare as values of the column's type
+   * when both sides hold one, and as canonical JSON otherwise; a `Date` the column's codec could not
+   * read into a value equals nothing. Two expressions compare as text, with
+   * case and whitespace ignored outside quotes. An expected expression that writes a literal, read by
+   * the column's codec during introspection, matches a reported literal when the two values are
+   * equal; when the codec could not read one of them, it compares with the reported text. A resolved
+   * side against a raw-only side is a mismatch; two raw-only nodes compare their text.
    */
   isEqualTo(other: DiffableNode): boolean;
+  /**
+   * For two default expressions, the text the database reads back, since it may store an expression
+   * in a form of its own. Otherwise why the column's codec could not read the database's default, or
+   * the value each side holds.
+   */
+  explainMismatch(actual: DiffableNode | undefined): MismatchExplanation | undefined;
+  private storedExpressionForm;
 }
 //#endregion
 //#region src/ir/sql-column-ir.d.ts
@@ -236,24 +277,28 @@ declare class SqlColumnDefaultIR extends SqlSchemaIRNode implements DiffableNode
 type SqlAnnotations = {
   readonly [namespace: string]: unknown;
 };
+/** What introspection hands over about the element type of one column. */
+interface ReportedSqlType {
+  /** The element type's text as the database reports it: on Postgres its catalog text (`format_type`), on SQLite the declared type from `PRAGMA table_info`. */
+  readonly text: string;
+  /** The target's word for the type's kind, such as `enum`; undefined for a base type. */
+  readonly kind: string | undefined;
+  readonly schema: string | undefined;
+  /** The type's name, unquoted. */
+  readonly name: string | undefined;
+}
 interface SqlColumnIRInput {
   readonly name: string;
-  readonly nativeType: string;
+  /**
+   * The column's element type as text; nothing compares it. On the contract-derived side, the name a migration writes for the type the column is stored as, with an enum named as the contract names it. On the introspected side, the type as introspection reads it: on Postgres the `format_type` text, which keeps the schema of a type off the search path, except that an enum is named as a contract names it; on SQLite the declared type, lower-cased. Mismatch messages and the schema tree show it, and default parsing reads it: the target's `resolveDefault` hook on the contract side, and SQLite's default reader on the introspected side. Columns are compared by {@link storedType} and {@link storedTypeParams}.
+   */
+  readonly typeText: string;
   readonly nullable: boolean;
   /** Raw database default expression (e.g. `'hello'::text`, `nextval('seq')`). */
   readonly default?: string;
   readonly annotations?: SqlAnnotations;
-  /** True when the column is a native array (e.g. `text[]`, `int4[]`). The `nativeType` carries the element type only (e.g. `text`, `int4`). */
+  /** True when the column is a native array (e.g. `text[]`, `int4[]`). The `typeText` carries the element type only (e.g. `text`, `int4`). */
   readonly many?: boolean;
-  /**
-   * Fully resolved native type, comparable across the two diff sides:
-   * the contract-derived side stamps the codec-expanded type (typeRef
-   * resolved, parameterized types expanded, `[]` appended for arrays);
-   * the introspected side stamps the target-normalized type with the same
-   * `[]` convention. Stamped at construction by derivation/introspection;
-   * absent on raw hand-built nodes.
-   */
-  readonly resolvedNativeType?: string;
   /**
    * Structured default, comparable across the two diff sides: the
    * contract-derived side stamps the contract's `ColumnDefault`; the
@@ -262,6 +307,12 @@ interface SqlColumnIRInput {
    * the introspected raw default could not be parsed.
    */
   readonly resolvedDefault?: ColumnDefault;
+  /**
+   * The contract's default exactly as authored, before the target's `resolveDefault` hook. The
+   * planner's DDL builders render this one, so the DDL carries the authored expression while
+   * `resolvedDefault` is what the diff compares. Absent on the introspected side.
+   */
+  readonly authoredDefault?: ColumnDefault;
   /**
    * The column's resolved codec reference — the identity the migration
    * planner's op-builders resolve DDL type rendering against at plan time
@@ -270,29 +321,39 @@ interface SqlColumnIRInput {
    * end)` op-path called. Carried the same way the query AST carries
    * `CodecRef` (TML-2456) and the migration DDL renderer (TML-2918).
    * Stamped on the EXPECTED (contract-derived) column at derivation,
-   * post-`typeRef` resolution (the referenced storage type's own
-   * codec/params, not the column's `typeRef` pointer). Absent on
+   * from the column's own codec and params. Absent on
    * introspected/hand-built nodes — the actual side never renders DDL —
    * and never compared by `isEqualTo`.
    */
   readonly codecRef?: CodecRef;
   /**
-   * The column's resolved BASE native type: pre-parameter-expansion,
-   * pre-array-suffix (e.g. `character`, not `character(36)` or
-   * `character[]`). Distinct from {@link resolvedNativeType} (the EXPANDED
-   * comparison value) — DDL rendering re-expands a parameterized type at
-   * plan time from this base, so it must not already carry the expansion.
-   * Stamped alongside {@link codecRef}.
+   * The type the column is stored as, whose name DDL writes and the database reports (ADR 254): on the contract-derived side the type its codec's data type is stored as, on the introspected side the type that claims the reported type. Absent on an introspected column no data type claims.
    */
-  readonly codecBaseNativeType?: string;
+  readonly storedType?: DataType;
+  /** The parameters of {@link storedType} in its normal form, for comparing; empty for a type without parameters. Present exactly when `storedType` is. DDL writes the parameters as written, from {@link codecRef}. */
+  readonly storedTypeParams?: DataTypeParams;
   /**
-   * True when the contract column declared its type via a named
-   * `storage.types` reference (`typeRef`) rather than inline fields — the
-   * migration planner quotes the base native type as an identifier in this
-   * case (e.g. a native enum's type name), matching the pre-`plan(start,
-   * end)` rendering exactly.
+   * A literal default as a value of the column's data type (ADR 254): on the contract-derived side read from the contract by the column's type, on the introspected side read from the database by the column's codec. The diff compares defaults by it. Absent when no type or codec read one.
    */
-  readonly codecNamedType?: boolean;
+  readonly defaultValue?: SqlDefaultValue;
+  /** Why the column's codec could not read the literal default the database reports. Introspected side only. */
+  readonly defaultUnreadable?: string;
+  /**
+   * When the contract's default is an expression that writes a literal, such as `` sql`'hello'::bytea` ``, the value the column's codec reads from that literal. Introspection reads it, beside the reported default, because only introspection reads with a codec; the diff compares it with the reported default's value. Introspected side only.
+   */
+  readonly defaultExpressionValue?: SqlDefaultValue;
+  /**
+   * The `sql` literal that writes a SQL text, or `undefined` when no literal reads back as that
+   * text. The SQL family supplies it, so a mismatch can show a default as the user would write it.
+   * Stamped on the contract-derived column; absent on introspected nodes.
+   */
+  readonly sqlExpressionLiteralFor?: SqlExpressionLiteralFor;
+  /** The element type as the database reports it. Set by introspection; absent on contract-derived nodes. */
+  readonly reportedType?: ReportedSqlType;
+  /**
+   * The element type exactly as the database catalog prints it, on a contract-derived column whose data type's name is its catalog text (ADR 273). Such a column's type is compared by this text, not by {@link storedType}: see {@link sqlColumnTypesEqual}.
+   */
+  readonly catalogText?: string;
 }
 /**
  * Schema IR node for a single column on a table, as observed by
@@ -303,30 +364,40 @@ interface SqlColumnIRInput {
  *
  * Implements `DiffableNode` so a column is directly a table's diff-tree
  * child: `id` is the column name (unique among a table's columns); `isEqualTo`
- * compares this column's own attributes only — never children, since a
- * column is a leaf. When both sides carry `resolvedNativeType` (stamped at
- * derivation/introspection), the comparison uses the resolved values —
- * resolved native type, nullability, and structured default equality per
- * the relational walk's `columnDefaultsEqual` semantics, with `this` as the
- * expected side. Otherwise it falls back to comparing raw fields.
+ * compares this column's own attributes only, never its default, which is a
+ * child node: the type by {@link sqlColumnTypesEqual}, and nullability.
  */
 declare class SqlColumnIR extends SqlSchemaIRNode implements DiffableNode {
   readonly nodeKind: "sql-column";
   readonly name: string;
-  readonly nativeType: string;
+  /** See {@link SqlColumnIRInput.typeText}. */
+  readonly typeText: string;
   readonly nullable: boolean;
   readonly default?: string;
   readonly annotations?: SqlAnnotations;
-  /** True when the column is a native array (e.g. `text[]`, `int4[]`). The `nativeType` carries the element type only (e.g. `text`, `int4`). */
+  /** True when the column is a native array (e.g. `text[]`, `int4[]`). The `typeText` carries the element type only (e.g. `text`, `int4`). */
   readonly many?: boolean;
-  readonly resolvedNativeType?: string;
   readonly resolvedDefault?: ColumnDefault;
+  /** See {@link SqlColumnIRInput.authoredDefault}. Non-enumerable so it stays out of JSON and structural equality. */
+  readonly authoredDefault?: ColumnDefault;
   /** See {@link SqlColumnIRInput.codecRef}. Non-enumerable so it stays out of JSON and structural equality. */
   readonly codecRef?: CodecRef;
-  /** See {@link SqlColumnIRInput.codecBaseNativeType}. Non-enumerable, same reason as {@link codecRef}. */
-  readonly codecBaseNativeType?: string;
-  /** See {@link SqlColumnIRInput.codecNamedType}. Non-enumerable, same reason as {@link codecRef}. */
-  readonly codecNamedType?: boolean;
+  /** See {@link SqlColumnIRInput.storedType}. Non-enumerable, same reason as {@link codecRef}. */
+  readonly storedType?: DataType;
+  /** See {@link SqlColumnIRInput.storedTypeParams}. Non-enumerable, same reason as {@link codecRef}. */
+  readonly storedTypeParams?: DataTypeParams;
+  /** See {@link SqlColumnIRInput.defaultValue}. Non-enumerable, same reason as {@link codecRef}. */
+  readonly defaultValue?: SqlDefaultValue;
+  /** See {@link SqlColumnIRInput.defaultUnreadable}. Non-enumerable, same reason as {@link codecRef}. */
+  readonly defaultUnreadable?: string;
+  /** See {@link SqlColumnIRInput.defaultExpressionValue}. Non-enumerable, same reason as {@link codecRef}. */
+  readonly defaultExpressionValue?: SqlDefaultValue;
+  /** See {@link SqlColumnIRInput.sqlExpressionLiteralFor}. Non-enumerable, same reason as {@link codecRef}. */
+  readonly sqlExpressionLiteralFor?: SqlExpressionLiteralFor;
+  /** See {@link SqlColumnIRInput.reportedType}. Non-enumerable, same reason as {@link codecRef}. */
+  readonly reportedType?: ReportedSqlType;
+  /** See {@link SqlColumnIRInput.catalogText}. Non-enumerable, same reason as {@link codecRef}. */
+  readonly catalogText?: string;
   constructor(input: SqlColumnIRInput);
   get id(): string;
   /**
@@ -336,15 +407,24 @@ declare class SqlColumnIR extends SqlSchemaIRNode implements DiffableNode {
    * from this column's own fields.
    */
   children(): readonly DiffableNode[];
+  /** This column under another name, with every other field as it is. */
+  withName(name: string): SqlColumnIR;
   static is(node: SqlSchemaIRNode): node is SqlColumnIR;
   /**
-   * Compares the column's own attributes only — the default lives on the
-   * child node. When both sides carry `resolvedNativeType`, the resolved
-   * value governs (array-ness rides on its `[]` suffix); otherwise raw
-   * fields compare.
+   * Compares the column's own attributes only — the default lives on the child node: the type, by {@link sqlColumnTypesEqual}, and nullability.
    */
   isEqualTo(other: DiffableNode): boolean;
+  /** Why `actual` is not this column: the two types as written and reported, or the nullability of each. The two sides always hold different values. */
+  explainMismatch(actual: DiffableNode | undefined): MismatchExplanation | undefined;
 }
+/** The parts of a column that make its type. */
+type SqlColumnType = Pick<SqlColumnIR, 'storedType' | 'storedTypeParams' | 'many' | 'catalogText' | 'reportedType'>;
+/**
+ * Whether two columns have the same type: both have a stored type, the two are one data type, their parameters are equal as canonical JSON, and both or neither are lists. A column no data type claims has no stored type and never has the same type as another. ADR 254.
+ *
+ * When either column carries a {@link SqlColumnIR.catalogText}, the two compare by text instead, exactly, with `[]` for a list: that text against the other column's catalog text or reported text. ADR 273.
+ */
+declare function sqlColumnTypesEqual(a: SqlColumnType, b: SqlColumnType): boolean;
 //#endregion
 //#region src/ir/sql-foreign-key-ir.d.ts
 type SqlReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
@@ -665,30 +745,5 @@ declare class SqlSchemaIR extends SqlSchemaIRNode implements DiffableNode {
   children(): readonly DiffableNode[];
 }
 //#endregion
-//#region src/types.d.ts
-/**
- * SQL type metadata for control-plane and execution-plane type
- * availability and mapping. Read-only view of type information
- * without encode/decode behavior.
- */
-interface SqlTypeMetadata {
-  /** Namespaced type identifier, e.g. `pg/int4@1`, `pg/text@1`. */
-  readonly typeId: string;
-  /** Contract scalar type IDs this type can handle. */
-  readonly targetTypes: readonly string[];
-  /**
-   * Native database type name (target-specific). Optional because
-   * not all types have a native database representation.
-   */
-  readonly nativeType?: string;
-}
-/**
- * Registry interface for SQL type metadata. Provides read-only
- * iteration over type metadata entries.
- */
-interface SqlTypeMetadataRegistry {
-  values(): IterableIterator<SqlTypeMetadata>;
-}
-//#endregion
-export { SqlUniqueIR as C, relationalNodeEntityKind as D, defineNonEnumerable as E, relationalNodeGranularity as O, SqlTypeMetadataRegistry as S, assertNode as T, SqlSchemaIRInput as _, SqlCheckConstraintIR as a, SqlTableIRInput as b, SqlColumnDefaultIRInput as c, SqlForeignKeyIR as d, SqlForeignKeyIRInput as f, SqlSchemaIR as g, SqlReferentialAction as h, SqlAnnotations as i, SqlColumnIR as l, SqlIndexIRInput as m, PrimaryKeyInput as n, SqlCheckConstraintIRInput as o, SqlIndexIR as p, RelationalSchemaNodeKind as r, SqlColumnDefaultIR as s, PrimaryKey as t, SqlColumnIRInput as u, SqlSchemaIRNode as v, SqlUniqueIRInput as w, SqlTypeMetadata as x, SqlTableIR as y };
-//# sourceMappingURL=types-YStFFkKs-D9UAmnON.d.mts.map
+export { relationalNodeGranularity as A, SqlTableIR as C, assertNode as D, SqlUniqueIRInput as E, sqlDefaultValuesEqual as M, defineNonEnumerable as O, SqlSchemaIRNode as S, SqlUniqueIR as T, SqlIndexIR as _, SqlAnnotations as a, SqlSchemaIR as b, SqlColumnDefaultIR as c, SqlColumnIRInput as d, SqlColumnType as f, SqlForeignKeyIRInput as g, SqlForeignKeyIR as h, ReportedSqlType as i, sqlColumnTypesEqual as j, relationalNodeEntityKind as k, SqlColumnDefaultIRInput as l, SqlExpressionLiteralFor as m, PrimaryKeyInput as n, SqlCheckConstraintIR as o, SqlDefaultValue as p, RelationalSchemaNodeKind as r, SqlCheckConstraintIRInput as s, PrimaryKey as t, SqlColumnIR as u, SqlIndexIRInput as v, SqlTableIRInput as w, SqlSchemaIRInput as x, SqlReferentialAction as y };
+//# sourceMappingURL=types-CuCxAQat-Dz8P4xyt.d.mts.map

package/dist/types-CuCxAQat-Dz8P4xyt.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CuCxAQat-Dz8P4xyt.d.mts","names":[],"sources":["../../../../2-sql-family/1-core/schema-ir/dist/types-CuCxAQat.d.mts"],"mappings":"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"}

package/dist/types-DfKvtJwS-CrpWTGBJ.d.mts

@@ -0,0 +1,273 @@
+import "./sql-node-kEz6YFZo-1ogT6Cxt.mjs";
+import "./check-constraint-B7qGu6rc-Bk2ezWXu.mjs";
+import { n as ForeignKeyIndex, o as ReferentialAction } from "./foreign-key-qkDFfG8t-TaK_GYWR.mjs";
+import "./unique-constraint-M5TlQnJQ-qX-maNUV.mjs";
+import "./sql-index-ByAAE7K8-Dqtn_vUL.mjs";
+import "./storage-table-Bf1ZjnxO-pUj6pyP0.mjs";
+import "./storage-value-set-BGlj5Uus-ny2k-0PA.mjs";
+import "./sql-storage-DeCAh5Hi-CEM-m8cs.mjs";
+import "./serialized-index-CrgG8ct1-DKVJ7TDX.mjs";
+import { CodecTrait } from "@prisma/orm-framework/components/codec";
+import { ControlDriverInstance } from "@prisma/orm-framework/components/control";
+//#region ../../../2-sql-family/1-core/contract/dist/types-DfKvtJwS.d.mts
+//#region src/types.d.ts
+interface SqlControlDriverInstance<T extends string = string> extends ControlDriverInstance<'sql', T> {
+  query<Row = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<{
+    readonly rows: Row[];
+  }>;
+}
+type ForeignKeyOptions = {
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  readonly index?: ForeignKeyIndex;
+};
+type SqlModelFieldStorage = {
+  readonly column: string;
+  readonly codecId?: string;
+  readonly nullable?: boolean;
+};
+type SqlModelStorage = {
+  readonly table: string;
+  readonly namespaceId: string;
+  readonly fields: Record<string, SqlModelFieldStorage>;
+};
+declare const DEFAULT_FK_CONSTRAINT = true;
+declare const DEFAULT_FK_INDEX = true;
+declare function applyFkDefaults(fk: {
+  constraint?: boolean | undefined;
+  index?: boolean | string | undefined;
+}, overrideDefaults?: {
+  constraint?: boolean | undefined;
+  index?: boolean | undefined;
+}): {
+  constraint: boolean;
+  index: boolean | string;
+};
+type NamespacedFieldTypeMap = Record<string, Record<string, Record<string, unknown>>>;
+type NamespacedStorageColumnTypeMap = Record<string, Record<string, Record<string, unknown>>>;
+/**
+ * What one aggregate produces: the id of the codec its result carries, and whether that result can be null. The codec id is the whole of the result's identity — a `sum` leaves its input's type parameters behind, and a result that keeps them is one whose codec id is the input's own.
+ */
+type AggregateResultType = {
+  readonly output: string;
+  readonly nullable: boolean;
+};
+/**
+ * One aggregate operation's settled overloads.
+ *
+ * `byCodec` answers per input codec, precedence already applied: a codec claimed by an exact overload carries that overload's result, and one served by a trait fallback carries the fallback's. `anyInput` answers an input no row claims, and `withoutInput` answers a call that carries no input at all — `count()` over rows.
+ *
+ * Only codecs the composed stack contributes appear, so an availability this map advertises is one the runtime will honour.
+ */
+type AggregateOperationTypes = {
+  readonly byCodec: Record<string, AggregateResultType>;
+  readonly withoutInput?: AggregateResultType;
+  readonly anyInput?: AggregateResultType;
+};
+/** Aggregate operations keyed by name (`count`, `sum`, …). */
+type AggregateTypesBase = Record<string, AggregateOperationTypes>;
+/** The parts of an aggregate descriptor its result type depends on. */
+type AggregateOverload = {
+  readonly operation: string;
+  readonly input: {
+    readonly kind: string;
+    readonly codecId?: string;
+    readonly trait?: string;
+  };
+  readonly output: {
+    readonly kind: string;
+    readonly codecId?: string;
+  };
+  readonly nullable: boolean;
+};
+/** A result as an overload declares it: a named codec, or `self` for the codec of the input it serves. */
+type OverloadResult<Descriptor> = {
+  readonly output: Descriptor extends {
+    readonly output: {
+      readonly kind: 'codec';
+      readonly codecId: infer Output;
+    };
+  } ? Output : 'self';
+  readonly nullable: Descriptor extends {
+    readonly nullable: infer Nullable;
+  } ? Nullable : never;
+};
+type OperationsOf<Descriptors> = Descriptors extends {
+  readonly operation: infer Name extends string;
+} ? Name : never;
+type ExactCodecIds<Descriptors> = Descriptors extends {
+  readonly input: {
+    readonly kind: 'codec';
+    readonly codecId: infer CodecId extends string;
+  };
+} ? CodecId : never;
+type ExactOverloads<Descriptors, CodecId> = Descriptors extends {
+  readonly input: {
+    readonly kind: 'codec';
+    readonly codecId: infer Claimed;
+  };
+} ? CodecId extends Claimed ? Descriptors : never : never;
+type ClaimedTraits<Descriptors> = Descriptors extends {
+  readonly input: {
+    readonly kind: 'trait';
+    readonly trait: infer Trait extends string;
+  };
+} ? Trait : never;
+type TraitOverloads<Descriptors, Trait> = Descriptors extends {
+  readonly input: {
+    readonly kind: 'trait';
+    readonly trait: infer Claimed;
+  };
+} ? Trait extends Claimed ? Descriptors : never : never;
+type InputlessOverload<Descriptors, Kind extends 'none' | 'any'> = Extract<Descriptors, {
+  readonly input: {
+    readonly kind: Kind;
+  };
+}>;
+type OperationOverloads<Descriptors> = {
+  readonly exact: { readonly [CodecId in ExactCodecIds<Descriptors>]: OverloadResult<ExactOverloads<Descriptors, CodecId>>; };
+  readonly trait: { readonly [Trait in ClaimedTraits<Descriptors>]: OverloadResult<TraitOverloads<Descriptors, Trait>>; };
+  readonly none: [InputlessOverload<Descriptors, 'none'>] extends [never] ? never : OverloadResult<InputlessOverload<Descriptors, 'none'>>;
+  readonly any: [InputlessOverload<Descriptors, 'any'>] extends [never] ? never : OverloadResult<InputlessOverload<Descriptors, 'any'>>;
+};
+type OverloadTable<Descriptors> = { readonly [Operation in OperationsOf<Descriptors>]: OperationOverloads<Extract<Descriptors, {
+  readonly operation: Operation;
+}>>; };
+type IsUnionOf<T, Whole = T> = T extends unknown ? ([Whole] extends [T] ? false : true) : never;
+type CodecTraitsOfId<CodecTypes, CodecId> = CodecId extends keyof CodecTypes ? CodecTypes[CodecId] extends {
+  readonly traits: infer Traits;
+} ? Traits : never : never;
+type SettledResult<Overloads extends OperationOverloads<never>, CodecId, Traits> = CodecId extends keyof Overloads['exact'] ? Overloads['exact'][CodecId] : Extract<keyof Overloads['trait'], Traits> extends (infer Trait) ? [Trait] extends [never] ? never : true extends IsUnionOf<Trait> ? never : Overloads['trait'][Trait & keyof Overloads['trait']] : never;
+type SettledRow<Result, CodecId> = {
+  readonly output: Result extends {
+    readonly output: infer Output;
+  } ? Output extends 'self' ? CodecId : Output : never;
+  readonly nullable: Result extends {
+    readonly nullable: infer Nullable;
+  } ? Nullable : never;
+};
+type InputlessRows<Overloads extends OperationOverloads<never>> = ([Overloads['none']] extends [never] ? [Overloads['any']] extends [never] ? Record<never, never> : {
+  readonly withoutInput: SettledRow<Overloads['any'], never>;
+} : {
+  readonly withoutInput: SettledRow<Overloads['none'], never>;
+}) & ([Overloads['any']] extends [never] ? Record<never, never> : {
+  readonly anyInput: SettledRow<Overloads['any'], never>;
+});
+type SettledOperation<Overloads extends OperationOverloads<never>, CodecTypes> = {
+  readonly byCodec: { readonly [CodecId in (keyof CodecTypes & string) | (keyof Overloads['exact'] & string) as [SettledResult<Overloads, CodecId, CodecTraitsOfId<CodecTypes, CodecId>>] extends [never] ? never : CodecId]: SettledRow<SettledResult<Overloads, CodecId, CodecTraitsOfId<CodecTypes, CodecId>>, CodecId>; };
+} & InputlessRows<Overloads>;
+type SettledAggregateTypes<Table, CodecTypes> = { readonly [Operation in keyof Table]: Table[Operation] extends (infer Overloads extends OperationOverloads<never>) ? SettledOperation<Overloads, CodecTypes> : never; };
+/**
+ * The aggregate result types of a stack, settled from the aggregate descriptors its components contribute against the codecs it composes, as emission writes them into `AggregateTypes`: an exact overload first, then the one trait overload a codec's traits select, and the overloads that take no input or any input. The codecs a row can key are the contract's and those an exact overload names, which the stack contributes though its codec type map may not list them.
+ */
+type AggregateTypesFromDescriptors<Descriptors extends AggregateOverload, CodecTypes extends Record<string, unknown>> = SettledAggregateTypes<OverloadTable<Descriptors>, CodecTypes>;
+type TypeMaps<TCodecTypes extends Record<string, {
+  output: unknown;
+}> = Record<string, never>, TQueryOperationTypes extends Record<string, unknown> = Record<string, never>, TFieldOutputTypes extends NamespacedFieldTypeMap = Record<string, never>, TFieldInputTypes extends NamespacedFieldTypeMap = Record<string, never>, TStorageColumnTypes extends NamespacedStorageColumnTypeMap = Record<string, never>, TStorageColumnInputTypes extends NamespacedStorageColumnTypeMap = Record<string, never>, TAggregateTypes extends AggregateTypesBase = Record<string, never>> = {
+  readonly codecTypes: TCodecTypes;
+  readonly queryOperationTypes: TQueryOperationTypes;
+  readonly fieldOutputTypes: TFieldOutputTypes;
+  readonly fieldInputTypes: TFieldInputTypes;
+  readonly storageColumnTypes: TStorageColumnTypes;
+  readonly storageColumnInputTypes: TStorageColumnInputTypes;
+  readonly aggregateTypes: TAggregateTypes;
+};
+type AggregateTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly aggregateTypes: infer A;
+} ? A extends AggregateTypesBase ? A : Record<string, never> : Record<string, never>;
+type CodecTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly codecTypes: infer C;
+} ? C extends Record<string, {
+  output: unknown;
+}> ? C : Record<string, never> : Record<string, never>;
+/**
+ * Dispatch hint identifying the first-argument target of an operation.
+ *
+ * Used by ORM column helpers to decide whether an operation is reachable on a
+ * field. Names a concrete codec identity, a set of capability traits the
+ * field's codec must carry, or targets list-typed (`many`) fields. Element
+ * capability gating for list ops travels in `elementTraits`.
+ */
+type QueryOperationSelfSpec = {
+  readonly codecId: string;
+  readonly traits?: never;
+  readonly many?: never;
+} | {
+  readonly traits: readonly CodecTrait[];
+  readonly codecId?: never;
+  readonly many?: never;
+} | {
+  readonly many: true;
+  readonly elementTraits?: readonly CodecTrait[];
+  readonly codecId?: never;
+  readonly traits?: never;
+};
+/**
+ * Structural shape an operation's impl must return: any value carrying a
+ * codec-exact `returnType` descriptor. `Expression<T>` (from
+ * `@internal/sql-relational-core/expression`, with `T extends ScopeField`)
+ * extends this. Trait-targeted returns are deliberately excluded — predicate
+ * detection and result decoding both depend on knowing the concrete return
+ * codec.
+ */
+type QueryOperationReturn = {
+  readonly returnType: {
+    readonly codecId: string;
+    readonly nullable: boolean;
+  };
+};
+type QueryOperationTypeEntry = {
+  readonly self?: QueryOperationSelfSpec;
+  readonly impl: (...args: never[]) => QueryOperationReturn;
+};
+type SqlQueryOperationTypes<_CT extends Record<string, {
+  readonly input: unknown;
+  readonly output: unknown;
+}>, T extends Record<string, QueryOperationTypeEntry>> = T;
+type QueryOperationTypesBase = Record<string, QueryOperationTypeEntry>;
+/**
+ * A pack's query operation types as a function of the contract's codec types. A pack declares an interface extending this one whose `queryOperationTypes` reads `this['codecTypes']`; {@link ApplyQueryOperationTypes} supplies the codec types.
+ */
+interface QueryOperationTypesFunction {
+  readonly codecTypes: Record<never, {
+    readonly input: unknown;
+    readonly output: unknown;
+  }>;
+  readonly queryOperationTypes: Record<string, unknown>;
+}
+type ApplyQueryOperationTypes<TypeFunction extends QueryOperationTypesFunction, CodecTypes extends Record<string, {
+  readonly input: unknown;
+  readonly output: unknown;
+}>> = (TypeFunction & {
+  readonly codecTypes: CodecTypes;
+})['queryOperationTypes'];
+type QueryOperationTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly queryOperationTypes: infer Q;
+} ? Q extends Record<string, unknown> ? Q : Record<string, never> : Record<string, never>;
+type TypeMapsPhantomKey = '__@internal/sql-contract/typeMaps@__';
+type ContractWithTypeMaps<TContract, TTypeMaps> = TContract & { readonly [K in TypeMapsPhantomKey]?: TTypeMaps; };
+type ExtractTypeMapsFromContract<T> = TypeMapsPhantomKey extends keyof T ? NonNullable<T[TypeMapsPhantomKey & keyof T]> : never;
+type FieldOutputTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly fieldOutputTypes: infer F;
+} ? F extends NamespacedFieldTypeMap ? F : Record<string, never> : Record<string, never>;
+type FieldInputTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly fieldInputTypes: infer F;
+} ? F extends NamespacedFieldTypeMap ? F : Record<string, never> : Record<string, never>;
+type StorageColumnTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly storageColumnTypes: infer F;
+} ? F extends NamespacedStorageColumnTypeMap ? F : Record<string, never> : Record<string, never>;
+type StorageColumnInputTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly storageColumnInputTypes: infer F;
+} ? F extends NamespacedStorageColumnTypeMap ? F : Record<string, never> : Record<string, never>;
+type ExtractCodecTypes<T> = CodecTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractQueryOperationTypes<T> = QueryOperationTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractFieldOutputTypes<T> = FieldOutputTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractFieldInputTypes<T> = FieldInputTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractStorageColumnTypes<T> = StorageColumnTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractStorageColumnInputTypes<T> = StorageColumnInputTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractAggregateTypes<T> = AggregateTypesOf<ExtractTypeMapsFromContract<T>>;
+type ResolveCodecTypes<TContract, TTypeMaps> = [TTypeMaps] extends [never] ? ExtractCodecTypes<TContract> : CodecTypesOf<TTypeMaps>;
+//#endregion
+export { ResolveCodecTypes as A, NamespacedStorageColumnTypeMap as C, QueryOperationTypesBase as D, QueryOperationTypeEntry as E, StorageColumnInputTypesOf as F, StorageColumnTypesOf as I, TypeMaps as L, SqlModelFieldStorage as M, SqlModelStorage as N, QueryOperationTypesFunction as O, SqlQueryOperationTypes as P, TypeMapsPhantomKey as R, NamespacedFieldTypeMap as S, QueryOperationSelfSpec as T, ExtractStorageColumnTypes as _, AggregateTypesOf as a, FieldOutputTypesOf as b, ContractWithTypeMaps as c, ExtractAggregateTypes as d, ExtractCodecTypes as f, ExtractStorageColumnInputTypes as g, ExtractQueryOperationTypes as h, AggregateTypesFromDescriptors as i, SqlControlDriverInstance as j, QueryOperationTypesOf as k, DEFAULT_FK_CONSTRAINT as l, ExtractFieldOutputTypes as m, AggregateResultType as n, ApplyQueryOperationTypes as o, ExtractFieldInputTypes as p, AggregateTypesBase as r, CodecTypesOf as s, AggregateOperationTypes as t, DEFAULT_FK_INDEX as u, ExtractTypeMapsFromContract as v, QueryOperationReturn as w, ForeignKeyOptions as x, FieldInputTypesOf as y, applyFkDefaults as z };
+//# sourceMappingURL=types-DfKvtJwS-CrpWTGBJ.d.mts.map

package/dist/types-DfKvtJwS-CrpWTGBJ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DfKvtJwS-CrpWTGBJ.d.mts","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/types-DfKvtJwS.d.mts"],"mappings":";;;;;;;;;;;;;UAYU,yBAAyB,mCAAmC,6BAA6B;EACjG,MAAM,MAAM,yBAAyB,aAAa,8BAA8B;aACrE,MAAM;;;KAGd;WACM;WACA,WAAW;WACX,WAAW;WACX,QAAQ;;KAEd;WACM;WACA;WACA;;KAEN;WACM;WACA;WACA,QAAQ,eAAe;;cAEpB;cACA;iBACG,gBAAgB;EAC/B;EACA;GACC;EACD;EACA;;EAEA;EACA;;KAEG,yBAAyB,eAAe,eAAe;KACvD,iCAAiC,eAAe,eAAe;;;;KAI/D;WACM;WACA;;;;;;;;;KASN;WACM,SAAS,eAAe;WACxB,eAAe;WACf,WAAW;;;KAGjB,qBAAqB,eAAe;;KAEpC;WACM;WACA;aACE;aACA;aACA;;WAEF;aACE;aACA;;WAEF;;;KAGN,eAAe;WACT,QAAQ;aACN;eACE;eACA,eAAe;;MAExB;WACK,UAAU;aACR,gBAAgB;MACvB;;KAED,aAAa,eAAe;WACtB,iBAAiB;IACxB;KACC,cAAc,eAAe;WACvB;aACE;aACA,eAAe;;IAExB;KACC,eAAe,aAAa,WAAW;WACjC;aACE;aACA,eAAe;;IAExB,gBAAgB,UAAU;KACzB,cAAc,eAAe;WACvB;aACE;aACA,aAAa;;IAEtB;KACC,eAAe,aAAa,SAAS;WAC/B;aACE;aACA,aAAa;;IAEtB,cAAc,UAAU;KACvB,kBAAkB,aAAa,+BAA+B,QAAQ;WAChE;aACE,MAAM;;;KAGd,mBAAmB;WACb,mBAAmB,WAAW,cAAc,eAAe,eAAe,eAAe,aAAa;WACtG,mBAAmB,SAAS,cAAc,eAAe,eAAe,eAAe,aAAa;WACpG,OAAO,kBAAkB,gDAAgD,eAAe,kBAAkB;WAC1G,MAAM,kBAAkB,+CAA+C,eAAe,kBAAkB;;KAE9G,cAAc,2BAA2B,aAAa,aAAa,eAAe,mBAAmB,QAAQ;WACvG,WAAW;;KAEjB,UAAU,GAAG,QAAQ,KAAK,sBAAsB,gBAAgB;KAChE,gBAAgB,YAAY,WAAW,sBAAsB,aAAa,WAAW;WAC/E,cAAc;IACrB;KACC,cAAc,kBAAkB,2BAA2B,SAAS,UAAU,sBAAsB,qBAAqB,mBAAmB,WAAW,cAAc,oBAAoB,uBAAuB,UAAU,8CAA8C,UAAU,iBAAiB,mBAAmB,cAAc;KACpU,WAAW,QAAQ;WACb,QAAQ;aACN,cAAc;MACrB,wBAAwB,UAAU;WAC7B,UAAU;aACR,gBAAgB;MACvB;;KAED,cAAc,kBAAkB,+BAA+B,sCAAsC,oCAAoC;WACnI,cAAc,WAAW;;WAEzB,cAAc,WAAW;OAC7B,oCAAoC;WAChC,UAAU,WAAW;;KAE3B,iBAAiB,kBAAkB,2BAA2B;WACxD,qBAAqB,kBAAkB,8BAA8B,iCAAiC,cAAc,WAAW,SAAS,gBAAgB,YAAY,qCAAqC,UAAU,WAAW,cAAc,WAAW,SAAS,gBAAgB,YAAY,WAAW;IAC9S,cAAc;KACb,sBAAsB,OAAO,0BAA0B,mBAAmB,QAAQ,MAAM,0BAA0B,kBAAkB,6BAA6B,iBAAiB,WAAW;;;;KAI7L,8BAA8B,oBAAoB,mBAAmB,mBAAmB,2BAA2B,sBAAsB,cAAc,cAAc;KACrK,SAAS,oBAAoB;EAChC;KACG,uBAAuB,6BAA6B,0BAA0B,uBAAuB,0BAA0B,yBAAyB,uBAAuB,yBAAyB,yBAAyB,uBAAuB,4BAA4B,iCAAiC,uBAAuB,iCAAiC,iCAAiC,uBAAuB,wBAAwB,qBAAqB;WAC5c,YAAY;WACZ,qBAAqB;WACrB,kBAAkB;WAClB,iBAAiB;WACjB,oBAAoB;WACpB,yBAAyB;WACzB,gBAAgB;;KAEtB,iBAAiB,MAAM,qBAAqB,wBAAwB;WAC9D,sBAAsB;IAC7B,UAAU,qBAAqB,IAAI,wBAAwB;KAC1D,aAAa,MAAM,qBAAqB,wBAAwB;WAC1D,kBAAkB;IACzB,UAAU;EACZ;KACG,IAAI,wBAAwB;;;;;;;;;KAS5B;WACM;WACA;WACA;;WAEA,iBAAiB;WACjB;WACA;;WAEA;WACA,yBAAyB;WACzB;WACA;;;;;;;;;;KAUN;WACM;aACE;aACA;;;KAGR;WACM,OAAO;WACP,UAAU,kBAAkB;;KAElC,uBAAuB,YAAY;WAC7B;WACA;IACP,UAAU,eAAe,4BAA4B;KACpD,0BAA0B,eAAe;;;;UAIpC;WACC,YAAY;aACV;aACA;;WAEF,qBAAqB;;KAE3B,yBAAyB,qBAAqB,6BAA6B,mBAAmB;WACxF;WACA;OACJ;WACI,YAAY;;KAElB,sBAAsB,MAAM,qBAAqB,wBAAwB;WACnE,2BAA2B;IAClC,UAAU,0BAA0B,IAAI,wBAAwB;KAC/D;KACA,qBAAqB,WAAW,aAAa,wBAAwB,KAAK,sBAAsB;KAChG,4BAA4B,KAAK,iCAAiC,IAAI,YAAY,EAAE,2BAA2B;KAC/G,mBAAmB,MAAM,qBAAqB,wBAAwB;WAChE,wBAAwB;IAC/B,UAAU,yBAAyB,IAAI,wBAAwB;KAC9D,kBAAkB,MAAM,qBAAqB,wBAAwB;WAC/D,uBAAuB;IAC9B,UAAU,yBAAyB,IAAI,wBAAwB;KAC9D,qBAAqB,MAAM,qBAAqB,wBAAwB;WAClE,0BAA0B;IACjC,UAAU,iCAAiC,IAAI,wBAAwB;KACtE,0BAA0B,MAAM,qBAAqB,wBAAwB;WACvE,+BAA+B;IACtC,UAAU,iCAAiC,IAAI,wBAAwB;KACtE,kBAAkB,KAAK,aAAa,4BAA4B;KAChE,2BAA2B,KAAK,sBAAsB,4BAA4B;KAClF,wBAAwB,KAAK,mBAAmB,4BAA4B;KAC5E,uBAAuB,KAAK,kBAAkB,4BAA4B;KAC1E,0BAA0B,KAAK,qBAAqB,4BAA4B;KAChF,+BAA+B,KAAK,0BAA0B,4BAA4B;KAC1F,sBAAsB,KAAK,iBAAiB,4BAA4B;KACxE,kBAAkB,WAAW,cAAc,6BAA6B,kBAAkB,aAAa,aAAa"}