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

package/dist/contract-builder-C_Zi57iD.d.mts

@@ -0,0 +1,1967 @@
+import { n as ForeignKeyIndex, o as ReferentialAction } from "./foreign-key-qkDFfG8t-TaK_GYWR.mjs";
+import { a as SqlNamespaceBase, c as SqlNamespaceInput, l as SqlStorage, t as AuthoredStorageTypeInstance } from "./sql-storage-DeCAh5Hi-CEM-m8cs.mjs";
+import { O as QueryOperationTypesFunction, c as ContractWithTypeMaps, i as AggregateTypesFromDescriptors, o as ApplyQueryOperationTypes } from "./types-DfKvtJwS-CrpWTGBJ.mjs";
+import { t as ColumnTypesFromStorage } from "./types-CkAd8SWm.mjs";
+import { r as PackEntityHandle } from "./entity-handle-lowering-hook-BuvLtgFi.mjs";
+import "./derived-checks-DpPkO6Dt-9U9UJZOo.mjs";
+import { r as SqlExpression } from "./sql-expression-B4BrhGPi.mjs";
+import { i as IndexTypeRegistration } from "./index-types-H1O43iYT-BD0VwPqV.mjs";
+import "./index-types-snhtt_Fo.mjs";
+import { n as AuthoredIndexMethod } from "./index-naming-Cs6wwia3.mjs";
+import { AuthoringArgumentDescriptor, AuthoringFieldPresetDescriptor, AuthoringTypeAliasDescriptor, AuthoringTypeConstructorDescriptor, AuthoringWarning } from "@prisma/orm-framework/components/authoring";
+import { StorageType } from "@prisma/orm-framework/components/ir";
+import { CodecLookupWithDescriptors, ColumnTypeDescriptor, DataTypeLookup, ScalarFieldDeclarationBuilder } from "@prisma/orm-framework/components/codec";
+import { ColumnDefault, Contract, ContractExecutionSection, ContractRelation, ControlPolicy, EnumMemberValueType, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue, FieldTypesFromDomain, JsonValue, NamespaceId, StorageHashBase } from "@prisma/orm-framework/contract/types";
+import { ExtensionPackRef, ExtensionPackValues, FamilyPackRef, GeneratorFunctionCall, GeneratorHelpersOf, GeneratorPhase, TargetPackRef } from "@prisma/orm-framework/components/components";
+import { BoundEnumType, CanonicalArguments, CodecInput, CodecInput as CodecInput$1, CodecTypeMap, CodecTypeMap as CodecTypeMap$1, DataTypeArgumentTypes, EntityHelpersFromNamespace, EnumMember, EnumTypeHandle, ExtractAuthoringNamespaceFromPack, ExtractDataTypeArgumentTypesFromPack, ExtractParameterizedOutputTypesFromPack, ForeignKeyDefaultsState, MergeExtensionAuthoringNamespaces, ResolveTemplateValue, TupleFromArgumentDescriptors, UnionToIntersection, bindEnumType, enumType, member } from "@prisma/orm-framework/contract-authoring";
+//#region ../../../2-sql-family/2-authoring/contract-ts/dist/contract-builder.d.mts
+//#region src/contract-definition.d.ts
+/**
+ * Namespace-scoped pack-entity attachments, the internal build IR carrying
+ * the lowered `entities` handle list: namespace id → entity kind (the
+ * discriminator the target/extension pack registered its
+ * `AuthoringContributions.entityTypes` descriptor under, e.g. `native_enum`)
+ * → entity name → the lowered entity instance. Generic on purpose — neither
+ * the framework nor `contract-ts` names a specific entity kind here; the
+ * shape mirrors `SqlNamespaceInput.entries` (`entries.<kind>[name]`), just
+ * namespace-nested so an attachment can target any declared namespace
+ * (default or named), not only the contract's default namespace. Produced by
+ * the generic entity-handle walk in `buildContractDefinition`; never an
+ * author-facing input.
+ */
+type AttachedEntities = Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
+/**
+ * A literal default as an authoring surface builds it: a value of the column codec's input type, which the contract build encodes through that codec into a {@link ColumnDefault}. Only the codec knows the type, so it is `unknown` until encoded.
+ */
+type AuthoredColumnDefaultLiteralValue = unknown;
+type AuthoredColumnDefault = ColumnDefault | {
+  readonly kind: 'literal';
+  readonly value: AuthoredColumnDefaultLiteralValue;
+  /**
+   * Whether the value is already in the form the contract stores. A text contract source
+   * reads a written default into the stored form itself, through the column's data type and
+   * its casts, so the build stores it as it stands; a TypeScript `.default(value)` hands over an
+   * application value, which the column's codec encodes. ADR 254.
+   */
+  readonly inStoredForm?: boolean;
+};
+/** The type of a scalar: a codec and its type parameters, the domain's `ScalarFieldType` without its kind. */
+type ScalarTypeDescriptor = Pick<ColumnTypeDescriptor, 'codecId' | 'typeParams'>;
+/**
+ * The column-free part of a scalar field. A value-object member is exactly this; a model field ({@link FieldNode}) adds its column.
+ */
+interface ScalarMemberNode {
+  readonly fieldName: string;
+  readonly descriptor: ScalarTypeDescriptor;
+  readonly nullable: boolean;
+  readonly many?: boolean;
+  readonly elementNullable?: boolean;
+  /** Present when the field is typed by an enum. */
+  readonly enumTypeHandle?: EnumTypeHandle;
+}
+/**
+ * A column as storage describes it, with no field. A model field ({@link FieldNode}) is a column node that is also a scalar member; a table node ({@link TableNode}) holds column nodes for columns no field maps.
+ */
+interface ColumnNode {
+  readonly columnName: string;
+  readonly descriptor: ColumnTypeDescriptor;
+  readonly nullable: boolean;
+  readonly many?: boolean;
+  readonly elementNullable?: boolean;
+  readonly default?: AuthoredColumnDefault;
+  /** Present when the column is typed by an `enumType()` enum, which gives it the enum's storage value set and a membership check. */
+  readonly enumTypeHandle?: EnumTypeHandle;
+}
+/** A scalar model field: a scalar member with its column, and the defaults the runtime fills. */
+interface FieldNode extends ScalarMemberNode, ColumnNode {
+  readonly descriptor: ColumnTypeDescriptor;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+}
+interface PrimaryKeyNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+interface UniqueConstraintNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+/** A definition-tree index's element structure — column tuple xor expression. */
+type IndexNodeElements = {
+  /** Column tuple. */
+  readonly columns: readonly string[];
+  readonly expression?: never;
+} | {
+  readonly columns?: never;
+  /** Opaque SQL: the entire element list of CREATE INDEX — never parsed. */
+  readonly expression: string;
+};
+type IndexNode = IndexNodeElements & AuthoredIndexMethod & {
+  /** Opaque SQL: partial-index predicate (WHERE body, without the keyword). */
+  readonly where: string | undefined;
+  readonly unique: boolean | undefined;
+  /** Exact physical name (`map:`) — adopted verbatim, no wire hash. */
+  readonly map: string | undefined;
+  /** Wire-name prefix (`name:`) — lowers to `<name>_<8hex>`. */
+  readonly name: string | undefined;
+};
+/**
+ * A definition-tree check constraint: `map` adopts an exact physical name
+ * verbatim, `name` is a wire-name prefix — exactly one is required (a check
+ * has no column tuple to derive a default from, unlike an index).
+ */
+type CheckNode = {
+  readonly expression: string;
+  readonly map: string | undefined;
+  readonly name: string | undefined;
+};
+/** A foreign key's target named by the model that maps the target table. */
+interface ForeignKeyModelReference {
+  readonly model: string;
+  readonly table: string;
+  readonly columns: readonly string[];
+  /**
+   * Namespace coordinate of the referenced table. When omitted the
+   * assembler resolves the coordinate from the referenced model node's
+   * own `namespaceId`; the field exists so authoring paths that already
+   * know the target namespace can stamp it explicitly.
+   */
+  readonly namespaceId?: string;
+  /**
+   * Contract-space identity of the referenced table. When present, the
+   * table lives in a different contract space (identified by this value)
+   * rather than the current contract. Absent for local FKs.
+   */
+  readonly spaceId?: string;
+}
+/** A foreign key's target named by its table, which a model or a table node of this contract declares. Without `namespaceId`, or with an empty one, the table is in the default namespace. */
+interface ForeignKeyTableReference {
+  readonly model?: never;
+  readonly table: string;
+  readonly columns: readonly string[];
+  readonly namespaceId?: string;
+  readonly spaceId?: never;
+}
+interface ForeignKeyNode {
+  readonly columns: readonly string[];
+  readonly references: ForeignKeyModelReference | ForeignKeyTableReference;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  readonly constraint?: boolean;
+  /** `true` for a derived backing index, `false` for none, or the name of an index, unique constraint or primary key of the same table that backs the foreign key. */
+  readonly index?: boolean | string;
+}
+interface RelationNode {
+  readonly fieldName: string;
+  readonly toModel: string;
+  /**
+   * Physical table of the related model. Undefined only for a cross-space
+   * relation whose handle carries no static table name.
+   */
+  readonly toTable: string | undefined;
+  /**
+   * Namespace coordinate of the related model. When omitted the assembler
+   * resolves the coordinate from the referenced model node's own
+   * `namespaceId`; the field exists so authoring paths that already know the
+   * target namespace can stamp it explicitly — required to disambiguate a
+   * relation to a model whose bare name also exists in another namespace.
+   */
+  readonly toNamespaceId?: string;
+  readonly cardinality: '1:1' | '1:N' | 'N:1' | 'N:M';
+  /**
+   * Whether the related row may be absent, as stated by the schema. Present on
+   * every `'1:1'` and `'N:1'` relation; absent on `'1:N'` and `'N:M'`.
+   */
+  readonly nullable?: boolean;
+  /**
+   * Contract-space identity of the related model. When present, the
+   * related model lives in a different contract space. Absent for local
+   * (same-space) relations.
+   */
+  readonly spaceId?: string;
+  /**
+   * Namespace coordinate of the related model in the foreign space.
+   * Only set when `spaceId` is present.
+   */
+  readonly namespaceId?: string;
+  readonly on: {
+    readonly parentTable: string;
+    readonly parentColumns: readonly string[];
+    readonly childTable: string | undefined;
+    readonly childColumns: readonly string[];
+  };
+  readonly through?: {
+    readonly table: string;
+    /**
+     * Namespace the junction table lives in. Set from the junction model's
+     * declared namespace at lowering time; junction table names are unique per
+     * namespace, not globally, so this disambiguates a junction whose bare table
+     * name also exists in another namespace. Omitted for a junction in the
+     * default namespace (resolved to the target's default at build time).
+     */
+    readonly namespaceId?: string;
+    readonly parentColumns: readonly string[];
+    readonly childColumns: readonly string[];
+  };
+}
+/**
+ * The column-free part of a field typed by a value object. A value-object member is exactly this; a model field ({@link ValueObjectFieldNode}) adds its column.
+ */
+interface ValueObjectMemberNode {
+  readonly fieldName: string;
+  readonly valueObjectName: string;
+  readonly nullable: boolean;
+  readonly many?: boolean;
+  readonly elementNullable?: boolean;
+}
+/**
+ * A model field typed by a value object. It is stored in one column of the storage type the target declares for value objects, carried in `descriptor`; a list of value objects is stored in that one column too.
+ */
+interface ValueObjectFieldNode extends ValueObjectMemberNode, Pick<ColumnNode, 'columnName' | 'descriptor' | 'default'> {
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+}
+interface ValueObjectNode {
+  readonly name: string;
+  readonly fields: readonly (ScalarMemberNode | ValueObjectMemberNode)[];
+}
+/**
+ * Whether a field is stored in a list column. A list of scalars is; a list of value objects is not, because it is stored in one column whose value is the whole list, as one JSON array.
+ */
+declare function storedAsListColumn(field: {
+  readonly list: boolean;
+  readonly typedByValueObject: boolean;
+}): boolean;
+/** Whether a field or member is typed by a value object. */
+declare function isValueObjectMember(field: ScalarMemberNode | ValueObjectMemberNode): field is ValueObjectMemberNode;
+/** What a table declares besides its columns. A model states these for its table, and so does a table node for a table no model maps. */
+interface TableProperties {
+  readonly id?: PrimaryKeyNode;
+  readonly uniques?: readonly UniqueConstraintNode[];
+  readonly indexes?: readonly IndexNode[];
+  readonly checks?: readonly CheckNode[];
+  readonly foreignKeys?: readonly ForeignKeyNode[];
+  readonly control?: ControlPolicy;
+}
+interface ModelNode extends TableProperties {
+  readonly modelName: string;
+  readonly tableName: string;
+  /**
+   * Resolved namespace coordinate for this model — the key into the
+   * parent contract's `SqlStorage.namespaces` map. Omitting the field
+   * (or setting it to the framework's `UNBOUND_NAMESPACE_ID` sentinel)
+   * selects the late-bound slot, which renders as unqualified DDL.
+   *
+   * Populated by per-target PSL interpreters from the resolved
+   * `namespace { … }` AST bucket; the TS builder also sets it from the
+   * per-model `namespace` field once that authoring surface lands.
+   */
+  readonly namespaceId?: string;
+  readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
+  readonly relations?: readonly RelationNode[];
+  /**
+   * Single-table-inheritance variants share their base model's storage table:
+   * the variant's columns are materialised onto the base `ModelNode`, and this
+   * model contributes a domain model but no storage table of its own. When set,
+   * the assembler builds the domain model but skips creating a (shadow) storage
+   * table and a root for this model — the base owns both.
+   */
+  readonly sharesBaseTable?: boolean;
+}
+/**
+ * A table's storage declared without a model. Naming a table a model maps adds columns to it and nothing else; naming any other table declares the whole table.
+ */
+interface TableNode extends TableProperties {
+  /** Namespace coordinate of the table. Omitted or empty means the target's default namespace. */
+  readonly namespaceId?: string;
+  readonly tableName: string;
+  readonly columns: readonly ColumnNode[];
+}
+/** A component whose capabilities a contract carries, such as an adapter. */
+type CapabilityContributor = {
+  readonly capabilities: Readonly<Record<string, Readonly<Record<string, boolean>>>>;
+};
+interface ContractDefinition {
+  readonly target: TargetPackRef<'sql', string>;
+  readonly defaultControlPolicy?: ControlPolicy;
+  readonly extensions?: Record<string, ExtensionPackRef<'sql', string>>;
+  /** Capabilities of the stack the contract runs with beyond its target's and extensions', such as its adapter's. They join the target's and the extensions', as `prisma contract emit` joins them. */
+  readonly capabilities?: CapabilityContributor['capabilities'];
+  /**
+   * Test-fixture escape hatch: pins the emitted `storage.storageHash`
+   * instead of computing it from content. A pinned hash is not
+   * content-derived, so snapshot content verification
+   * (`MIGRATION.CONTRACT_SNAPSHOT_CONTENT_MISMATCH`) rejects any migration
+   * snapshot addressed by it — never set this in a real project.
+   */
+  readonly storageHash?: string;
+  readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
+  readonly databaseTypes?: Record<string, AuthoredStorageTypeInstance>;
+  /**
+   * Declared namespace coordinates for this contract — populates
+   * `SqlStorage.namespaces` together with `createNamespace`.
+   */
+  readonly namespaces?: readonly string[];
+  /**
+   * Authoring warnings collected by the definition producer before the
+   * build runs (the PSL interpreter's entity factories run ahead of
+   * `buildSqlContractFromDefinition`); seeds the build's single per-build
+   * flush. Required key: a producer with nothing collected states
+   * `undefined` explicitly.
+   */
+  readonly warnings: readonly AuthoringWarning[] | undefined;
+  /** Target-supplied factory that materialises a `SqlNamespaceBase` concretion for a declared namespace coordinate. */
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
+  readonly models: readonly ModelNode[];
+  /** Storage no model maps: columns added to a model's table, and tables with no model. */
+  readonly tables?: readonly TableNode[];
+  readonly valueObjects?: readonly ValueObjectNode[];
+  /**
+   * Domain enum handles authored via `enumType()`. Each entry lowers to a
+   * domain `enum` entry and a storage `valueSet` entry in the contract's
+   * default namespace.
+   */
+  readonly enums?: Record<string, EnumTypeHandle>;
+  /**
+   * Pack-entity attachments lowered from the `entities` handle list, keyed by
+   * namespace then entity kind then name. Each entity lands in
+   * `storage.namespaces[ns].entries.<kind>`; when the registered entity-type
+   * descriptor's factory output implements the
+   * `SqlValueSetDerivingEntityTypeOutput.deriveValueSet` hook, the derived
+   * value-set also folds into `entries.valueSet`, mirroring how `enums` flows
+   * there. Internal build IR — populated by `buildContractDefinition`, not an
+   * author input.
+   */
+  readonly attachedEntities?: AttachedEntities;
+}
+//#endregion
+//#region src/contract-dsl.d.ts
+type NamingStrategy = 'identity' | 'snake_case';
+type NamingConfig = {
+  readonly tables?: NamingStrategy;
+  readonly columns?: NamingStrategy;
+};
+type NamedConstraintNameSpec<Name extends string = string> = {
+  readonly name: Name;
+};
+type ScalarFieldState<Descriptor extends ColumnTypeDescriptor = ColumnTypeDescriptor, EnumHandle extends EnumTypeHandle | undefined = undefined, Nullable extends boolean = boolean, ColumnName extends string | undefined = string | undefined, IdSpec extends NamedConstraintSpec | undefined = undefined, UniqueSpec extends NamedConstraintSpec | undefined = undefined, Many extends false | {
+  readonly elementNullable: boolean;
+} = false, Defaults extends FieldDefaultPresence = FieldDefaultPresence> = {
+  readonly kind: 'scalar';
+  /** Exists only in types: whether the column has a database default, and in which phases the client generates its value. */
+  readonly __defaultPresence?: Defaults;
+  readonly descriptor?: Descriptor | undefined;
+  readonly enumHandle?: EnumHandle | undefined;
+  readonly nullable: Nullable;
+  readonly columnName?: ColumnName | undefined;
+  readonly default?: AuthoredColumnDefault | undefined;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases | undefined;
+  readonly generatorCalls?: FieldGeneratorCalls | undefined;
+  readonly many: Many;
+} & (IdSpec extends NamedConstraintSpec ? {
+  readonly id: IdSpec;
+} : {
+  readonly id?: undefined;
+}) & (UniqueSpec extends NamedConstraintSpec ? {
+  readonly unique: UniqueSpec;
+} : {
+  readonly unique?: undefined;
+});
+/** Whether a field's column has a database default, and whether the client generates its value on create and on update. */
+type FieldDefaultPresence = {
+  readonly column: boolean;
+  readonly onCreate: boolean;
+  readonly onUpdate: boolean;
+};
+/** The generator function calls a field's `.onCreate(...)` and `.onUpdate(...)` give, resolved by the field's codec when the contract is built. */
+type FieldGeneratorCalls = {
+  readonly onCreate?: GeneratorFunctionCall;
+  readonly onUpdate?: GeneratorFunctionCall;
+};
+type WithGeneratedPhase<State extends AnyScalarFieldState, Phase extends GeneratorPhase> = State extends ScalarFieldState<infer Descriptor, infer EnumHandle, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec, infer Many, infer Defaults> ? ScalarFieldState<Descriptor, EnumHandle, Nullable, ColumnName, IdSpec, UniqueSpec, Many, {
+  readonly column: Defaults['column'];
+  readonly onCreate: Phase extends 'onCreate' ? true : Defaults['onCreate'];
+  readonly onUpdate: Phase extends 'onUpdate' ? true : Defaults['onUpdate'];
+}> : State;
+type WithColumnDefault<State extends AnyScalarFieldState> = State extends ScalarFieldState<infer Descriptor, infer EnumHandle, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec, infer Many, infer Defaults> ? ScalarFieldState<Descriptor, EnumHandle, Nullable, ColumnName, IdSpec, UniqueSpec, Many, {
+  readonly column: true;
+  readonly onCreate: Defaults['onCreate'];
+  readonly onUpdate: Defaults['onUpdate'];
+}> : State;
+type AnyScalarFieldState = {
+  readonly kind: 'scalar';
+  readonly descriptor?: ColumnTypeDescriptor | undefined;
+  readonly enumHandle?: EnumTypeHandle | undefined;
+  readonly nullable: boolean;
+  readonly columnName?: string | undefined;
+  readonly default?: AuthoredColumnDefault | undefined;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases | undefined;
+  readonly generatorCalls?: FieldGeneratorCalls | undefined;
+  readonly many: false | {
+    readonly elementNullable: boolean;
+  };
+  readonly id?: NamedConstraintSpec | undefined;
+  readonly unique?: NamedConstraintSpec | undefined;
+};
+type HasNamedConstraintId<State extends AnyScalarFieldState> = State extends ScalarFieldState<ColumnTypeDescriptor, EnumTypeHandle | undefined, boolean, string | undefined, infer IdSpec, NamedConstraintSpec | undefined, false | {
+  readonly elementNullable: boolean;
+}> ? IdSpec extends NamedConstraintSpec ? true : false : false;
+type HasNamedConstraintUnique<State extends AnyScalarFieldState> = State extends ScalarFieldState<ColumnTypeDescriptor, EnumTypeHandle | undefined, boolean, string | undefined, NamedConstraintSpec | undefined, infer UniqueSpec, false | {
+  readonly elementNullable: boolean;
+}> ? UniqueSpec extends NamedConstraintSpec ? true : false : false;
+type FieldSqlSpecForState<State extends AnyScalarFieldState> = {
+  readonly column?: string;
+} & (HasNamedConstraintId<State> extends true ? {
+  readonly id?: NamedConstraintNameSpec;
+} : Record<never, never>) & (HasNamedConstraintUnique<State> extends true ? {
+  readonly unique?: NamedConstraintNameSpec;
+} : Record<never, never>);
+type ApplyFieldSqlSpec<State extends AnyScalarFieldState, Spec extends FieldSqlSpecForState<State>> = State extends ScalarFieldState<infer Descriptor, infer EnumHandle, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec, infer Many, infer Defaults> ? ScalarFieldState<Descriptor, EnumHandle, Nullable, Spec extends {
+  readonly column: infer NextColumn extends string;
+} ? NextColumn : ColumnName, Spec extends {
+  readonly id: {
+    readonly name: infer IdName extends string;
+  };
+} ? IdSpec extends NamedConstraintSpec ? NamedConstraintSpec<IdName> : IdSpec : IdSpec, Spec extends {
+  readonly unique: {
+    readonly name: infer UniqueName extends string;
+  };
+} ? UniqueSpec extends NamedConstraintSpec ? NamedConstraintSpec<UniqueName> : UniqueSpec : UniqueSpec, Many, Defaults> : AnyScalarFieldState;
+type GeneratedFieldSpec = {
+  readonly type: ColumnTypeDescriptor;
+  readonly typeParams?: Record<string, unknown>;
+  readonly generated: ExecutionMutationDefaultValue;
+};
+type CarriesCodecInput<Input> = {
+  /** Exists only in types: carries the input type of the column's codec, which `.default()` takes. */
+  __codecInput?(input: Input): void;
+};
+type WithCodecInput<Descriptor, Input> = Descriptor & CarriesCodecInput<Input>;
+type DefaultInputOf<State> = State extends {
+  readonly descriptor?: infer Descriptor;
+} ? NonNullable<Descriptor> extends CarriesCodecInput<infer Input> ? Input : unknown : unknown;
+type IsList<State> = State extends {
+  readonly many: {
+    readonly elementNullable: boolean;
+  };
+} ? true : false;
+type NullElementOf<State> = State extends {
+  readonly many: {
+    readonly elementNullable: true;
+  };
+} ? null : never;
+type DefaultLiteralOf<State> = unknown extends DefaultInputOf<State> ? unknown : IsList<State> extends true ? readonly (DefaultInputOf<State> | NullElementOf<State>)[] : DefaultInputOf<State>;
+type EnumHandleOf<State> = State extends {
+  readonly enumHandle?: infer EnumHandle;
+} ? string extends EnumHandle ? never : Extract<EnumHandle, EnumTypeHandle> : never;
+type DefaultArgumentOf<State> = ([EnumHandleOf<State>] extends [never] ? DefaultLiteralOf<State> | ColumnDefault | SqlExpression : IsList<State> extends true ? readonly (EnumHandleOf<State>['values'][number] | NullElementOf<State>)[] : EnumHandleOf<State>['values'][number]) | (State extends {
+  readonly nullable: true;
+} ? null : never);
+type ApplyMany<State extends AnyScalarFieldState, ElementsNullable extends boolean> = State extends ScalarFieldState<infer Descriptor, infer EnumHandle, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec, false | {
+  readonly elementNullable: boolean;
+}, infer Defaults> ? ScalarFieldState<Descriptor, EnumHandle, Nullable, ColumnName, IdSpec, UniqueSpec, {
+  readonly elementNullable: ElementsNullable;
+}, Defaults> : AnyScalarFieldState;
+type ManyOptions = {
+  readonly elementsNullable: true;
+} | {
+  readonly elementsNullable: false;
+};
+declare class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFieldState> implements ScalarFieldDeclarationBuilder {
+  private readonly state;
+  readonly __state: State;
+  constructor(state: State);
+  /**
+   * Returns the physical column name when `.column(name)` was called, or
+   * `undefined` when the field uses the default (logical field name) mapping.
+   * Used by cross-space FK lowering to stamp the physical column name onto
+   * `TargetFieldRef.columnName` so FK target columns are resolved correctly.
+   */
+  get physicalColumnName(): string | undefined;
+  optional(): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer EnumHandle, boolean, infer ColumnName, infer IdSpec, infer UniqueSpec, infer Many, infer Defaults> ? ScalarFieldState<Descriptor, EnumHandle, true, ColumnName, IdSpec, UniqueSpec, Many, Defaults> : AnyScalarFieldState>;
+  column<ColumnName extends string>(name: ColumnName): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer EnumHandle, infer Nullable, string | undefined, infer IdSpec, infer UniqueSpec, infer Many, infer Defaults> ? ScalarFieldState<Descriptor, EnumHandle, Nullable, ColumnName, IdSpec, UniqueSpec, Many, Defaults> : AnyScalarFieldState>;
+  many(): ScalarFieldBuilder<ApplyMany<State, false>>;
+  many(options: {
+    readonly elementsNullable: true;
+  }): ScalarFieldBuilder<ApplyMany<State, true>>;
+  many(options: {
+    readonly elementsNullable: false;
+  }): ScalarFieldBuilder<ApplyMany<State, false>>;
+  default<Self extends {
+    readonly __state: AnyScalarFieldState;
+  }>(this: Self, value: DefaultArgumentOf<Self['__state']>): ScalarFieldBuilder<WithColumnDefault<State>>;
+  /** Generates the field's value in the client when a row is created without one, with a call from `gen`, such as `gen.uuid()`. */
+  onCreate(call: GeneratorFunctionCall): ScalarFieldBuilder<WithGeneratedPhase<State, 'onCreate'>>;
+  /** Generates the field's value in the client every time a row is updated, with a call from `gen`, such as `gen.now()`. */
+  onUpdate(call: GeneratorFunctionCall): ScalarFieldBuilder<WithGeneratedPhase<State, 'onUpdate'>>;
+  /**
+   * @deprecated Write `.default(now())` or `.default(autoincrement())`, or `` .default(sql`...`) `` for any other SQL. Removed in 8.0.0.
+   */
+  defaultSql(expression: string): ScalarFieldBuilder<WithColumnDefault<State>>;
+  id<const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer EnumHandle, infer Nullable, infer ColumnName, NamedConstraintSpec | undefined, infer UniqueSpec, infer Many, infer Defaults> ? ScalarFieldState<Descriptor, EnumHandle, Nullable, ColumnName, NamedConstraintSpec<Name>, UniqueSpec, Many, Defaults> : AnyScalarFieldState>;
+  unique<const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer EnumHandle, infer Nullable, infer ColumnName, infer IdSpec, NamedConstraintSpec | undefined, infer Many, infer Defaults> ? ScalarFieldState<Descriptor, EnumHandle, Nullable, ColumnName, IdSpec, NamedConstraintSpec<Name>, Many, Defaults> : AnyScalarFieldState>;
+  sql<const Spec extends FieldSqlSpecForState<State>>(spec: Spec): ScalarFieldBuilder<ApplyFieldSqlSpec<State, Spec>>;
+  build(): State;
+}
+declare class EnumScalarFieldBuilder<Handle extends EnumTypeHandle, State extends AnyScalarFieldState = ScalarFieldState<ColumnTypeDescriptor, Handle, false, undefined>> extends ScalarFieldBuilder<State> {
+  #private;
+  constructor(state: State, handle: Handle);
+  default<Self extends {
+    readonly __state: AnyScalarFieldState;
+  }>(this: Self, value: DefaultArgumentOf<Self['__state']>): EnumScalarFieldBuilder<Handle, WithColumnDefault<State>>;
+  defaultSql(_expression: never): never;
+}
+type CodecTypesOfNoPacks = Record<never, never>;
+/** The defaults a field built from `Descriptor` starts with: the generators of a contributed type alias, or none. */
+type ColumnDefaultPresence<Descriptor> = {
+  readonly column: boolean;
+  readonly onCreate: AliasGeneratesIn<Descriptor, 'onCreate'>;
+  readonly onUpdate: AliasGeneratesIn<Descriptor, 'onUpdate'>;
+};
+type AliasGeneratesIn<Descriptor, Phase extends GeneratorPhase> = Descriptor extends {
+  readonly generatorCalls: { readonly [K in Phase]: GeneratorFunctionCall; };
+} ? true : boolean;
+type ColumnFieldHelper<CodecTypes extends CodecTypeMap = CodecTypesOfNoPacks> = <const Descriptor extends ColumnTypeDescriptor>(descriptor: Descriptor) => ScalarFieldBuilder<ScalarFieldState<WithCodecInput<Descriptor, CodecInput<CodecTypes, Descriptor>>, undefined, false, undefined, undefined, undefined, false, ColumnDefaultPresence<Descriptor>>>;
+type NamedTypeFieldHelper = <Handle extends EnumTypeHandle>(handle: Handle) => EnumScalarFieldBuilder<Handle>;
+type WithGeneratedTypeParams<Descriptor, TypeParams> = TypeParams extends Record<string, unknown> ? Descriptor & {
+  readonly typeParams: TypeParams;
+} : Descriptor;
+declare function generatedField<Descriptor extends ColumnTypeDescriptor, TypeParams extends Record<string, unknown> | undefined = undefined>(spec: GeneratedFieldSpec & {
+  readonly type: Descriptor;
+  readonly typeParams?: TypeParams;
+}): ScalarFieldBuilder<ScalarFieldState<WithGeneratedTypeParams<Descriptor, TypeParams>, undefined, false, undefined, undefined, undefined, false, {
+  readonly column: false;
+  readonly onCreate: true;
+  readonly onUpdate: false;
+}>>;
+type RelationModelRefSource = 'string' | 'token' | 'lazyToken';
+type TargetFieldRefSource = 'string' | 'token';
+type EagerRelationModelName<ModelName extends string = string, Source extends Exclude<RelationModelRefSource, 'lazyToken'> = Exclude<RelationModelRefSource, 'lazyToken'>> = {
+  readonly kind: 'relationModelName';
+  readonly source: Source;
+  readonly modelName: ModelName;
+};
+type LazyRelationModelName<ModelName extends string = string> = {
+  readonly kind: 'lazyRelationModelName';
+  readonly source: 'lazyToken';
+  readonly resolve: () => ModelName;
+};
+type RelationModelSource<ModelName extends string = string> = EagerRelationModelName<ModelName> | LazyRelationModelName<ModelName>;
+type BelongsToRelation<ToModel extends string = string, FromField extends string | readonly string[] = string | readonly string[], ToField extends string | readonly string[] = string | readonly string[], SqlSpec extends BelongsToRelationSqlSpec | undefined = undefined, TargetSpaceId extends string = string> = {
+  readonly kind: 'belongsTo';
+  /** The contract space of the target model, `'<self>'` for this contract's own models. Type-only. */
+  readonly __targetSpaceId?: TargetSpaceId;
+  readonly toModel: RelationModelSource<ToModel>;
+  readonly from: FromField;
+  readonly to: ToField;
+  readonly sql?: SqlSpec;
+  /**
+   * Whether the related row may be absent. Defaults to whether any `from`
+   * field is nullable; an explicit value that contradicts them is rejected.
+   */
+  readonly optional?: boolean;
+  /**
+   * Contract-space identity of the target model. Populated when
+   * `belongsTo` receives a cross-space branded handle. Absent for
+   * local (same-space) relations.
+   */
+  readonly spaceId?: string;
+  /**
+   * Physical table name of the cross-space target model. Only set
+   * when `spaceId` is present; read from the handle's `tableName`.
+   */
+  readonly tableName?: string;
+  /**
+   * Namespace coordinate of the cross-space target model.
+   * Only set when `spaceId` is present.
+   */
+  readonly namespaceId?: string;
+};
+type HasManyRelation<ToModel extends string = string, ByField extends string | readonly string[] = string | readonly string[]> = {
+  readonly kind: 'hasMany';
+  readonly toModel: RelationModelSource<ToModel>;
+  readonly by: ByField;
+};
+type HasOneRelation<ToModel extends string = string, ByField extends string | readonly string[] = string | readonly string[]> = {
+  readonly kind: 'hasOne';
+  readonly toModel: RelationModelSource<ToModel>;
+  readonly by: ByField;
+};
+type ManyToManyRelation<ToModel extends string = string, ThroughModel extends string = string, FromField extends string | readonly string[] = string | readonly string[], ToField extends string | readonly string[] = string | readonly string[]> = {
+  readonly kind: 'manyToMany';
+  readonly toModel: RelationModelSource<ToModel>;
+  readonly through: RelationModelSource<ThroughModel>;
+  readonly from: FromField;
+  readonly to: ToField;
+};
+type RelationState = BelongsToRelation<string, string | readonly string[], string | readonly string[], BelongsToRelationSqlSpec | undefined> | HasManyRelation | HasOneRelation | ManyToManyRelation;
+type AnyRelationState = RelationState;
+type AnyRelationBuilder = RelationBuilder<AnyRelationState>;
+type ApplyBelongsToRelationSqlSpec<State extends RelationState, SqlSpec extends BelongsToRelationSqlSpec> = State extends BelongsToRelation<infer ToModel, infer FromField, infer ToField, BelongsToRelationSqlSpec | undefined, infer TargetSpaceId> ? BelongsToRelation<ToModel, FromField, ToField, SqlSpec, TargetSpaceId> : never;
+declare class RelationBuilder<State extends RelationState = AnyRelationState> {
+  private readonly state;
+  readonly __state: State;
+  constructor(state: State);
+  sql<const SqlSpec extends BelongsToRelationSqlSpec>(this: State extends BelongsToRelation<string, string | readonly string[], string | readonly string[], BelongsToRelationSqlSpec | undefined> ? RelationBuilder<State> : never, spec: SqlSpec): RelationBuilder<ApplyBelongsToRelationSqlSpec<State, SqlSpec>>;
+  build(): State;
+}
+/**
+ * Reference to a column on the current (local) model.
+ *
+ * Source columns are always local to the contract being authored. The
+ * cross-space brand lives on `TargetFieldRef` (the target side of a foreign
+ * key), not here.
+ */
+type ColumnRef<FieldName extends string = string> = {
+  readonly kind: 'columnRef';
+  readonly fieldName: FieldName;
+};
+/**
+ * Reference to a field on a target model, produced by model `.refs` and
+ * `constraints.ref(modelName, fieldName)`.
+ *
+ * The `TSpaceId` phantom parameter carries the contract-space identity of the
+ * target model. Local model handles produce `TSpaceId = '<self>'`; extension
+ * handles carry the extension's `spaceId`. The brand is propagated from the
+ * parent `ContractModelBuilder` via the `spaceId?` property: absent means local
+ * (`'<self>'`), present means cross-space.
+ */
+type TargetFieldRef<ModelName extends string = string, FieldName extends string = string, TSpaceId extends string = string> = {
+  readonly kind: 'targetFieldRef';
+  readonly source: TargetFieldRefSource;
+  readonly modelName: ModelName;
+  readonly fieldName: FieldName;
+  /**
+   * Cross-space discriminator. When present, the referenced model lives in a
+   * different contract space identified by this value. Absent for local refs.
+   */
+  readonly spaceId?: TSpaceId extends '<self>' ? never : TSpaceId;
+  /**
+   * Namespace id of the cross-space target model (e.g. `'auth'` for
+   * `supabase` `auth.User`). Only present for cross-space refs.
+   */
+  readonly namespaceId?: string;
+  /**
+   * Physical table name of the cross-space target model. Only present for
+   * cross-space refs; allows the lowering path to bypass the local model
+   * registry.
+   */
+  readonly tableName?: string;
+  /**
+   * Physical column name of the target field. Populated for cross-space refs
+   * when the extension handle's field used `.column(name)` to rename the
+   * physical column. When absent the logical `fieldName` is used as the column
+   * name. Only relevant for cross-space FK lowering — local FKs resolve column
+   * names via the local `fieldToColumn` map.
+   */
+  readonly columnName?: string;
+};
+type ModelTokenRefs<ModelName extends string, Fields extends Record<string, ScalarFieldBuilder>, TSpaceId extends string = '<self>'> = { readonly [K in keyof Fields]: TargetFieldRef<ModelName, K & string, TSpaceId>; };
+type ConstraintOptions<Name extends string | undefined = string | undefined> = {
+  readonly name?: Name;
+};
+type IndexTypeMap = Record<string, {
+  readonly options: unknown;
+}>;
+type IndexOptionsBase<Name extends string | undefined> = {
+  readonly name?: Name;
+  /** Exact physical name — adopted verbatim, no wire hash. Xor `name`. */
+  readonly map?: string;
+  /** Opaque SQL: partial-index predicate (WHERE body, without the keyword). */
+  readonly where?: SqlExpression;
+  readonly unique?: boolean;
+};
+type IndexInput<Name extends string | undefined, IndexTypes extends IndexTypeMap> = keyof IndexTypes extends never ? IndexOptionsBase<Name> : (IndexOptionsBase<Name> & {
+  readonly type?: never;
+  readonly options?: never;
+}) | { readonly [K in keyof IndexTypes & string]: IndexOptionsBase<Name> & {
+  readonly type: K;
+  readonly options: IndexOptionsInput<IndexTypes[K]['options']>;
+}; }[keyof IndexTypes & string];
+type IndexSpecCapture<Map, Type, Where, Unique, IndexTypes extends IndexTypeMap> = {
+  readonly map?: Map;
+  readonly where?: Where;
+  readonly unique?: Unique;
+} & (keyof IndexTypes extends never ? Record<never, never> : {
+  readonly type?: Type;
+});
+type IndexSpecFrom<Map, Type, Where, Unique, IndexTypes extends IndexTypeMap> = {
+  readonly map: Map;
+  readonly type: Type;
+  readonly options: Type extends keyof IndexTypes ? IndexTypes[Type]['options'] extends (infer Options extends Record<string, unknown>) ? Options : Record<string, unknown> : undefined;
+  readonly partial: [Where] extends [undefined] ? false : true;
+  readonly unique: Unique;
+};
+/**
+ * The expression overload's input: the whole CREATE INDEX element list as
+ * one opaque `sql` value. `name` or `map` is required — enforced at lowering
+ * with the same diagnostics as PSL.
+ */
+type ExpressionIndexInput<Name extends string | undefined, IndexTypes extends IndexTypeMap> = IndexInput<Name, IndexTypes> & {
+  readonly expression: IndexExpressionInput;
+};
+type ForeignKeyOptions<Name extends string | undefined = string | undefined> = ConstraintOptions<Name> & {
+  readonly onDelete?: 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+  readonly onUpdate?: 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+  readonly constraint?: boolean;
+  /**
+   * `false` for no backing index, or the name of an index, unique constraint or primary key the table declares, used instead of a derived backing index. The name is the `name` or `map` it was given, or an index's stored name, and its first columns must be the foreign key's columns in order.
+   */
+  readonly index?: boolean | string;
+};
+type BelongsToRelationSqlSpec<Name extends string | undefined = string | undefined> = {
+  readonly fk?: ForeignKeyOptions<Name>;
+};
+type IdConstraint<FieldNames extends readonly string[] = readonly string[], Name extends string | undefined = string | undefined> = {
+  readonly kind: 'id';
+  readonly fields: FieldNames;
+  readonly name?: Name;
+};
+type UniqueConstraint<FieldNames extends readonly string[] = readonly string[], Name extends string | undefined = string | undefined> = {
+  readonly kind: 'unique';
+  readonly fields: FieldNames;
+  readonly name?: Name;
+};
+/** A field the lowering resolved, as the renderer sees it. */
+type DeferredIndexColumn = {
+  /** The storage column name, after `.column()` and the naming convention. */
+  readonly name: string;
+  /** The codec the column stores its values through. */
+  readonly codecId: string;
+};
+/**
+ * An index expression rendered at lowering, once the storage column names are
+ * known. `fields` resolve exactly as the field-tuple form's do — a `.column()`
+ * override first, then the contract's column naming convention — and `render`
+ * receives the resolved names in the same order. Authoring code cannot know
+ * either, so an expression over a column has to be written this way rather
+ * than as a `sql` value, or it silently stops matching the column it names.
+ */
+type DeferredIndexExpression = {
+  readonly fields: readonly ColumnRef[];
+  readonly render: (columns: readonly DeferredIndexColumn[]) => string;
+};
+/** Opaque SQL, either written out or rendered at lowering. */
+type IndexExpressionInput = SqlExpression | DeferredIndexExpression;
+/**
+ * Index options rendered at lowering from the storage columns the index covers, in order: its
+ * `fields`, or the `fields` of a deferred expression. For options that name columns, which authoring
+ * code cannot know.
+ */
+type DeferredIndexOptions<Options = Record<string, unknown>> = (columns: readonly DeferredIndexColumn[]) => Options;
+/** Options, either written out or rendered at lowering. */
+type IndexOptionsInput<Options = Record<string, unknown>> = Options | DeferredIndexOptions<Options>;
+/** An authored index constraint's element structure — field tuple xor expression. */
+type IndexConstraintElements<FieldNames extends readonly string[] = readonly string[]> = {
+  /** Field-name tuple. */
+  readonly fields: FieldNames;
+  readonly expression?: never;
+} | {
+  readonly fields?: never;
+  /** Opaque SQL: the entire CREATE INDEX element list — never parsed. */
+  readonly expression: IndexExpressionInput;
+};
+/** Options only exist as options of a type, so the pair is one union. */
+type IndexConstraintMethod = {
+  readonly type?: undefined;
+  readonly options?: undefined;
+} | {
+  readonly type: string;
+  readonly options?: IndexOptionsInput;
+};
+/**
+ * An index's options as a function of its model's columns: `options` reads `this['columnOf']`, which maps each field name of the model to its column name. A helper whose options name fields, such as a full-text index's weight groups, declares one so the contract's type states the options with column names, as the build writes them.
+ */
+interface IndexOptionsFunction {
+  readonly columnOf: Record<never, string>;
+  readonly options: unknown;
+}
+/** What an index's type records beyond its fields and name: its exact `map` name, its type, and its options or a function that gives them. Exists only in types. */
+type IndexSpec = {
+  readonly map?: string | undefined;
+  readonly type?: string | undefined;
+  readonly options?: unknown;
+  readonly partial?: boolean;
+  readonly unique?: boolean | undefined;
+};
+type IndexConstraint<FieldNames extends readonly string[] = readonly string[], Name extends string | undefined = string | undefined, Spec extends IndexSpec = IndexSpec> = IndexConstraintElements<FieldNames> & IndexConstraintMethod & {
+  readonly kind: 'index';
+  readonly where?: SqlExpression;
+  readonly unique?: boolean;
+  readonly name?: Name;
+  readonly map?: string;
+  readonly __spec?: Spec;
+};
+/**
+ * An authored check constraint, as returned by {@link check}: `map` adopts an
+ * exact physical name verbatim, `name` is a wire-name prefix. Unlike an
+ * index there is no column tuple to derive a default name from, so exactly
+ * one of `name` or `map` is required — enforced at lowering, same as PSL.
+ */
+type AuthoredCheckConstraint = {
+  readonly kind: 'check';
+  readonly expression: SqlExpression;
+  readonly name?: string;
+  readonly map?: string;
+};
+type ForeignKeyConstraint<SourceFieldNames extends readonly string[] = readonly string[], TargetModelName extends string = string, TargetFieldNames extends readonly string[] = readonly string[], Name extends string | undefined = string | undefined, Index extends boolean | string | undefined = boolean | string | undefined> = {
+  readonly kind: 'fk';
+  readonly fields: SourceFieldNames;
+  readonly targetModel: TargetModelName;
+  readonly targetFields: TargetFieldNames;
+  readonly targetSource?: TargetFieldRefSource;
+  /**
+   * Cross-space discriminator. When present, the FK target lives in a
+   * different contract space identified by this value. Absent for local FKs.
+   */
+  readonly targetSpaceId?: string;
+  /**
+   * Namespace coordinate of the cross-space target model. Populated when
+   * the target model handle carries a `namespace` (e.g. `auth` for supabase
+   * `auth.User`). Absent for local FKs.
+   */
+  readonly targetNamespaceId?: string;
+  /**
+   * Table name of the cross-space target. Populated for cross-space FKs
+   * so the lowering path doesn't need a local model lookup.
+   */
+  readonly targetTableName?: string;
+  readonly name?: Name;
+  readonly onDelete?: 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+  readonly onUpdate?: 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+  readonly constraint?: boolean;
+  readonly index?: Index;
+};
+declare function createConstraintsDsl<IndexTypes extends IndexTypeMap = Record<never, never>>(): {
+  ref: <ModelName extends string, FieldName extends string>(modelName: ModelName, fieldName: FieldName) => TargetFieldRef<ModelName, FieldName>;
+  id: {
+    <FieldName extends string, const Name extends string | undefined = undefined>(field: ColumnRef<FieldName>, options?: NamedConstraintSpec<Name>): IdConstraint<readonly [FieldName], Name>;
+    <FieldNames extends readonly string[], const Name extends string | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: NamedConstraintSpec<Name>): IdConstraint<FieldNames, Name>;
+  };
+  unique: {
+    <FieldName extends string, const Name extends string | undefined = undefined>(field: ColumnRef<FieldName>, options?: ConstraintOptions<Name>): UniqueConstraint<readonly [FieldName], Name>;
+    <FieldNames extends readonly string[], const Name extends string | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: ConstraintOptions<Name>): UniqueConstraint<FieldNames, Name>;
+  };
+  index: {
+    <FieldNames extends readonly string[], const Name extends string | undefined = undefined, const Map extends string | undefined = undefined, const Type extends (keyof IndexTypes & string) | undefined = undefined, const Where extends SqlExpression | undefined = undefined, const Unique extends boolean | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: IndexInput<Name, IndexTypes> & IndexSpecCapture<Map, Type, Where, Unique, IndexTypes>): IndexConstraint<FieldNames, NoInfer<Name>, IndexSpecFrom<NoInfer<Map>, NoInfer<Type>, NoInfer<Where>, NoInfer<Unique>, IndexTypes>>;
+    <const Name extends string | undefined = undefined, const Map extends string | undefined = undefined, const Type extends (keyof IndexTypes & string) | undefined = undefined, const Where extends SqlExpression | undefined = undefined, const Unique extends boolean | undefined = undefined>(options: ExpressionIndexInput<Name, IndexTypes> & IndexSpecCapture<Map, Type, Where, Unique, IndexTypes>): IndexConstraint<never, NoInfer<Name>, IndexSpecFrom<NoInfer<Map>, NoInfer<Type>, NoInfer<Where>, NoInfer<Unique>, IndexTypes>>;
+  };
+  foreignKey: {
+    <SourceFieldName extends string, TargetModelName extends string, TargetFieldName extends string, const Name extends string | undefined = undefined, const Index extends boolean | string | undefined = undefined>(field: ColumnRef<SourceFieldName>, target: TargetFieldRef<TargetModelName, TargetFieldName>, options?: ForeignKeyOptions<Name> & {
+      readonly index?: Index;
+    }): ForeignKeyConstraint<readonly [SourceFieldName], TargetModelName, readonly [TargetFieldName], Name, Index>;
+    <SourceFieldNames extends readonly string[], TargetModelName extends string, TargetFieldNames extends readonly string[], const Name extends string | undefined = undefined, const Index extends boolean | string | undefined = undefined>(fields: { readonly [K in keyof SourceFieldNames]: ColumnRef<SourceFieldNames[K] & string>; }, target: { readonly [K in keyof TargetFieldNames]: TargetFieldRef<TargetModelName, TargetFieldNames[K] & string>; }, options?: ForeignKeyOptions<Name> & {
+      readonly index?: Index;
+    }): ForeignKeyConstraint<SourceFieldNames, TargetModelName, TargetFieldNames, Name, Index>;
+  };
+};
+type ConstraintsDsl = ReturnType<typeof createConstraintsDsl>;
+/**
+ * Declares an authored CHECK constraint for a model's `.sql({ checks: [...] })`.
+ * Unlike `index()`, `check()` names no column tuple — the predicate is opaque
+ * SQL — so it needs no field-ref context and is a plain top-level function
+ * rather than a method on `constraints`.
+ */
+declare function check(input: {
+  readonly expression: SqlExpression;
+  readonly name?: string;
+  readonly map?: string;
+}): AuthoredCheckConstraint;
+type ModelAttributesSpec = {
+  readonly id?: IdConstraint;
+  readonly uniques?: readonly UniqueConstraint[];
+};
+type SqlStageSpec = {
+  readonly table?: string;
+  readonly control?: ControlPolicy;
+  readonly indexes?: readonly IndexConstraint[];
+  readonly checks?: readonly AuthoredCheckConstraint[];
+  readonly foreignKeys?: readonly ForeignKeyConstraint[];
+};
+type FieldRefs<Fields extends Record<string, ScalarFieldBuilder>> = { readonly [K in keyof Fields]: ColumnRef<K & string>; };
+type AttributeContext<Fields extends Record<string, ScalarFieldBuilder>> = {
+  readonly fields: FieldRefs<Fields>;
+  readonly constraints: Pick<ConstraintsDsl, 'id' | 'unique'>;
+};
+type PackAwareIndex<IndexTypes extends IndexTypeMap> = {
+  <FieldNames extends readonly string[], const Name extends string | undefined = undefined, const Map extends string | undefined = undefined, const Type extends (keyof IndexTypes & string) | undefined = undefined, const Where extends SqlExpression | undefined = undefined, const Unique extends boolean | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: IndexInput<Name, IndexTypes> & IndexSpecCapture<Map, Type, Where, Unique, IndexTypes>): IndexConstraint<FieldNames, NoInfer<Name>, IndexSpecFrom<NoInfer<Map>, NoInfer<Type>, NoInfer<Where>, NoInfer<Unique>, IndexTypes>>;
+  <const Name extends string | undefined = undefined, const Map extends string | undefined = undefined, const Type extends (keyof IndexTypes & string) | undefined = undefined, const Where extends SqlExpression | undefined = undefined, const Unique extends boolean | undefined = undefined>(options: ExpressionIndexInput<Name, IndexTypes> & IndexSpecCapture<Map, Type, Where, Unique, IndexTypes>): IndexConstraint<never, NoInfer<Name>, IndexSpecFrom<NoInfer<Map>, NoInfer<Type>, NoInfer<Where>, NoInfer<Unique>, IndexTypes>>;
+};
+type PackAwareSqlConstraints<IndexTypes extends IndexTypeMap> = {
+  readonly foreignKey: ConstraintsDsl['foreignKey'];
+  readonly ref: ConstraintsDsl['ref'];
+  readonly index: PackAwareIndex<IndexTypes>;
+};
+type SqlContext<Fields extends Record<string, ScalarFieldBuilder>, IndexTypes extends IndexTypeMap = Record<never, never>> = {
+  readonly cols: FieldRefs<Fields>;
+  readonly constraints: PackAwareSqlConstraints<IndexTypes>;
+};
+type StageInput<Context, Spec> = Spec | ((context: Context) => Spec);
+type StaticLiteralName<Name> = Name extends string ? (string extends Name ? never : Name) : never;
+type NamedConstraintLiteralName<Constraint> = Constraint extends {
+  readonly name?: infer Name;
+} ? StaticLiteralName<Name> : never;
+type DuplicateLiteralNames<Items extends readonly unknown[], Seen extends string = never, Duplicates extends string = never> = Items extends readonly [infer First, ...infer Rest extends readonly unknown[]] ? NamedConstraintLiteralName<First> extends (infer Name extends string) ? Name extends Seen ? DuplicateLiteralNames<Rest, Seen, Duplicates | Name> : DuplicateLiteralNames<Rest, Seen | Name, Duplicates> : DuplicateLiteralNames<Rest, Seen, Duplicates> : Duplicates;
+type InlineIdLiteralName<Fields extends Record<string, ScalarFieldBuilder>> = { readonly [FieldName in keyof Fields]: FieldStateOf<Fields[FieldName]> extends {
+  readonly id: {
+    readonly name?: infer Name;
+  };
+} ? StaticLiteralName<Name> : never; }[keyof Fields];
+type AttributeIdLiteralName<AttributesSpec extends ModelAttributesSpec | undefined> = AttributesSpec extends {
+  readonly id?: {
+    readonly name?: infer Name;
+  };
+} ? StaticLiteralName<Name> : never;
+type ModelIdLiteralName<Fields extends Record<string, ScalarFieldBuilder>, AttributesSpec extends ModelAttributesSpec | undefined> = [AttributeIdLiteralName<AttributesSpec>] extends [never] ? InlineIdLiteralName<Fields> : AttributeIdLiteralName<AttributesSpec>;
+type AttributeUniques<AttributesSpec extends ModelAttributesSpec | undefined> = AttributesSpec extends {
+  readonly uniques?: infer Uniques extends readonly unknown[];
+} ? Uniques : readonly [];
+type SqlIndexes<SqlSpec extends SqlStageSpec | undefined> = SqlSpec extends {
+  readonly indexes?: infer Indexes extends readonly unknown[];
+} ? Indexes : readonly [];
+type SqlForeignKeys<SqlSpec extends SqlStageSpec | undefined> = SqlSpec extends {
+  readonly foreignKeys?: infer ForeignKeys extends readonly unknown[];
+} ? ForeignKeys : readonly [];
+type ModelNamedObjects<AttributesSpec extends ModelAttributesSpec | undefined, SqlSpec extends SqlStageSpec | undefined> = [...AttributeUniques<AttributesSpec>, ...SqlIndexes<SqlSpec>, ...SqlForeignKeys<SqlSpec>];
+type InlineUniqueLiteralName<Field> = FieldStateOf<Field> extends {
+  readonly unique: {
+    readonly name?: infer Name;
+  };
+} ? StaticLiteralName<Name> : never;
+type RelationForeignKeyLiteralName<Relation> = RelationStateOf<Relation> extends {
+  readonly sql?: infer Spec;
+} ? Spec extends {
+  readonly fk?: {
+    readonly name?: infer Name;
+  };
+} ? StaticLiteralName<Name> : never : never;
+type ModelLiteralNamesBySource<Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder>, AttributesSpec extends ModelAttributesSpec | undefined, SqlSpec extends SqlStageSpec | undefined> = { readonly [FieldName in keyof Fields & string as `field:${FieldName}`]: InlineUniqueLiteralName<Fields[FieldName]>; } & { readonly [RelationName in keyof Relations & string as `relation:${RelationName}`]: RelationForeignKeyLiteralName<Relations[RelationName]>; } & {
+  readonly id: ModelIdLiteralName<Fields, AttributesSpec>;
+  readonly stages: NamedConstraintLiteralName<ModelNamedObjects<AttributesSpec, SqlSpec>[number]>;
+};
+type LiteralNamesInMoreThanOneSource<NamesBySource> = { readonly [Source in keyof NamesBySource]: NamesBySource[Source] & NamesBySource[Exclude<keyof NamesBySource, Source>]; }[keyof NamesBySource];
+type HasDuplicateModelNames<Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder>, AttributesSpec extends ModelAttributesSpec | undefined, SqlSpec extends SqlStageSpec | undefined> = [DuplicateLiteralNames<ModelNamedObjects<AttributesSpec, SqlSpec>> | LiteralNamesInMoreThanOneSource<ModelLiteralNamesBySource<Fields, Relations, AttributesSpec, SqlSpec>>] extends [never] ? false : true;
+type ValidateSqlStageSpec<Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder>, AttributesSpec extends ModelAttributesSpec | undefined, SqlSpec extends SqlStageSpec> = HasDuplicateModelNames<Fields, Relations, AttributesSpec, SqlSpec> extends true ? never : SqlSpec;
+type ValidateAttributesStageSpec<Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder>, SqlSpec extends SqlStageSpec | undefined, AttributesSpec extends ModelAttributesSpec> = HasDuplicateModelNames<Fields, Relations, AttributesSpec, SqlSpec> extends true ? never : AttributesSpec;
+type DuplicateModelNamesError = 'Error: two ids, uniques, indexes or foreign keys on this model have the same name';
+type ModelDuplicateNames<Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder>, AttributesSpec extends ModelAttributesSpec | undefined, SqlSpec extends SqlStageSpec | undefined> = [AttributesSpec] extends [never] ? DuplicateModelNamesError : [SqlSpec] extends [never] ? DuplicateModelNamesError : HasDuplicateModelNames<Fields, Relations, AttributesSpec, SqlSpec> extends true ? DuplicateModelNamesError : undefined;
+declare class ContractModelBuilder<ModelName extends string | undefined, Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>, AttributesSpec extends ModelAttributesSpec | undefined = undefined, SqlSpec extends SqlStageSpec | undefined = undefined, IndexTypes extends IndexTypeMap = Record<never, never>, TSpaceId extends string = '<self>', Namespace extends string | undefined = string | undefined> {
+  readonly stageOne: {
+    readonly modelName?: ModelName;
+    readonly namespace?: Namespace;
+    readonly fields: Fields;
+    readonly relations: Relations;
+  };
+  readonly attributesFactory?: StageInput<AttributeContext<Fields>, AttributesSpec> | undefined;
+  readonly sqlFactory?: StageInput<SqlContext<Fields, IndexTypes>, SqlSpec> | undefined;
+  readonly spaceId?: TSpaceId | undefined;
+  readonly tableName?: string | undefined;
+  readonly __name: ModelName;
+  readonly __namespace: Namespace;
+  readonly __fields: Fields;
+  readonly __relations: Relations;
+  readonly __attributes: AttributesSpec;
+  readonly __sql: SqlSpec;
+  readonly __indexTypes: IndexTypes;
+  readonly __spaceId: TSpaceId;
+  readonly __duplicateNames: ModelDuplicateNames<Fields, Relations, AttributesSpec, SqlSpec>;
+  readonly refs: ModelName extends string ? ModelTokenRefs<ModelName, Fields, TSpaceId> : never;
+  constructor(stageOne: {
+    readonly modelName?: ModelName;
+    readonly namespace?: Namespace;
+    readonly fields: Fields;
+    readonly relations: Relations;
+  }, attributesFactory?: StageInput<AttributeContext<Fields>, AttributesSpec> | undefined, sqlFactory?: StageInput<SqlContext<Fields, IndexTypes>, SqlSpec> | undefined, spaceId?: TSpaceId | undefined, tableName?: string | undefined);
+  ref<FieldName extends keyof Fields & string>(this: ModelName extends string ? ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, SqlSpec, IndexTypes, TSpaceId, Namespace> : never, fieldName: FieldName): TargetFieldRef<ModelName & string, FieldName>;
+  relations<const NextRelations extends Record<string, AnyRelationBuilder>>(relations: NextRelations): ContractModelBuilder<ModelName, Fields, Relations & NextRelations, AttributesSpec, SqlSpec, IndexTypes, TSpaceId, Namespace>;
+  attributes<const NextAttributesSpec extends ModelAttributesSpec>(specOrFactory: StageInput<AttributeContext<Fields>, NextAttributesSpec>): [ValidateAttributesStageSpec<Fields, Relations, SqlSpec, NextAttributesSpec>] extends [never] ? ContractModelBuilder<ModelName, Fields, Relations, never, SqlSpec, IndexTypes, TSpaceId, Namespace> : ContractModelBuilder<ModelName, Fields, Relations, NextAttributesSpec, SqlSpec, IndexTypes, TSpaceId, Namespace>;
+  sql<const NextSqlSpec extends SqlStageSpec>(specOrFactory: StageInput<SqlContext<Fields, IndexTypes>, NextSqlSpec>): [ValidateSqlStageSpec<Fields, Relations, AttributesSpec, NextSqlSpec>] extends [never] ? ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, never, IndexTypes, TSpaceId, Namespace> : ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, NextSqlSpec, IndexTypes, TSpaceId, Namespace>;
+  buildAttributesSpec(): AttributesSpec;
+  buildSqlSpec(): SqlSpec;
+}
+type NamedModelTokenShape<ModelName extends string = string, Fields extends Record<string, ScalarFieldBuilder> = Record<string, ScalarFieldBuilder>> = {
+  readonly stageOne: {
+    readonly modelName?: ModelName;
+    readonly fields: Fields;
+  };
+};
+type AnyNamedModelToken = NamedModelTokenShape<string, Record<string, ScalarFieldBuilder>>;
+type LazyNamedModelToken<Token extends AnyNamedModelToken = AnyNamedModelToken> = () => Token;
+type RelationFieldSelection<FieldName extends string> = FieldName | readonly FieldName[];
+type RelationModelName<Target> = Target extends NamedModelTokenShape<infer ModelName extends string, Record<string, ScalarFieldBuilder>> ? ModelName : Target extends (() => infer Token) ? RelationModelName<Token> : never;
+type RelationSpaceId<Target> = Target extends {
+  readonly __spaceId: infer SpaceId extends string;
+} ? SpaceId : Target extends (() => infer Token) ? RelationSpaceId<Token> : '<self>';
+type RelationModelFieldNames<Target> = Target extends NamedModelTokenShape<string, infer Fields> ? keyof Fields & string : Target extends (() => infer Token) ? RelationModelFieldNames<Token> : never;
+type ContractInput<Family extends FamilyPackRef<string> = FamilyPackRef<string>, Target extends TargetPackRef<'sql', string> = TargetPackRef<'sql', string>, DatabaseTypes extends Record<string, AuthoredStorageTypeInstance> = Record<never, never>, Models extends Record<string, ContractModelBuilder<string | undefined, Record<string, ScalarFieldBuilder>, Record<string, AnyRelationBuilder>, ModelAttributesSpec | undefined, SqlStageSpec | undefined>> = Record<never, never>, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined> = {
+  readonly family: Family;
+  readonly target: Target;
+  readonly extensions?: Extensions;
+  /** The adapter the contract runs with. Its capabilities join the target's and the extensions', as `prisma contract emit` and the runtime join them. The Postgres and SQLite `defineContract` supply it. */
+  readonly adapter?: CapabilityContributor;
+  readonly naming?: NamingConfig;
+  readonly storageHash?: string;
+  readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
+  readonly defaultControlPolicy?: ControlPolicy;
+  /**
+   * Declared namespace coordinates the contract recognises. Per-model
+   * `namespace` references must reference an entry in this list (or the
+   * Postgres-specific late-binding keyword `unbound`). Reserved values:
+   *
+   * - `__unbound__` — IR sentinel for the late-binding slot.
+   * - `__unspecified__` — parser-synthesised AST bucket for top-level
+   *   declarations (not a real namespace).
+   * - `unbound` — Postgres-specific reserved keyword (the PSL surface
+   *   uses `namespace unbound { … }` to opt into late binding).
+   *
+   * SQLite contracts must declare an empty list (or omit the field) —
+   * SQLite has no schema concept and emits unqualified DDL.
+   *
+   * Populates `SqlStorage.namespaces` together with the
+   * {@link ContractInput.createNamespace} factory: each declared name
+   * (plus the framework-reserved `UNBOUND_NAMESPACE_ID` sentinel) is
+   * resolved through `createNamespace` and stored as the matching slot
+   * value. Models reference declared namespaces via their per-model
+   * `namespace` coordinate; entries that go unreferenced still occupy a
+   * slot so contracts that pre-declare schemas surface them on the live
+   * storage walk.
+   */
+  readonly namespaces?: readonly string[];
+  /**
+   * Target-supplied factory that materialises a `SqlNamespaceBase` concretion
+   * for a declared namespace coordinate. The SQL family layer is
+   * target-agnostic and cannot import concretions like
+   * `PostgresSchema` or `SqliteUnboundDatabase`; the factory is the
+   * seam by which target packs hand the family the right runtime
+   * representation.
+   *
+   * Called once per distinct namespace id discovered in the contract:
+   * each entry of {@link ContractInput.namespaces}, every
+   * `StorageTable.namespaceId` referenced by a model, and the
+   * framework `UNBOUND_NAMESPACE_ID` sentinel (always present so the
+   * late-bound slot stays available regardless of authoring choices).
+   */
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
+  /** The database types this contract space registers in `storage.types`, such as an extension's base type. No column references them. */
+  readonly databaseTypes?: DatabaseTypes;
+  readonly models?: Models;
+  /** The codecs of the packs the contract is authored with; a column's database type is its codec's data type's. */
+  readonly codecLookup: CodecLookupWithDescriptors;
+  /** The data types of the packs the contract is authored with. */
+  readonly dataTypeLookup: DataTypeLookup;
+  /**
+   * Domain enum handles authored via `enumType()`. Each handle lowers to a
+   * domain `enum` entry and a storage `valueSet` entry in the target's
+   * default namespace. Fields reference the enum via `field.namedType(handle)`.
+   */
+  readonly enums?: Record<string, EnumTypeHandle>;
+  /**
+   * Author-declared pack-entity handles, lowered by the pack that registered
+   * each handle's `entityKind` (through the SQL-family batch lowering hook)
+   * into namespace-scoped entry attachments at build time. Generic on
+   * purpose — neither this type nor the walk names a specific kind; a handle
+   * whose kind no composed pack registers is a build error. This is the only
+   * public channel for attaching pack entities.
+   */
+  readonly entities?: readonly PackEntityHandle[];
+};
+declare function model<const ModelName extends string, Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>, const Namespace extends string | undefined = undefined>(modelName: ModelName, input: {
+  readonly fields: Fields;
+  readonly relations?: Relations;
+  readonly namespace?: Namespace;
+}): ContractModelBuilder<ModelName, Fields, Relations, undefined, undefined, Record<never, never>, '<self>', NoInfer<Namespace>>;
+declare function model<Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>, const Namespace extends string | undefined = undefined>(input: {
+  readonly fields: Fields;
+  readonly relations?: Relations;
+  readonly namespace?: Namespace;
+}): ContractModelBuilder<undefined, Fields, Relations, undefined, undefined, Record<never, never>, '<self>', NoInfer<Namespace>>;
+/**
+ * Factory for building a standalone branded extension model handle.
+ *
+ * Use this instead of `new ContractModelBuilder(…)` when constructing handles
+ * for models that live in a foreign contract space (e.g. a Supabase extension
+ * model referenced by a user's contract). The `spaceId` brands the returned
+ * handle so `refs.<field>.spaceId` carries the foreign space identifier.
+ *
+ * @param name - The domain model name as declared in the foreign contract
+ *   (e.g. `'AuthUser'`, not a bare table alias like `'User'`).
+ * @param input.namespace - The namespace within the foreign space (e.g. `'auth'`).
+ * @param input.fields - Field definitions (use `field.column(…)`).
+ * @param input.table - The physical table name in the foreign schema.
+ * @param spaceId - The extension space identifier (e.g. `'supabase'`).
+ */
+declare function extensionModel<const ModelName extends string, Fields extends Record<string, ScalarFieldBuilder>, const TSpaceId extends string>(name: ModelName, input: {
+  readonly namespace: string;
+  readonly fields: Fields;
+  readonly table: string;
+}, spaceId: TSpaceId): ContractModelBuilder<ModelName, Fields, Record<never, never>, undefined, undefined, Record<never, never>, TSpaceId>;
+declare function belongsTo<Token extends AnyNamedModelToken, const FromField extends string | readonly string[], const ToField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
+  readonly from: FromField;
+  readonly to: ToField;
+  readonly optional?: boolean;
+}): RelationBuilder<BelongsToRelation<RelationModelName<Token>, FromField, ToField, undefined, RelationSpaceId<Token>>>;
+declare function belongsTo<ToModel extends string, const FromField extends string | readonly string[], const ToField extends string | readonly string[]>(toModel: ToModel, options: {
+  readonly from: FromField;
+  readonly to: ToField;
+  readonly optional?: boolean;
+}): RelationBuilder<BelongsToRelation<ToModel, FromField, ToField, undefined, '<self>'>>;
+declare function hasMany<Token extends AnyNamedModelToken, const ByField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
+  readonly by: ByField;
+}): RelationBuilder<HasManyRelation<RelationModelName<Token>, ByField>>;
+declare function hasMany<ToModel extends string, const ByField extends string | readonly string[]>(toModel: ToModel, options: {
+  readonly by: ByField;
+}): RelationBuilder<HasManyRelation<ToModel, ByField>>;
+declare function hasOne<Token extends AnyNamedModelToken, const ByField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
+  readonly by: ByField;
+}): RelationBuilder<HasOneRelation<RelationModelName<Token>, ByField>>;
+declare function hasOne<ToModel extends string, const ByField extends string | readonly string[]>(toModel: ToModel, options: {
+  readonly by: ByField;
+}): RelationBuilder<HasOneRelation<ToModel, ByField>>;
+declare function manyToMany<ToToken extends AnyNamedModelToken, ThroughToken extends AnyNamedModelToken, const FromField extends RelationFieldSelection<RelationModelFieldNames<ThroughToken>>, const ToField extends RelationFieldSelection<RelationModelFieldNames<ThroughToken>>>(toModel: ToToken | LazyNamedModelToken<ToToken>, options: {
+  readonly through: ThroughToken | LazyNamedModelToken<ThroughToken>;
+  readonly from: FromField;
+  readonly to: ToField;
+}): RelationBuilder<ManyToManyRelation<RelationModelName<ToToken>, RelationModelName<ThroughToken>, FromField, ToField>>;
+declare function manyToMany<ToModel extends string, ThroughModel extends string, const FromField extends string | readonly string[], const ToField extends string | readonly string[]>(toModel: ToModel, options: {
+  readonly through: ThroughModel;
+  readonly from: FromField;
+  readonly to: ToField;
+}): RelationBuilder<ManyToManyRelation<ToModel, ThroughModel, FromField, ToField>>;
+declare const rel: {
+  belongsTo: typeof belongsTo;
+  hasMany: typeof hasMany;
+  hasOne: typeof hasOne;
+  manyToMany: typeof manyToMany;
+};
+declare const field: {
+  column: ColumnFieldHelper<CodecTypesOfNoPacks>;
+  generated: typeof generatedField;
+  namedType: NamedTypeFieldHelper;
+};
+type FieldStateOf<T> = T extends ScalarFieldBuilder<infer State> ? State : never;
+type RelationStateOf<T> = T extends RelationBuilder<infer State> ? State : never;
+type IdFieldNames<T> = T extends IdConstraint<infer FieldNames> ? FieldNames : readonly string[];
+type AttributeStageIdFieldNames<T> = T extends {
+  readonly id?: infer I;
+} ? I extends IdConstraint ? IdFieldNames<I> : undefined : undefined;
+//#endregion
+//#region src/authoring-type-utils.d.ts
+type UnionToIntersection$1<U> = (U extends unknown ? (value: U) => void : never) extends ((value: infer I) => void) ? I : never;
+type NamedConstraintSpec<Name extends string | undefined = string | undefined> = {
+  readonly name?: Name;
+};
+type NamedConstraintState<Enabled extends boolean, Name extends string | undefined = undefined> = Enabled extends true ? NamedConstraintSpec<Name> : undefined;
+type SupportsNamedConstraintOptions<Descriptor extends AuthoringFieldPresetDescriptor> = Descriptor['output'] extends {
+  readonly id: true;
+} ? true : Descriptor['output'] extends {
+  readonly unique: true;
+} ? true : false;
+type PresetCodecId<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[]> = ResolveTemplateValue<Descriptor['output']['codecId'], Args> extends string ? ResolveTemplateValue<Descriptor['output']['codecId'], Args> : string;
+type DefinedTypeParams<TypeParams> = { readonly [K in keyof TypeParams as TypeParams[K] extends undefined ? never : K]: TypeParams[K]; };
+type PresetTypeParams<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[]> = Descriptor['output'] extends {
+  readonly typeParams: infer Template;
+} ? DefinedTypeParams<ResolveTemplateValue<Template, Args>> extends (infer TypeParams) ? keyof TypeParams extends never ? Record<never, never> : {
+  readonly typeParams: TypeParams;
+} : Record<never, never> : Record<never, never>;
+type PresetPhaseTemplate<Defaults, Phase extends GeneratorPhase> = Defaults extends { readonly [K in Phase]: infer Template; } ? Template : undefined;
+type PresetPhasePresent<Template, Args extends readonly unknown[]> = Template extends {
+  readonly kind: 'select';
+  readonly index: infer Index extends number;
+  readonly cases: infer Cases;
+} ? Args[Index] extends keyof Cases ? true : false : [Template] extends [undefined] ? false : true;
+type PresetGeneratesIn<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[], Phase extends GeneratorPhase> = Descriptor['output'] extends {
+  readonly executionDefaults: infer Defaults;
+} ? PresetPhasePresent<PresetPhaseTemplate<Defaults, Phase>, Args> : false;
+type FieldBuilderFromPresetDescriptor<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[] = readonly [], ConstraintName extends string | undefined = undefined, CodecTypes extends CodecTypeMap = Record<never, never>> = ScalarFieldBuilder<ScalarFieldState<WithCodecInput<ColumnTypeDescriptor<PresetCodecId<Descriptor, Args>> & PresetTypeParams<Descriptor, Args>, CodecInput<CodecTypes, {
+  readonly codecId: PresetCodecId<Descriptor, Args>;
+}>>, undefined, ResolveTemplateValue<Descriptor['output']['nullable'], Args> extends true ? true : false, undefined, NamedConstraintState<ResolveTemplateValue<Descriptor['output']['id'], Args> extends true ? true : false, ConstraintName>, NamedConstraintState<ResolveTemplateValue<Descriptor['output']['unique'], Args> extends true ? true : false, ConstraintName>, false, {
+  readonly column: Descriptor['output'] extends {
+    readonly default: object;
+  } ? true : false;
+  readonly onCreate: PresetGeneratesIn<Descriptor, Args, 'onCreate'>;
+  readonly onUpdate: PresetGeneratesIn<Descriptor, Args, 'onUpdate'>;
+}>>;
+type FieldHelperFunctionWithoutNamedConstraint<Descriptor extends AuthoringFieldPresetDescriptor, CodecTypes extends CodecTypeMap = Record<never, never>, ValueTypes extends DataTypeArgumentTypes = Record<never, never>> = Descriptor extends {
+  readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
+} ? <const Params extends TupleFromArgumentDescriptors<Args, ValueTypes>>(...args: Params) => FieldBuilderFromPresetDescriptor<Descriptor, Params, undefined, CodecTypes> : () => FieldBuilderFromPresetDescriptor<Descriptor, readonly [], undefined, CodecTypes>;
+/**
+ * An intersection of two call signatures rather than one rest-tuple signature
+ * with a trailing `options?`. Once optional descriptors yield optional tuple
+ * slots, `Params` can infer as the empty tuple, and a single-argument call
+ * such as `field.id.nanoid({ size: 16 })` would bind its preset argument to
+ * the trailing optional `options` parameter. Resolving the no-options
+ * signature first, and falling through to the options-required signature only
+ * when the argument list cannot satisfy it, keeps both spellings working.
+ */
+type FieldHelperFunctionWithNamedConstraint<Descriptor extends AuthoringFieldPresetDescriptor, CodecTypes extends CodecTypeMap = Record<never, never>, ValueTypes extends DataTypeArgumentTypes = Record<never, never>> = Descriptor extends {
+  readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
+} ? (<const Params extends TupleFromArgumentDescriptors<Args, ValueTypes>>(...args: Params) => FieldBuilderFromPresetDescriptor<Descriptor, Params, undefined, CodecTypes>) & (<const Params extends TupleFromArgumentDescriptors<Args, ValueTypes>, const Name extends string | undefined = undefined>(...args: [...params: Params, options: NamedConstraintSpec<Name>]) => FieldBuilderFromPresetDescriptor<Descriptor, Params, Name, CodecTypes>) : <const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>) => FieldBuilderFromPresetDescriptor<Descriptor, readonly [], Name, CodecTypes>;
+type FieldHelperFunction<Descriptor extends AuthoringFieldPresetDescriptor, CodecTypes extends CodecTypeMap = Record<never, never>, ValueTypes extends DataTypeArgumentTypes = Record<never, never>> = SupportsNamedConstraintOptions<Descriptor> extends true ? FieldHelperFunctionWithNamedConstraint<Descriptor, CodecTypes, ValueTypes> : FieldHelperFunctionWithoutNamedConstraint<Descriptor, CodecTypes, ValueTypes>;
+type FieldHelpersFromNamespace<Namespace, CodecTypes extends CodecTypeMap = Record<never, never>, ValueTypes extends DataTypeArgumentTypes = Record<never, never>> = { readonly [K in keyof Namespace]: Namespace[K] extends AuthoringFieldPresetDescriptor ? FieldHelperFunction<Namespace[K], CodecTypes, ValueTypes> : Namespace[K] extends Record<string, unknown> ? FieldHelpersFromNamespace<Namespace[K], CodecTypes, ValueTypes> : unknown; };
+//#endregion
+//#region src/contract-types.d.ts
+type PublicCodecTypes<CodecTypes extends Record<string, {
+  readonly output: unknown;
+}>> = { readonly [CodecId in keyof CodecTypes]: Pick<CodecTypes[CodecId], Extract<keyof CodecTypes[CodecId], 'input' | 'output' | 'traits' | 'keepsWrittenForm'>>; };
+type ExtractCodecTypesFromPack<P> = P extends {
+  __codecTypes?: infer C extends Record<string, {
+    readonly output: unknown;
+  }>;
+} ? PublicCodecTypes<C> : Record<never, never>;
+type MergeExtensionCodecTypes<Packs extends Record<string, unknown>> = UnionToIntersection$1<{ [K in keyof Packs]: ExtractCodecTypesFromPack<Packs[K]>; }[keyof Packs]>;
+type MergeExtensionCodecTypesSafe<Packs> = Packs extends Record<string, unknown> ? keyof Packs extends never ? Record<never, never> : MergeExtensionCodecTypes<Packs> : Record<never, never>;
+type ExtractIndexTypesFromPack<P> = P extends {
+  readonly indexTypes: IndexTypeRegistration<infer M>;
+} ? M : Record<never, never>;
+type AllIndexTypeLiterals<Packs> = Packs extends Record<string, unknown> ? { [K in keyof Packs]: keyof ExtractIndexTypesFromPack<Packs[K]>; }[keyof Packs] & string : never;
+type MergeExtensionIndexTypes<Packs extends Record<string, unknown>> = { readonly [Lit in AllIndexTypeLiterals<Packs>]: Extract<{ [K in keyof Packs]: Lit extends keyof ExtractIndexTypesFromPack<Packs[K]> ? ExtractIndexTypesFromPack<Packs[K]>[Lit] : never; }[keyof Packs], {
+  readonly options: unknown;
+}>; };
+type DefinitionExtensions<Definition> = Definition extends {
+  readonly extensions?: infer Packs extends Record<string, ExtensionPackRef<'sql', string>>;
+} ? Packs : Record<never, never>;
+type ExtractPackCapabilities<P> = P extends {
+  readonly capabilities?: infer Caps extends Record<string, Record<string, boolean>>;
+} ? Caps : never;
+type ExtensionCapabilityMatrices<Packs> = Packs extends Record<string, unknown> ? { [K in keyof Packs]: Defaulted<ExtractPackCapabilities<Packs[K]>, Record<never, never>>; }[keyof Packs] : never;
+type KeysOfEach<T> = T extends unknown ? keyof T : never;
+type NamespaceOfEach<Matrices, Namespace> = Matrices extends unknown ? Namespace extends keyof Matrices ? Matrices[Namespace] : never : never;
+type FlagOfEach<Flags, Flag> = Flags extends unknown ? Flag extends keyof Flags ? Flags[Flag] : never : never;
+type MergeExtensionPackCapabilities<Packs> = { readonly [Namespace in KeysOfEach<ExtensionCapabilityMatrices<Packs>>]: { readonly [Flag in KeysOfEach<NamespaceOfEach<ExtensionCapabilityMatrices<Packs>, Namespace>>]: FlagOfEach<NamespaceOfEach<ExtensionCapabilityMatrices<Packs>, Namespace>, Flag> extends true ? true : false; }; };
+type Defaulted<T, Fallback> = [T] extends [never] ? Fallback : T;
+type DefinitionAdapter<Definition> = Definition extends {
+  readonly adapter?: infer Adapter;
+} ? Present<Adapter> : never;
+type EnabledCapabilityFlags<Flags> = { readonly [Flag in keyof Flags as Flags[Flag] extends true ? Flag : never]: true; };
+type EnabledCapabilities<Capabilities> = { readonly [Namespace in keyof Capabilities as keyof EnabledCapabilityFlags<Capabilities[Namespace]> extends never ? never : Namespace]: EnabledCapabilityFlags<Capabilities[Namespace]>; };
+type OverrideCapabilities<Earlier, Later> = { readonly [Namespace in keyof Earlier | keyof Later]: Namespace extends keyof Later ? Namespace extends keyof Earlier ? Omit<Earlier[Namespace], keyof Later[Namespace]> & Later[Namespace] : Later[Namespace] : Namespace extends keyof Earlier ? Earlier[Namespace] : never; };
+type DerivedCapabilities<Definition> = EnabledCapabilities<OverrideCapabilities<OverrideCapabilities<Defaulted<ExtractPackCapabilities<DefinitionTarget<Definition>>, Record<never, never>>, Defaulted<ExtractPackCapabilities<DefinitionAdapter<Definition>>, Record<never, never>>>, MergeExtensionPackCapabilities<DefinitionExtensions<Definition>>>>;
+type ExtractQueryOperationTypesFromPack<P, CodecTypes extends Record<string, {
+  readonly input: unknown;
+  readonly output: unknown;
+}>> = P extends {
+  readonly __queryOperationTypes?: infer TypeFunction;
+} ? Present<TypeFunction> extends (infer Defined extends QueryOperationTypesFunction) ? ApplyQueryOperationTypes<Defined, CodecTypes> : Record<never, never> : Record<never, never>;
+type PackQueryOperationTypes<Definition> = UnionToIntersection$1<{ [K in keyof AllPacks<Definition>]: ExtractQueryOperationTypesFromPack<AllPacks<Definition>[K], CodecTypesFromDefinition<Definition>>; }[keyof AllPacks<Definition>]>;
+type QueryOperationTypesFromDefinition<Definition> = PackQueryOperationTypes<Definition> extends (infer Operations extends Record<string, unknown>) ? Operations : Record<string, never>;
+type PackAggregateDescriptors<Pack> = Pack extends {
+  readonly types?: infer Types;
+} ? Present<Types> extends {
+  readonly aggregateDescriptors?: infer Descriptors;
+} ? Present<Descriptors> extends ReadonlyArray<infer Descriptor> ? Descriptor extends {
+  readonly operation: infer Operation;
+} ? string extends Operation ? never : Descriptor : never : never : never : never;
+type ExtensionAggregateDescriptors<Definition> = { [K in keyof DefinitionExtensions<Definition>]: PackAggregateDescriptors<DefinitionExtensions<Definition>[K]>; }[keyof DefinitionExtensions<Definition>];
+type AggregateTypesFromDefinition<Definition> = AggregateTypesFromDescriptors<PackAggregateDescriptors<DefinitionTarget<Definition>> | PackAggregateDescriptors<DefinitionAdapter<Definition>> | ExtensionAggregateDescriptors<Definition>, CodecTypesFromDefinition<Definition>>;
+type DefinitionTargetId<Definition> = Definition extends {
+  readonly target: TargetPackRef<'sql', infer Target>;
+} ? Target : never;
+type Present<T> = Exclude<T, undefined>;
+type CodecTypesFromDefinition<Definition> = ExtractCodecTypesFromPack<Definition extends {
+  readonly target: infer Target;
+} ? Target : never> & MergeExtensionCodecTypesSafe<DefinitionExtensions<Definition>>;
+type DefinitionTarget<Definition> = Definition extends {
+  readonly target: infer Target;
+} ? Target : never;
+type AllPacks<Definition> = DefinitionExtensions<Definition> & {
+  readonly __target: DefinitionTarget<Definition>;
+};
+type DefinitionModels<Definition> = Definition extends {
+  readonly models?: unknown;
+} ? Present<Definition['models']> extends Record<string, unknown> ? Present<Definition['models']> : Record<never, never> : Record<never, never>;
+type DefinitionNamespaces<Definition> = Definition extends {
+  readonly namespaces?: infer Names extends readonly string[];
+} ? string[] extends Names ? never : readonly string[] extends Names ? never : Names[number] : never;
+type DefinitionTypes<Definition> = Definition extends {
+  readonly databaseTypes?: unknown;
+} ? Present<Definition['databaseTypes']> extends Record<string, StorageType> ? Present<Definition['databaseTypes']> : Record<never, never> : Record<never, never>;
+type DefinitionTableNaming<Definition> = Definition extends {
+  readonly naming?: {
+    readonly tables?: infer Strategy extends string;
+  };
+} ? Strategy : undefined;
+type DefinitionColumnNaming<Definition> = Definition extends {
+  readonly naming?: {
+    readonly columns?: infer Strategy extends string;
+  };
+} ? Strategy : undefined;
+type FirstChar<S extends string> = S extends `${infer First}${string}` ? First : '';
+type CharKind<C extends string> = C extends '' ? 'end' : C extends Lowercase<C> ? C extends Uppercase<C> ? 'other' : 'lower' : 'upper';
+type ShouldInsertSnakeUnderscore<PrevKind extends 'start' | 'lower' | 'upper' | 'other' | 'end', Current extends string, Next extends string> = CharKind<Current> extends 'upper' ? PrevKind extends 'start' ? false : PrevKind extends 'lower' | 'other' ? true : CharKind<Next> extends 'lower' ? true : false : false;
+type SnakeCaseInternal<S extends string, PrevKind extends 'start' | 'lower' | 'upper' | 'other' | 'end' = 'start'> = S extends `${infer Current}${infer Rest}` ? `${ShouldInsertSnakeUnderscore<PrevKind, Current, FirstChar<Rest>> extends true ? '_' : ''}${Lowercase<Current>}${SnakeCaseInternal<Rest, CharKind<Current>>}` : '';
+type SnakeCase<S extends string> = string extends S ? string : SnakeCaseInternal<S>;
+type ApplyNamingType<Name extends string, Strategy extends string | undefined> = string extends Name ? string : Strategy extends 'snake_case' ? SnakeCase<Name> : Name;
+type ModelNames<Definition> = keyof DefinitionModels<Definition> & string;
+type ModelFields<Definition, ModelName extends ModelNames<Definition>> = DefinitionModels<Definition>[ModelName] extends {
+  readonly stageOne: {
+    readonly fields: Record<string, ScalarFieldBuilder>;
+  };
+} ? DefinitionModels<Definition>[ModelName]['stageOne']['fields'] : Record<never, never>;
+type ModelFieldNames<Definition, ModelName extends ModelNames<Definition>> = keyof ModelFields<Definition, ModelName> & string;
+type StagedModelRelations<Definition, ModelName extends ModelNames<Definition>> = DefinitionModels<Definition>[ModelName] extends {
+  readonly stageOne: {
+    readonly relations: infer R;
+  };
+} ? R extends Record<string, unknown> ? R : Record<never, never> : Record<never, never>;
+type StagedModelRelationNames<Definition, ModelName extends ModelNames<Definition>> = keyof StagedModelRelations<Definition, ModelName> & string;
+type ModelFieldState<Definition, ModelName extends ModelNames<Definition>, FieldName extends ModelFieldNames<Definition, ModelName>> = FieldStateOf<ModelFields<Definition, ModelName>[FieldName]>;
+type ModelSql<Definition, ModelName extends ModelNames<Definition>> = DefinitionModels<Definition>[ModelName] extends {
+  readonly __sql: infer SqlSpec;
+} ? SqlSpec : undefined;
+type ModelAttributes<Definition, ModelName extends ModelNames<Definition>> = DefinitionModels<Definition>[ModelName] extends {
+  readonly __attributes: infer AttributesSpec;
+} ? AttributesSpec : undefined;
+type FieldDescriptorOf<FieldState> = Present<FieldState extends {
+  readonly descriptor?: infer Descriptor;
+} ? Descriptor : never>;
+type FieldEnumHandleOf<FieldState> = Present<FieldState extends {
+  readonly enumHandle?: infer EnumHandle;
+} ? EnumHandle : never>;
+type FieldNullableOf<FieldState> = FieldState extends {
+  readonly nullable: infer Nullable extends boolean;
+} ? Nullable : boolean;
+type FieldManyOf<FieldState> = FieldState extends {
+  readonly many: infer Many extends false | {
+    readonly elementNullable: boolean;
+  };
+} ? Many : false;
+type FieldDefaultPresenceOf<FieldState> = Present<FieldState extends {
+  readonly __defaultPresence?: infer Defaults;
+} ? Defaults : never>;
+type FieldHasColumnDefault<FieldState> = FieldDefaultPresenceOf<FieldState> extends {
+  readonly column: true;
+} ? true : false;
+type FieldGeneratesIn<FieldState, Phase extends GeneratorPhase> = FieldDefaultPresenceOf<FieldState> extends { readonly [K in Phase]: true; } ? true : false;
+type GeneratedPhaseKeys<FieldState> = (FieldGeneratesIn<FieldState, 'onCreate'> extends true ? {
+  readonly onCreate: ExecutionMutationDefaultValue;
+} : unknown) & (FieldGeneratesIn<FieldState, 'onUpdate'> extends true ? {
+  readonly onUpdate: ExecutionMutationDefaultValue;
+} : unknown);
+type FieldColumnOverrideOf<FieldState> = Present<FieldState extends {
+  readonly columnName?: infer ColumnName;
+} ? ColumnName : never>;
+type FieldInlineIdSpecOf<FieldState> = Present<FieldState extends {
+  readonly id?: infer IdSpec;
+} ? IdSpec : never>;
+type DescriptorCodecId<Descriptor> = Descriptor extends {
+  readonly codecId: infer CodecId extends string;
+} ? string extends CodecId ? ColumnSpecCodecId<Descriptor> : CodecId : string;
+type ColumnSpecCodecId<Descriptor> = Descriptor extends {
+  readonly codecFactory: (...args: never[]) => {
+    readonly id: infer Id extends string;
+  };
+} ? Id : string;
+type DescriptorTypeParams<Descriptor> = Descriptor extends {
+  readonly typeParams: infer TypeParams extends Record<string, unknown>;
+} ? [keyof TypeParams] extends [never] ? undefined : TypeParams : undefined;
+type EnumFieldHandle<FieldState> = [FieldEnumHandleOf<FieldState>] extends [never] ? never : FieldEnumHandleOf<FieldState> extends EnumTypeHandle ? FieldEnumHandleOf<FieldState> : never;
+type EnumHandleDescriptor<Handle> = Handle extends {
+  readonly codecId: infer CodecId extends string;
+} ? {
+  readonly codecId: CodecId;
+} : never;
+type ResolveFieldDescriptor<FieldState> = [EnumFieldHandle<FieldState>] extends [never] ? FieldDescriptorOf<FieldState> : EnumHandleDescriptor<EnumFieldHandle<FieldState>>;
+type ResolveFieldColumnTypeParams<FieldState> = DescriptorTypeParams<FieldDescriptorOf<FieldState>>;
+type ModelTableName<Definition, ModelName extends ModelNames<Definition>> = [Present<ModelSql<Definition, ModelName> extends {
+  readonly table?: infer TableName;
+} ? TableName : never>] extends [never] ? ApplyNamingType<ModelName, DefinitionTableNaming<Definition>> : Present<ModelSql<Definition, ModelName> extends {
+  readonly table?: infer TableName;
+} ? TableName : never> extends (infer ExplicitTableName extends string) ? ExplicitTableName : ApplyNamingType<ModelName, DefinitionTableNaming<Definition>>;
+type ModelColumnName<Definition, ModelName extends ModelNames<Definition>, FieldName extends ModelFieldNames<Definition, ModelName>> = [FieldColumnOverrideOf<ModelFieldState<Definition, ModelName, FieldName>>] extends [never] ? ApplyNamingType<FieldName, DefinitionColumnNaming<Definition>> : FieldColumnOverrideOf<ModelFieldState<Definition, ModelName, FieldName>> extends (infer ExplicitColumnName extends string) ? ExplicitColumnName : ApplyNamingType<FieldName, DefinitionColumnNaming<Definition>>;
+type FieldNamesToColumnNames<Definition, ModelName extends ModelNames<Definition>, FieldNames extends readonly string[]> = FieldNames extends readonly [] ? readonly [] : FieldNames extends readonly [infer First extends ModelFieldNames<Definition, ModelName>, ...infer Rest extends readonly string[]] ? readonly [ModelColumnName<Definition, ModelName, First>, ...FieldNamesToColumnNames<Definition, ModelName, Rest>] : readonly string[];
+type InlineIdFieldName<Definition, ModelName extends ModelNames<Definition>> = { [FieldName in ModelFieldNames<Definition, ModelName>]: [FieldInlineIdSpecOf<ModelFieldState<Definition, ModelName, FieldName>>] extends [never] ? never : FieldName; }[ModelFieldNames<Definition, ModelName>];
+type InlineIdFieldNames<Definition, ModelName extends ModelNames<Definition>> = [InlineIdFieldName<Definition, ModelName>] extends [never] ? undefined : readonly [InlineIdFieldName<Definition, ModelName>];
+type InlineIdName<Definition, ModelName extends ModelNames<Definition>> = { [FieldName in ModelFieldNames<Definition, ModelName>]: FieldInlineIdSpecOf<ModelFieldState<Definition, ModelName, FieldName>> extends {
+  readonly name?: infer Name extends string;
+} ? Name : never; }[ModelFieldNames<Definition, ModelName>];
+type AttributeIdFieldNames<Definition, ModelName extends ModelNames<Definition>> = AttributeStageIdFieldNames<ModelAttributes<Definition, ModelName>>;
+type AttributeIdName<Definition, ModelName extends ModelNames<Definition>> = Present<ModelAttributes<Definition, ModelName> extends {
+  readonly id?: {
+    readonly name?: infer Name extends string;
+  };
+} ? Name : never>;
+type ModelIdFieldNames<Definition, ModelName extends ModelNames<Definition>> = [AttributeIdFieldNames<Definition, ModelName>] extends [undefined] ? InlineIdFieldNames<Definition, ModelName> : AttributeIdFieldNames<Definition, ModelName>;
+type ModelIdName<Definition, ModelName extends ModelNames<Definition>> = [AttributeIdName<Definition, ModelName>] extends [never] ? Present<InlineIdName<Definition, ModelName>> : AttributeIdName<Definition, ModelName>;
+type StorageColumn<CodecId extends string, Nullable extends boolean, TypeParams extends Record<string, unknown> | undefined = undefined, Many extends false | {
+  readonly elementNullable: boolean;
+} = false, HasDefault extends boolean = false> = {
+  readonly dataType: string;
+  readonly codecId: CodecId;
+  readonly nullable: Nullable;
+} & (HasDefault extends true ? {
+  readonly default: ColumnDefault;
+} : Record<never, never>) & (TypeParams extends Record<string, unknown> ? {
+  readonly typeParams: TypeParams;
+} : Record<never, never>) & {
+  readonly many: Many;
+};
+type ModelStorageColumn<Definition, ModelName extends ModelNames<Definition>, FieldName extends string> = FieldName extends ModelFieldNames<Definition, ModelName> ? StorageColumn<DescriptorCodecId<ResolveFieldDescriptor<ModelFieldState<Definition, ModelName, FieldName>>>, FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>>, ResolveFieldColumnTypeParams<ModelFieldState<Definition, ModelName, FieldName>>, FieldManyOf<ModelFieldState<Definition, ModelName, FieldName>>, FieldHasColumnDefault<ModelFieldState<Definition, ModelName, FieldName>>> : never;
+type StagedRelationState<Definition, ModelName extends ModelNames<Definition>, RelName extends StagedModelRelationNames<Definition, ModelName>> = StagedModelRelations<Definition, ModelName>[RelName] extends {
+  readonly __state: infer State;
+} ? State : never;
+type RelationSourceModelName<Source> = Source extends {
+  readonly modelName: infer Name extends string;
+} ? Name : Source extends {
+  readonly resolve: () => infer Name extends string;
+} ? Name : never;
+type RelationFieldTuple<Fields> = Fields extends readonly string[] ? Fields : readonly [Extract<Fields, string>];
+type RelationFieldUnion<Fields> = Fields extends readonly (infer FieldName)[] ? FieldName : Fields;
+type ModelAnchorFieldNames<Definition, ModelName extends ModelNames<Definition>> = ModelIdFieldNames<Definition, ModelName> extends (infer IdFields extends readonly string[]) ? IdFields : readonly ['id'];
+type AnyFieldNullable<Definition, ModelName extends ModelNames<Definition>, Fields> = true extends (RelationFieldUnion<Fields> extends (infer FieldName) ? FieldName extends ModelFieldNames<Definition, ModelName> ? FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>> : boolean : never) ? true : false;
+type BelongsToNullable<Definition, ModelName extends ModelNames<Definition>, State> = AnyFieldNullable<Definition, ModelName, State extends {
+  readonly from: infer From;
+} ? From : never>;
+type BuiltRelationTarget<Definition, Target extends ModelNames<Definition>> = {
+  readonly namespace: ModelNamespace<Definition, Target> & NamespaceId;
+  readonly model: Target;
+};
+type JunctionTargetColumns<Definition, Target extends ModelNames<Definition>> = ModelIdFieldNames<Definition, Target> extends (infer IdFields extends readonly string[]) ? FieldNamesToColumnNames<Definition, Target, IdFields> : BuiltUnique<Definition, Target>['columns'];
+type BuiltManyToManyRelation<Definition, ModelName extends ModelNames<Definition>, Target extends ModelNames<Definition>, State> = State extends {
+  readonly through: infer ThroughSource;
+  readonly from: infer From;
+  readonly to: infer To;
+} ? RelationSourceModelName<ThroughSource> extends (infer Through extends ModelNames<Definition>) ? {
+  readonly to: BuiltRelationTarget<Definition, Target>;
+  readonly cardinality: 'N:M';
+  readonly on: {
+    readonly localFields: ModelAnchorFieldNames<Definition, ModelName>;
+    readonly targetFields: FieldNamesToColumnNames<Definition, Through, RelationFieldTuple<From>>;
+  };
+  readonly through: {
+    readonly table: ModelTableName<Definition, Through>;
+    readonly namespaceId: ModelNamespace<Definition, Through>;
+    readonly parentColumns: FieldNamesToColumnNames<Definition, Through, RelationFieldTuple<From>>;
+    readonly childColumns: FieldNamesToColumnNames<Definition, Through, RelationFieldTuple<To>>;
+    readonly targetColumns: JunctionTargetColumns<Definition, Target>;
+  };
+} : ContractRelation : ContractRelation;
+type BuiltSameSpaceRelationByKind<Definition, ModelName extends ModelNames<Definition>, Target extends ModelNames<Definition>, State> = State extends {
+  readonly kind: 'belongsTo';
+  readonly from: infer From;
+  readonly to: infer To;
+} ? {
+  readonly to: BuiltRelationTarget<Definition, Target>;
+  readonly cardinality: 'N:1';
+  readonly nullable: BelongsToNullable<Definition, ModelName, State>;
+  readonly on: {
+    readonly localFields: RelationFieldTuple<From>;
+    readonly targetFields: RelationFieldTuple<To>;
+  };
+} : State extends {
+  readonly kind: 'hasMany';
+  readonly by: infer By;
+} ? {
+  readonly to: BuiltRelationTarget<Definition, Target>;
+  readonly cardinality: '1:N';
+  readonly on: {
+    readonly localFields: ModelAnchorFieldNames<Definition, ModelName>;
+    readonly targetFields: RelationFieldTuple<By>;
+  };
+} : State extends {
+  readonly kind: 'hasOne';
+  readonly by: infer By;
+} ? {
+  readonly to: BuiltRelationTarget<Definition, Target>;
+  readonly cardinality: '1:1';
+  readonly nullable: true;
+  readonly on: {
+    readonly localFields: ModelAnchorFieldNames<Definition, ModelName>;
+    readonly targetFields: RelationFieldTuple<By>;
+  };
+} : State extends {
+  readonly kind: 'manyToMany';
+} ? BuiltManyToManyRelation<Definition, ModelName, Target, State> : ContractRelation;
+type IsOtherSpaceTarget<State> = State extends {
+  readonly __targetSpaceId?: infer SpaceId;
+} ? [Present<SpaceId>] extends ['<self>'] ? false : true : false;
+type BuiltRelation<Definition, ModelName extends ModelNames<Definition>, State> = IsOtherSpaceTarget<State> extends true ? ContractRelation : BuiltSameSpaceRelation<Definition, ModelName, State>;
+type BuiltSameSpaceRelation<Definition, ModelName extends ModelNames<Definition>, State> = State extends {
+  readonly toModel: infer Source;
+} ? RelationSourceModelName<Source> extends (infer Target extends ModelNames<Definition>) ? BuiltSameSpaceRelationByKind<Definition, ModelName, Target, State> : ContractRelation : ContractRelation;
+type ExecutionDefaultEntries<Definition> = { [ModelName in ModelNames<Definition>]: { [FieldName in ModelFieldNames<Definition, ModelName>]: true extends FieldGeneratesIn<ModelFieldState<Definition, ModelName, FieldName>, 'onCreate'> | FieldGeneratesIn<ModelFieldState<Definition, ModelName, FieldName>, 'onUpdate'> ? ContractExecutionSection['mutations']['defaults'][number] & GeneratedPhaseKeys<ModelFieldState<Definition, ModelName, FieldName>> & {
+  readonly ref: {
+    readonly namespace: ModelNamespace<Definition, ModelName>;
+    readonly entry: ModelTableName<Definition, ModelName>;
+    readonly field: ModelColumnName<Definition, ModelName, FieldName>;
+  };
+} : never; }[ModelFieldNames<Definition, ModelName>]; }[ModelNames<Definition>];
+type BuiltExecution<Definition> = [ExecutionDefaultEntries<Definition>] extends [never] ? {
+  readonly execution?: ContractExecutionSection;
+} : {
+  readonly execution: ContractExecutionSection & {
+    readonly mutations: {
+      readonly defaults: ReadonlyArray<ExecutionDefaultEntries<Definition>>;
+    };
+  };
+};
+type DomainFieldTypeParams<TypeParams> = TypeParams extends Record<string, unknown> ? keyof TypeParams extends never ? Record<never, never> : {
+  readonly typeParams: TypeParams;
+} : Record<never, never>;
+type DomainFieldMany<Many> = Many extends false ? Record<never, never> : {
+  readonly many: Many;
+};
+type BuiltModels<Definition> = { readonly [ModelName in ModelNames<Definition>]: {
+  readonly storage: {
+    readonly table: ModelTableName<Definition, ModelName>;
+    readonly namespaceId: ModelNamespace<Definition, ModelName>;
+    readonly fields: { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: {
+      readonly column: ModelColumnName<Definition, ModelName, FieldName>;
+    }; };
+  };
+  readonly fields: { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: {
+    readonly nullable: ModelStorageColumn<Definition, ModelName, FieldName>['nullable'];
+    readonly type: {
+      readonly kind: 'scalar';
+      readonly codecId: ModelStorageColumn<Definition, ModelName, FieldName>['codecId'];
+    } & DomainFieldTypeParams<FieldColumnTypeParams<ModelFieldState<Definition, ModelName, FieldName>>>;
+  } & DomainFieldMany<FieldManyOf<ModelFieldState<Definition, ModelName, FieldName>>>; };
+  readonly relations: { readonly [RelName in StagedModelRelationNames<Definition, ModelName>]: BuiltRelation<Definition, ModelName, StagedRelationState<Definition, ModelName, RelName>>; };
+}; };
+type BuiltModelColumnMappings<Definition, ModelName extends ModelNames<Definition>> = BuiltModels<Definition>[ModelName]['storage']['fields'];
+type BuiltModelTableName<Definition, ModelName extends ModelNames<Definition>> = BuiltModels<Definition>[ModelName]['storage']['table'];
+type BuiltStorageTableColumns<Definition, ModelName extends ModelNames<Definition>> = { readonly [FieldName in keyof BuiltModelColumnMappings<Definition, ModelName> & string as BuiltModelColumnMappings<Definition, ModelName>[FieldName]['column']]: ModelStorageColumn<Definition, ModelName, FieldName>; };
+type FieldUniqueSpecOf<FieldState> = FieldState extends {
+  readonly unique: infer UniqueSpec;
+} ? [UniqueSpec] extends [{
+  readonly name?: infer Name;
+}] ? {
+  readonly name: Name;
+} : never : never;
+type UniqueName$1<Name> = Present<Name> extends (infer Defined extends string) ? Defined : never;
+type InlineUnique<Definition, ModelName extends ModelNames<Definition>> = { [FieldName in ModelFieldNames<Definition, ModelName>]: FieldUniqueSpecOf<ModelFieldState<Definition, ModelName, FieldName>> extends (infer Spec) ? [Spec] extends [never] ? never : Spec extends {
+  readonly name: infer Name;
+} ? {
+  readonly columns: readonly [ModelColumnName<Definition, ModelName, FieldName>];
+  readonly name?: UniqueName$1<Name>;
+} : never : never; }[ModelFieldNames<Definition, ModelName>];
+type AttributeUnique<Definition, ModelName extends ModelNames<Definition>> = ModelAttributes<Definition, ModelName> extends {
+  readonly uniques?: infer Uniques extends readonly unknown[];
+} ? Uniques[number] extends (infer Unique) ? Unique extends {
+  readonly fields: infer Fields extends readonly string[];
+} ? number extends Fields['length'] ? never : {
+  readonly columns: FieldNamesToColumnNames<Definition, ModelName, Fields>;
+  readonly name?: Unique extends {
+    readonly name?: infer Name;
+  } ? UniqueName$1<Name> : never;
+} : never : never : never;
+type BuiltUnique<Definition, ModelName extends ModelNames<Definition>> = InlineUnique<Definition, ModelName> | AttributeUnique<Definition, ModelName>;
+type JoinColumns<Columns> = Columns extends readonly [infer Only extends string] ? Only : Columns extends readonly [infer First extends string, ...infer Rest] ? `${First}_${JoinColumns<Rest>}` : string;
+type SameColumns<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+type ModelColumnOf<Definition, ModelName extends ModelNames<Definition>> = { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: ModelColumnName<Definition, ModelName, FieldName>; };
+type DeclaredIndexConstraints<Definition, ModelName extends ModelNames<Definition>> = ModelSql<Definition, ModelName> extends {
+  readonly indexes?: infer Indexes extends readonly unknown[];
+} ? Indexes : readonly [];
+type IndexColumns<Definition, ModelName extends ModelNames<Definition>, Constraint> = [Constraint] extends [{
+  readonly fields?: infer Fields;
+}] ? Present<Fields> extends (infer Defined extends readonly string[]) ? [Defined] extends [never] ? readonly [] : number extends Defined['length'] ? readonly string[] : FieldNamesToColumnNames<Definition, ModelName, Defined> : readonly [] : readonly [];
+type IndexSpecOfConstraint<Constraint> = [Constraint] extends [{
+  readonly __spec?: infer Spec;
+}] ? Present<Spec> : never;
+type IndexMapOf<Constraint> = IndexSpecOfConstraint<Constraint> extends {
+  readonly map: infer Map extends string;
+} ? Map : never;
+type IndexNameOf<Constraint> = [Constraint] extends [{
+  readonly name?: infer Name;
+}] ? Present<Name> extends (infer Defined extends string) ? Defined : never : never;
+type IndexNaming<Definition, ModelName extends ModelNames<Definition>, Constraint> = [IndexMapOf<Constraint>] extends [never] ? {
+  readonly name: string;
+  readonly prefix: [IndexNameOf<Constraint>] extends [never] ? `${ModelTableName<Definition, ModelName>}_${JoinColumns<IndexColumns<Definition, ModelName, Constraint>>}_idx` : IndexNameOf<Constraint>;
+} : {
+  readonly name: IndexMapOf<Constraint>;
+};
+type IndexMethod<Definition, ModelName extends ModelNames<Definition>, Constraint> = [IndexSpecOfConstraint<Constraint>] extends [never] ? Record<never, never> : IndexMethodOfSpec<Definition, ModelName, IndexSpecOfConstraint<Constraint>>;
+type IndexMethodOfSpec<Definition, ModelName extends ModelNames<Definition>, Spec> = (Spec extends {
+  readonly type: infer Type extends string;
+} ? {
+  readonly type: Type;
+} : Record<never, never>) & (Spec extends {
+  readonly options: infer Options;
+} ? [Options] extends [undefined] ? Record<never, never> : {
+  readonly options: Options extends IndexOptionsFunction ? (Options & {
+    readonly columnOf: ModelColumnOf<Definition, ModelName>;
+  })['options'] : Options;
+} : Record<never, never>);
+type BuiltDeclaredIndexOf<Definition, ModelName extends ModelNames<Definition>, Constraint> = IndexNaming<Definition, ModelName, Constraint> & {
+  readonly columns: IndexColumns<Definition, ModelName, Constraint>;
+  readonly unique: boolean;
+} & IndexMethod<Definition, ModelName, Constraint>;
+type BuiltDeclaredIndexesOf<Definition, ModelName extends ModelNames<Definition>, Constraints extends readonly unknown[]> = { readonly [K in keyof Constraints]: BuiltDeclaredIndexOf<Definition, ModelName, Constraints[K]>; }[number];
+type BuiltDeclaredIndex<Definition, ModelName extends ModelNames<Definition>> = BuiltDeclaredIndexesOf<Definition, ModelName, DeclaredIndexConstraints<Definition, ModelName>>;
+type DefaultForeignKeyIndex<Definition> = Definition extends {
+  readonly foreignKeyDefaults?: infer Defaults;
+} ? [Present<Defaults>] extends [never] ? true : Present<Defaults> extends {
+  readonly index: false;
+} ? false : true : true;
+type DerivesBackingIndex<Definition, Intent> = [Present<Intent>] extends [never] ? DefaultForeignKeyIndex<Definition> : Present<Intent> extends false ? false : Present<Intent> extends true ? true : Present<Intent> extends string ? string extends Present<Intent> ? DefaultForeignKeyIndex<Definition> : false : DefaultForeignKeyIndex<Definition>;
+type RelationForeignKey<RelationSql> = [Present<RelationSql>] extends [never] ? never : Present<RelationSql> extends {
+  readonly fk?: infer ForeignKey;
+} ? Present<ForeignKey> : never;
+type ModelForeignKeyFields<Definition, ModelName extends ModelNames<Definition>> = (ModelSql<Definition, ModelName> extends {
+  readonly foreignKeys?: infer ForeignKeys extends readonly unknown[];
+} ? ForeignKeys[number] extends (infer ForeignKey) ? ForeignKey extends {
+  readonly fields: infer Fields extends readonly string[];
+} ? DerivesBackingIndex<Definition, ForeignKey extends {
+  readonly index?: infer Intent;
+} ? Intent : undefined> extends true ? Fields : never : never : never : never) | { [RelName in StagedModelRelationNames<Definition, ModelName>]: StagedRelationState<Definition, ModelName, RelName> extends {
+  readonly kind: 'belongsTo';
+  readonly from: infer From;
+  readonly sql?: infer RelationSql;
+} ? RelationForeignKey<RelationSql> extends (infer ForeignKey) ? [ForeignKey] extends [never] ? never : DerivesBackingIndex<Definition, ForeignKey extends {
+  readonly index?: infer Intent;
+} ? Intent : undefined> extends true ? RelationFieldTuple<From> : never : never : never; }[StagedModelRelationNames<Definition, ModelName>];
+type BackingIndexIsRedundant<Definition, ModelName extends ModelNames<Definition>, Columns> = true extends SameColumns<Columns, ModelIdFieldNames<Definition, ModelName> extends (infer IdFields extends readonly string[]) ? FieldNamesToColumnNames<Definition, ModelName, IdFields> : never> | (BuiltUnique<Definition, ModelName> extends (infer Unique) ? Unique extends {
+  readonly columns: infer UniqueColumns;
+} ? SameColumns<Columns, UniqueColumns> : never : never) | (PlainDeclaredIndexColumns<Definition, ModelName> extends (infer DeclaredColumns) ? DeclaredColumns extends unknown ? SameColumns<Columns, DeclaredColumns> : never : never) ? true : false;
+type PlainDeclaredIndexColumnsOf<Definition, ModelName extends ModelNames<Definition>, Constraints extends readonly unknown[]> = { readonly [K in keyof Constraints]: IndexSpecOfConstraint<Constraints[K]> extends {
+  readonly type: undefined;
+  readonly options: undefined;
+  readonly partial: false;
+} ? IndexColumns<Definition, ModelName, Constraints[K]> : never; }[number];
+type PlainDeclaredIndexColumns<Definition, ModelName extends ModelNames<Definition>> = PlainDeclaredIndexColumnsOf<Definition, ModelName, DeclaredIndexConstraints<Definition, ModelName>>;
+type AsciiCharacter = ' ' | '!' | '"' | '#' | '$' | '%' | '&' | "'" | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[' | '\\' | ']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~';
+/**
+ * A derived wire-name prefix as the build shortens it: to its first 54 bytes (`WIRE_NAME_PREFIX_MAX_BYTES`). Each ASCII character is one byte. A name with another character before the cut has a byte length the type does not count, so it gives `never` and the index has no name in the type.
+ */
+type DerivedWireNamePrefix<Name extends string, Kept extends string = '', Bytes extends readonly unknown[] = []> = string extends Name ? string : Bytes['length'] extends 54 ? Kept : Name extends `${infer Character}${infer Rest}` ? Character extends AsciiCharacter ? DerivedWireNamePrefix<Rest, `${Kept}${Character}`, [...Bytes, unknown]> : never : Kept;
+type BuiltBackingIndex<Definition, ModelName extends ModelNames<Definition>> = ModelForeignKeyFields<Definition, ModelName> extends (infer Fields) ? Fields extends readonly string[] ? FieldNamesToColumnNames<Definition, ModelName, Fields> extends (infer Columns) ? BackingIndexIsRedundant<Definition, ModelName, Columns> extends true ? never : {
+  readonly name: string;
+  readonly prefix: DerivedWireNamePrefix<`${ModelTableName<Definition, ModelName>}_${JoinColumns<Columns>}_idx`>;
+  readonly columns: Columns;
+  readonly unique: false;
+} : never : never : never;
+type BuiltIndex<Definition, ModelName extends ModelNames<Definition>> = BuiltDeclaredIndex<Definition, ModelName> | BuiltBackingIndex<Definition, ModelName>;
+type BuiltStorageTables<Definition, Ns extends string> = { readonly [ModelName in ModelsInNamespace<Definition, Ns> as BuiltModelTableName<Definition, ModelName>]: {
+  readonly columns: BuiltStorageTableColumns<Definition, ModelName>;
+  readonly uniques: ReadonlyArray<BuiltUnique<Definition, ModelName>>;
+  readonly indexes: ReadonlyArray<BuiltIndex<Definition, ModelName>>;
+  readonly foreignKeys: ReadonlyArray<{
+    readonly source: {
+      readonly namespaceId: NamespaceId;
+      readonly tableName: string;
+      readonly columns: readonly string[];
+    };
+    readonly target: {
+      readonly namespaceId: NamespaceId;
+      readonly spaceId?: string;
+      readonly tableName: string;
+      readonly columns: readonly string[];
+    };
+    readonly name?: string;
+    readonly onDelete?: ReferentialAction;
+    readonly onUpdate?: ReferentialAction;
+    readonly index?: ForeignKeyIndex;
+  }>;
+} & (ModelIdFieldNames<Definition, ModelName> extends readonly string[] ? {
+  readonly primaryKey: {
+    readonly columns: FieldNamesToColumnNames<Definition, ModelName, ModelIdFieldNames<Definition, ModelName>>;
+    readonly name?: ModelIdName<Definition, ModelName>;
+  };
+} : Record<never, never>); };
+type DefinitionEnums<Definition> = Definition extends {
+  readonly enums?: infer E;
+} ? Present<E> extends Record<string, EnumTypeHandle> ? string extends keyof Present<E> ? Record<never, never> : Present<E> : Record<never, never> : Record<never, never>;
+type BuiltDocumentScopedTypes<Definition> = { readonly [K in keyof DefinitionTypes<Definition> as DefinitionTypes<Definition>[K] extends AuthoredStorageTypeInstance ? K : never]: DefinitionTypes<Definition>[K] & {
+  readonly dataType: string;
+}; };
+type BuiltDomain<Definition> = BuiltDocumentScopedTypes<Definition> extends Record<never, never> ? Record<never, never> : {
+  readonly __unbound__: {
+    readonly types: BuiltDocumentScopedTypes<Definition>;
+  };
+};
+type HandleName<Handle> = Handle extends EnumTypeHandle<infer Name> ? Name : never;
+type StoredEnumValue<Value> = Value extends JsonValue ? Value : JsonValue;
+type EnumHandleMembers<Handle, Stored extends boolean> = Handle extends EnumTypeHandle<string, infer Values, infer Names> ? { readonly [I in keyof Values]: {
+  readonly name: I extends keyof Names ? Names[I] : never;
+  readonly value: Stored extends true ? StoredEnumValue<Values[I]> : Values[I];
+}; } : never;
+type EnumHandleEntries<Enums> = { readonly [K in keyof Enums as HandleName<Enums[K]>]: {
+  readonly codecId: Enums[K] extends {
+    readonly codecId: infer CodecId;
+  } ? CodecId : string;
+  readonly members: EnumHandleMembers<Enums[K], true>;
+}; };
+type EnumHandleMemberTypes<Enums, CodecTypes> = { readonly [K in keyof Enums as HandleName<Enums[K]>]: Enums[K] extends EnumTypeHandle<string, infer Values, infer Names, Record<string, unknown>, infer CodecId> ? { readonly [I in keyof Values]: {
+  readonly name: I extends keyof Names ? Names[I] : never;
+  readonly value: EnumMemberValueType<CodecTypes, CodecId, Values[I]>;
+}; } : never; };
+type EnumHandleValueSets<Enums> = { readonly [K in keyof Enums as HandleName<Enums[K]>]: {
+  readonly kind: 'valueSet';
+  readonly values: Enums[K] extends EnumTypeHandle<string, infer Values> ? { readonly [I in keyof Values]: StoredEnumValue<Values[I]>; } : never;
+}; };
+type DefinitionHasEnums<Definition> = keyof DefinitionEnums<Definition> extends never ? false : true;
+type HoldsDefinitionEnums<Definition, Ns extends string> = DefinitionHasEnums<Definition> extends true ? Ns extends DefaultStorageNamespaceId<Definition> ? true : false : false;
+type BuiltDomainNamespace<Definition, Ns extends string> = {
+  readonly models: { readonly [ModelName in ModelsInNamespace<Definition, Ns>]: BuiltModels<Definition>[ModelName]; };
+} & (HoldsDefinitionEnums<Definition, Ns> extends true ? {
+  readonly enum: EnumHandleEntries<DefinitionEnums<Definition>>;
+  readonly enumMemberTypes?: EnumHandleMemberTypes<DefinitionEnums<Definition>, CodecTypesFromDefinition<Definition>>;
+} : Record<never, never>);
+type DefaultStorageNamespaceId<Definition> = DefinitionTarget<Definition> extends {
+  readonly defaultNamespaceId: infer Id extends string;
+} ? Id : never;
+type ModelNamespaceOf<Definition, Namespace> = [Namespace] extends [undefined] ? DefaultStorageNamespaceId<Definition> : Namespace extends '' | undefined ? DefaultStorageNamespaceId<Definition> : Namespace;
+type ModelNamespace<Definition, ModelName extends ModelNames<Definition>> = DefinitionModels<Definition>[ModelName] extends {
+  readonly __namespace: infer Namespace extends string | undefined;
+} ? ModelNamespaceOf<Definition, Namespace> : DefaultStorageNamespaceId<Definition>;
+type ModelNamespaces<Definition> = { [ModelName in ModelNames<Definition>]: ModelNamespace<Definition, ModelName>; }[ModelNames<Definition>] & string;
+type ModelsInNamespace<Definition, Ns extends string> = string extends ModelNamespaces<Definition> ? ModelNames<Definition> : { [ModelName in ModelNames<Definition>]: Ns extends ModelNamespace<Definition, ModelName> ? ModelName : never; }[ModelNames<Definition>];
+type DomainNamespaceIds<Definition> = (ModelNamespaces<Definition> | ([ModelNames<Definition>] extends [never] ? DefaultStorageNamespaceId<Definition> : never) | (keyof DefinitionEnums<Definition> extends never ? never : DefaultStorageNamespaceId<Definition>)) & string;
+type StorageNamespaceIds<Definition> = (DefaultStorageNamespaceId<Definition> | DefinitionNamespaces<Definition> | ModelNamespaces<Definition>) & string;
+type BuiltStorage<Definition> = {
+  readonly storageHash: StorageHashBase<string>;
+  readonly types?: BuiltDocumentScopedTypes<Definition>;
+  readonly namespaces: { readonly [Ns in StorageNamespaceIds<Definition>]: {
+    readonly id: Ns;
+    readonly kind: string;
+    readonly entries: {
+      readonly table: BuiltStorageTables<Definition, Ns>;
+    } & (HoldsDefinitionEnums<Definition, Ns> extends true ? {
+      readonly valueSet: EnumHandleValueSets<DefinitionEnums<Definition>>;
+    } : Record<never, never>);
+  }; };
+};
+type EnumValueUnion<FieldState> = [FieldEnumHandleOf<FieldState>] extends [EnumTypeHandle<string, infer Values>] ? readonly unknown[] extends Values ? never : Values[number] : never;
+type DescriptorEntityMembers<Descriptor> = Descriptor extends {
+  readonly entityRef: {
+    readonly entity: {
+      readonly members: infer Members extends readonly string[];
+    };
+  };
+} ? Members : never;
+type DescriptorValueSetUnion<FieldState> = [FieldDescriptorOf<FieldState>] extends [never] ? never : readonly string[] extends DescriptorEntityMembers<FieldDescriptorOf<FieldState>> ? never : DescriptorEntityMembers<FieldDescriptorOf<FieldState>>[number];
+type FieldColumnTypeParams<FieldState> = DescriptorTypeParams<FieldDescriptorOf<FieldState>>;
+type ParameterizedOutputTypesFromDefinition<Definition> = { [K in keyof AllPacks<Definition>]: ExtractParameterizedOutputTypesFromPack<AllPacks<Definition>[K]>; }[keyof AllPacks<Definition>];
+type ColumnSpecCodecOutput<Descriptor> = Descriptor extends {
+  readonly codecFactory: (...args: never[]) => infer Codec;
+} ? Codec extends {
+  fromWire(...args: never[]): Promise<infer Output>;
+} ? Output : never : never;
+type FieldValueUnion<FieldState> = [EnumValueUnion<FieldState>] extends [never] ? DescriptorValueSetUnion<FieldState> : EnumValueUnion<FieldState>;
+type FieldTypeOverride<Definition, ModelName extends ModelNames<Definition>, FieldName extends ModelFieldNames<Definition, ModelName>> = ModelFieldState<Definition, ModelName, FieldName> extends (infer FieldState) ? [FieldValueUnion<FieldState>] extends [never] ? [ColumnSpecCodecOutput<FieldDescriptorOf<FieldState>>] extends [never] ? never : {
+  readonly output: ColumnSpecCodecOutput<FieldDescriptorOf<FieldState>>;
+} : {
+  readonly output: FieldValueUnion<FieldState>;
+  readonly input: FieldValueUnion<FieldState>;
+} : never;
+type FieldTypeOverrides<Definition> = { readonly [Ns in DomainNamespaceIds<Definition>]: {
+  readonly models: { readonly [ModelName in ModelsInNamespace<Definition, Ns>]: { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldTypeOverride<Definition, ModelName, FieldName>; }; };
+}; };
+type ColumnTypeOverrides<Definition> = { readonly [Ns in StorageNamespaceIds<Definition>]: { readonly [ModelName in ModelsInNamespace<Definition, Ns> as BuiltModelTableName<Definition, ModelName>]: { readonly [FieldName in ModelFieldNames<Definition, ModelName> as BuiltModelColumnMappings<Definition, ModelName>[FieldName]['column']]: FieldTypeOverride<Definition, ModelName, FieldName>; }; }; };
+type ResolvedTypeMap<Map> = { readonly [Ns in keyof Map]: { readonly [Entity in keyof Map[Ns]]: string extends keyof Map[Ns][Entity] ? Map[Ns][Entity] : { readonly [Name in keyof Map[Ns][Entity]]: Map[Ns][Entity][Name]; }; }; };
+type BuiltDomainNamespaces<Definition> = { readonly [Ns in DomainNamespaceIds<Definition>]: BuiltDomainNamespace<Definition, Ns>; };
+type SqlContractResult<Definition> = ContractWithTypeMaps<Omit<Contract<BuiltStorage<Definition>>, 'domain' | 'execution'> & BuiltExecution<Definition> & {
+  readonly target: DefinitionTargetId<Definition>;
+  readonly targetFamily: 'sql';
+} & {
+  readonly domain: {
+    readonly namespaces: BuiltDomainNamespaces<Definition>;
+  } & BuiltDomain<Definition>;
+} & {
+  readonly extensions: DefinitionExtensions<Definition>;
+  readonly capabilities: DerivedCapabilities<Definition>;
+}, {
+  readonly codecTypes: CodecTypesFromDefinition<Definition>;
+  readonly queryOperationTypes: QueryOperationTypesFromDefinition<Definition>;
+  readonly fieldOutputTypes: ResolvedTypeMap<FieldTypesFromDomain<BuiltDomainNamespaces<Definition>, CodecTypesFromDefinition<Definition>, ParameterizedOutputTypesFromDefinition<Definition>, FieldTypeOverrides<Definition>, 'output'>>;
+  readonly fieldInputTypes: ResolvedTypeMap<FieldTypesFromDomain<BuiltDomainNamespaces<Definition>, CodecTypesFromDefinition<Definition>, ParameterizedOutputTypesFromDefinition<Definition>, FieldTypeOverrides<Definition>, 'input'>>;
+  readonly storageColumnTypes: ResolvedTypeMap<ColumnTypesFromStorage<BuiltStorage<Definition>, CodecTypesFromDefinition<Definition>, ParameterizedOutputTypesFromDefinition<Definition>, ColumnTypeOverrides<Definition>, 'output'>>;
+  readonly storageColumnInputTypes: ResolvedTypeMap<ColumnTypesFromStorage<BuiltStorage<Definition>, CodecTypesFromDefinition<Definition>, ParameterizedOutputTypesFromDefinition<Definition>, ColumnTypeOverrides<Definition>, 'input'>>;
+  readonly aggregateTypes: AggregateTypesFromDefinition<Definition>;
+}>;
+//#endregion
+//#region src/composed-authoring-helpers.d.ts
+type ExtractTypeNamespaceFromPack<Pack> = ExtractAuthoringNamespaceFromPack<Pack, 'type', Record<never, never>>;
+type ExtractFieldNamespaceFromPack<Pack> = ExtractAuthoringNamespaceFromPack<Pack, 'field', Record<never, never>>;
+type ExtractEntitiesNamespaceFromPack<Pack> = ExtractAuthoringNamespaceFromPack<Pack, 'entityTypes', Record<never, never>>;
+type MergeExtensionTypeNamespaces<Extensions> = MergeExtensionAuthoringNamespaces<Extensions, 'type'>;
+type MergeExtensionFieldNamespaces<Extensions> = MergeExtensionAuthoringNamespaces<Extensions, 'field'>;
+type MergeExtensionEntityNamespaces<Extensions> = MergeExtensionAuthoringNamespaces<Extensions, 'entityTypes'>;
+type StorageTypeFromDescriptor<Descriptor extends AuthoringTypeConstructorDescriptor, Args extends readonly unknown[]> = {
+  readonly kind: 'codec-instance';
+  readonly codecId: ResolveTemplateValue<Descriptor['output']['codecId'], Args>;
+} & (Descriptor['output'] extends {
+  readonly typeParams: infer TypeParams extends Record<string, unknown>;
+} ? {
+  readonly typeParams: ResolveTemplateValue<TypeParams, Args>;
+} : {
+  readonly typeParams: Record<never, never>;
+});
+type TypeHelperFunction<Descriptor extends AuthoringTypeConstructorDescriptor, ValueTypes extends DataTypeArgumentTypes> = Descriptor extends {
+  readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
+} ? <const Params extends TupleFromArgumentDescriptors<Args, ValueTypes>>(...args: Params) => StorageTypeFromDescriptor<Descriptor, CanonicalArguments<Args, Params, ValueTypes>> : () => StorageTypeFromDescriptor<Descriptor, readonly []>;
+type AliasGeneratorCalls<Output> = (Output extends {
+  readonly onCreate: GeneratorFunctionCall;
+} ? {
+  readonly onCreate: GeneratorFunctionCall;
+} : unknown) & (Output extends {
+  readonly onUpdate: GeneratorFunctionCall;
+} ? {
+  readonly onUpdate: GeneratorFunctionCall;
+} : unknown);
+type TypeAliasHelperFunction<Descriptor extends AuthoringTypeAliasDescriptor> = () => {
+  readonly kind: 'codec-instance';
+  readonly codecId: Descriptor['output']['type']['codecId'];
+  readonly typeParams: Descriptor['output']['type'] extends {
+    readonly typeParams: infer TypeParams extends Record<string, unknown>;
+  } ? TypeParams : Record<never, never>;
+} & (Descriptor['output'] extends {
+  readonly onCreate: GeneratorFunctionCall;
+} | {
+  readonly onUpdate: GeneratorFunctionCall;
+} ? {
+  readonly generatorCalls: AliasGeneratorCalls<Descriptor['output']>;
+} : unknown);
+type TypeHelpersFromNamespace<Namespace, ValueTypes extends DataTypeArgumentTypes> = { readonly [K in keyof Namespace]: Namespace[K] extends AuthoringTypeConstructorDescriptor ? TypeHelperFunction<Namespace[K], ValueTypes> : Namespace[K] extends AuthoringTypeAliasDescriptor ? TypeAliasHelperFunction<Namespace[K]> : Namespace[K] extends Record<string, unknown> ? TypeHelpersFromNamespace<Namespace[K], ValueTypes> : never; };
+type MergeExtensionDataTypeArgumentTypes<Extensions> = Extensions extends Record<string, unknown> ? keyof Extensions extends never ? Record<never, never> : UnionToIntersection<{ [K in keyof Extensions]: ExtractDataTypeArgumentTypesFromPack<Extensions[K]>; }[keyof Extensions]> : Record<never, never>;
+type DataTypeArgumentTypesOfPacks<Family, Target, Extensions> = ExtractDataTypeArgumentTypesFromPack<Family> & ExtractDataTypeArgumentTypesFromPack<Target> & MergeExtensionDataTypeArgumentTypes<Extensions>;
+type FieldHelpersForCodecs<CodecTypes extends CodecTypeMap> = Pick<typeof field, 'generated'> & {
+  readonly column: ColumnFieldHelper<CodecTypes>;
+  readonly namedType: NamedTypeFieldHelper;
+};
+type CodecTypesOfPacks<Family, Target, Extensions> = ExtractCodecTypesFromPack<Family> & ExtractCodecTypesFromPack<Target> & MergeExtensionCodecTypesSafe<Extensions>;
+type MergeAllPackIndexTypes<Family, Target, Extensions> = MergeExtensionIndexTypes<{
+  readonly __family: Family;
+  readonly __target: Target;
+} & (Extensions extends Record<string, unknown> ? Extensions : Record<never, never>)>;
+type PackAwareModel<IndexTypes extends IndexTypeMap> = {
+  <const ModelName extends string, Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>, const Namespace extends string | undefined = undefined>(modelName: ModelName, input: {
+    readonly fields: Fields;
+    readonly relations?: Relations;
+    readonly namespace?: Namespace;
+  }): ContractModelBuilder<ModelName, Fields, Relations, undefined, undefined, IndexTypes, '<self>', NoInfer<Namespace>>;
+  <Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>, const Namespace extends string | undefined = undefined>(input: {
+    readonly fields: Fields;
+    readonly relations?: Relations;
+    readonly namespace?: Namespace;
+  }): ContractModelBuilder<undefined, Fields, Relations, undefined, undefined, IndexTypes, '<self>', NoInfer<Namespace>>;
+};
+type ComposedAuthoringHelpers<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined> = EntityHelpersFromNamespace<ExtractEntitiesNamespaceFromPack<Family> & ExtractEntitiesNamespaceFromPack<Target> & MergeExtensionEntityNamespaces<Extensions>> & {
+  readonly field: FieldHelpersForCodecs<CodecTypesOfPacks<Family, Target, Extensions>> & FieldHelpersFromNamespace<ExtractFieldNamespaceFromPack<Family> & ExtractFieldNamespaceFromPack<Target> & MergeExtensionFieldNamespaces<Extensions>, CodecTypesOfPacks<Family, Target, Extensions>, DataTypeArgumentTypesOfPacks<Family, Target, Extensions>>;
+  readonly model: PackAwareModel<MergeAllPackIndexTypes<Family, Target, Extensions>>;
+  readonly rel: typeof rel;
+  readonly type: TypeHelpersFromNamespace<ExtractTypeNamespaceFromPack<Family> & ExtractTypeNamespaceFromPack<Target> & MergeExtensionTypeNamespaces<Extensions>, DataTypeArgumentTypesOfPacks<Family, Target, Extensions>>;
+  readonly gen: GeneratorHelpersOf<Family | Target | ExtensionPackValues<Extensions>>;
+};
+declare function createComposedAuthoringHelpers<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined>(options: {
+  readonly family: Family;
+  readonly target: Target;
+  readonly extensions?: Extensions;
+  readonly codecLookup: CodecLookupWithDescriptors;
+}): ComposedAuthoringHelpers<Family, Target, Extensions>;
+//#endregion
+//#region src/build-contract.d.ts
+declare function buildSqlContractFromDefinition(definition: ContractDefinition, codecLookup: CodecLookupWithDescriptors, dataTypeLookup: DataTypeLookup): Contract<SqlStorage>;
+//#endregion
+//#region src/contract-builder.d.ts
+type ModelLike = {
+  readonly stageOne: {
+    readonly modelName?: string;
+    readonly namespace?: string | undefined;
+    readonly fields: Record<string, ScalarFieldBuilder>;
+    readonly relations: Record<string, RelationBuilder<RelationState>>;
+  };
+  readonly __attributes: ModelAttributesSpec | undefined;
+  readonly __sql: SqlStageSpec | undefined;
+  readonly __duplicateNames: undefined;
+  buildAttributesSpec(): ModelAttributesSpec | undefined;
+  buildSqlSpec(): SqlStageSpec | undefined;
+};
+type ContractDefinition$1<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, DatabaseTypes extends Record<string, AuthoredStorageTypeInstance>, Models extends Record<string, ModelLike>, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Naming extends ContractInput['naming'] | undefined, StorageHash extends string | undefined, ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined, Namespaces extends readonly string[] | undefined = undefined, Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>> = {
+  readonly family: Family;
+  readonly target: Target;
+  readonly extensions?: Extensions;
+  readonly naming?: Naming;
+  readonly storageHash?: StorageHash;
+  readonly foreignKeyDefaults?: ForeignKeyDefaults;
+  readonly defaultControlPolicy?: ControlPolicy;
+  readonly namespaces?: Namespaces;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
+  readonly databaseTypes?: DatabaseTypes;
+  readonly models?: Models;
+  readonly codecLookup: CodecLookupWithDescriptors;
+  readonly dataTypeLookup: DataTypeLookup;
+  readonly enums?: Enums;
+  readonly entities?: readonly PackEntityHandle[];
+};
+type ContractScaffold<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Naming extends ContractInput['naming'] | undefined, StorageHash extends string | undefined, ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined, Namespaces extends readonly string[] | undefined = undefined, Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>> = {
+  readonly family: Family;
+  readonly target: Target;
+  readonly extensions?: Extensions;
+  readonly naming?: Naming;
+  readonly storageHash?: StorageHash;
+  readonly foreignKeyDefaults?: ForeignKeyDefaults;
+  readonly defaultControlPolicy?: ControlPolicy;
+  readonly namespaces?: Namespaces;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
+  readonly databaseTypes?: never;
+  readonly models?: never;
+  readonly codecLookup: CodecLookupWithDescriptors;
+  readonly dataTypeLookup: DataTypeLookup;
+  readonly enums?: Enums;
+  readonly entities?: readonly PackEntityHandle[];
+};
+type ContractFactory<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, DatabaseTypes extends Record<string, AuthoredStorageTypeInstance>, Models extends Record<string, ModelLike>, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>> = (helpers: ComposedAuthoringHelpers<Family, Target, Extensions>) => {
+  readonly databaseTypes?: DatabaseTypes;
+  readonly models?: Models;
+  readonly enums?: Enums;
+  readonly entities?: readonly PackEntityHandle[];
+};
+type BoundDefinitionInput<DatabaseTypes extends Record<string, AuthoredStorageTypeInstance> = Record<never, never>, Models extends Record<string, ModelLike> = Record<never, never>, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, Naming extends ContractInput['naming'] | undefined = undefined, StorageHash extends string | undefined = undefined, ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined, Namespaces extends readonly string[] | undefined = undefined> = {
+  readonly extensions?: Extensions;
+  readonly naming?: Naming;
+  readonly storageHash?: StorageHash;
+  readonly foreignKeyDefaults?: ForeignKeyDefaults;
+  readonly defaultControlPolicy?: ControlPolicy;
+  readonly namespaces?: Namespaces;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
+  readonly databaseTypes?: DatabaseTypes;
+  readonly models?: Models;
+  readonly codecLookup: CodecLookupWithDescriptors;
+  readonly dataTypeLookup: DataTypeLookup;
+  readonly enums?: Record<string, EnumTypeHandle>;
+  readonly entities?: readonly PackEntityHandle[];
+};
+type LiteralEnums<E extends Record<string, EnumTypeHandle>> = string extends keyof E ? Record<never, never> : E;
+type MergeEnums<ScaffoldEnums extends Record<string, EnumTypeHandle>, FactoryEnums extends Record<string, EnumTypeHandle>> = LiteralEnums<ScaffoldEnums> & LiteralEnums<FactoryEnums>;
+type WithFamilyTarget<Input, F extends FamilyPackRef<string>, T extends TargetPackRef<'sql', string>> = Input & {
+  readonly family: F;
+  readonly target: T;
+};
+/**
+ * Shared builder that assembles a SqlContract with pre-bound family and target.
+ * Extension wrappers keep their own public overloads and delegate their impl body here;
+ * this is a plain overloaded function (not a factory returning an overloaded function)
+ * so no overloaded-function-return cast is needed.
+ *
+ * Overload 1: definition form (no factory).
+ */
+declare function buildBoundContract<const F extends FamilyPackRef<string>, const T extends TargetPackRef<'sql', string>, const Definition extends BoundDefinitionInput<Record<string, AuthoredStorageTypeInstance>, Record<string, ModelLike>, Record<string, ExtensionPackRef<'sql', string>> | undefined, ContractInput['naming'] | undefined, string | undefined, ForeignKeyDefaultsState | undefined, readonly string[] | undefined>>(family: F, target: T, definition: Definition, factory?: undefined): SqlContractResult<WithFamilyTarget<Definition, F, T>>;
+/**
+ * Overload 2: factory form.
+ */
+declare function buildBoundContract<const F extends FamilyPackRef<string>, const T extends TargetPackRef<'sql', string>, const Definition extends BoundDefinitionInput<Record<string, AuthoredStorageTypeInstance>, Record<string, ModelLike>, Record<string, ExtensionPackRef<'sql', string>> | undefined, ContractInput['naming'] | undefined, string | undefined, ForeignKeyDefaultsState | undefined, readonly string[] | undefined>, const Built extends {
+  readonly databaseTypes?: Record<string, AuthoredStorageTypeInstance>;
+  readonly models?: Record<string, ModelLike>;
+  readonly enums?: Record<string, EnumTypeHandle>;
+  readonly entities?: readonly PackEntityHandle[];
+}>(family: F, target: T, definition: Definition, factory: (helpers: ComposedAuthoringHelpers<F, T, NonNullable<Definition['extensions']>>) => Built): SqlContractResult<WithFamilyTarget<Definition & Built, F, T>>;
+declare function defineContract<const Family extends FamilyPackRef<string>, const Target extends TargetPackRef<'sql', string>, const DatabaseTypes extends Record<string, AuthoredStorageTypeInstance> = Record<never, never>, const Models extends Record<string, ModelLike> = Record<never, never>, const Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, const Naming extends ContractInput['naming'] | undefined = undefined, const StorageHash extends string | undefined = undefined, const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined, const Namespaces extends readonly string[] | undefined = undefined, const Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>>(definition: ContractDefinition$1<Family, Target, DatabaseTypes, Models, Extensions, Naming, StorageHash, ForeignKeyDefaults, Namespaces, Enums>): SqlContractResult<ContractDefinition$1<Family, Target, DatabaseTypes, Models, Extensions, Naming, StorageHash, ForeignKeyDefaults, Namespaces, Enums>>;
+declare function defineContract<const Family extends FamilyPackRef<string>, const Target extends TargetPackRef<'sql', string>, const DatabaseTypes extends Record<string, AuthoredStorageTypeInstance> = Record<never, never>, const Models extends Record<string, ModelLike> = Record<never, never>, const Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, const Naming extends ContractInput['naming'] | undefined = undefined, const StorageHash extends string | undefined = undefined, const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined, const Namespaces extends readonly string[] | undefined = undefined, const ScaffoldEnums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>, const FactoryEnums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>>(definition: ContractScaffold<Family, Target, Extensions, Naming, StorageHash, ForeignKeyDefaults, Namespaces, ScaffoldEnums>, factory: ContractFactory<Family, Target, DatabaseTypes, Models, Extensions, FactoryEnums>): SqlContractResult<ContractDefinition$1<Family, Target, DatabaseTypes, Models, Extensions, Naming, StorageHash, ForeignKeyDefaults, Namespaces, MergeEnums<ScaffoldEnums, FactoryEnums>>>;
+//#endregion
+//#region src/contract-lowering.d.ts
+/**
+ * `ContractInput`'s `Extensions` parameter defaults to `undefined`, but lowering
+ * reads the extension-pack record at runtime, so the input is widened here.
+ */
+type LoweringInput = Omit<ContractInput, 'extensions'> & {
+  readonly extensions?: Record<string, ExtensionPackRef<'sql', string>> | undefined;
+};
+declare function buildContractDefinition(definition: LoweringInput): ContractDefinition;
+//#endregion
+//#region src/default-functions.d.ts
+/** The database's current time, the same default PSL writes as `@default(now())`. */
+declare function now(): ColumnDefault;
+/** A database-assigned sequence value, the same default PSL writes as `@default(autoincrement())`. */
+declare function autoincrement(): ColumnDefault;
+//#endregion
+export { extensionModel as $, MergeEnums as A, UniqueConstraintNode as B, ForeignKeyTableReference as C, IndexOptionsFunction as D, IndexNode as E, ScalarFieldBuilder as F, bindEnumType as G, ValueObjectMemberNode as H, ScalarMemberNode as I, buildSqlContractFromDefinition as J, buildBoundContract as K, TableNode as L, ModelNode as M, PrimaryKeyNode as N, IndexOptionsInput as O, RelationNode as P, enumType as Q, TableProperties as R, ForeignKeyNode as S, IndexExpressionInput as T, ValueObjectNode as U, ValueObjectFieldNode as V, autoincrement as W, createComposedAuthoringHelpers as X, check as Y, defineContract as Z, EnumMember as _, CheckNode as a, rel as at, FieldNode as b, ColumnNode as c, ContractDefinition as d, field as et, ContractInput as f, DeferredIndexOptions as g, DeferredIndexExpression as h, BoundEnumType as i, now as it, ModelLike as j, ManyOptions as k, ColumnRef as l, DeferredIndexColumn as m, AuthoredColumnDefault as n, member as nt, CodecInput$1 as o, storedAsListColumn as ot, ContractModelBuilder as p, buildContractDefinition as q, AuthoredColumnDefaultLiteralValue as r, model as rt, CodecTypeMap$1 as s, AttachedEntities as t, isValueObjectMember as tt, ComposedAuthoringHelpers as u, EnumTypeHandle as v, IndexConstraint as w, ForeignKeyModelReference as x, ExtractCodecTypesFromPack as y, TargetFieldRef as z };
+//# sourceMappingURL=contract-builder-C_Zi57iD.d.mts.map