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

package/dist/contract-builder-MvJJrQ-5.d.mts

@@ -0,0 +1,1306 @@
+import { a as ReferentialAction } from "./foreign-key-BSy9u4O4-BnsOe5Nf.mjs";
+import { t as Index$1 } from "./sql-index-DsI8HAeK-BJsn-jvD.mjs";
+import { c as SqlStorage, d as StorageTypeInstance, i as SqlNamespaceBase, s as SqlNamespaceInput } from "./sql-storage-B0QwiTg6-B8DVctJm.mjs";
+import { k as TypeMaps, n as ContractWithTypeMaps } from "./types-CuDrWc5v-ISVXBmBs.mjs";
+import "./types-BchwQpmO.mjs";
+import { r as PackEntityHandle } from "./entity-handle-lowering-hook-CIvRKBfa.mjs";
+import { n as AuthoredIndexMethod } from "./index-naming-BZWoh45T.mjs";
+import { i as IndexTypeRegistration } from "./index-types-DPVhsW0v-D-BikM4h.mjs";
+import "./index-types-CNhHgKHi.mjs";
+import { StorageType } from "@prisma/orm-framework/components/ir";
+import { ColumnDefault, ColumnDefaultLiteralInputValue, Contract, ContractEnum, ContractRelation, ContractValueObject, ControlPolicy, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue, NamespaceId, StorageHashBase } from "@prisma/orm-framework/contract/types";
+import { AuthoringArgumentDescriptor, AuthoringFieldPresetDescriptor, AuthoringTypeConstructorDescriptor, AuthoringWarning } from "@prisma/orm-framework/components/authoring";
+import { BoundEnumType, CodecInput, CodecTypeMap, EntityHelpersFromNamespace, EnumMember, EnumTypeHandle, ExtractAuthoringNamespaceFromPack, ForeignKeyDefaultsState, MergeExtensionAuthoringNamespaces, bindEnumType, enumType, member } from "@prisma/orm-framework/contract-authoring";
+import { CodecLookup, ColumnTypeDescriptor } from "@prisma/orm-framework/components/codec";
+import { ExtensionPackRef, FamilyPackRef, TargetPackRef } from "@prisma/orm-framework/components/components";
+//#region ../../../2-sql/2-authoring/contract-ts/dist/contract-builder.d.mts
+//#region src/contract-dsl.d.ts
+type NamingStrategy = 'identity' | 'snake_case';
+type NamingConfig = {
+  readonly tables?: NamingStrategy;
+  readonly columns?: NamingStrategy;
+};
+type NamedStorageTypeRef = string | StorageTypeInstance | EnumTypeHandle;
+type NamedConstraintNameSpec<Name extends string = string> = {
+  readonly name: Name;
+};
+type ScalarFieldState<Descriptor extends ColumnTypeDescriptor = ColumnTypeDescriptor, TypeRef extends NamedStorageTypeRef | undefined = undefined, Nullable extends boolean = boolean, ColumnName extends string | undefined = string | undefined, IdSpec extends NamedConstraintSpec | undefined = undefined, UniqueSpec extends NamedConstraintSpec | undefined = undefined, Many extends boolean = false> = {
+  readonly kind: 'scalar';
+  readonly descriptor?: Descriptor | undefined;
+  readonly typeRef?: TypeRef | undefined;
+  readonly nullable: Nullable;
+  readonly columnName?: ColumnName | undefined;
+  readonly default?: ColumnDefault | undefined;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases | undefined;
+  readonly many?: Many extends true ? true : undefined;
+} & (IdSpec extends NamedConstraintSpec ? {
+  readonly id: IdSpec;
+} : {
+  readonly id?: undefined;
+}) & (UniqueSpec extends NamedConstraintSpec ? {
+  readonly unique: UniqueSpec;
+} : {
+  readonly unique?: undefined;
+});
+type AnyScalarFieldState = {
+  readonly kind: 'scalar';
+  readonly descriptor?: ColumnTypeDescriptor | undefined;
+  readonly typeRef?: NamedStorageTypeRef | undefined;
+  readonly nullable: boolean;
+  readonly columnName?: string | undefined;
+  readonly default?: ColumnDefault | undefined;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases | undefined;
+  readonly many?: boolean | undefined;
+  readonly id?: NamedConstraintSpec | undefined;
+  readonly unique?: NamedConstraintSpec | undefined;
+};
+type HasNamedConstraintId<State extends AnyScalarFieldState> = State extends ScalarFieldState<ColumnTypeDescriptor, NamedStorageTypeRef | undefined, boolean, string | undefined, infer IdSpec, NamedConstraintSpec | undefined, boolean> ? IdSpec extends NamedConstraintSpec ? true : false : false;
+type HasNamedConstraintUnique<State extends AnyScalarFieldState> = State extends ScalarFieldState<ColumnTypeDescriptor, NamedStorageTypeRef | undefined, boolean, string | undefined, NamedConstraintSpec | undefined, infer UniqueSpec, 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 TypeRef, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec, infer Many> ? ScalarFieldState<Descriptor, TypeRef, 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> : AnyScalarFieldState;
+type GeneratedFieldSpec = {
+  readonly type: ColumnTypeDescriptor;
+  readonly typeParams?: Record<string, unknown>;
+  readonly generated: ExecutionMutationDefaultValue;
+};
+declare class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFieldState> {
+  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 TypeRef, boolean, infer ColumnName, infer IdSpec, infer UniqueSpec, infer Many> ? ScalarFieldState<Descriptor, TypeRef, true, ColumnName, IdSpec, UniqueSpec, Many> : AnyScalarFieldState>;
+  column<ColumnName extends string>(name: ColumnName): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, string | undefined, infer IdSpec, infer UniqueSpec, infer Many> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, UniqueSpec, Many> : AnyScalarFieldState>;
+  many(): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec, boolean> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, UniqueSpec, true> : AnyScalarFieldState>;
+  default(value: ColumnDefaultLiteralInputValue | ColumnDefault): ScalarFieldBuilder<State>;
+  defaultSql(expression: string): ScalarFieldBuilder<State>;
+  id<const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, infer ColumnName, NamedConstraintSpec | undefined, infer UniqueSpec, infer Many> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, NamedConstraintSpec<Name>, UniqueSpec, Many> : AnyScalarFieldState>;
+  unique<const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, infer ColumnName, infer IdSpec, NamedConstraintSpec | undefined, infer Many> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, NamedConstraintSpec<Name>, Many> : 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(value: Handle['values'][number]): EnumScalarFieldBuilder<Handle, State>;
+  defaultSql(_expression: never): never;
+}
+declare function columnField<Descriptor extends ColumnTypeDescriptor>(descriptor: Descriptor): ScalarFieldBuilder<ScalarFieldState<Descriptor, undefined, false, undefined>>;
+declare function generatedField<Descriptor extends ColumnTypeDescriptor>(spec: GeneratedFieldSpec & {
+  readonly type: Descriptor;
+}): ScalarFieldBuilder<ScalarFieldState<Descriptor, undefined, false, undefined>>;
+declare function namedTypeField<TypeRef extends string>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<ColumnTypeDescriptor, TypeRef, false, undefined>>;
+declare function namedTypeField<TypeRef extends StorageTypeInstance>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<ColumnTypeDescriptor<TypeRef['codecId']>, TypeRef, false, undefined>>;
+declare function namedTypeField<Handle extends EnumTypeHandle>(typeRef: Handle): EnumScalarFieldBuilder<Handle>;
+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> = {
+  readonly kind: 'belongsTo';
+  readonly toModel: RelationModelSource<ToModel>;
+  readonly from: FromField;
+  readonly to: ToField;
+  readonly sql?: SqlSpec;
+  /**
+   * 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> ? BelongsToRelation<ToModel, FromField, ToField, SqlSpec> : 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?: string;
+  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: IndexTypes[K]['options'];
+}; }[keyof IndexTypes & string];
+/**
+ * The expression overload's input: the whole CREATE INDEX element list as
+ * one opaque string. `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: string;
+};
+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;
+  readonly index?: boolean;
+};
+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[]> = {
+  readonly kind: 'unique';
+  readonly fields: FieldNames;
+  readonly name?: string;
+};
+/** 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: string;
+};
+/** 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?: Record<string, unknown>;
+};
+type IndexConstraint<FieldNames extends readonly string[] = readonly string[], Name extends string | undefined = string | undefined> = IndexConstraintElements<FieldNames> & IndexConstraintMethod & {
+  readonly kind: 'index';
+  readonly where?: string;
+  readonly unique?: boolean;
+  readonly name?: Name;
+  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> = {
+  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?: boolean;
+};
+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, Name extends string | undefined = undefined>(field: ColumnRef<FieldName>, options?: NamedConstraintSpec<Name>): IdConstraint<readonly [FieldName], Name>;
+    <FieldNames extends readonly string[], 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>(field: ColumnRef<FieldName>, options?: ConstraintOptions): UniqueConstraint<readonly [FieldName]>;
+    <FieldNames extends readonly string[]>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: ConstraintOptions): UniqueConstraint<FieldNames>;
+  };
+  index: {
+    <FieldNames extends readonly string[], Name extends string | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: IndexInput<Name, IndexTypes>): IndexConstraint<FieldNames, Name>;
+    <Name extends string | undefined = undefined>(options: ExpressionIndexInput<Name, IndexTypes>): IndexConstraint<never, Name>;
+  };
+  foreignKey: {
+    <SourceFieldName extends string, TargetModelName extends string, TargetFieldName extends string, Name extends string | undefined = undefined>(field: ColumnRef<SourceFieldName>, target: TargetFieldRef<TargetModelName, TargetFieldName>, options?: ForeignKeyOptions<Name>): ForeignKeyConstraint<readonly [SourceFieldName], TargetModelName, readonly [TargetFieldName], Name>;
+    <SourceFieldNames extends readonly string[], TargetModelName extends string, TargetFieldNames extends readonly string[], Name extends 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>): ForeignKeyConstraint<SourceFieldNames, TargetModelName, TargetFieldNames, Name>;
+  };
+};
+type ConstraintsDsl = ReturnType<typeof createConstraintsDsl>;
+type ModelAttributesSpec = {
+  readonly id?: IdConstraint;
+  readonly uniques?: readonly UniqueConstraint[];
+};
+type SqlStageSpec = {
+  readonly table?: string;
+  readonly control?: ControlPolicy;
+  readonly indexes?: readonly IndexConstraint[];
+  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[], Name extends string | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: IndexInput<Name, IndexTypes>): IndexConstraint<FieldNames, Name>;
+  <Name extends string | undefined = undefined>(options: ExpressionIndexInput<Name, IndexTypes>): IndexConstraint<never, Name>;
+};
+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 SqlIndexes<SqlSpec extends SqlStageSpec> = SqlSpec extends {
+  readonly indexes?: infer Indexes extends readonly unknown[];
+} ? Indexes : readonly [];
+type SqlForeignKeys<SqlSpec extends SqlStageSpec> = SqlSpec extends {
+  readonly foreignKeys?: infer ForeignKeys extends readonly unknown[];
+} ? ForeignKeys : readonly [];
+type SqlNamedObjects<SqlSpec extends SqlStageSpec> = [...SqlIndexes<SqlSpec>, ...SqlForeignKeys<SqlSpec>];
+type ValidateSqlStageSpec<Fields extends Record<string, ScalarFieldBuilder>, AttributesSpec extends ModelAttributesSpec | undefined, SqlSpec extends SqlStageSpec> = [DuplicateLiteralNames<SqlNamedObjects<SqlSpec>>] extends [never] ? [Extract<ModelIdLiteralName<Fields, AttributesSpec>, NamedConstraintLiteralName<SqlNamedObjects<SqlSpec>[number]>>] extends [never] ? SqlSpec : never : never;
+type ValidateAttributesStageSpec<Fields extends Record<string, ScalarFieldBuilder>, SqlSpec extends SqlStageSpec | undefined, AttributesSpec extends ModelAttributesSpec> = SqlSpec extends SqlStageSpec ? [Extract<ModelIdLiteralName<Fields, AttributesSpec>, NamedConstraintLiteralName<SqlNamedObjects<SqlSpec>[number]>>] extends [never] ? AttributesSpec : never : AttributesSpec;
+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>'> {
+  readonly stageOne: {
+    readonly modelName?: ModelName;
+    readonly namespace?: string;
+    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 __fields: Fields;
+  readonly __relations: Relations;
+  readonly __attributes: AttributesSpec;
+  readonly __sql: SqlSpec;
+  readonly __indexTypes: IndexTypes;
+  readonly __spaceId: TSpaceId;
+  readonly refs: ModelName extends string ? ModelTokenRefs<ModelName, Fields, TSpaceId> : never;
+  constructor(stageOne: {
+    readonly modelName?: ModelName;
+    readonly namespace?: string;
+    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> : 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>;
+  attributes<const NextAttributesSpec extends ModelAttributesSpec>(specOrFactory: StageInput<AttributeContext<Fields>, ValidateAttributesStageSpec<Fields, SqlSpec, NextAttributesSpec>>): ContractModelBuilder<ModelName, Fields, Relations, NextAttributesSpec, SqlSpec, IndexTypes, TSpaceId>;
+  sql<const NextSqlSpec extends SqlStageSpec>(specOrFactory: StageInput<SqlContext<Fields, IndexTypes>, NextSqlSpec>): [ValidateSqlStageSpec<Fields, AttributesSpec, NextSqlSpec>] extends [never] ? ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, never, IndexTypes, TSpaceId> : ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, NextSqlSpec, IndexTypes, TSpaceId>;
+  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 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>, Types extends Record<string, StorageTypeInstance> = 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;
+  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;
+  readonly types?: Types;
+  readonly models?: Models;
+  readonly codecLookup?: CodecLookup;
+  /**
+   * 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>>(modelName: ModelName, input: {
+  readonly fields: Fields;
+  readonly relations?: Relations;
+  readonly namespace?: string;
+}): ContractModelBuilder<ModelName, Fields, Relations>;
+declare function model<Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>>(input: {
+  readonly fields: Fields;
+  readonly relations?: Relations;
+  readonly namespace?: string;
+}): ContractModelBuilder<undefined, Fields, Relations>;
+/**
+ * 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, FromField extends string | readonly string[], ToField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
+  readonly from: FromField;
+  readonly to: ToField;
+}): RelationBuilder<BelongsToRelation<RelationModelName<Token>, FromField, ToField>>;
+declare function belongsTo<ToModel extends string, FromField extends string | readonly string[], ToField extends string | readonly string[]>(toModel: ToModel, options: {
+  readonly from: FromField;
+  readonly to: ToField;
+}): RelationBuilder<BelongsToRelation<ToModel, FromField, ToField>>;
+declare function hasMany<Token extends AnyNamedModelToken, ByField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
+  readonly by: ByField;
+}): RelationBuilder<HasManyRelation<RelationModelName<Token>, ByField>>;
+declare function hasMany<ToModel extends string, ByField extends string | readonly string[]>(toModel: ToModel, options: {
+  readonly by: ByField;
+}): RelationBuilder<HasManyRelation<ToModel, ByField>>;
+declare function hasOne<Token extends AnyNamedModelToken, ByField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
+  readonly by: ByField;
+}): RelationBuilder<HasOneRelation<RelationModelName<Token>, ByField>>;
+declare function hasOne<ToModel extends string, ByField extends string | readonly string[]>(toModel: ToModel, options: {
+  readonly by: ByField;
+}): RelationBuilder<HasOneRelation<ToModel, ByField>>;
+declare function manyToMany<ToToken extends AnyNamedModelToken, ThroughToken extends AnyNamedModelToken, FromField extends RelationFieldSelection<RelationModelFieldNames<ThroughToken>>, 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, FromField extends string | readonly string[], 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: typeof columnField;
+  generated: typeof generatedField;
+  namedType: typeof namedTypeField;
+};
+type FieldStateOf<T> = T extends ScalarFieldBuilder<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<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 OptionalObjectArgumentKeys<Properties extends Record<string, AuthoringArgumentDescriptor>> = { readonly [K in keyof Properties]: Properties[K] extends {
+  readonly optional: true;
+} ? K : never; }[keyof Properties];
+type RequiredObjectArgumentKeys<Properties extends Record<string, AuthoringArgumentDescriptor>> = Exclude<keyof Properties, OptionalObjectArgumentKeys<Properties>>;
+/**
+ * When every property is optional the result must be a plain weak type rather
+ * than `{} & { … }`: TypeScript's weak-type check rejects an object sharing
+ * none of the target's properties, but only when the target is weak — and an
+ * intersection with `{}` is not. The TS authoring surface runs no runtime
+ * argument validation, so this check is the only thing rejecting a foreign key
+ * such as `field.nanoid({ bogus: 1 })`.
+ */
+type ObjectArgumentType<Properties extends Record<string, AuthoringArgumentDescriptor>> = [RequiredObjectArgumentKeys<Properties>] extends [never] ? { readonly [K in OptionalObjectArgumentKeys<Properties>]?: ArgTypeFromDescriptor<Properties[K]>; } : { readonly [K in RequiredObjectArgumentKeys<Properties>]: ArgTypeFromDescriptor<Properties[K]>; } & { readonly [K in OptionalObjectArgumentKeys<Properties>]?: ArgTypeFromDescriptor<Properties[K]>; };
+type ArgTypeFromDescriptor<Arg extends AuthoringArgumentDescriptor> = Arg extends {
+  readonly kind: 'string';
+} ? string : Arg extends {
+  readonly kind: 'boolean';
+} ? boolean : Arg extends {
+  readonly kind: 'number';
+} ? number : Arg extends {
+  readonly kind: 'stringArray';
+} ? readonly string[] : Arg extends {
+  readonly kind: 'option';
+  readonly values: infer Values extends readonly string[];
+} ? Values[number] : Arg extends {
+  readonly kind: 'object';
+  readonly properties: infer Properties extends Record<string, AuthoringArgumentDescriptor>;
+} ? ObjectArgumentType<Properties> : never;
+/**
+ * Recursive rewrite (not a mapped tuple type) so a descriptor marked
+ * `optional: true` gets an optional tuple slot (`Type?`), letting callers
+ * omit it and every optional arg after it. Required args must precede
+ * optional args in a descriptor's `args` list — TypeScript rejects an
+ * optional tuple element followed by a required one, and the runtime
+ * (`validateAuthoringHelperArguments`'s `minimumArgs`) already treats an
+ * optional-before-required arg as effectively required.
+ */
+type TupleFromArgumentDescriptors<Args extends readonly AuthoringArgumentDescriptor[]> = Args extends readonly [infer Head extends AuthoringArgumentDescriptor, ...infer Tail extends readonly AuthoringArgumentDescriptor[]] ? Head extends {
+  readonly optional: true;
+} ? readonly [ArgTypeFromDescriptor<Head>?, ...TupleFromArgumentDescriptors<Tail>] : readonly [ArgTypeFromDescriptor<Head>, ...TupleFromArgumentDescriptors<Tail>] : readonly [];
+type SupportsNamedConstraintOptions<Descriptor extends AuthoringFieldPresetDescriptor> = Descriptor['output'] extends {
+  readonly id: true;
+} ? true : Descriptor['output'] extends {
+  readonly unique: true;
+} ? true : false;
+type ResolveTemplateValue<Template, Args extends readonly unknown[]> = Template extends {
+  readonly kind: 'arg';
+  readonly index: infer Index extends number;
+  readonly path?: infer Path extends readonly string[] | undefined;
+  readonly default?: infer Default;
+} ? ResolveTemplateArgValue<Args[Index], Path, Default, Args> : Template extends readonly unknown[] ? { readonly [K in keyof Template]: ResolveTemplateValue<Template[K], Args>; } : Template extends Record<string, unknown> ? { readonly [K in keyof Template]: ResolveTemplateValue<Template[K], Args>; } : Template;
+type ResolveTemplatePathValue<Value, Path extends readonly string[] | undefined> = Path extends readonly [infer Segment extends string, ...infer Rest extends readonly string[]] ? Segment extends keyof NonNullable<Value> ? ResolveTemplatePathValue<NonNullable<Value>[Segment], Rest> : never : Value;
+type ResolveTemplateDefaultValue<Value, Default, Args extends readonly unknown[]> = Default extends undefined ? Value : [Value] extends [never] ? ResolveTemplateValue<Default, Args> : undefined extends Value ? Exclude<Value, undefined> | ResolveTemplateValue<Default, Args> : Value;
+type ResolveTemplateArgValue<Value, Path extends readonly string[] | undefined, Default, Args extends readonly unknown[]> = ResolveTemplateDefaultValue<ResolveTemplatePathValue<Value, Path>, Default, Args>;
+type FieldBuilderFromPresetDescriptor<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[] = readonly [], ConstraintName extends string | undefined = undefined> = ScalarFieldBuilder<ScalarFieldState<ColumnTypeDescriptor<ResolveTemplateValue<Descriptor['output']['codecId'], Args> extends string ? ResolveTemplateValue<Descriptor['output']['codecId'], Args> : string>, 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>>>;
+type FieldHelperFunctionWithoutNamedConstraint<Descriptor extends AuthoringFieldPresetDescriptor> = Descriptor extends {
+  readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
+} ? <const Params extends TupleFromArgumentDescriptors<Args>>(...args: Params) => FieldBuilderFromPresetDescriptor<Descriptor, Params> : () => FieldBuilderFromPresetDescriptor<Descriptor, readonly []>;
+/**
+ * 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> = Descriptor extends {
+  readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
+} ? (<const Params extends TupleFromArgumentDescriptors<Args>>(...args: Params) => FieldBuilderFromPresetDescriptor<Descriptor, Params>) & (<const Params extends TupleFromArgumentDescriptors<Args>, const Name extends string | undefined = undefined>(...args: [...params: Params, options: NamedConstraintSpec<Name>]) => FieldBuilderFromPresetDescriptor<Descriptor, Params, Name>) : <const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>) => FieldBuilderFromPresetDescriptor<Descriptor, readonly [], Name>;
+type FieldHelperFunction<Descriptor extends AuthoringFieldPresetDescriptor> = SupportsNamedConstraintOptions<Descriptor> extends true ? FieldHelperFunctionWithNamedConstraint<Descriptor> : FieldHelperFunctionWithoutNamedConstraint<Descriptor>;
+type FieldHelpersFromNamespace<Namespace> = { readonly [K in keyof Namespace]: Namespace[K] extends AuthoringFieldPresetDescriptor ? FieldHelperFunction<Namespace[K]> : Namespace[K] extends Record<string, unknown> ? FieldHelpersFromNamespace<Namespace[K]> : never; };
+//#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'>>; };
+type ExtractCodecTypesFromPack<P> = P extends {
+  __codecTypes?: infer C extends Record<string, {
+    readonly output: unknown;
+  }>;
+} ? PublicCodecTypes<C> : Record<string, never>;
+type MergeExtensionCodecTypes<Packs extends Record<string, unknown>> = UnionToIntersection<{ [K in keyof Packs]: ExtractCodecTypesFromPack<Packs[K]>; }[keyof Packs]>;
+type MergeExtensionCodecTypesSafe<Packs> = Packs extends Record<string, unknown> ? keyof Packs extends never ? Record<string, never> : MergeExtensionCodecTypes<Packs> : Record<string, 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 MergeExtensionPackCapabilities<Packs> = Packs extends Record<string, unknown> ? keyof Packs extends never ? Record<string, never> : UnionToIntersection<{ [K in keyof Packs]: ExtractPackCapabilities<Packs[K]>; }[keyof Packs]> : Record<string, never>;
+type Defaulted<T, Fallback> = [T] extends [never] ? Fallback : T;
+type DerivedCapabilities<Definition> = Defaulted<ExtractPackCapabilities<DefinitionTarget<Definition>>, Record<string, never>> & MergeExtensionPackCapabilities<DefinitionExtensions<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 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 types?: unknown;
+} ? Present<Definition['types']> extends Record<string, StorageType> ? Present<Definition['types']> : 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 FieldTypeRefOf<FieldState> = Present<FieldState extends {
+  readonly typeRef?: infer TypeRef;
+} ? TypeRef : never>;
+type FieldNullableOf<FieldState> = FieldState extends {
+  readonly nullable: infer Nullable extends boolean;
+} ? Nullable : boolean;
+type FieldManyOf<FieldState> = FieldState extends {
+  readonly many?: true;
+} ? true : false;
+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;
+} ? CodecId : string;
+type DescriptorNativeType<Descriptor> = Descriptor extends {
+  readonly nativeType: infer NativeType extends string;
+} ? NativeType : string;
+type DescriptorTypeParams<Descriptor> = Descriptor extends {
+  readonly typeParams: infer TypeParams extends Record<string, unknown>;
+} ? TypeParams : undefined;
+type DescriptorTypeRef<Descriptor> = Descriptor extends {
+  readonly typeRef: infer TypeRef extends string;
+} ? TypeRef : undefined;
+type LookupNamedStorageTypeKeyByValue<Definition, TypeRef extends StorageType> = { [TypeName in keyof DefinitionTypes<Definition> & string]: [TypeRef] extends [DefinitionTypes<Definition>[TypeName]] ? [DefinitionTypes<Definition>[TypeName]] extends [TypeRef] ? TypeName : never : never; }[keyof DefinitionTypes<Definition> & string];
+type ResolveNamedStorageTypeKey<Definition, TypeRef> = TypeRef extends string ? TypeRef : TypeRef extends StorageType ? [LookupNamedStorageTypeKeyByValue<Definition, TypeRef>] extends [never] ? string : LookupNamedStorageTypeKeyByValue<Definition, TypeRef> : never;
+type ResolveNamedStorageType<Definition, TypeRef> = ResolveNamedStorageTypeKey<Definition, TypeRef> extends (infer TypeName extends string) ? TypeName extends keyof DefinitionTypes<Definition> ? DefinitionTypes<Definition>[TypeName] : StorageTypeInstance : StorageTypeInstance;
+type EnumFieldHandle<FieldState> = [FieldTypeRefOf<FieldState>] extends [never] ? never : FieldTypeRefOf<FieldState> extends EnumTypeHandle ? FieldTypeRefOf<FieldState> : never;
+type EnumHandleDescriptor<Handle> = Handle extends {
+  readonly codecId: infer CodecId extends string;
+  readonly nativeType: infer NativeType extends string;
+} ? {
+  readonly codecId: CodecId;
+  readonly nativeType: NativeType;
+} : never;
+type ResolveFieldDescriptor<Definition, FieldState> = [EnumFieldHandle<FieldState>] extends [never] ? [FieldDescriptorOf<FieldState>] extends [never] ? ResolveNamedStorageType<Definition, FieldTypeRefOf<FieldState>> : FieldDescriptorOf<FieldState> : EnumHandleDescriptor<EnumFieldHandle<FieldState>>;
+type ResolveFieldColumnTypeRef<Definition, FieldState> = [EnumFieldHandle<FieldState>] extends [never] ? [FieldTypeRefOf<FieldState>] extends [never] ? DescriptorTypeRef<FieldDescriptorOf<FieldState>> : ResolveNamedStorageTypeKey<Definition, FieldTypeRefOf<FieldState>> : undefined;
+type ResolveFieldColumnTypeParams<Definition, FieldState> = [ResolveFieldColumnTypeRef<Definition, FieldState>] extends [string] ? undefined : 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, NativeType extends string, TypeRef extends string | undefined = undefined, TypeParams extends Record<string, unknown> | undefined = undefined, Many extends boolean = false> = {
+  readonly nativeType: NativeType;
+  readonly codecId: CodecId;
+  readonly nullable: Nullable;
+  readonly default?: ColumnDefault;
+} & (TypeRef extends string ? {
+  readonly typeRef: TypeRef;
+} : Record<never, never>) & (TypeParams extends Record<string, unknown> ? {
+  readonly typeParams: TypeParams;
+} : Record<never, never>) & (Many extends true ? {
+  readonly many: true;
+} : Record<never, never>);
+type ModelStorageColumn<Definition, ModelName extends ModelNames<Definition>, FieldName extends string> = FieldName extends ModelFieldNames<Definition, ModelName> ? StorageColumn<DescriptorCodecId<ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName, FieldName>>>, FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>>, DescriptorNativeType<ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName, FieldName>>>, ResolveFieldColumnTypeRef<Definition, ModelFieldState<Definition, ModelName, FieldName>>, ResolveFieldColumnTypeParams<Definition, ModelFieldState<Definition, ModelName, FieldName>>, FieldManyOf<ModelFieldState<Definition, ModelName, FieldName>>> : never;
+type BuiltModels<Definition> = { readonly [ModelName in ModelNames<Definition>]: {
+  readonly storage: {
+    readonly table: ModelTableName<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'];
+    };
+  }; };
+  readonly relations: { readonly [RelName in StagedModelRelationNames<Definition, ModelName>]: ContractRelation; };
+}; };
+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 BuiltStorageTables<Definition> = { readonly [ModelName in ModelNames<Definition> as BuiltModelTableName<Definition, ModelName>]: {
+  readonly columns: BuiltStorageTableColumns<Definition, ModelName>;
+  readonly uniques: ReadonlyArray<{
+    readonly columns: readonly string[];
+    readonly name?: string;
+  }>;
+  readonly indexes: ReadonlyArray<Index$1>;
+  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 constraint: boolean;
+    readonly index: boolean;
+  }>;
+} & (ModelIdFieldNames<Definition, ModelName> extends readonly string[] ? {
+  readonly primaryKey: {
+    readonly columns: FieldNamesToColumnNames<Definition, ModelName, ModelIdFieldNames<Definition, ModelName>>;
+    readonly name?: ModelIdName<Definition, ModelName>;
+  };
+} : Record<string, 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 EnumHandleAccessorType<Handle> = Handle extends EnumTypeHandle<infer _Name, infer Values, infer Names, infer MembersMap> ? {
+  readonly values: Values;
+  readonly names: Names;
+  readonly members: MembersMap;
+  has(v: Values[number]): boolean;
+  nameOf(v: Values[number]): string | undefined;
+  ordinalOf(v: Values[number]): number;
+} : never;
+type BuiltEnumAccessors<Definition> = { readonly [K in keyof DefinitionEnums<Definition>]: EnumHandleAccessorType<DefinitionEnums<Definition>[K]>; };
+type BuiltDocumentScopedTypes<Definition> = { readonly [K in keyof DefinitionTypes<Definition> as DefinitionTypes<Definition>[K] extends StorageTypeInstance ? K : never]: DefinitionTypes<Definition>[K]; };
+type BuiltDomain<Definition> = BuiltDocumentScopedTypes<Definition> extends Record<never, never> ? Record<string, never> : {
+  readonly __unbound__: {
+    readonly types: BuiltDocumentScopedTypes<Definition>;
+  };
+};
+type BuiltDomainNamespace<Definition> = {
+  readonly models: BuiltModels<Definition>;
+  readonly valueObjects?: Record<string, ContractValueObject>;
+  readonly enum?: Record<string, ContractEnum>;
+};
+type DefaultStorageNamespaceId<Definition> = DefinitionTargetId<Definition> extends 'postgres' ? 'public' : '__unbound__';
+type BuiltStorage<Definition> = {
+  readonly storageHash: StorageHashBase<string>;
+  readonly types?: BuiltDocumentScopedTypes<Definition>;
+  readonly namespaces: { readonly [K in DefaultStorageNamespaceId<Definition>]: {
+    readonly id: K;
+    readonly kind: string;
+    readonly entries: {
+      readonly table: BuiltStorageTables<Definition>;
+    };
+  }; } & { readonly [Ns in Exclude<DefinitionNamespaces<Definition>, DefaultStorageNamespaceId<Definition>>]: {
+    readonly id: Ns;
+    readonly kind: string;
+    readonly entries: {
+      readonly table: Record<never, never>;
+    };
+  }; };
+};
+type StorageColumnManyOf<Col> = Col extends {
+  readonly many: true;
+} ? true : false;
+type EnumValueUnion<FieldState> = [FieldTypeRefOf<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 CodecChannelType<Definition, ModelName extends ModelNames<Definition>, FieldName extends ModelFieldNames<Definition, ModelName>, Channel extends 'output' | 'input'> = ModelStorageColumn<Definition, ModelName, FieldName>['codecId'] extends (infer Id extends keyof CodecTypesFromDefinition<Definition>) ? CodecTypesFromDefinition<Definition>[Id] extends { readonly [K in Channel]: infer T; } ? StorageColumnManyOf<ModelStorageColumn<Definition, ModelName, FieldName>> extends true ? ReadonlyArray<T> : T : unknown : unknown;
+type FieldValueUnion<FieldState> = [EnumValueUnion<FieldState>] extends [never] ? DescriptorValueSetUnion<FieldState> : EnumValueUnion<FieldState>;
+type FieldChannelType<Definition, ModelName extends ModelNames<Definition>, FieldName extends ModelFieldNames<Definition, ModelName>, Channel extends 'output' | 'input'> = ([FieldValueUnion<ModelFieldState<Definition, ModelName, FieldName>>] extends [never] ? CodecChannelType<Definition, ModelName, FieldName, Channel> : StorageColumnManyOf<ModelStorageColumn<Definition, ModelName, FieldName>> extends true ? ReadonlyArray<FieldValueUnion<ModelFieldState<Definition, ModelName, FieldName>>> : FieldValueUnion<ModelFieldState<Definition, ModelName, FieldName>>) | (FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>> extends true ? null : never);
+type FieldChannelTypes<Definition, Channel extends 'output' | 'input'> = { readonly [Ns in DefaultStorageNamespaceId<Definition>]: { readonly [ModelName in ModelNames<Definition>]: { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldChannelType<Definition, ModelName, FieldName, Channel>; }; }; };
+type StorageColumnChannelTypes<Definition, Channel extends 'output' | 'input'> = { readonly [Ns in DefaultStorageNamespaceId<Definition>]: { readonly [ModelName in ModelNames<Definition> as BuiltModelTableName<Definition, ModelName>]: { readonly [FieldName in ModelFieldNames<Definition, ModelName> as BuiltModelColumnMappings<Definition, ModelName>[FieldName]['column']]: FieldChannelType<Definition, ModelName, FieldName, Channel>; }; }; };
+type SqlContractResult<Definition> = ContractWithTypeMaps<Omit<Contract<BuiltStorage<Definition>>, 'domain'> & {
+  readonly target: DefinitionTargetId<Definition>;
+  readonly targetFamily: 'sql';
+} & {
+  readonly domain: {
+    readonly namespaces: Readonly<Record<string, BuiltDomainNamespace<Definition>>>;
+  } & BuiltDomain<Definition>;
+} & {
+  readonly extensions: keyof DefinitionExtensions<Definition> extends never ? Record<string, never> : DefinitionExtensions<Definition>;
+  readonly capabilities: DerivedCapabilities<Definition>;
+  readonly enumAccessors: BuiltEnumAccessors<Definition>;
+}, TypeMaps<CodecTypesFromDefinition<Definition>, Record<string, never>, FieldChannelTypes<Definition, 'output'>, FieldChannelTypes<Definition, 'input'>, StorageColumnChannelTypes<Definition, 'output'>, StorageColumnChannelTypes<Definition, 'input'>>>;
+//#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>;
+  readonly nativeType: ResolveTemplateValue<Descriptor['output']['nativeType'], 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> = Descriptor extends {
+  readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
+} ? <const Params extends TupleFromArgumentDescriptors<Args>>(...args: Params) => StorageTypeFromDescriptor<Descriptor, Params> : () => StorageTypeFromDescriptor<Descriptor, readonly []>;
+type TypeHelpersFromNamespace<Namespace> = { readonly [K in keyof Namespace]: Namespace[K] extends AuthoringTypeConstructorDescriptor ? TypeHelperFunction<Namespace[K]> : Namespace[K] extends Record<string, unknown> ? TypeHelpersFromNamespace<Namespace[K]> : never; };
+type CoreFieldHelpers = Pick<typeof field, 'column' | 'generated' | 'namedType'>;
+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>>(modelName: ModelName, input: {
+    readonly fields: Fields;
+    readonly relations?: Relations;
+    readonly namespace?: string;
+  }): ContractModelBuilder<ModelName, Fields, Relations, undefined, undefined, IndexTypes>;
+  <Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>>(input: {
+    readonly fields: Fields;
+    readonly relations?: Relations;
+    readonly namespace?: string;
+  }): ContractModelBuilder<undefined, Fields, Relations, undefined, undefined, IndexTypes>;
+};
+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: CoreFieldHelpers & FieldHelpersFromNamespace<ExtractFieldNamespaceFromPack<Family> & ExtractFieldNamespaceFromPack<Target> & MergeExtensionFieldNamespaces<Extensions>>;
+  readonly model: PackAwareModel<MergeAllPackIndexTypes<Family, Target, Extensions>>;
+  readonly rel: typeof rel;
+  readonly type: TypeHelpersFromNamespace<ExtractTypeNamespaceFromPack<Family> & ExtractTypeNamespaceFromPack<Target> & MergeExtensionTypeNamespaces<Extensions>>;
+};
+//#endregion
+//#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>>>>>>;
+interface FieldNode {
+  readonly fieldName: string;
+  readonly columnName: string;
+  readonly descriptor: ColumnTypeDescriptor;
+  readonly nullable: boolean;
+  readonly default?: ColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+  readonly many?: boolean;
+  /** Present when the field was authored with `field.namedType(enumHandle)`. */
+  readonly enumTypeHandle?: EnumTypeHandle;
+}
+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;
+};
+interface ForeignKeyNode {
+  readonly columns: readonly string[];
+  readonly references: {
+    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;
+  };
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  readonly constraint?: boolean;
+  readonly index?: boolean;
+}
+interface RelationNode {
+  readonly fieldName: string;
+  readonly toModel: string;
+  readonly toTable: string;
+  /**
+   * 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';
+  /**
+   * 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;
+    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[];
+  };
+}
+interface ValueObjectFieldNode {
+  readonly fieldName: string;
+  readonly columnName: string;
+  readonly valueObjectName: string;
+  readonly nullable: boolean;
+  readonly default?: ColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+  readonly many?: boolean;
+}
+interface ValueObjectNode {
+  readonly name: string;
+  readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
+}
+interface ModelNode {
+  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 id?: PrimaryKeyNode;
+  readonly uniques?: readonly UniqueConstraintNode[];
+  readonly indexes?: readonly IndexNode[];
+  readonly foreignKeys?: readonly ForeignKeyNode[];
+  readonly relations?: readonly RelationNode[];
+  readonly control?: ControlPolicy;
+  /**
+   * 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;
+}
+interface ContractDefinition {
+  readonly target: TargetPackRef<'sql', string>;
+  readonly defaultControlPolicy?: ControlPolicy;
+  readonly extensions?: Record<string, ExtensionPackRef<'sql', string>>;
+  readonly storageHash?: string;
+  readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
+  readonly storageTypes?: Record<string, StorageTypeInstance>;
+  /**
+   * 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[];
+  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/build-contract.d.ts
+declare function buildSqlContractFromDefinition(definition: ContractDefinition, codecLookup?: CodecLookup): Contract<SqlStorage>;
+//#endregion
+//#region src/contract-builder.d.ts
+type ModelLike = {
+  readonly stageOne: {
+    readonly modelName?: string;
+    readonly namespace?: string;
+    readonly fields: Record<string, ScalarFieldBuilder>;
+    readonly relations: Record<string, RelationBuilder<RelationState>>;
+  };
+  readonly __attributes: ModelAttributesSpec | undefined;
+  readonly __sql: SqlStageSpec | undefined;
+  buildAttributesSpec(): ModelAttributesSpec | undefined;
+  buildSqlSpec(): SqlStageSpec | undefined;
+};
+type ContractDefinition$1<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Types extends Record<string, StorageTypeInstance>, 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 types?: Types;
+  readonly models?: Models;
+  readonly codecLookup?: CodecLookup;
+  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 types?: never;
+  readonly models?: never;
+  readonly codecLookup?: CodecLookup;
+  readonly enums?: Enums;
+  readonly entities?: readonly PackEntityHandle[];
+};
+type ContractFactory<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Types extends Record<string, StorageTypeInstance>, 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 types?: Types;
+  readonly models?: Models;
+  readonly enums?: Enums;
+  readonly entities?: readonly PackEntityHandle[];
+};
+type BoundDefinitionInput<Types extends Record<string, StorageTypeInstance> = 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 types?: Types;
+  readonly models?: Models;
+  readonly codecLookup?: CodecLookup;
+  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, StorageTypeInstance>, 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, StorageTypeInstance>, Record<string, ModelLike>, Record<string, ExtensionPackRef<'sql', string>> | undefined, ContractInput['naming'] | undefined, string | undefined, ForeignKeyDefaultsState | undefined, readonly string[] | undefined>, const Built extends {
+  readonly types?: Record<string, StorageTypeInstance>;
+  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 Types extends Record<string, StorageTypeInstance> = 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, Types, Models, Extensions, Naming, StorageHash, ForeignKeyDefaults, Namespaces, Enums>): SqlContractResult<ContractDefinition$1<Family, Target, Types, Models, Extensions, Naming, StorageHash, ForeignKeyDefaults, Namespaces, Enums>>;
+declare function defineContract<const Family extends FamilyPackRef<string>, const Target extends TargetPackRef<'sql', string>, const Types extends Record<string, StorageTypeInstance> = 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, Types, Models, Extensions, FactoryEnums>): SqlContractResult<ContractDefinition$1<Family, Target, Types, Models, Extensions, Naming, StorageHash, ForeignKeyDefaults, Namespaces, MergeEnums<ScaffoldEnums, FactoryEnums>>>;
+//#endregion
+//#region src/contract-lowering.d.ts
+declare function buildContractDefinition(definition: ContractInput): ContractDefinition;
+//#endregion
+export { field as A, bindEnumType as C, defineContract as D, buildSqlContractFromDefinition as E, model as M, rel as N, enumType as O, UniqueConstraintNode as S, buildContractDefinition as T, ModelNode as _, ComposedAuthoringHelpers as a, ScalarFieldBuilder as b, ContractModelBuilder as c, ExtractCodecTypesFromPack as d, FieldNode as f, ModelLike as g, MergeEnums as h, CodecTypeMap as i, member as j, extensionModel as k, EnumMember as l, IndexNode as m, BoundEnumType as n, ContractDefinition as o, ForeignKeyNode as p, CodecInput as r, ContractInput as s, AttachedEntities as t, EnumTypeHandle as u, PrimaryKeyNode as v, buildBoundContract as w, TargetFieldRef as x, RelationNode as y };
+//# sourceMappingURL=contract-builder-MvJJrQ-5.d.mts.map