@prisma/orm-family-sql 0.16.0-dev.36

package/dist/orm-client.d.mts

@@ -0,0 +1,1316 @@
+import { a as CodecRef$1 } from "./codec-types-MOaceoPi-C5eL2sao.mjs";
+import { a as StorageTable, r as StorageColumn } from "./storage-table-BBaAmanc-BwR37LMA.mjs";
+import { c as SqlStorage } from "./sql-storage-B0QwiTg6-B8DVctJm.mjs";
+import { a as ExtractCodecTypes, c as ExtractQueryOperationTypes, s as ExtractFieldOutputTypes } from "./types-CuDrWc5v-ISVXBmBs.mjs";
+import "./types-BchwQpmO.mjs";
+import { a as AndExpr, h as BinaryExpr, it as OrderByItem, o as AnyExpression, rt as OrExpr, tt as NullCheckExpr, yt as WhereArg } from "./types-DIBA80mc-wf5wLmON.mjs";
+import "./ast-DSuzmsWn.mjs";
+import { a as Expression } from "./expression-DIf8F4Mc.mjs";
+import { r as ExecutionContext } from "./query-lane-context-DtdVMqoz-C2Tj5QHA.mjs";
+import "./query-lane-context-Bz8XJZ45.mjs";
+import { o as ComputeColumnJsType, y as RuntimeScope } from "./types-Dl20lxky-DC_jdA0T.mjs";
+import "./types-DMxc5KZa.mjs";
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { AnnotationValue, AsyncIterableResult, MetaBuilder, OperationKind } from "@prisma/orm-framework/components/runtime";
+import { SimplifyDeep } from "@prisma/orm-framework/utils/simplify-deep";
+//#region ../../../3-extensions/sql-orm-client/dist/index.d.mts
+//#region src/types.d.ts
+type AggregateFn = 'count' | 'sum' | 'avg' | 'min' | 'max';
+interface IncludeScalar<Result> extends RowSelection<Result> {
+  readonly kind: 'includeScalar';
+  readonly fn: AggregateFn;
+  readonly column?: string;
+  readonly state: CollectionState;
+}
+interface IncludeRowsBranch {
+  readonly kind: 'rows';
+  readonly state: CollectionState;
+}
+interface IncludeScalarBranch {
+  readonly kind: 'scalar';
+  readonly selector: IncludeScalar<unknown>;
+}
+type IncludeCombineBranch = IncludeRowsBranch | IncludeScalarBranch;
+interface IncludeCombine<ResultShape extends Record<string, unknown>> extends RowSelection<ResultShape> {
+  readonly kind: 'includeCombine';
+  readonly branches: Readonly<Record<string, IncludeCombineBranch>>;
+}
+interface IncludeThroughDescriptor {
+  readonly table: string;
+  /** Namespace the junction table lives in, as declared in the contract. */
+  readonly namespaceId: string;
+  /** FK columns in the junction table that point to the parent. */
+  readonly parentColumns: readonly string[];
+  /** FK columns in the junction table that point to the target (child). */
+  readonly childColumns: readonly string[];
+  /** PK columns in the target table that the junction's childColumns reference. */
+  readonly targetColumns: readonly string[];
+  /** Resolved column names in the parent table that junction.parentColumns reference. */
+  readonly parentLocalColumns: readonly string[];
+}
+interface IncludeExpr {
+  readonly relationName: string;
+  readonly relatedModelName: string;
+  readonly relatedNamespaceId: string;
+  readonly relatedTableName: string;
+  readonly localTableName: string;
+  readonly targetColumn: string;
+  readonly localColumn: string;
+  readonly cardinality: RelationCardinalityTag | undefined;
+  readonly through?: IncludeThroughDescriptor;
+  readonly nested: CollectionState;
+  readonly scalar: IncludeScalar<unknown> | undefined;
+  readonly combine: Readonly<Record<string, IncludeCombineBranch>> | undefined;
+}
+interface CollectionState {
+  readonly filters: readonly AnyExpression[];
+  readonly includes: readonly IncludeExpr[];
+  readonly orderBy: readonly OrderByItem[] | undefined;
+  readonly cursor: Readonly<Record<string, unknown>> | undefined;
+  readonly distinct: readonly string[] | undefined;
+  readonly distinctOn: readonly string[] | undefined;
+  readonly selectedFields: readonly string[] | undefined;
+  readonly limit: number | undefined;
+  readonly offset: number | undefined;
+  readonly variantName: string | undefined;
+  /**
+   * Annotations attached to this query at terminal-call time.
+   * Populated transiently by terminal methods (`first`, `all`, `create`,
+   * etc.) just before dispatch — `Collection` itself has no chainable
+   * `.annotate()`. Stored as a `Map<namespace, AnnotationValue>` so
+   * duplicate namespaces last-write-win. Empty on a fresh state.
+   */
+  readonly annotations: ReadonlyMap<string, AnnotationValue<unknown, OperationKind>>;
+}
+declare function emptyState(): CollectionState;
+interface CollectionTypeState {
+  readonly hasOrderBy: boolean;
+  readonly hasWhere: boolean;
+  readonly hasUniqueFilter: boolean;
+  readonly variantName: string | undefined;
+  /**
+   * The namespace coordinate this collection resolves at — set by the
+   * `orm.<ns>.<Model>` facet so the create/update/where input types (and the
+   * read row) resolve the model's fields within its namespace. `never` for a
+   * directly-constructed collection (resolution falls back to the model's own
+   * `storage.namespaceId`). Carried in the type state so it survives chaining
+   * (`.where(...)`, `.variant(...)`, …) automatically.
+   */
+  readonly nsId: string;
+}
+type RelationCardinalityTag = '1:1' | 'N:1' | '1:N' | 'N:M';
+type DefaultCollectionTypeState = {
+  readonly hasOrderBy: false;
+  readonly hasWhere: false;
+  readonly hasUniqueFilter: false;
+  readonly variantName: undefined;
+  readonly nsId: never;
+};
+type WithNsId<State extends CollectionTypeState, NsId extends string> = Omit<State, 'nsId'> & {
+  readonly nsId: NsId;
+};
+interface RuntimeConnection extends RuntimeScope {
+  release?(): Promise<void>;
+  transaction?(): Promise<RuntimeTransaction>;
+}
+interface RuntimeTransaction extends RuntimeScope {
+  commit?(): Promise<void>;
+  rollback?(): Promise<void>;
+}
+interface RuntimeQueryable extends RuntimeScope {
+  connection?(): Promise<RuntimeConnection>;
+  transaction?(): Promise<RuntimeTransaction>;
+}
+interface CollectionContext<TContract extends Contract<SqlStorage>> {
+  readonly runtime: RuntimeQueryable;
+  readonly context: ExecutionContext<TContract>;
+}
+type ComparisonMethodFns<T> = {
+  eq(value: T): AnyExpression;
+  neq(value: T): AnyExpression;
+  gt(value: T): AnyExpression;
+  lt(value: T): AnyExpression;
+  gte(value: T): AnyExpression;
+  lte(value: T): AnyExpression;
+  like(pattern: string): AnyExpression;
+  in(values: readonly T[]): AnyExpression;
+  notIn(values: readonly T[]): AnyExpression;
+  isNull(): AnyExpression;
+  isNotNull(): AnyExpression;
+  asc(): OrderByItem;
+  desc(): OrderByItem;
+};
+/**
+ * Trait-gated comparison methods. Only methods whose required traits are all present in `Traits` are included.
+ *
+ * - `traits: []` → always available (isNull, isNotNull)
+ */
+type ComparisonMethods<T, Traits> = { [K in keyof ComparisonMethodsMeta as [ComparisonMethodsMeta[K]['traits'][number]] extends [Traits] ? K : never]: ComparisonMethodFns<T>[K]; };
+type QueryOperationReturnTraits<Returns, TCodecTypes extends Record<string, unknown>> = Returns extends {
+  readonly codecId: infer Id extends string;
+} ? Id extends keyof TCodecTypes ? TCodecTypes[Id] extends {
+  readonly traits: infer Traits;
+} ? Traits : never : never : never;
+type QueryOperationReturnJsType<Returns, TCodecTypes extends Record<string, unknown>> = Returns extends {
+  readonly codecId: infer Id extends string;
+  readonly nullable: infer N;
+} ? Id extends keyof TCodecTypes ? TCodecTypes[Id] extends {
+  readonly output: infer O;
+} ? N extends true ? O | null : O : unknown : unknown : unknown;
+type IsBooleanReturn<Returns, TCodecTypes extends Record<string, unknown>> = Returns extends {
+  readonly codecId: infer Id extends string;
+} ? Id extends keyof TCodecTypes ? TCodecTypes[Id] extends {
+  readonly traits: infer T;
+} ? 'boolean' extends T ? true : false : false : false : false;
+/**
+ * Extract the `{codecId, nullable}` spec carried inside an `Expression<T>`. Used to recover the op's return spec from its impl signature so the pre-existing `QueryOperationReturn*` helpers can consume it unchanged.
+ */
+type SpecOf<E> = E extends Expression<infer T> ? T : never;
+type ImplReturnSpec<Impl> = Impl extends ((...args: never[]) => infer Ret) ? SpecOf<Ret> : never;
+/**
+ * Builds the ORM column-method signature for an operation.
+ *
+ * - User args: drops the impl's first parameter (the column is bound at access time) and forwards the rest unchanged. Each remaining arg keeps its authored `CodecExpression` / `TraitExpression` shape — so callers can pass a raw JS value, another column handle (which itself implements `Expression`), or `null` when nullable.
+ * - Return: predicate ops (boolean-traited return) yield `AnyExpression`; non-predicate ops yield `ComparisonMethods<JsType, Traits>` of the return codec.
+ */
+type QueryOperationMethod<Op, TCodecTypes extends Record<string, unknown>> = Op extends {
+  readonly impl: (...args: never[]) => unknown;
+} ? Op['impl'] extends ((first: never, ...rest: infer UserArgs extends readonly unknown[]) => unknown) ? ImplReturnSpec<Op['impl']> extends (infer Returns) ? IsBooleanReturn<Returns, TCodecTypes> extends true ? (...args: UserArgs) => AnyExpression : (...args: UserArgs) => ComparisonMethods<QueryOperationReturnJsType<Returns, TCodecTypes>, QueryOperationReturnTraits<Returns, TCodecTypes>> : never : never : never;
+/**
+ * Tests whether an operation's `self` dispatch hint reaches a field with the given codec identity. Codec hints match by identity; trait hints match when every required trait is present in the field codec's trait set.
+ */
+type OpMatchesField<Op, CodecId extends string, CT extends Record<string, unknown>> = Op extends {
+  readonly self: infer Self;
+} ? Self extends {
+  readonly codecId: CodecId;
+} ? true : Self extends {
+  readonly traits: infer RequiredTraits extends readonly string[];
+} ? CodecId extends keyof CT ? CT[CodecId] extends {
+  readonly traits: infer FieldTraits;
+} ? [RequiredTraits[number]] extends [FieldTraits] ? true : false : false : false : false : false;
+type FieldOperations<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string> = FieldCodecId<TContract, ModelName, FieldName> extends (infer CodecId extends string) ? ExtractQueryOperationTypes<TContract> extends (infer AllOps) ? { [OpName in keyof AllOps & string as OpMatchesField<AllOps[OpName], CodecId, ExtractCodecTypes<TContract>> extends true ? OpName : never]: QueryOperationMethod<AllOps[OpName], ExtractCodecTypes<TContract>>; } : unknown : unknown;
+/**
+ * Declares trait requirements and runtime factory for each comparison method.
+ *
+ * - `traits: []` means "no trait required" — always available
+ * - Multi-trait: `traits: ['equality', 'order']` means BOTH traits are required
+ */
+declare const COMPARISON_METHODS_META: {
+  readonly eq: {
+    readonly traits: readonly ["equality"];
+    readonly create: (left: AnyExpression, codec: CodecRef$1 | undefined) => (value: unknown) => BinaryExpr | NullCheckExpr;
+  };
+  readonly neq: {
+    readonly traits: readonly ["equality"];
+    readonly create: (left: AnyExpression, codec: CodecRef$1 | undefined) => (value: unknown) => BinaryExpr | NullCheckExpr;
+  };
+  readonly in: {
+    readonly traits: readonly ["equality"];
+    readonly create: (left: AnyExpression, codec: CodecRef$1 | undefined) => (values: readonly unknown[]) => BinaryExpr;
+  };
+  readonly notIn: {
+    readonly traits: readonly ["equality"];
+    readonly create: (left: AnyExpression, codec: CodecRef$1 | undefined) => (values: readonly unknown[]) => BinaryExpr;
+  };
+  readonly gt: {
+    readonly traits: readonly ["order"];
+    readonly create: (left: AnyExpression, codec: CodecRef$1 | undefined) => (value: unknown) => BinaryExpr | NullCheckExpr;
+  };
+  readonly lt: {
+    readonly traits: readonly ["order"];
+    readonly create: (left: AnyExpression, codec: CodecRef$1 | undefined) => (value: unknown) => BinaryExpr | NullCheckExpr;
+  };
+  readonly gte: {
+    readonly traits: readonly ["order"];
+    readonly create: (left: AnyExpression, codec: CodecRef$1 | undefined) => (value: unknown) => BinaryExpr | NullCheckExpr;
+  };
+  readonly lte: {
+    readonly traits: readonly ["order"];
+    readonly create: (left: AnyExpression, codec: CodecRef$1 | undefined) => (value: unknown) => BinaryExpr | NullCheckExpr;
+  };
+  readonly like: {
+    readonly traits: readonly ["textual"];
+    readonly create: (left: AnyExpression, codec: CodecRef$1 | undefined) => (value: unknown) => BinaryExpr | NullCheckExpr;
+  };
+  readonly asc: {
+    readonly traits: readonly ["order"];
+    readonly create: (left: AnyExpression) => () => OrderByItem;
+  };
+  readonly desc: {
+    readonly traits: readonly ["order"];
+    readonly create: (left: AnyExpression) => () => OrderByItem;
+  };
+  readonly isNull: {
+    readonly traits: readonly [];
+    readonly create: (left: AnyExpression) => () => NullCheckExpr;
+  };
+  readonly isNotNull: {
+    readonly traits: readonly [];
+    readonly create: (left: AnyExpression) => () => NullCheckExpr;
+  };
+};
+type ComparisonMethodsMeta = typeof COMPARISON_METHODS_META;
+type RelationPredicate<TContract extends Contract<SqlStorage>, ModelName extends string> = (model: ModelAccessor<TContract, ModelName>) => AnyExpression;
+type RelationPredicateInput<TContract extends Contract<SqlStorage>, ModelName extends string> = RelationPredicate<TContract, ModelName> | Record<string, unknown>;
+type RelationFilterAccessor<TContract extends Contract<SqlStorage>, RelatedModelName extends string> = {
+  some(predicate?: RelationPredicateInput<TContract, RelatedModelName>): AnyExpression;
+  every(predicate: RelationPredicateInput<TContract, RelatedModelName>): AnyExpression;
+  none(predicate?: RelationPredicateInput<TContract, RelatedModelName>): AnyExpression;
+};
+type ScalarModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in keyof FieldsOf<TContract, ModelName, NsId> & string]: Expression<{
+  codecId: FieldCodecId<TContract, ModelName, K, NsId>;
+  nullable: FieldNullable<TContract, ModelName, K, NsId>;
+}> & ComparisonMethods<FieldJsType<TContract, ModelName, K, NsId>, FieldTraits<TContract, ModelName, K, NsId>> & FieldOperations<TContract, ModelName, K>; };
+type RelationModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string> = { [K in RelationNames<TContract, ModelName>]: RelationFilterAccessor<TContract, RelatedModelName<TContract, ModelName, K> & string>; };
+type ModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ScalarModelAccessor<TContract, ModelName, NsId> & RelationModelAccessor<TContract, ModelName>;
+/**
+ * The predicate accessor for a collection narrowed to a variant. When a real
+ * variant is selected its (possibly MTI) fields and relations are merged onto
+ * the base accessor so `t.variant('Feature').where(x => x.priority…)` and
+ * `t.variant('Feature').where(x => x.assignee.some(…))` type-check; with no
+ * variant the accessor is the plain base `ModelAccessor` and is unchanged.
+ */
+type VariantAwareModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName extends string | undefined, NsId extends string = never> = [VariantName] extends [string] ? VariantName extends VariantNames<TContract, ModelName, NsId> ? ScalarModelAccessor<TContract, ModelName, NsId> & ScalarModelAccessor<TContract, VariantName, NsId> & RelationModelAccessor<TContract, ModelName> & RelationModelAccessor<TContract, VariantName> : ModelAccessor<TContract, ModelName, NsId> : ModelAccessor<TContract, ModelName, NsId>;
+/**
+ * The flat default row of a single model: its own declared fields mapped to
+ * their JS types, with no variant flattening. Use this when you want exactly
+ * one model's fields (e.g. building the variant pieces, create/update inputs,
+ * column-name maps).
+ *
+ * Contrast with {@link InferRootRow}, which is the *read-shape* of a root
+ * collection: for a polymorphic base it discriminates over the variants and
+ * flattens each variant's own `DefaultModelRow` onto the base. `InferRootRow`
+ * is built from `DefaultModelRow`, not the other way around, so it can't be
+ * re-expressed in terms of `InferRootRow`.
+ */
+type DefaultModelRow<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in keyof FieldsOf<TContract, ModelName, NsId> & string]: FieldJsType<TContract, ModelName, K, NsId>; };
+type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+type VariantRow<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+  readonly discriminator: {
+    readonly field: infer DiscField extends string;
+  };
+  readonly variants: infer V;
+} ? V extends Record<string, {
+  readonly value: string;
+}> ? { [VK in keyof V]: VK extends string & CollectionModelName<TContract> ? Simplify<Omit<DefaultModelRow<TContract, ModelName, NsId>, DiscField> & DefaultModelRow<TContract, VK, NsId> & Record<DiscField, V[VK]['value']>> : never; }[keyof V] : DefaultModelRow<TContract, ModelName, NsId> : DefaultModelRow<TContract, ModelName, NsId>;
+type InferRootRow<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = VariantRow<TContract, ModelName, NsId>;
+type VariantNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+  readonly variants: infer V extends Record<string, unknown>;
+} ? keyof V & string : never;
+type VariantModelRow<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+  readonly discriminator: {
+    readonly field: infer DiscField extends string;
+  };
+  readonly variants: infer V;
+} ? V extends Record<string, {
+  readonly value: string;
+}> ? VariantName extends keyof V & string & CollectionModelName<TContract> ? Simplify<Omit<DefaultModelRow<TContract, ModelName, NsId>, DiscField> & DefaultModelRow<TContract, VariantName, NsId> & Record<DiscField, V[VariantName]['value']>> : DefaultModelRow<TContract, ModelName, NsId> : DefaultModelRow<TContract, ModelName, NsId> : DefaultModelRow<TContract, ModelName, NsId>;
+declare const aggregateResultBrand: unique symbol;
+interface AggregateSelector<Result> {
+  readonly kind: 'aggregate';
+  readonly fn: AggregateFn;
+  readonly column?: string;
+  readonly [aggregateResultBrand]?: Result;
+}
+type AggregateSpec = Record<string, AggregateSelector<unknown>>;
+type AggregateResult<Spec extends AggregateSpec> = { [K in keyof Spec]: Spec[K] extends AggregateSelector<infer Result> ? Result : never; };
+interface AggregateBuilder<TContract extends Contract<SqlStorage>, ModelName extends string> {
+  count(): AggregateSelector<number>;
+  sum<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): AggregateSelector<number | null>;
+  avg<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): AggregateSelector<number | null>;
+  min<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): AggregateSelector<number | null>;
+  max<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): AggregateSelector<number | null>;
+}
+type HavingComparisonMethods<T> = Pick<ComparisonMethods<T, 'equality' | 'order'>, 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte'>;
+interface HavingBuilder<TContract extends Contract<SqlStorage>, ModelName extends string> {
+  count(): HavingComparisonMethods<number>;
+  sum<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): HavingComparisonMethods<number | null>;
+  avg<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): HavingComparisonMethods<number | null>;
+  min<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): HavingComparisonMethods<number | null>;
+  max<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): HavingComparisonMethods<number | null>;
+}
+type ShorthandWhereFilter<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Partial<{ [K in keyof DefaultModelRow<TContract, ModelName, NsId> & string]: DefaultModelRow<TContract, ModelName, NsId>[K] | null | undefined; }>;
+type NamespaceModelsOf<TContract extends Contract<SqlStorage>, NsId extends string> = NsId extends keyof TContract['domain']['namespaces'] ? TContract['domain']['namespaces'][NsId]['models'] extends (infer M extends Record<string, unknown>) ? M : Record<string, never> : Record<string, never>;
+type ScannedModelDef<TContract extends Contract<SqlStorage>, ModelName extends string> = { [Ns in keyof TContract['domain']['namespaces']]: ModelName extends keyof TContract['domain']['namespaces'][Ns]['models'] ? TContract['domain']['namespaces'][Ns]['models'][ModelName] : never; }[keyof TContract['domain']['namespaces']];
+type ModelDef<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = [NsId] extends [never] ? ScannedModelDef<TContract, ModelName> : ModelName extends keyof NamespaceModelsOf<TContract, NsId> ? NamespaceModelsOf<TContract, NsId>[ModelName] : never;
+type NamespaceContainingTable<TContract extends Contract<SqlStorage>, TableName extends string> = { [K in keyof TContract['storage']['namespaces'] & string]: TContract['storage']['namespaces'][K] extends {
+  readonly entries: {
+    readonly table: infer Tables;
+  };
+} ? TableName extends keyof Tables ? K : never : never; }[keyof TContract['storage']['namespaces'] & string];
+type ResolvedNsId<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = [NsId] extends [never] ? ModelDef<TContract, ModelName> extends {
+  readonly storage: {
+    readonly namespaceId: infer N extends string;
+  };
+} ? N : ModelDef<TContract, ModelName> extends {
+  readonly storage: {
+    readonly table: infer T extends string;
+  };
+} ? NamespaceContainingTable<TContract, T> : never : NsId;
+type FieldsOf<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+  readonly fields: infer F;
+} ? F extends Record<string, unknown> ? F : Record<string, never> : Record<string, never>;
+type ModelStorageFields<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+  readonly storage: {
+    readonly fields: infer Fields;
+  };
+} ? Fields extends Record<string, {
+  readonly column: string;
+}> ? Fields : never : never;
+type ModelFieldToColumnMap<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelStorageFields<TContract, ModelName, NsId> extends (infer Fields) ? Fields extends Record<string, {
+  readonly column: string;
+}> ? { readonly [F in keyof Fields]: Fields[F]['column']; } : never : never;
+type FieldToColumnMapSafe<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelFieldToColumnMap<TContract, ModelName, NsId> extends Record<string, string> ? ModelFieldToColumnMap<TContract, ModelName, NsId> : never;
+type ModelTableName<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+  readonly storage: {
+    readonly table: infer T extends string;
+  };
+} ? T : never;
+type FieldColumnName<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = (FieldToColumnMapSafe<TContract, ModelName, NsId> extends never ? FieldName : FieldName extends keyof FieldToColumnMapSafe<TContract, ModelName, NsId> ? FieldToColumnMapSafe<TContract, ModelName, NsId>[FieldName] : FieldName) & string;
+type NamespaceTableDef<TContract extends Contract<SqlStorage>, TableName extends string, NsId extends string = never> = [NsId] extends [never] ? { [K in keyof TContract['storage']['namespaces']]: TContract['storage']['namespaces'][K] extends {
+  readonly entries: {
+    readonly table: infer Tables;
+  };
+} ? TableName extends keyof Tables ? Tables[TableName] : never : never; }[keyof TContract['storage']['namespaces']] : NsId extends keyof TContract['storage']['namespaces'] ? TContract['storage']['namespaces'][NsId] extends {
+  readonly entries: {
+    readonly table: infer Tables;
+  };
+} ? TableName extends keyof Tables ? Tables[TableName] : never : never : never;
+type ResolvedStorageColumn<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = ModelTableName<TContract, ModelName, NsId> extends (infer TableName extends string) ? FieldColumnName<TContract, ModelName, FieldName, NsId> extends (infer ColName extends string) ? NamespaceTableDef<TContract, TableName, ResolvedNsId<TContract, ModelName, NsId>> extends {
+  readonly columns: infer Columns;
+} ? ColName extends keyof Columns ? Columns[ColName] extends StorageColumn ? Columns[ColName] : never : never : never : never : never;
+type FieldStorageJsType<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = ResolvedStorageColumn<TContract, ModelName, FieldName, NsId> extends (infer Col extends StorageColumn) ? Col extends StorageColumn ? ComputeColumnJsType<TContract, ResolvedNsId<TContract, ModelName, NsId>, ModelTableName<TContract, ModelName, NsId> & string, FieldColumnName<TContract, ModelName, FieldName, NsId> & string, ExtractCodecTypes<TContract>> : never : never;
+type NamespaceFieldOutputType<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = ResolvedNsId<TContract, ModelName, NsId> extends (infer Ns extends string) ? ExtractFieldOutputTypes<TContract> extends (infer Outputs) ? Ns extends keyof Outputs ? Outputs[Ns] extends (infer NamespaceOutputs) ? ModelName extends keyof NamespaceOutputs ? NamespaceOutputs[ModelName] extends (infer ModelOutputs) ? FieldName extends keyof ModelOutputs ? ModelOutputs[FieldName] : never : never : never : never : never : never : never;
+type FieldJsType<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = [NamespaceFieldOutputType<TContract, ModelName, FieldName, NsId>] extends [never] ? [FieldStorageJsType<TContract, ModelName, FieldName, NsId>] extends [never] ? unknown : FieldStorageJsType<TContract, ModelName, FieldName, NsId> : NamespaceFieldOutputType<TContract, ModelName, FieldName, NsId>;
+type FieldStorageColumn<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = ResolvedStorageColumn<TContract, ModelName, FieldName, NsId>;
+type FieldCodecId<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = FieldStorageColumn<TContract, ModelName, FieldName, NsId> extends {
+  readonly codecId: infer Id extends string;
+} ? Id : never;
+type FieldNullable<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = FieldStorageColumn<TContract, ModelName, FieldName, NsId> extends {
+  readonly nullable: infer N extends boolean;
+} ? N : false;
+type FieldTraits<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = FieldCodecId<TContract, ModelName, FieldName, NsId> extends (infer Id extends string) ? Id extends keyof ExtractCodecTypes<TContract> ? ExtractCodecTypes<TContract>[Id] extends {
+  readonly traits: infer T;
+} ? T : never : never : never;
+type NumericFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in keyof DefaultModelRow<TContract, ModelName, NsId> & string]: 'numeric' extends FieldTraits<TContract, ModelName, K, NsId> ? K : never; }[keyof DefaultModelRow<TContract, ModelName, NsId> & string];
+type ExecutionDefaultEntry<TContract extends Contract<SqlStorage>> = TContract['execution'] extends {
+  readonly mutations: {
+    readonly defaults: infer Defaults;
+  };
+} ? Defaults extends ReadonlyArray<unknown> ? Defaults[number] : never : never;
+type HasExecutionCreateDefault<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = [Extract<ExecutionDefaultEntry<TContract>, {
+  readonly ref: {
+    readonly table: ModelTableName<TContract, ModelName, NsId>;
+    readonly column: FieldColumnName<TContract, ModelName, FieldName, NsId>;
+  } & ([NsId] extends [never] ? unknown : {
+    readonly namespace: NsId;
+  });
+  readonly onCreate?: unknown;
+}>] extends [never] ? false : true;
+type IsOptionalCreateField<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = FieldStorageColumn<TContract, ModelName, FieldName, NsId> extends (infer Column) ? Column extends StorageColumn ? Column['nullable'] extends true ? true : Column extends {
+  readonly default: unknown;
+} ? true : HasExecutionCreateDefault<TContract, ModelName, FieldName, NsId> : HasExecutionCreateDefault<TContract, ModelName, FieldName, NsId> : HasExecutionCreateDefault<TContract, ModelName, FieldName, NsId>;
+type CreateFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = keyof DefaultModelRow<TContract, ModelName, NsId> & string;
+type RequiredCreateFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in CreateFieldNames<TContract, ModelName, NsId>]-?: IsOptionalCreateField<TContract, ModelName, K, NsId> extends true ? never : K; }[CreateFieldNames<TContract, ModelName, NsId>];
+type OptionalCreateFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in CreateFieldNames<TContract, ModelName, NsId>]-?: IsOptionalCreateField<TContract, ModelName, K, NsId> extends true ? K : never; }[CreateFieldNames<TContract, ModelName, NsId>];
+type CreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Pick<DefaultModelRow<TContract, ModelName, NsId>, RequiredCreateFieldNames<TContract, ModelName, NsId>> & Partial<Pick<DefaultModelRow<TContract, ModelName, NsId>, OptionalCreateFieldNames<TContract, ModelName, NsId>>> & RelationMutationFields<TContract, ModelName, 'create'>;
+type IsPolymorphicBase<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+  readonly discriminator: unknown;
+  readonly variants: Record<string, unknown>;
+} ? true : false;
+type DiscriminatorFieldName<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+  readonly discriminator: {
+    readonly field: infer F extends string;
+  };
+} ? F : never;
+type VariantCreateInput<TContract extends Contract<SqlStorage>, BaseModelName extends string, VariantName extends string, NsId extends string = never> = Omit<CreateInput<TContract, BaseModelName, NsId>, DiscriminatorFieldName<TContract, BaseModelName, NsId>> & CreateInput<TContract, VariantName, NsId>;
+type ResolvedCreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, VName extends string | undefined, NsId extends string = never> = IsPolymorphicBase<TContract, ModelName, NsId> extends true ? VName extends string ? VariantCreateInput<TContract, ModelName, VName, NsId> : never : CreateInput<TContract, ModelName, NsId>;
+type ModelStorageTableDef<TContract extends Contract<SqlStorage>, ModelName extends string> = ModelTableName<TContract, ModelName> extends (infer TableName extends string) ? NamespaceTableDef<TContract, TableName> : never;
+type PrimaryKeyConstraintColumns<TContract extends Contract<SqlStorage>, ModelName extends string> = ModelStorageTableDef<TContract, ModelName> extends {
+  readonly primaryKey: {
+    readonly columns: infer Columns extends readonly string[];
+  };
+} ? Columns : never;
+type UniqueConstraintColumns<TContract extends Contract<SqlStorage>, ModelName extends string> = ModelStorageTableDef<TContract, ModelName> extends {
+  readonly uniques: infer Uniques;
+} ? Uniques extends ReadonlyArray<infer Unique> ? Unique extends {
+  readonly columns: infer Columns extends readonly string[];
+} ? Columns : never : never : never;
+type FieldNameForColumn<TContract extends Contract<SqlStorage>, ModelName extends string, ColumnName extends string> = { [K in keyof DefaultModelRow<TContract, ModelName> & string]: FieldColumnName<TContract, ModelName, K> extends ColumnName ? K : never; }[keyof DefaultModelRow<TContract, ModelName> & string] extends (infer Matched) ? Matched extends string ? Matched : ColumnName : ColumnName;
+type RowValueForField<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string> = FieldName extends keyof DefaultModelRow<TContract, ModelName> ? DefaultModelRow<TContract, ModelName>[FieldName] : unknown;
+type CriterionFromConstraintColumns<TContract extends Contract<SqlStorage>, ModelName extends string, Columns extends readonly string[]> = string extends Columns[number] ? Record<string, unknown> : { [C in Columns[number] as FieldNameForColumn<TContract, ModelName, C>]: RowValueForField<TContract, ModelName, FieldNameForColumn<TContract, ModelName, C>>; };
+type ConstraintColumnsUnion<TContract extends Contract<SqlStorage>, ModelName extends string> = PrimaryKeyConstraintColumns<TContract, ModelName> | UniqueConstraintColumns<TContract, ModelName>;
+type UniqueConstraintCriterion<TContract extends Contract<SqlStorage>, ModelName extends string> = ConstraintColumnsUnion<TContract, ModelName> extends (infer Columns) ? Columns extends readonly string[] ? CriterionFromConstraintColumns<TContract, ModelName, Columns> : never : never;
+type RelationConnectCriterion<TContract extends Contract<SqlStorage>, ModelName extends string> = [UniqueConstraintCriterion<TContract, ModelName>] extends [never] ? Record<string, unknown> : UniqueConstraintCriterion<TContract, ModelName>;
+interface RelationMutationCreate<TContract extends Contract<SqlStorage>, ModelName extends string> {
+  readonly kind: 'create';
+  readonly data: readonly MutationCreateInput<TContract, ModelName>[];
+}
+interface RelationMutationConnect<TContract extends Contract<SqlStorage>, ModelName extends string> {
+  readonly kind: 'connect';
+  readonly criteria: readonly RelationConnectCriterion<TContract, ModelName>[];
+}
+interface RelationMutationDisconnect<TContract extends Contract<SqlStorage>, ModelName extends string> {
+  readonly kind: 'disconnect';
+  readonly criteria?: readonly RelationConnectCriterion<TContract, ModelName>[];
+}
+type RelationMutation<TContract extends Contract<SqlStorage>, ModelName extends string> = RelationMutationCreate<TContract, ModelName> | RelationMutationConnect<TContract, ModelName> | RelationMutationDisconnect<TContract, ModelName>;
+type RelationThrough<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string> = RelationsOf<TContract, ModelName> extends (infer Rels extends Record<string, unknown>) ? RelName extends keyof Rels ? Rels[RelName] extends {
+  readonly through: infer Through extends {
+    readonly table: string;
+    readonly parentColumns: readonly string[];
+    readonly childColumns: readonly string[];
+  };
+} ? Through : never : never : never;
+type HasJunctionThrough<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string> = [RelationThrough<TContract, ModelName, RelName>] extends [never] ? false : true;
+/**
+ * Resolves a storage table name to its owning domain model by scanning the
+ * model map for the model whose `storage.table` and `storage.namespaceId`
+ * match. Junction tables (e.g. `user_roles`) surface their generated model
+ * (e.g. `UserRole`) so the junction's own field nullability/defaults can be
+ * inspected.
+ */
+type ModelNameForTable<TContract extends Contract<SqlStorage>, NamespaceId extends string, TableName extends string> = { [M in keyof NamespaceModelsOf<TContract, NamespaceId> & string]: NamespaceModelsOf<TContract, NamespaceId>[M] extends {
+  readonly storage: {
+    readonly namespaceId: NamespaceId;
+    readonly table: TableName;
+  };
+} ? M : never; }[keyof NamespaceModelsOf<TContract, NamespaceId> & string];
+/**
+ * A junction field is a *payload* field when its backing column is neither a
+ * parent-side nor a child-side foreign-key column of the join. Those payload
+ * fields are the ones the relation API can't populate from `create`/`connect`.
+ */
+type JunctionPayloadFieldNames<TContract extends Contract<SqlStorage>, JunctionModel extends string, JoinColumns extends string, NsId extends string = never> = { [F in CreateFieldNames<TContract, JunctionModel, NsId>]: FieldColumnName<TContract, JunctionModel, F, NsId> extends JoinColumns ? never : F; }[CreateFieldNames<TContract, JunctionModel, NsId>];
+/**
+ * True when the relation's junction carries at least one required payload
+ * column — a non-join column that is not nullable and has no default. Such a
+ * relation can't be populated through nested `create`, so its create input is
+ * disabled at the type level (mirroring the runtime guard in
+ * `mutation-executor.ts`).
+ */
+type HasRequiredJunctionPayload<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string> = RelationThrough<TContract, ModelName, RelName> extends (infer Through extends {
+  readonly table: string;
+  readonly namespaceId: string;
+  readonly parentColumns: readonly string[];
+  readonly childColumns: readonly string[];
+}) ? ModelNameForTable<TContract, Through['namespaceId'], Through['table']> extends (infer JunctionModel extends string) ? JunctionPayloadFieldNames<TContract, JunctionModel, Through['parentColumns'][number] | Through['childColumns'][number], Through['namespaceId']> extends (infer PayloadFields extends string) ? { [F in PayloadFields]: IsOptionalCreateField<TContract, JunctionModel, F, Through['namespaceId']> extends true ? never : F; }[PayloadFields] extends never ? false : true : false : false : false;
+type DisconnectMutator<TContract extends Contract<SqlStorage>, ModelName extends string, BareDisconnectDisabled extends boolean> = BareDisconnectDisabled extends true ? (criteria: readonly RelationConnectCriterion<TContract, ModelName>[]) => RelationMutationDisconnect<TContract, ModelName> : {
+  (): RelationMutationDisconnect<TContract, ModelName>;
+  (criteria: readonly RelationConnectCriterion<TContract, ModelName>[]): RelationMutationDisconnect<TContract, ModelName>;
+};
+interface RelationMutator<TContract extends Contract<SqlStorage>, ModelName extends string, LinkWritesDisabled extends boolean = false, BareDisconnectDisabled extends boolean = false, DisconnectDisabled extends boolean = false> {
+  create(data: LinkWritesDisabled extends true ? never : MutationCreateInput<TContract, ModelName>): RelationMutationCreate<TContract, ModelName>;
+  create(data: LinkWritesDisabled extends true ? never : readonly MutationCreateInput<TContract, ModelName>[]): RelationMutationCreate<TContract, ModelName>;
+  connect(criterion: LinkWritesDisabled extends true ? never : RelationConnectCriterion<TContract, ModelName>): RelationMutationConnect<TContract, ModelName>;
+  connect(criteria: LinkWritesDisabled extends true ? never : readonly RelationConnectCriterion<TContract, ModelName>[]): RelationMutationConnect<TContract, ModelName>;
+  readonly disconnect: DisconnectDisabled extends true ? (criteria: never) => RelationMutationDisconnect<TContract, ModelName> : DisconnectMutator<TContract, ModelName, BareDisconnectDisabled>;
+}
+type RelationMutationCallback<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends RelationNames<TContract, ModelName>, Context extends 'create' | 'update' = 'update'> = (mutator: RelationMutator<TContract, RelatedModelName<TContract, ModelName, RelName> & string, HasRequiredJunctionPayload<TContract, ModelName, RelName>, HasJunctionThrough<TContract, ModelName, RelName>, Context extends 'create' ? true : false>) => RelationMutation<TContract, RelatedModelName<TContract, ModelName, RelName> & string>;
+type RelationMutationFields<TContract extends Contract<SqlStorage>, ModelName extends string, Context extends 'create' | 'update' = 'update'> = Partial<{ [K in RelationNames<TContract, ModelName>]: RelationMutationCallback<TContract, ModelName, K, Context>; }>;
+type AllModelRelationEntries<TContract extends Contract<SqlStorage>> = { [Ns in keyof TContract['domain']['namespaces']]: { [M in keyof TContract['domain']['namespaces'][Ns]['models']]: TContract['domain']['namespaces'][Ns]['models'][M] extends {
+  readonly relations: infer R extends Record<string, unknown>;
+} ? R[keyof R] : never; }[keyof TContract['domain']['namespaces'][Ns]['models']]; }[keyof TContract['domain']['namespaces']];
+type RelationDefWithTargetFields = {
+  readonly to: {
+    readonly model: string;
+  };
+  readonly on: {
+    readonly targetFields: readonly string[];
+  };
+};
+type ChildForeignKeyFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string> = Extract<AllModelRelationEntries<TContract>, RelationDefWithTargetFields> extends (infer Relation) ? Relation extends {
+  readonly to: {
+    readonly model: ModelName;
+  };
+  readonly on: {
+    readonly targetFields: infer Fields extends readonly string[];
+  };
+} ? Fields[number] : never : never;
+type NestedOptionalCreateFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = OptionalCreateFieldNames<TContract, ModelName, NsId> | Extract<ChildForeignKeyFieldNames<TContract, ModelName>, CreateFieldNames<TContract, ModelName, NsId>>;
+type NestedRequiredCreateFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Exclude<CreateFieldNames<TContract, ModelName, NsId>, NestedOptionalCreateFieldNames<TContract, ModelName, NsId>>;
+type NestedCreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Pick<DefaultModelRow<TContract, ModelName, NsId>, NestedRequiredCreateFieldNames<TContract, ModelName, NsId>> & Partial<Pick<DefaultModelRow<TContract, ModelName, NsId>, NestedOptionalCreateFieldNames<TContract, ModelName, NsId>>>;
+type AtLeastOne<T> = keyof T extends never ? never : { [K in keyof T]-?: Pick<T, K> & Partial<Omit<T, K>>; }[keyof T];
+type MutationCreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = NestedCreateInput<TContract, ModelName, NsId> & RelationMutationFields<TContract, ModelName, 'create'>;
+type MutationCreateInputWithRelations<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = NestedCreateInput<TContract, ModelName, NsId> & AtLeastOne<RelationMutationFields<TContract, ModelName, 'create'>>;
+type MutationUpdateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Partial<DefaultModelRow<TContract, ModelName, NsId>> & RelationMutationFields<TContract, ModelName, 'update'>;
+type ModelRelations<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+  readonly relations: infer R;
+} ? R extends Record<string, unknown> ? R : Record<string, never> : Record<string, never>;
+type ExactRecord<T> = T extends Record<string, unknown> ? string extends keyof T ? Record<string, never> : T : Record<string, never>;
+type RelationsOf<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ExactRecord<ModelRelations<TContract, ModelName, NsId>>;
+type RelationNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = (string extends keyof RelationsOf<TContract, ModelName, NsId> ? never : { [K in keyof RelationsOf<TContract, ModelName, NsId>]: RelationsOf<TContract, ModelName, NsId>[K] extends never ? never : K; }[keyof RelationsOf<TContract, ModelName, NsId>]) & string;
+type IsUnion<T, Whole = T> = T extends Whole ? ([Whole] extends [T] ? false : true) : never;
+type IsSingletonString<T> = [T] extends [string] ? string extends T ? false : IsUnion<T> extends true ? false : true : false;
+type SelectedVariantNames<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName, NsId extends string> = [VariantName] extends [string] ? string extends VariantName ? VariantNames<TContract, ModelName, NsId> : VariantName : never;
+type VariantDeclaredRelationKeys<TContract extends Contract<SqlStorage>, VariantName extends string, NsId extends string> = VariantName extends string ? keyof RelationsOf<TContract, VariantName, NsId> : never;
+type SelectedVariantDeclaredRelationKeys<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName, NsId extends string> = VariantDeclaredRelationKeys<TContract, SelectedVariantNames<TContract, ModelName, VariantName, NsId>, NsId>;
+type VariantAwareIncludeRelationNames<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName, NsId extends string = never> = IsSingletonString<VariantName> extends true ? RelationNames<TContract, Extract<VariantName, string>, NsId> | Exclude<RelationNames<TContract, ModelName, NsId>, keyof RelationsOf<TContract, Extract<VariantName, string>, NsId>> : [VariantName] extends [string] ? Exclude<RelationNames<TContract, ModelName, NsId>, SelectedVariantDeclaredRelationKeys<TContract, ModelName, VariantName, NsId>> : RelationNames<TContract, ModelName, NsId>;
+type IncludeRelationOwner<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName, RelName extends string, NsId extends string = never> = IsSingletonString<VariantName> extends true ? RelName extends keyof RelationsOf<TContract, Extract<VariantName, string>, NsId> ? Extract<VariantName, string> : ModelName : ModelName;
+type RelationModelName<Relation> = Relation extends {
+  readonly to: {
+    readonly model: infer To extends string;
+  };
+} ? To : never;
+type RelatedModelName<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = RelationsOf<TContract, ModelName, NsId> extends (infer Rels) ? Rels extends Record<string, unknown> ? RelName extends keyof Rels ? RelationModelName<Rels[RelName]> : never : never : never;
+type RelationTargetNamespace<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = [NsId] extends [never] ? never : RelationsOf<TContract, ModelName, NsId> extends (infer Rels) ? Rels extends Record<string, unknown> ? RelName extends keyof Rels ? Rels[RelName] extends {
+  readonly to: {
+    readonly namespace: infer N extends string;
+  };
+} ? N : never : never : never : never;
+type RelationCardinalityFromRelation<Relation> = Relation extends {
+  readonly cardinality: infer Cardinality extends RelationCardinalityTag;
+} ? Cardinality : '1:N';
+type RelationCardinality<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = RelationsOf<TContract, ModelName, NsId> extends (infer Rels) ? Rels extends Record<string, unknown> ? RelName extends keyof Rels ? RelationCardinalityFromRelation<Rels[RelName]> : '1:N' : '1:N' : '1:N';
+type RelationLocalFieldColumns<TContract extends Contract<SqlStorage>, ModelName extends string, Relation> = Relation extends {
+  readonly on: {
+    readonly localFields: infer Fields extends readonly string[];
+  };
+} ? MapFieldsToColumns<TContract, ModelName, Fields> : readonly [];
+type MapFieldsToColumns<TContract extends Contract<SqlStorage>, ModelName extends string, Fields extends readonly string[]> = Fields extends readonly [infer Head extends string, ...infer Tail extends string[]] ? readonly [FieldColumnName<TContract, ModelName, Head>, ...MapFieldsToColumns<TContract, ModelName, Tail>] : readonly [];
+type AnyColumnNullable<Columns extends Record<string, StorageColumn>, ColNames extends readonly string[]> = ColNames extends readonly [infer Head extends string, ...infer Tail extends string[]] ? Head extends keyof Columns ? Columns[Head]['nullable'] extends true ? true : AnyColumnNullable<Columns, Tail> : true : false;
+type HasForeignKeyForCols<FKs extends readonly unknown[], Cols extends readonly string[]> = FKs extends readonly [infer Head, ...infer Tail extends unknown[]] ? Head extends {
+  readonly source: {
+    readonly columns: Cols;
+  };
+} ? true : HasForeignKeyForCols<Tail, Cols> : false;
+type IsFkSideOfRelation<Table extends StorageTable, ParentCols extends readonly string[]> = Table extends {
+  readonly foreignKeys: infer FKs extends readonly unknown[];
+} ? HasForeignKeyForCols<FKs, ParentCols> : false;
+type IsToOneRelationNullable<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = ModelTableName<TContract, ModelName, NsId> extends (infer TableName extends string) ? NamespaceTableDef<TContract, TableName, ResolvedNsId<TContract, ModelName, NsId>> extends (infer Table extends StorageTable) ? RelationsOf<TContract, ModelName, NsId> extends (infer Rels extends Record<string, unknown>) ? RelName extends keyof Rels ? RelationLocalFieldColumns<TContract, ModelName, Rels[RelName]> extends (infer Cols extends readonly string[]) ? IsFkSideOfRelation<Table, Cols> extends true ? AnyColumnNullable<Table['columns'], Cols> : true : true : true : true : true : true;
+type IncludeRelationValue<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, IncludedRow, NsId extends string = never> = RelationCardinality<TContract, ModelName, RelName, NsId> extends '1:1' | 'N:1' ? IsToOneRelationNullable<TContract, ModelName, RelName, NsId> extends true ? IncludedRow | null : IncludedRow : IncludedRow[];
+type CollectionModelName<TContract extends Contract<SqlStorage>> = { [Ns in keyof TContract['domain']['namespaces']]: keyof TContract['domain']['namespaces'][Ns]['models'] & string; }[keyof TContract['domain']['namespaces']];
+//#endregion
+//#region src/collection-internal-types.d.ts
+interface CollectionInit<TContract extends Contract<SqlStorage>> {
+  readonly tableName?: string | undefined;
+  readonly namespaceId: string;
+  readonly state?: CollectionState | undefined;
+  readonly registry?: ReadonlyMap<string, CollectionConstructor<TContract>> | undefined;
+  readonly includeRefinementMode?: boolean | undefined;
+}
+type CollectionConstructor<TContract extends Contract<SqlStorage>> = new (ctx: CollectionContext<TContract>, modelName: string, options?: CollectionInit<TContract>) => Collection<TContract, string, unknown, CollectionTypeState>;
+type WithWhereState<State extends CollectionTypeState> = Omit<State, 'hasWhere'> & {
+  readonly hasWhere: true;
+};
+type WithOrderByState<State extends CollectionTypeState> = Omit<State, 'hasOrderBy'> & {
+  readonly hasOrderBy: true;
+};
+type WithVariantState<State extends CollectionTypeState, V extends string> = Omit<State, 'variantName'> & {
+  readonly variantName: V;
+};
+type IncludedRelationsForRow<TContract extends Contract<SqlStorage>, ModelName extends string, Row> = Omit<Row, keyof DefaultModelRow<TContract, ModelName>>;
+type IncludeRefinementTerminals = 'all' | 'first' | 'aggregate' | 'groupBy' | 'create' | 'createAll' | 'createAndCount' | 'update' | 'updateAll' | 'updateAndCount' | 'delete' | 'deleteAll' | 'deleteAndCount' | 'upsert';
+type IncludeRefinementScalarMethods = 'count' | 'sum' | 'avg' | 'min' | 'max' | 'combine';
+type IncludeRefinementCollection<TContract extends Contract<SqlStorage>, ModelName extends string, Row, State extends CollectionTypeState, IsToMany extends boolean> = Omit<Collection<TContract, ModelName, Row, State>, IncludeRefinementTerminals | (IsToMany extends true ? never : IncludeRefinementScalarMethods)>;
+type IsToManyRelation<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = RelationCardinality<TContract, ModelName, RelName, NsId> extends '1:N' | 'N:M' ? true : false;
+type IncludeRefinementResult<TContract extends Contract<SqlStorage>, RelatedName extends string, IsToMany extends boolean> = IncludeRefinementCollection<TContract, RelatedName, unknown, CollectionTypeState, IsToMany> | (IsToMany extends true ? IncludeScalar<unknown> | IncludeCombine<Record<string, unknown>> : never);
+declare const RowType: unique symbol;
+interface RowSelection<T> {
+  [RowType]: T;
+}
+type IncludeRefinementValue<TContract extends Contract<SqlStorage>, ParentModelName extends string, RelName extends string, DefaultIncludedRow, RefinedResult, NsId extends string = never> = RefinedResult extends RowSelection<infer V> ? RefinedResult extends {
+  readonly kind: 'includeScalar' | 'includeCombine';
+} ? V : IncludeRelationValue<TContract, ParentModelName, RelName, V, NsId> : IncludeRelationValue<TContract, ParentModelName, RelName, DefaultIncludedRow, NsId>;
+//#endregion
+//#region src/grouped-collection.d.ts
+interface GroupedCollectionInit {
+  readonly tableName: string;
+  readonly namespaceId: string;
+  readonly baseFilters: readonly AnyExpression[];
+  readonly groupByFields: readonly string[];
+  readonly groupByColumns: readonly string[];
+  readonly havingFilters: readonly AnyExpression[];
+}
+type GroupByFieldName<TContract extends Contract<SqlStorage>, ModelName extends string> = keyof DefaultModelRow<TContract, ModelName> & string;
+declare class GroupedCollection<TContract extends Contract<SqlStorage>, ModelName extends string, GroupFields extends readonly GroupByFieldName<TContract, ModelName>[]> {
+  readonly ctx: CollectionContext<TContract>;
+  private readonly contract;
+  readonly modelName: ModelName;
+  readonly tableName: string;
+  readonly namespaceId: string;
+  readonly baseFilters: readonly AnyExpression[];
+  readonly groupByFields: readonly string[];
+  readonly groupByColumns: readonly string[];
+  readonly havingFilters: readonly AnyExpression[];
+  constructor(ctx: CollectionContext<TContract>, modelName: ModelName, options: GroupedCollectionInit);
+  having(predicate: (having: HavingBuilder<TContract, ModelName>) => AnyExpression): GroupedCollection<TContract, ModelName, GroupFields>;
+  /**
+   * Read terminal: run a grouped aggregate query.
+   *
+   * Accepts an optional `configure` callback that receives a
+   * `MetaBuilder<'read'>` for attaching typed annotations.
+   * Annotations are merged into the compiled plan's `meta.annotations`.
+   */
+  aggregate<Spec extends AggregateSpec>(fn: (aggregate: AggregateBuilder<TContract, ModelName>) => Spec, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Array<SimplifyDeep<Pick<DefaultModelRow<TContract, ModelName>, GroupFields[number]> & AggregateResult<Spec>>>>;
+}
+//#endregion
+//#region src/collection.d.ts
+type WhereDirectInput = WhereArg;
+declare class Collection<TContract extends Contract<SqlStorage>, ModelName extends string, Row = SimplifyDeep<InferRootRow<TContract, ModelName>>, State extends CollectionTypeState = DefaultCollectionTypeState> implements RowSelection<Row> {
+  #private;
+  readonly [RowType]: Row;
+  /** @internal */
+  readonly ctx: CollectionContext<TContract>;
+  /** @internal */
+  private readonly contract;
+  /** @internal */
+  readonly modelName: ModelName;
+  /** @internal */
+  readonly tableName: string;
+  /** @internal */
+  readonly namespaceId: string;
+  /** @internal */
+  readonly state: CollectionState;
+  /** @internal */
+  readonly registry: ReadonlyMap<string, CollectionConstructor<TContract>>;
+  /** @internal */
+  readonly includeRefinementMode: boolean;
+  constructor(ctx: CollectionContext<TContract>, modelName: ModelName, options: CollectionInit<TContract>);
+  /**
+   * Narrow the collection with a `WHERE` predicate. Returns a new
+   * collection — chain further builders or run a terminal on it.
+   *
+   * Accepts a callback receiving a typed model accessor, a raw
+   * `WhereArg` expression, or a shorthand field/value object. Multiple
+   * calls are AND-combined.
+   *
+   * ```typescript
+   * // Callback form with column-level operators:
+   * const matches = await db.orm.User.where((u) => u.email.eq('alice@example.com')).all();
+   *
+   * // Shorthand object form:
+   * const user = await db.orm.User.where({ id: 1, active: true }).first();
+   *
+   * // Chained AND — still a builder, run a terminal to execute:
+   * const adults = await db.orm.User.where({ active: true }).where((u) => u.age.gt(18)).all();
+   * ```
+   */
+  where(fn: (model: VariantAwareModelAccessor<TContract, ModelName, State['variantName'], State['nsId']>) => WhereDirectInput): Collection<TContract, ModelName, Row, WithWhereState<State>>;
+  where(input: WhereDirectInput): Collection<TContract, ModelName, Row, WithWhereState<State>>;
+  where(fn: (model: VariantAwareModelAccessor<TContract, ModelName, State['variantName'], State['nsId']>) => WhereArg): Collection<TContract, ModelName, Row, WithWhereState<State>>;
+  where(filters: ShorthandWhereFilter<TContract, ModelName, State['nsId']>): Collection<TContract, ModelName, Row, WithWhereState<State>>;
+  /**
+   * Narrow a polymorphic model to a specific variant. The returned
+   * collection has the variant's row shape and a discriminator filter
+   * is automatically applied. Chaining `.variant(...)` again replaces
+   * the previous variant filter.
+   *
+   * ```typescript
+   * // Read only admin users (STI):
+   * const admins = await db.orm.User.variant('Admin').all();
+   *
+   * // Iterate the rows:
+   * for await (const admin of db.orm.User.variant('Admin').all()) {
+   *   console.log(admin.role);
+   * }
+   *
+   * // Insert under a variant — discriminator is injected automatically:
+   * await db.orm.User.variant('Admin').create({ name: 'Ada', role: 'super' });
+   * ```
+   */
+  variant<V extends VariantNames<TContract, ModelName>>(variantName: V): Collection<TContract, ModelName, VariantModelRow<TContract, ModelName, V>, WithVariantState<WithWhereState<State>, V>>;
+  /**
+   * Eagerly load a related model. The relation appears on every
+   * returned row under its declared name; to-one relations are mapped
+   * to a single object (or `null`), to-many relations to an array.
+   *
+   * An optional refinement callback receives a child collection that
+   * can be further constrained, projected, ordered, paginated, or
+   * reduced to scalars via `count()`/`sum()`/etc. or to multiple
+   * sub-aggregates via `combine()`.
+   *
+   * ```typescript
+   * // Simple include — every user comes back with its posts array:
+   * const users = await db.orm.User.include('posts').all();
+   *
+   * // Refine the related collection:
+   * const withRecent = await db.orm.User.include('posts', (posts) =>
+   *   posts.where({ published: true }).orderBy((p) => p.createdAt.desc()).take(5),
+   * ).all();
+   *
+   * // Reduce a to-many relation to a scalar value:
+   * const withCounts = await db.orm.User.include('posts', (posts) => posts.count()).all();
+   *
+   * // Multiple sub-views via combine():
+   * const overview = await db.orm.User.include('posts', (posts) =>
+   *   posts.combine({ recent: posts.take(3), total: posts.count() }),
+   * ).all();
+   * ```
+   */
+  include<RelName extends VariantAwareIncludeRelationNames<TContract, ModelName, State['variantName'], State['nsId']>, RelationOwner extends string = IncludeRelationOwner<TContract, ModelName, State['variantName'], RelName, State['nsId']> & string, RelatedName extends RelatedModelName<TContract, RelationOwner, RelName, State['nsId']> & string = RelatedModelName<TContract, RelationOwner, RelName, State['nsId']> & string, TargetNs extends string = RelationTargetNamespace<TContract, RelationOwner, RelName, State['nsId']>, IsToMany extends boolean = IsToManyRelation<TContract, RelationOwner, RelName, State['nsId']>, RefinedResult extends IncludeRefinementResult<TContract, RelatedName, IsToMany> = IncludeRefinementCollection<TContract, RelatedName, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, CollectionTypeState, IsToMany>>(relationName: RelName, refineFn?: (collection: IncludeRefinementCollection<TContract, RelatedName, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, DefaultCollectionTypeState, IsToMany>) => RefinedResult): Collection<TContract, ModelName, SimplifyDeep<Row & { [K in RelName]: IncludeRefinementValue<TContract, RelationOwner, K, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, RefinedResult, State['nsId']>; }>, State>;
+  /**
+   * Project the row down to a subset of scalar fields. Previously
+   * included relations are preserved on the resulting row shape; only
+   * scalar columns are narrowed.
+   *
+   * ```typescript
+   * const summaries = await db.orm.User.select('id', 'email').all();
+   * // typeof summaries[number] === { id: ...; email: ... }
+   *
+   * for await (const row of db.orm.User.select('id', 'email').all()) {
+   *   console.log(row.id, row.email);
+   * }
+   * ```
+   */
+  select<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]]>(...fields: Fields): Collection<TContract, ModelName, SimplifyDeep<Pick<DefaultModelRow<TContract, ModelName>, Fields[number]> & IncludedRelationsForRow<TContract, ModelName, Row>>, State>;
+  /**
+   * Append an `ORDER BY` clause. Pass a single selector callback or an
+   * array of callbacks; each receives a typed model accessor whose
+   * columns expose `.asc()` and `.desc()`. Multiple calls append to the
+   * existing list (left-to-right ordering preserved).
+   *
+   * Calling `orderBy(...)` unlocks `cursor(...)` and `distinctOn(...)`,
+   * which both require a defined sort order.
+   *
+   * ```typescript
+   * const newest = await db.orm.User.orderBy((u) => u.createdAt.desc()).all();
+   *
+   * const byName = await db.orm.User
+   *   .orderBy([(u) => u.lastName.asc(), (u) => u.firstName.asc()])
+   *   .all();
+   * ```
+   */
+  orderBy(selection: ((model: VariantAwareModelAccessor<TContract, ModelName, State['variantName']>) => OrderByItem) | ReadonlyArray<(model: VariantAwareModelAccessor<TContract, ModelName, State['variantName']>) => OrderByItem>): Collection<TContract, ModelName, Row, WithOrderByState<State>>;
+  /**
+   * Switch to grouped-aggregate mode. Returns a `GroupedCollection`
+   * whose `.aggregate(...)` terminal produces one row per group with
+   * the chosen key columns plus the requested aggregates.
+   *
+   * ```typescript
+   * const stats = await db.orm.Post
+   *   .where({ published: true })
+   *   .groupBy('userId')
+   *   .aggregate((agg) => ({ count: agg.count(), totalViews: agg.sum('views') }));
+   * // [{ userId: 1, count: 3, totalViews: 120 }, ...]
+   * ```
+   */
+  groupBy<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]]>(...fields: Fields): GroupedCollection<TContract, ModelName, Fields>;
+  /**
+   * Scalar reducer — reduces a to-many relation to the number of
+   * related rows. Use inside an `include(...)` refinement callback as
+   * `include(..., (rel) => rel.count())`; throws if called elsewhere.
+   * The parent row's relation field becomes that count instead of an
+   * array.
+   *
+   * ```typescript
+   * const users = await db.orm.User.include('posts', (posts) => posts.count()).all();
+   * // each user row: { ...user, posts: number }
+   * ```
+   */
+  count(): IncludeScalar<number>;
+  /**
+   * Scalar reducer — reduces a to-many relation to the sum of `field`
+   * across related rows. Returns `null` when there are no related
+   * rows. Use inside an `include(...)` refinement callback; throws if
+   * called elsewhere.
+   *
+   * ```typescript
+   * const users = await db.orm.User.include('posts', (posts) => posts.sum('views')).all();
+   * // each user row: { ...user, posts: number | null }
+   * ```
+   */
+  sum<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): IncludeScalar<number | null>;
+  /**
+   * Scalar reducer — reduces a to-many relation to the average of
+   * `field` across related rows. Returns `null` when there are no
+   * related rows. Use inside an `include(...)` refinement callback;
+   * throws if called elsewhere.
+   *
+   * ```typescript
+   * const users = await db.orm.User.include('posts', (posts) => posts.avg('views')).all();
+   * // each user row: { ...user, posts: number | null }
+   * ```
+   */
+  avg<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): IncludeScalar<number | null>;
+  /**
+   * Scalar reducer — reduces a to-many relation to the minimum value
+   * of `field` across related rows. Returns `null` when there are no
+   * related rows. Use inside an `include(...)` refinement callback;
+   * throws if called elsewhere.
+   *
+   * ```typescript
+   * const users = await db.orm.User.include('posts', (posts) => posts.min('views')).all();
+   * ```
+   */
+  min<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): IncludeScalar<number | null>;
+  /**
+   * Scalar reducer — reduces a to-many relation to the maximum value
+   * of `field` across related rows. Returns `null` when there are no
+   * related rows. Use inside an `include(...)` refinement callback;
+   * throws if called elsewhere.
+   *
+   * ```typescript
+   * const users = await db.orm.User.include('posts', (posts) => posts.max('views')).all();
+   * ```
+   */
+  max<FieldName extends NumericFieldNames<TContract, ModelName>>(field: FieldName): IncludeScalar<number | null>;
+  /**
+   * Produce multiple named sub-views of a to-many relation in a
+   * single `include(...)`. Each branch is either another refined
+   * collection (mapped to a row array on the parent) or a scalar
+   * reducer such as `count()`/`sum(...)`. Only valid inside an
+   * `include(...)` refinement callback for to-many relations.
+   *
+   * ```typescript
+   * const users = await db.orm.User.include('posts', (posts) =>
+   *   posts.combine({
+   *     recent: posts.where({ published: true }).take(3),
+   *     total: posts.count(),
+   *     averageViews: posts.avg('views'),
+   *   }),
+   * ).all();
+   * // each user row: {
+   * //   ...user,
+   * //   posts: { recent: Post[]; total: number; averageViews: number | null };
+   * // }
+   * ```
+   */
+  combine<Spec extends Record<string, Collection<TContract, ModelName, unknown, CollectionTypeState> | IncludeScalar<unknown>>>(spec: Spec): IncludeCombine<{ [K in keyof Spec]: Spec[K] extends IncludeScalar<infer ScalarResult> ? ScalarResult : Spec[K] extends Collection<TContract, ModelName, infer BranchRow, CollectionTypeState> ? BranchRow[] : never; }>;
+  /**
+   * Resume pagination from a known cursor position. Requires a prior
+   * `orderBy(...)` so the cursor has a stable basis; provide a value
+   * for every column referenced by the active `orderBy(...)` so each
+   * ordered axis has a defined boundary.
+   *
+   * ```typescript
+   * const page1 = await db.orm.Post
+   *   .orderBy((p) => p.createdAt.desc())
+   *   .take(20)
+   *   .all();
+   *
+   * const last = page1[page1.length - 1]!;
+   * const page2 = await db.orm.Post
+   *   .orderBy((p) => p.createdAt.desc())
+   *   .cursor({ createdAt: last.createdAt })
+   *   .take(20)
+   *   .all();
+   * ```
+   */
+  cursor(cursorValues: State['hasOrderBy'] extends true ? Partial<Record<keyof DefaultModelRow<TContract, ModelName> & string, unknown>> : never): Collection<TContract, ModelName, Row, State>;
+  /**
+   * Emit `SELECT DISTINCT` keyed on the given fields. Replaces any
+   * previous `distinct(...)` / `distinctOn(...)` selection.
+   *
+   * ```typescript
+   * const groups = await db.orm.User.distinct('country', 'role').all();
+   * ```
+   */
+  distinct<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]]>(...fields: Fields): Collection<TContract, ModelName, Row, State>;
+  /**
+   * Emit `SELECT DISTINCT ON (fields)` — keep the first row per
+   * distinct key according to the current `orderBy(...)`. Requires a
+   * prior `orderBy(...)`; replaces any previous `distinct(...)` /
+   * `distinctOn(...)` selection.
+   *
+   * ```typescript
+   * // Latest post per user:
+   * const latestPerUser = await db.orm.Post
+   *   .orderBy([(p) => p.userId.asc(), (p) => p.createdAt.desc()])
+   *   .distinctOn('userId')
+   *   .all();
+   * ```
+   */
+  distinctOn<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]]>(...fields: State['hasOrderBy'] extends true ? Fields : never): Collection<TContract, ModelName, Row, State>;
+  /**
+   * Apply `LIMIT n`. Replaces any previous limit set on this collection.
+   *
+   * ```typescript
+   * const firstTen = await db.orm.User.orderBy((u) => u.id.asc()).take(10).all();
+   * ```
+   */
+  take(n: number): Collection<TContract, ModelName, Row, State>;
+  /**
+   * Apply `OFFSET n`. Replaces any previous offset set on this collection.
+   *
+   * ```typescript
+   * const page2 = await db.orm.User
+   *   .orderBy((u) => u.id.asc())
+   *   .skip(10)
+   *   .take(10)
+   *   .all();
+   * ```
+   */
+  skip(n: number): Collection<TContract, ModelName, Row, State>;
+  /**
+   * Read terminal: execute the query and stream every matching row.
+   *
+   * The returned `AsyncIterableResult<Row>` is BOTH a thenable that
+   * resolves to `Row[]` (so `await` collects all rows into an array)
+   * AND an async iterable (so `for await` streams rows as they
+   * arrive, without buffering the whole result set in memory). Pick
+   * whichever fits the caller. A single result can only be consumed
+   * once.
+   *
+   * Streaming is the default and the expected execution model. The
+   * only scenarios that fall back to buffering internally before
+   * yielding are drivers that cannot expose a cursor to the
+   * underlying database, and — for queries with `include(...)` —
+   * targets whose SQL dialect supports neither lateral joins nor
+   * correlated subqueries (so child rows cannot be stitched in a
+   * single streaming query). These are implementation details below
+   * the public API; the iteration shape itself is genuinely
+   * streaming whenever the driver and plan allow it.
+   *
+   * ```typescript
+   * // Thenable — collect to an array:
+   * const users = await db.orm.User.all();
+   * for (const user of users) console.log(user.id);
+   *
+   * // Async iterable — stream rows as they arrive:
+   * for await (const user of db.orm.User.all()) {
+   *   console.log(user.id);
+   * }
+   * ```
+   *
+   * Accepts an optional `configure` callback that receives a
+   * `MetaBuilder<'read'>` so the caller can attach typed user
+   * annotations to the executed plan. `meta.annotate(...)` enforces
+   * applicability at the type level and at runtime; annotations are
+   * merged into `plan.meta.annotations` at compile time.
+   *
+   * ```typescript
+   * await db.orm.User.all((meta) => meta.annotate(cacheAnnotation({ ttl: 60 })));
+   * ```
+   */
+  all(configure?: (meta: MetaBuilder<'read'>) => void): AsyncIterableResult<Row>;
+  /**
+   * Read terminal: return the first matching row, or `null` if none
+   * match. Optionally accepts a filter (callback or shorthand object)
+   * followed by a `configure` callback for typed read annotations.
+   *
+   * To attach annotations without further narrowing, pass `undefined`
+   * as the filter (or chain `.where(...)` first):
+   *
+   * ```typescript
+   * // No filter — first row in the collection:
+   * const someone = await db.orm.User.first();
+   *
+   * // Shorthand filter:
+   * const alice = await db.orm.User.first({ email: 'alice@example.com' });
+   *
+   * // Callback filter:
+   * const old = await db.orm.User.first((u) => u.age.gt(60));
+   *
+   * // Annotate without filtering further:
+   * await db.orm.User.first(undefined, (meta) =>
+   *   meta.annotate(cacheAnnotation({ ttl: 60 })),
+   * );
+   * ```
+   */
+  first(): Promise<Row | null>;
+  first(filter: undefined, configure: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
+  first(filter: (model: VariantAwareModelAccessor<TContract, ModelName, State['variantName'], State['nsId']>) => WhereArg, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
+  first(filter: ShorthandWhereFilter<TContract, ModelName, State['nsId']>, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
+  /**
+   * Read terminal: run an aggregate query (count, sum, avg, min, max)
+   * built via the `AggregateBuilder` callback. Returns one object
+   * with the requested aggregate values keyed by the aliases supplied
+   * in the spec.
+   *
+   * ```typescript
+   * const stats = await db.orm.Post
+   *   .where({ published: true })
+   *   .aggregate((agg) => ({
+   *     total: agg.count(),
+   *     averageViews: agg.avg('views'),
+   *     maxViews: agg.max('views'),
+   *   }));
+   * // { total: 42, averageViews: 17.3, maxViews: 9001 }
+   * ```
+   *
+   * Accepts an optional `configure` callback that receives a
+   * `MetaBuilder<'read'>` for attaching typed annotations.
+   * Annotations are merged into the compiled plan's `meta.annotations`.
+   */
+  aggregate<Spec extends AggregateSpec>(fn: (aggregate: AggregateBuilder<TContract, ModelName>) => Spec, configure?: (meta: MetaBuilder<'read'>) => void): Promise<AggregateResult<Spec>>;
+  /**
+   * Write terminal: insert one row and return it (with any configured
+   * `select(...)` / `include(...)` projections applied to the returned
+   * shape).
+   *
+   * Related rows can be created or linked through relation callbacks
+   * on parent/child-owned relations (one-to-one or one-to-many).
+   * The callback receives a mutator exposing `create(...)` and
+   * `connect(...)`; `disconnect(...)` is only supported in nested
+   * `update(...)` mutations. Many-to-many relations are not yet
+   * supported as nested-mutation targets.
+   *
+   * ```typescript
+   * // Simple insert:
+   * const user = await db.orm.User.create({
+   *   email: 'alice@example.com',
+   *   name: 'Alice',
+   * });
+   *
+   * // Nested create on a child-owned to-many relation:
+   * const author = await db.orm.User.create({
+   *   email: 'bob@example.com',
+   *   posts: (posts) => posts.create([
+   *     { title: 'Hello' },
+   *     { title: 'World' },
+   *   ]),
+   * });
+   *
+   * // Connect a child-owned post to an existing parent author:
+   * const reply = await db.orm.Post.create({
+   *   title: 'Re: Hello',
+   *   author: (author) => author.connect({ id: 1 }),
+   * });
+   * ```
+   *
+   * Accepts an optional `configure` callback that receives a
+   * `MetaBuilder<'write'>` for attaching typed annotations.
+   * Annotations are merged into the compiled mutation plan's
+   * `meta.annotations`.
+   *
+   * Note: when the input contains nested-mutation callbacks, the
+   * operation is executed as a graph of internal queries via
+   * `withMutationScope`. In that path, annotations apply to the
+   * logical `create()` call but do not currently flow into each
+   * constituent SQL statement issued for the related rows.
+   */
+  create(data: ResolvedCreateInput<TContract, ModelName, State['variantName'], State['nsId']>, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row>;
+  create(data: MutationCreateInputWithRelations<TContract, ModelName, State['nsId']>, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row>;
+  /**
+   * Write terminal: insert many rows and stream the inserted rows.
+   *
+   * The returned `AsyncIterableResult<Row>` is BOTH a thenable that
+   * resolves to `Row[]` AND an async iterable that streams inserted
+   * rows as they arrive. Use whichever shape fits the caller — but
+   * only consume it once. Streaming is the default; some
+   * driver/plan combinations may still buffer internally before
+   * yielding.
+   *
+   * ```typescript
+   * // Thenable — collect all inserted rows into an array:
+   * const created = await db.orm.User.createAll([
+   *   { email: 'a@example.com' },
+   *   { email: 'b@example.com' },
+   * ]);
+   *
+   * // Async iterable — stream inserted rows as they arrive:
+   * for await (const row of db.orm.User.createAll(seedUsers)) {
+   *   console.log('inserted', row.id);
+   * }
+   * ```
+   *
+   * Accepts an optional `configure` callback that receives a
+   * `MetaBuilder<'write'>` for attaching typed annotations to the
+   * compiled insert plan.
+   */
+  createAll(data: readonly ResolvedCreateInput<TContract, ModelName, State['variantName'], State['nsId']>[], configure?: (meta: MetaBuilder<'write'>) => void): AsyncIterableResult<Row>;
+  /**
+   * Write terminal: insert many rows without materializing the
+   * inserted rows, returning the number of inserted records.
+   *
+   * Prefer `createAll(...)` when you need the returned rows; prefer
+   * this when you only need to know how many rows were inserted (the
+   * compiled plan skips `RETURNING`).
+   *
+   * ```typescript
+   * const inserted = await db.orm.User.createAndCount([
+   *   { email: 'a@example.com' },
+   *   { email: 'b@example.com' },
+   * ]);
+   * // inserted === 2
+   * ```
+   *
+   * Not supported on MTI variants — use `createAll(...)` instead.
+   */
+  createAndCount(data: readonly ResolvedCreateInput<TContract, ModelName, State['variantName']>[], configure?: (meta: MetaBuilder<'write'>) => void): Promise<number>;
+  /**
+   * Write terminal: insert a row, or update the existing row on
+   * conflict. Returns the resulting row (the inserted one or the
+   * updated/existing one).
+   *
+   * `conflictOn` selects which unique constraint drives the conflict
+   * resolution — omit to use the model's primary key.
+   *
+   * ```typescript
+   * // Insert-or-update on email uniqueness:
+   * await db.orm.User.upsert({
+   *   create: { email: 'alice@example.com', name: 'Alice' },
+   *   update: { name: 'Alice (updated)' },
+   *   conflictOn: { email: 'alice@example.com' },
+   * });
+   *
+   * // Conditional create — `update: {}` keeps the existing row
+   * // unchanged. `conflictOn` must reference the constraint that
+   * // makes the row "already exist"; omit only when the conflict is
+   * // on the primary key. On conflict,
+   * // `ON CONFLICT DO NOTHING RETURNING ...` may return zero rows,
+   * // so a follow-up reload is issued to fetch and return the
+   * // existing row.
+   * await db.orm.User.upsert({
+   *   create: { email: 'alice@example.com', name: 'Alice' },
+   *   update: {},
+   *   conflictOn: { email: 'alice@example.com' },
+   * });
+   * ```
+   *
+   * Not supported on MTI variants.
+   */
+  upsert(input: {
+    create: ResolvedCreateInput<TContract, ModelName, State['variantName']>;
+    update: Partial<DefaultModelRow<TContract, ModelName>>;
+    conflictOn?: UniqueConstraintCriterion<TContract, ModelName>;
+  }, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row>;
+  /**
+   * Write terminal: update matching rows and return the first one (or
+   * `null` when no row matched). Requires a prior `.where(...)` —
+   * calling `update(...)` on an unfiltered collection is a type error.
+   *
+   * Related rows can be created or relinked through relation
+   * callbacks on parent/child-owned relations (one-to-one or
+   * one-to-many). The callback receives a mutator exposing
+   * `create(...)`, `connect(...)`, and `disconnect(...)`. Nested
+   * updates against existing related rows, and many-to-many relations
+   * as nested-mutation targets, are not supported through this API.
+   *
+   * ```typescript
+   * // Update one row by id:
+   * const updated = await db.orm.User
+   *   .where({ id: 1 })
+   *   .update({ name: 'Alice Renamed' });
+   *
+   * // Update + relink — runs as a graph of internal mutations:
+   * await db.orm.User
+   *   .where({ id: 1 })
+   *   .update({
+   *     name: 'Alice',
+   *     posts: (posts) => posts.connect([{ id: 5 }]),
+   *   });
+   * ```
+   *
+   * Accepts an optional `configure` callback that receives a
+   * `MetaBuilder<'write'>` for attaching typed annotations.
+   *
+   * Note: when the input contains nested-mutation callbacks, the
+   * operation is executed as a graph of internal queries via
+   * `withMutationScope`. In that path, annotations apply to the logical
+   * `update()` call but do not currently flow into each constituent SQL
+   * statement issued for the related rows.
+   */
+  update(data: State['hasWhere'] extends true ? MutationUpdateInput<TContract, ModelName, State['nsId']> : never, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row | null>;
+  /**
+   * Write terminal: update every matching row and stream the updated
+   * rows. Requires a prior `.where(...)` filter.
+   *
+   * The returned `AsyncIterableResult<Row>` is BOTH a thenable that
+   * resolves to `Row[]` AND an async iterable that streams updated
+   * rows as they arrive. Use whichever fits; a result can only be
+   * consumed once. Streaming is the default; some driver/plan
+   * combinations may still buffer internally before yielding.
+   *
+   * ```typescript
+   * // Thenable — collect updated rows into an array:
+   * const updated = await db.orm.Post
+   *   .where({ published: false })
+   *   .updateAll({ published: true });
+   *
+   * // Async iterable — stream updated rows as they arrive:
+   * for await (const row of db.orm.Post.where({ draft: true }).updateAll({ draft: false })) {
+   *   console.log('published', row.id);
+   * }
+   * ```
+   *
+   * Accepts an optional `configure` callback that receives a
+   * `MetaBuilder<'write'>` for attaching typed annotations.
+   */
+  updateAll(data: State['hasWhere'] extends true ? Partial<DefaultModelRow<TContract, ModelName, State['nsId']>> : never, configure?: (meta: MetaBuilder<'write'>) => void): AsyncIterableResult<Row>;
+  /**
+   * Write terminal: update every matching row without returning them,
+   * resolving to the count of rows that were updated. Requires a prior
+   * `.where(...)` filter.
+   *
+   * Prefer `updateAll(...)` when you need the updated rows; prefer
+   * this when you only need the affected-row count.
+   *
+   * ```typescript
+   * const count = await db.orm.Post
+   *   .where({ published: false })
+   *   .updateAndCount({ published: true });
+   * ```
+   */
+  updateAndCount(data: State['hasWhere'] extends true ? Partial<DefaultModelRow<TContract, ModelName, State['nsId']>> : never, configure?: (meta: MetaBuilder<'write'>) => void): Promise<number>;
+  /**
+   * Write terminal: delete matching rows and return the first deleted
+   * row (or `null` when no row matched). Requires a prior `.where(...)`
+   * — calling `delete()` on an unfiltered collection is a type error.
+   *
+   * ```typescript
+   * const deleted = await db.orm.User.where({ id: 1 }).delete();
+   * if (deleted) console.log('deleted', deleted.email);
+   * ```
+   *
+   * Accepts an optional `configure` callback that receives a
+   * `MetaBuilder<'write'>` for attaching typed annotations.
+   */
+  delete(this: State['hasWhere'] extends true ? Collection<TContract, ModelName, Row, State> : never, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row | null>;
+  /**
+   * Write terminal: delete every matching row and stream the deleted
+   * rows. Requires a prior `.where(...)` filter.
+   *
+   * The returned `AsyncIterableResult<Row>` is BOTH a thenable that
+   * resolves to `Row[]` AND an async iterable that streams deleted
+   * rows as they arrive. Use whichever fits; a result can only be
+   * consumed once. Streaming is the default; some driver/plan
+   * combinations may still buffer internally before yielding.
+   *
+   * ```typescript
+   * // Thenable — collect the deleted rows into an array:
+   * const deleted = await db.orm.Post.where({ archived: true }).deleteAll();
+   *
+   * // Async iterable — stream deleted rows as they arrive:
+   * for await (const row of db.orm.Post.where({ archived: true }).deleteAll()) {
+   *   console.log('removed', row.id);
+   * }
+   * ```
+   *
+   * Accepts an optional `configure` callback that receives a
+   * `MetaBuilder<'write'>` for attaching typed annotations.
+   */
+  deleteAll(this: State['hasWhere'] extends true ? Collection<TContract, ModelName, Row, State> : never, configure?: (meta: MetaBuilder<'write'>) => void): AsyncIterableResult<Row>;
+  /**
+   * Write terminal: delete every matching row without returning them,
+   * resolving to the count of rows that were deleted. Requires a prior
+   * `.where(...)` filter.
+   *
+   * Prefer `deleteAll(...)` when you need the deleted rows; prefer
+   * this when you only need the affected-row count.
+   *
+   * ```typescript
+   * const removed = await db.orm.Post.where({ archived: true }).deleteAndCount();
+   * ```
+   */
+  deleteAndCount(this: State['hasWhere'] extends true ? Collection<TContract, ModelName, Row, State> : never, configure?: (meta: MetaBuilder<'write'>) => void): Promise<number>;
+}
+//#endregion
+//#region src/filters.d.ts
+declare function and(...exprs: AnyExpression[]): AndExpr;
+declare function or(...exprs: AnyExpression[]): OrExpr;
+declare function not(expr: AnyExpression): AnyExpression;
+declare function all(): AnyExpression;
+//#endregion
+//#region src/model-accessor.d.ts
+declare function createModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName extends string | undefined = undefined>(context: ExecutionContext<TContract>, namespaceId: string, modelName: ModelName, variantName?: VariantName): VariantAwareModelAccessor<TContract, ModelName, VariantName>;
+//#endregion
+//#region src/orm.d.ts
+interface OrmOptions<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>> {
+  readonly runtime: RuntimeQueryable;
+  readonly collections?: Collections;
+  readonly context: ExecutionContext<TContract>;
+}
+type ModelNames<TContract extends Contract<SqlStorage>> = CollectionModelName<TContract>;
+type AnyCollectionClass = new (...args: never[]) => object;
+type CustomCollectionForKey<Collections extends Partial<Record<string, AnyCollectionClass>>, Key extends string> = Key extends keyof Collections ? Collections[Key] extends AnyCollectionClass ? InstanceType<Collections[Key]> : never : never;
+type ModelCollection<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>, NsId extends string, ModelName extends ModelNames<TContract>> = [CustomCollectionForKey<Collections, ModelName>] extends [never] ? Collection<TContract, ModelName, InferRootRow<TContract, ModelName, NsId>, WithNsId<DefaultCollectionTypeState, NsId>> : CustomCollectionForKey<Collections, ModelName>;
+type NamespaceModelNames<TContract extends Contract<SqlStorage>, NsId extends keyof TContract['domain']['namespaces']> = keyof TContract['domain']['namespaces'][NsId]['models'] & string & ModelNames<TContract>;
+type OrmNamespace<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>, NsId extends keyof TContract['domain']['namespaces']> = { [K in NamespaceModelNames<TContract, NsId>]: ModelCollection<TContract, Collections, NsId & string, K>; };
+type NamespacedClientMap<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>> = { [Ns in keyof TContract['domain']['namespaces']]: OrmNamespace<TContract, Collections, Ns>; };
+type OrmClient<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>> = NamespacedClientMap<TContract, Collections>;
+declare function orm<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>> = Record<never, never>>(options: OrmOptions<TContract, Collections>): OrmClient<TContract, Collections>;
+//#endregion
+export { type AggregateBuilder, type AggregateResult, type AggregateSpec, Collection, type CollectionContext, type CollectionModelName, type CollectionState, type CollectionTypeState, type ComparisonMethods, type CreateInput, type DefaultCollectionTypeState, type DefaultModelRow, GroupedCollection, type IncludeExpr, type ModelAccessor, type NumericFieldNames, type OrmOptions, type RelatedModelName, type RelationFilterAccessor, type RelationMutator, type RelationNames, type RelationPredicate, type RelationPredicateInput, type RelationsOf, type RuntimeQueryable, type ShorthandWhereFilter, type UniqueConstraintCriterion, all, and, createModelAccessor, emptyState, not, or, orm };
+//# sourceMappingURL=orm-client.d.mts.map