@prisma-next/sql-contract-ts 0.12.0 → 0.13.0-dev.2

package/dist/config-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"config-types.mjs","names":[],"sources":["../src/config-types.ts"],"sourcesContent":["import { pathToFileURL } from 'node:url';\nimport type { ContractConfig } from '@prisma-next/config/config-types';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type { TargetPackRef } from '@prisma-next/framework-components/components';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { ok } from '@prisma-next/utils/result';\nimport { extname } from 'pathe';\nimport { buildSqlContractFromDefinition } from './build-contract';\n\n/**\n * Derives the emit output path from the TS contract input so artefacts land\n * colocated with the source (e.g. `prisma/contract.ts` →\n * `prisma/contract.json`). Mirrors the same default-derivation logic in\n * `@prisma-next/sql-contract-psl/provider`.\n */\nfunction defaultOutputFromContractPath(contractPath: string): string {\n  const ext = extname(contractPath);\n  if (ext.length === 0) return `${contractPath}.json`;\n  return `${contractPath.slice(0, -ext.length)}.json`;\n}\n\nexport function emptyContract(options: {\n  readonly output?: string;\n  readonly target: TargetPackRef<'sql', string>;\n}): ContractConfig {\n  return {\n    source: {\n      load: async () => ok(buildSqlContractFromDefinition({ target: options.target, models: [] })),\n    },\n    ...ifDefined('output', options.output),\n  };\n}\n\nexport function typescriptContract(contract: Contract, output?: string): ContractConfig {\n  return {\n    source: {\n      load: async () => ok(contract),\n    },\n    // The in-memory variant has no input path to anchor on; fall through to\n    // the global default in `normalizeContractConfig` when caller doesn't pin it.\n    ...ifDefined('output', output),\n  };\n}\n\nexport function typescriptContractFromPath(contractPath: string, output?: string): ContractConfig {\n  return {\n    source: {\n      inputs: [contractPath],\n      load: async (context) => {\n        const [absolutePath] = context.resolvedInputs;\n        if (absolutePath === undefined) {\n          throw new Error(\n            'typescriptContractFromPath: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.',\n          );\n        }\n        const mod = await import(pathToFileURL(absolutePath).href);\n        const contract: Contract | undefined = mod.default ?? mod.contract;\n        if (contract === undefined) {\n          throw new Error(\n            `typescriptContractFromPath: module at \"${absolutePath}\" has no \"default\" or \"contract\" export.`,\n          );\n        }\n        return ok(contract);\n      },\n    },\n    output: output ?? defaultOutputFromContractPath(contractPath),\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAeA,SAAS,8BAA8B,cAA8B;CACnE,MAAM,MAAM,QAAQ,YAAY;CAChC,IAAI,IAAI,WAAW,GAAG,OAAO,GAAG,aAAa;CAC7C,OAAO,GAAG,aAAa,MAAM,GAAG,CAAC,IAAI,MAAM,EAAE;AAC/C;AAEA,SAAgB,cAAc,SAGX;CACjB,OAAO;EACL,QAAQ,EACN,MAAM,YAAY,GAAG,+BAA+B;GAAE,QAAQ,QAAQ;GAAQ,QAAQ,CAAC;EAAE,CAAC,CAAC,EAC7F;EACA,GAAG,UAAU,UAAU,QAAQ,MAAM;CACvC;AACF;AAEA,SAAgB,mBAAmB,UAAoB,QAAiC;CACtF,OAAO;EACL,QAAQ,EACN,MAAM,YAAY,GAAG,QAAQ,EAC/B;EAGA,GAAG,UAAU,UAAU,MAAM;CAC/B;AACF;AAEA,SAAgB,2BAA2B,cAAsB,QAAiC;CAChG,OAAO;EACL,QAAQ;GACN,QAAQ,CAAC,YAAY;GACrB,MAAM,OAAO,YAAY;IACvB,MAAM,CAAC,gBAAgB,QAAQ;IAC/B,IAAI,iBAAiB,KAAA,GACnB,MAAM,IAAI,MACR,8IACF;IAEF,MAAM,MAAM,MAAM,OAAO,cAAc,YAAY,EAAE;IACrD,MAAM,WAAiC,IAAI,WAAW,IAAI;IAC1D,IAAI,aAAa,KAAA,GACf,MAAM,IAAI,MACR,0CAA0C,aAAa,yCACzD;IAEF,OAAO,GAAG,QAAQ;GACpB;EACF;EACA,QAAQ,UAAU,8BAA8B,YAAY;CAC9D;AACF"}
+{"version":3,"file":"config-types.mjs","names":[],"sources":["../src/config-types.ts"],"sourcesContent":["import { pathToFileURL } from 'node:url';\nimport type { ContractConfig } from '@prisma-next/config/config-types';\nimport { applySpecifierDefaultControlPolicy } from '@prisma-next/contract/apply-specifier-default-control-policy';\nimport type { Contract, ControlPolicy } from '@prisma-next/contract/types';\nimport type { TargetPackRef } from '@prisma-next/framework-components/components';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { ok } from '@prisma-next/utils/result';\nimport { extname } from 'pathe';\nimport { buildSqlContractFromDefinition } from './build-contract';\n\n/**\n * Derives the emit output path from the TS contract input so artefacts land\n * colocated with the source (e.g. `prisma/contract.ts` →\n * `prisma/contract.json`). Mirrors the same default-derivation logic in\n * `@prisma-next/sql-contract-psl/provider`.\n */\nfunction defaultOutputFromContractPath(contractPath: string): string {\n  const ext = extname(contractPath);\n  if (ext.length === 0) return `${contractPath}.json`;\n  return `${contractPath.slice(0, -ext.length)}.json`;\n}\n\nexport interface TypeScriptContractSpecifierOptions {\n  readonly defaultControlPolicy?: ControlPolicy;\n}\n\nexport function emptyContract(options: {\n  readonly output?: string;\n  readonly target: TargetPackRef<'sql', string>;\n  readonly defaultControlPolicy?: ControlPolicy;\n}): ContractConfig {\n  return {\n    source: {\n      load: async () => {\n        const built = buildSqlContractFromDefinition({ target: options.target, models: [] });\n        return ok(applySpecifierDefaultControlPolicy(built, options.defaultControlPolicy));\n      },\n    },\n    ...ifDefined('output', options.output),\n  };\n}\n\nexport function typescriptContract(\n  contract: Contract,\n  output?: string,\n  options?: TypeScriptContractSpecifierOptions,\n): ContractConfig {\n  return {\n    source: {\n      load: async () =>\n        ok(applySpecifierDefaultControlPolicy(contract, options?.defaultControlPolicy)),\n    },\n    // The in-memory variant has no input path to anchor on; fall through to\n    // the global default in `normalizeContractConfig` when caller doesn't pin it.\n    ...ifDefined('output', output),\n  };\n}\n\nexport function typescriptContractFromPath(\n  contractPath: string,\n  output?: string,\n  options?: TypeScriptContractSpecifierOptions,\n): ContractConfig {\n  return {\n    source: {\n      inputs: [contractPath],\n      load: async (context) => {\n        const [absolutePath] = context.resolvedInputs;\n        if (absolutePath === undefined) {\n          throw new Error(\n            'typescriptContractFromPath: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.',\n          );\n        }\n        const mod = await import(pathToFileURL(absolutePath).href);\n        const contract: Contract | undefined = mod.default ?? mod.contract;\n        if (contract === undefined) {\n          throw new Error(\n            `typescriptContractFromPath: module at \"${absolutePath}\" has no \"default\" or \"contract\" export.`,\n          );\n        }\n        return ok(applySpecifierDefaultControlPolicy(contract, options?.defaultControlPolicy));\n      },\n    },\n    output: output ?? defaultOutputFromContractPath(contractPath),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAgBA,SAAS,8BAA8B,cAA8B;CACnE,MAAM,MAAM,QAAQ,YAAY;CAChC,IAAI,IAAI,WAAW,GAAG,OAAO,GAAG,aAAa;CAC7C,OAAO,GAAG,aAAa,MAAM,GAAG,CAAC,IAAI,MAAM,EAAE;AAC/C;AAMA,SAAgB,cAAc,SAIX;CACjB,OAAO;EACL,QAAQ,EACN,MAAM,YAAY;GAEhB,OAAO,GAAG,mCADI,+BAA+B;IAAE,QAAQ,QAAQ;IAAQ,QAAQ,CAAC;GAAE,CACjC,GAAG,QAAQ,oBAAoB,CAAC;EACnF,EACF;EACA,GAAG,UAAU,UAAU,QAAQ,MAAM;CACvC;AACF;AAEA,SAAgB,mBACd,UACA,QACA,SACgB;CAChB,OAAO;EACL,QAAQ,EACN,MAAM,YACJ,GAAG,mCAAmC,UAAU,SAAS,oBAAoB,CAAC,EAClF;EAGA,GAAG,UAAU,UAAU,MAAM;CAC/B;AACF;AAEA,SAAgB,2BACd,cACA,QACA,SACgB;CAChB,OAAO;EACL,QAAQ;GACN,QAAQ,CAAC,YAAY;GACrB,MAAM,OAAO,YAAY;IACvB,MAAM,CAAC,gBAAgB,QAAQ;IAC/B,IAAI,iBAAiB,KAAA,GACnB,MAAM,IAAI,MACR,8IACF;IAEF,MAAM,MAAM,MAAM,OAAO,cAAc,YAAY,CAAC,CAAC;IACrD,MAAM,WAAiC,IAAI,WAAW,IAAI;IAC1D,IAAI,aAAa,KAAA,GACf,MAAM,IAAI,MACR,0CAA0C,aAAa,yCACzD;IAEF,OAAO,GAAG,mCAAmC,UAAU,SAAS,oBAAoB,CAAC;GACvF;EACF;EACA,QAAQ,UAAU,8BAA8B,YAAY;CAC9D;AACF"}

package/dist/contract-builder.d.mts

@@ -1,19 +1,117 @@
-import { ColumnDefault, ColumnDefaultLiteralInputValue, Contract, ContractRelation, ExecutionMutationDefaultPhases, ExecutionMutationDefaultPhases as ExecutionMutationDefaultPhases$1, ExecutionMutationDefaultValue, NamespaceId, StorageHashBase } from "@prisma-next/contract/types";
+import { ColumnDefault, ColumnDefaultLiteralInputValue, Contract, ContractRelation, ControlPolicy, ExecutionMutationDefaultPhases, ExecutionMutationDefaultPhases as ExecutionMutationDefaultPhases$1, ExecutionMutationDefaultValue, NamespaceId, StorageHashBase } from "@prisma-next/contract/types";
 import { EntityHelpersFromNamespace, ExtractAuthoringNamespaceFromPack, ForeignKeyDefaultsState, MergeExtensionAuthoringNamespaces } from "@prisma-next/contract-authoring";
-import { Namespace } from "@prisma-next/framework-components/ir";
+import { Namespace, StorageType } from "@prisma-next/framework-components/ir";
 import { IndexTypeRegistration } from "@prisma-next/sql-contract/index-types";
 import { ContractWithTypeMaps, Index as Index$1, PostgresEnumStorageEntry, ReferentialAction, SqlNamespaceTablesInput, SqlStorage, StorageTypeInstance, TypeMaps } from "@prisma-next/sql-contract/types";
 import { AuthoringArgumentDescriptor, AuthoringFieldPresetDescriptor, AuthoringTypeConstructorDescriptor } from "@prisma-next/framework-components/authoring";
 import { ExtensionPackRef, FamilyPackRef, TargetPackRef } from "@prisma-next/framework-components/components";
 import { CodecLookup, ColumnTypeDescriptor } from "@prisma-next/framework-components/codec";
 
+//#region src/enum-type.d.ts
+/**
+ * A single enum member produced by `member()`. The `Name` and `Value` generics
+ * are preserved as literal types so `enumType()` can carry the ordered value
+ * tuple in its return type.
+ */
+interface EnumMember<Name extends string, Value extends string> {
+  readonly name: Name;
+  readonly value: Value;
+}
+/**
+ * Declare an enum member. The `value` defaults to `name` when omitted.
+ * Both generics are preserved as literals so downstream `enumType` can
+ * carry the ordered value tuple in its type.
+ */
+declare function member<const Name extends string>(name: Name): EnumMember<Name, Name>;
+declare function member<const Name extends string, const Value extends string>(name: Name, value: Value): EnumMember<Name, Value>;
+type MembersToValues<Members extends readonly EnumMember<string, string>[]> = { readonly [K in keyof Members]: Members[K] extends EnumMember<string, infer V> ? V : never };
+type MembersToNames<Members extends readonly EnumMember<string, string>[]> = { readonly [K in keyof Members]: Members[K] extends EnumMember<infer N, string> ? N : never };
+type MembersAccessorMap<Members extends readonly EnumMember<string, string>[]> = { readonly [M in Members[number] as M['name']]: M['value'] };
+/**
+ * Internal brand that identifies an EnumTypeHandle in the lowering pipeline.
+ * Not exported — callers only interact with `EnumTypeHandle`.
+ */
+declare const ENUM_TYPE_HANDLE_BRAND: unique symbol;
+/**
+ * Authoring handle returned by `enumType()`. Carries:
+ *
+ * - The ordered literal value tuple (`.values`) and name tuple (`.names`)
+ *   so downstream type-tests can assert literal preservation.
+ * - A namespaced member accessor map (`.members`) to avoid collisions with
+ *   `.values` / `.has` / `.nameOf` / `.ordinalOf`.
+ * - Runtime helpers `.has()`, `.nameOf()`, `.ordinalOf()`.
+ * - Internal metadata (`enumName`, `codecId`, `nativeType`,
+ *   `enumMembers`) for the lowering pipeline.
+ *
+ * The type is generic over the ordered value tuple so callers that assign
+ * `const Role = enumType(...)` retain the literal tuple on `.values`.
+ */
+interface EnumTypeHandle<Name extends string = string, Values extends readonly string[] = readonly string[], Names extends readonly string[] = readonly string[], MembersMap extends Record<string, string> = Record<string, string>> {
+  /** Internal brand for lowering-pipeline detection. */
+  readonly [ENUM_TYPE_HANDLE_BRAND]: true;
+  /** The enum's declared name (used as the key in domain `enum` / storage `valueSet`). */
+  readonly enumName: Name;
+  /** codecId from the codec passed to `enumType`. */
+  readonly codecId: string;
+  /** nativeType from the codec passed to `enumType`. */
+  readonly nativeType: string;
+  /** Ordered member list for lowering (name + value pairs). */
+  readonly enumMembers: readonly {
+    readonly name: string;
+    readonly value: string;
+  }[];
+  /** Ordered literal value tuple. Declaration order is preserved. */
+  readonly values: Values;
+  /** Ordered literal name tuple. Declaration order is preserved. */
+  readonly names: Names;
+  /**
+   * Namespaced accessor map: `Role.members.User === 'user'`.
+   * Namespaced under `.members` to avoid collisions with `.values` / `.has`.
+   */
+  readonly members: MembersMap;
+  /** Returns `true` if `v` is a declared member value. */
+  has(v: string): boolean;
+  /** Returns the member name for a value, or `undefined` if not found. */
+  nameOf(v: string): string | undefined;
+  /** Returns the zero-based declaration index of a value, or `-1` if not found. */
+  ordinalOf(v: string): number;
+}
+/**
+ * Declare a domain enum for use in TS-authoring contracts.
+ *
+ * - The codec is an explicit required argument — the `codecId` and
+ *   `nativeType` are taken from the passed `ColumnTypeDescriptor` (e.g.
+ *   `{ codecId: 'pg/text@1', nativeType: 'text' }` from a field preset
+ *   output or a direct inline object).
+ * - `const` generics on the members spread preserve the ordered literal
+ *   value tuple so `Role.values` is `readonly ['user','admin']`, not
+ *   `string[]`.
+ * - Well-formedness assertions at construction: non-empty member list;
+ *   unique names; unique values.
+ *
+ * The returned handle wires into `field.namedType(handle)` to set
+ * `valueSet` refs on both the domain field and the storage column.
+ *
+ * @example
+ * ```ts
+ * const Role = enumType('Role', { codecId: 'pg/text@1', nativeType: 'text' },
+ *   member('User', 'user'),
+ *   member('Admin', 'admin'),
+ * );
+ * // Role.values → readonly ['user', 'admin']
+ * // Role.members.User → 'user'
+ * ```
+ */
+declare function enumType<const Name extends string, const Codec extends Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'>, const Members extends readonly [EnumMember<string, string>, ...EnumMember<string, string>[]]>(name: Name, codec: Codec, ...members: Members): EnumTypeHandle<Name, MembersToValues<[...Members]>, MembersToNames<[...Members]>, MembersAccessorMap<[...Members]>>;
+declare function enumType(name: string, codec: Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'>, ...members: EnumMember<string, string>[]): EnumTypeHandle;
+//#endregion
 //#region src/contract-dsl.d.ts
 type NamingStrategy = 'identity' | 'snake_case';
 type NamingConfig = {
   readonly tables?: NamingStrategy;
   readonly columns?: NamingStrategy;
 };
-type NamedStorageTypeRef = string | StorageTypeInstance | PostgresEnumStorageEntry;
+type NamedStorageTypeRef = string | StorageTypeInstance | PostgresEnumStorageEntry | EnumTypeHandle;
 type NamedConstraintNameSpec<Name extends string = string> = {
   readonly name: Name;
 };
@@ -78,6 +176,13 @@ declare class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFi
   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 CodecId, infer TypeRef, boolean, infer ColumnName, infer IdSpec, infer UniqueSpec> ? ScalarFieldState<CodecId, TypeRef, true, ColumnName, IdSpec, UniqueSpec> : never>;
   column<ColumnName extends string>(name: ColumnName): ScalarFieldBuilder<State extends ScalarFieldState<infer CodecId, infer TypeRef, infer Nullable, string | undefined, infer IdSpec, infer UniqueSpec> ? ScalarFieldState<CodecId, TypeRef, Nullable, ColumnName, IdSpec, UniqueSpec> : never>;
   default(value: ColumnDefaultLiteralInputValue | ColumnDefault): ScalarFieldBuilder<State>;
@@ -94,6 +199,7 @@ declare function generatedField<Descriptor extends ColumnTypeDescriptor>(spec: G
 declare function namedTypeField<TypeRef extends string>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<string, TypeRef, false, undefined>>;
 declare function namedTypeField<TypeRef extends StorageTypeInstance>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<TypeRef['codecId'], TypeRef, false, undefined>>;
 declare function namedTypeField<TypeRef extends PostgresEnumStorageEntry>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<string, TypeRef, false, undefined>>;
+declare function namedTypeField<Handle extends EnumTypeHandle>(typeRef: Handle): ScalarFieldBuilder<ScalarFieldState<Handle['codecId'], Handle, false, undefined>>;
 type RelationModelRefSource = 'string' | 'token' | 'lazyToken';
 type TargetFieldRefSource = 'string' | 'token';
 type EagerRelationModelName<ModelName extends string = string, Source extends Exclude<RelationModelRefSource, 'lazyToken'> = Exclude<RelationModelRefSource, 'lazyToken'>> = {
@@ -113,6 +219,22 @@ type BelongsToRelation<ToModel extends string = string, FromField extends string
   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';
@@ -142,17 +264,58 @@ declare class RelationBuilder<State extends RelationState = AnyRelationState> {
   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;
 };
-type TargetFieldRef<ModelName extends string = string, FieldName extends string = string, Source extends TargetFieldRefSource = TargetFieldRefSource> = {
+/**
+ * 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: Source;
+  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>> = { readonly [K in keyof Fields]: TargetFieldRef<ModelName, K & 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;
 };
@@ -198,6 +361,22 @@ type ForeignKeyConstraint<SourceFieldNames extends readonly string[] = readonly
   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';
@@ -227,6 +406,7 @@ type ModelAttributesSpec = {
 };
 type SqlStageSpec = {
   readonly table?: string;
+  readonly control?: ControlPolicy;
   readonly indexes?: readonly IndexConstraint[];
   readonly foreignKeys?: readonly ForeignKeyConstraint[];
 };
@@ -271,7 +451,7 @@ type SqlForeignKeys<SqlSpec extends SqlStageSpec> = SqlSpec extends {
 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>> {
+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;
@@ -280,23 +460,26 @@ declare class ContractModelBuilder<ModelName extends string | undefined, Fields
   };
   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 refs: ModelName extends string ? ModelTokenRefs<ModelName, Fields> : never;
+  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);
+  }, 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>;
-  attributes<const NextAttributesSpec extends ModelAttributesSpec>(specOrFactory: StageInput<AttributeContext<Fields>, ValidateAttributesStageSpec<Fields, SqlSpec, NextAttributesSpec>>): ContractModelBuilder<ModelName, Fields, Relations, NextAttributesSpec, SqlSpec, IndexTypes>;
-  sql<const NextSqlSpec extends SqlStageSpec>(specOrFactory: StageInput<SqlContext<Fields, IndexTypes>, NextSqlSpec>): [ValidateSqlStageSpec<Fields, AttributesSpec, NextSqlSpec>] extends [never] ? ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, never, IndexTypes> : ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, NextSqlSpec, IndexTypes>;
+  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;
 }
@@ -318,6 +501,7 @@ type ContractInput<Family extends FamilyPackRef<string> = FamilyPackRef<string>,
   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
@@ -366,6 +550,12 @@ type ContractInput<Family extends FamilyPackRef<string> = FamilyPackRef<string>,
   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>;
 };
 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;
@@ -377,6 +567,26 @@ declare function model<Fields extends Record<string, ScalarFieldBuilder>, Relati
   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;
@@ -513,7 +723,7 @@ type DefinitionNamespaces<Definition> = Definition extends {
 } ? 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, StorageTypeInstance | PostgresEnumStorageEntry> ? Present<Definition['types']> : Record<never, never> : Record<never, never>;
+} ? 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;
@@ -577,8 +787,8 @@ type DescriptorTypeParams<Descriptor> = Descriptor extends {
 type DescriptorTypeRef<Descriptor> = Descriptor extends {
   readonly typeRef: infer TypeRef extends string;
 } ? TypeRef : undefined;
-type LookupNamedStorageTypeKeyByValue<Definition, TypeRef extends StorageTypeInstance | PostgresEnumStorageEntry> = { [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 StorageTypeInstance | PostgresEnumStorageEntry ? [LookupNamedStorageTypeKeyByValue<Definition, TypeRef>] extends [never] ? string : LookupNamedStorageTypeKeyByValue<Definition, TypeRef> : never;
+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 ResolveFieldDescriptor<Definition, FieldState> = [FieldDescriptorOf<FieldState>] extends [never] ? ResolveNamedStorageType<Definition, FieldTypeRefOf<FieldState>> : FieldDescriptorOf<FieldState>;
 type ResolveFieldColumnTypeRef<Definition, FieldState> = [FieldTypeRefOf<FieldState>] extends [never] ? DescriptorTypeRef<FieldDescriptorOf<FieldState>> : ResolveNamedStorageTypeKey<Definition, FieldTypeRefOf<FieldState>>;
@@ -648,6 +858,7 @@ type BuiltStorageTables<Definition> = { readonly [ModelName in ModelNames<Defini
     };
     readonly target: {
       readonly namespaceId: NamespaceId;
+      readonly spaceId?: string;
       readonly tableName: string;
       readonly columns: readonly string[];
     };
@@ -663,7 +874,7 @@ type BuiltStorageTables<Definition> = { readonly [ModelName in ModelNames<Defini
     readonly name?: ModelIdName<Definition, ModelName>;
   };
 } : Record<string, never>) };
-type BuiltDocumentScopedTypes<Definition> = { readonly [K in keyof DefinitionTypes<Definition> as DefinitionTypes<Definition>[K] extends PostgresEnumStorageEntry ? never : K]: DefinitionTypes<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>;
@@ -676,13 +887,15 @@ type BuiltStorage<Definition> = {
   readonly namespaces: { readonly [K in DefaultStorageNamespaceId<Definition>]: {
     readonly id: K;
     readonly kind: string;
-    readonly tables: BuiltStorageTables<Definition>;
-    readonly enum?: Readonly<Record<string, PostgresEnumStorageEntry>>;
+    readonly entries: {
+      readonly table: BuiltStorageTables<Definition>;
+    };
   } } & { readonly [Ns in Exclude<DefinitionNamespaces<Definition>, DefaultStorageNamespaceId<Definition>>]: {
     readonly id: Ns;
     readonly kind: string;
-    readonly tables: Record<never, never>;
-    readonly enum?: Readonly<Record<string, PostgresEnumStorageEntry>>;
+    readonly entries: {
+      readonly table: Record<never, never>;
+    };
   } };
 };
 type FieldOutputType<Definition, ModelName extends ModelNames<Definition>, FieldName extends ModelFieldNames<Definition, ModelName>> = ModelStorageColumn<Definition, ModelName, FieldName> extends infer Col ? Col extends {
@@ -758,6 +971,8 @@ interface FieldNode {
   readonly default?: ColumnDefault;
   readonly executionDefaults?: ExecutionMutationDefaultPhases$1;
   readonly many?: boolean;
+  /** Present when the field was authored with `field.namedType(enumHandle)`. */
+  readonly enumTypeHandle?: EnumTypeHandle;
 }
 interface PrimaryKeyNode {
   readonly columns: readonly string[];
@@ -786,6 +1001,12 @@ interface ForeignKeyNode {
      * 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;
@@ -797,7 +1018,26 @@ 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[];
@@ -843,9 +1083,19 @@ interface ModelNode {
   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 extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
@@ -853,7 +1103,7 @@ interface ContractDefinition {
   /**
    * Enum types declared inside a named `namespace { enum … }` block,
    * keyed first by namespace id then by type name. These are routed to
-   * `storage.namespaces[nsId].enum` rather than the implicit fallback
+   * `storage.namespaces[nsId].entries.type` rather than the implicit fallback
    * namespace used for top-level `storageTypes` enums.
    */
   readonly namespaceTypes?: Readonly<Record<string, Readonly<Record<string, PostgresEnumStorageEntry>>>>;
@@ -866,10 +1116,19 @@ interface ContractDefinition {
    * Target-supplied factory that materialises a `Namespace` concretion
    * for a declared namespace coordinate. Mirrors
    * `ContractInput.createNamespace`.
+   *
+   * The optional second argument carries target-specific enum types for the
+   * namespace (e.g. postgres enum registrations keyed by type name).
    */
-  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly createNamespace?: (input: SqlNamespaceTablesInput, enumTypes?: Readonly<Record<string, PostgresEnumStorageEntry>>) => Namespace;
   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>;
 }
 //#endregion
 //#region src/build-contract.d.ts
@@ -895,11 +1154,13 @@ type ContractDefinition$1<Family extends FamilyPackRef<string>, Target extends T
   readonly naming?: Naming;
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
+  readonly defaultControlPolicy?: ControlPolicy;
   readonly namespaces?: Namespaces;
   readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
+  readonly enums?: Record<string, EnumTypeHandle>;
 };
 type ContractScaffold<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, ExtensionPacks 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> = {
   readonly family: Family;
@@ -908,18 +1169,53 @@ type ContractScaffold<Family extends FamilyPackRef<string>, Target extends Targe
   readonly naming?: Naming;
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
+  readonly defaultControlPolicy?: ControlPolicy;
   readonly namespaces?: Namespaces;
   readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
   readonly types?: never;
   readonly models?: never;
   readonly codecLookup?: CodecLookup;
+  readonly enums?: Record<string, EnumTypeHandle>;
 };
 type ContractFactory<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry>, Models extends Record<string, ModelLike>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined> = (helpers: ComposedAuthoringHelpers<Family, Target, ExtensionPacks>) => {
   readonly types?: Types;
   readonly models?: Models;
 };
+type BoundDefinitionInput<Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = Record<never, never>, Models extends Record<string, ModelLike> = Record<never, never>, ExtensionPacks 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 extensionPacks?: ExtensionPacks;
+  readonly naming?: Naming;
+  readonly storageHash?: StorageHash;
+  readonly foreignKeyDefaults?: ForeignKeyDefaults;
+  readonly defaultControlPolicy?: ControlPolicy;
+  readonly namespaces?: Namespaces;
+  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly types?: Types;
+  readonly models?: Models;
+  readonly codecLookup?: CodecLookup;
+  readonly enums?: Record<string, EnumTypeHandle>;
+};
+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 | PostgresEnumStorageEntry>, 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 | PostgresEnumStorageEntry>, 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 | PostgresEnumStorageEntry>;
+  readonly models?: Record<string, ModelLike>;
+}>(family: F, target: T, definition: Definition, factory: (helpers: ComposedAuthoringHelpers<F, T, NonNullable<Definition['extensionPacks']>>) => 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 | PostgresEnumStorageEntry> = Record<never, never>, const Models extends Record<string, ModelLike> = Record<never, never>, const ExtensionPacks 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>(definition: ContractDefinition$1<Family, Target, Types, Models, ExtensionPacks, Naming, StorageHash, ForeignKeyDefaults, Namespaces>): SqlContractResult<ContractDefinition$1<Family, Target, Types, Models, ExtensionPacks, Naming, StorageHash, ForeignKeyDefaults, Namespaces>>;
 declare function defineContract<const Family extends FamilyPackRef<string>, const Target extends TargetPackRef<'sql', string>, const Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = Record<never, never>, const Models extends Record<string, ModelLike> = Record<never, never>, const ExtensionPacks 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>(definition: ContractScaffold<Family, Target, ExtensionPacks, Naming, StorageHash, ForeignKeyDefaults, Namespaces>, factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks>): SqlContractResult<ContractDefinition$1<Family, Target, Types, Models, ExtensionPacks, Naming, StorageHash, ForeignKeyDefaults, Namespaces>>;
 //#endregion
-export { type ComposedAuthoringHelpers, type ContractDefinition, type ContractInput, type ContractModelBuilder, type FieldNode, type ForeignKeyNode, type IndexNode, type ModelLike, type ModelNode, type PrimaryKeyNode, type RelationNode, type ScalarFieldBuilder, type UniqueConstraintNode, buildSqlContractFromDefinition, defineContract, field, model, rel };
+export { type ComposedAuthoringHelpers, type ContractDefinition, type ContractInput, type ContractModelBuilder, type EnumMember, type EnumTypeHandle, type FieldNode, type ForeignKeyNode, type IndexNode, type ModelLike, type ModelNode, type PrimaryKeyNode, type RelationNode, type ScalarFieldBuilder, type TargetFieldRef, type UniqueConstraintNode, buildBoundContract, buildSqlContractFromDefinition, defineContract, enumType, extensionModel, field, member, model, rel };
 //# sourceMappingURL=contract-builder.d.mts.map