@prisma/orm-family-sql 8.0.0-rc.18-dev.7 → 8.0.0-rc.18-dev.8

package/dist/{contract-builder-C4fgERNT.d.mts → contract-builder-ClsLO9DI.d.mts}

@@ -1,11 +1,10 @@
 import { t as CheckKind } from "./naming-BcD36g9T-DFyaudUa.mjs";
 import { n as ForeignKeyIndex, o as ReferentialAction } from "./foreign-key-qkDFfG8t-Fyrzd0VI.mjs";
-import { t as Index } from "./sql-index-ByAAE7K8-BpbPBWPD.mjs";
 import { a as SqlNamespaceBase, c as SqlNamespaceInput, l as SqlStorage, t as AuthoredStorageTypeInstance } from "./sql-storage-BTlJLUID-CGy3wuH4.mjs";
-import { P as TypeMaps, o as ContractWithTypeMaps } from "./types-DFZhLz18-Msi8wwig.mjs";
-import "./types-Uv3oTMAb.mjs";
+import { O as QueryOperationTypesFunction, c as ContractWithTypeMaps, i as AggregateTypesFromDescriptors, o as ApplyQueryOperationTypes } from "./types-zwKzjyma-CxZkmkUI.mjs";
+import { n as FieldTypesFromDomain, t as ColumnTypesFromStorage } from "./types-HD5m-h8B.mjs";
 import { r as PackEntityHandle } from "./entity-handle-lowering-hook-93syhZ0p.mjs";
-import "./derived-checks-DpPkO6Dt-ZEbWeWKL.mjs";
+import "./derived-checks-DpPkO6Dt--oL-Zi3r.mjs";
 import { r as SqlExpression } from "./sql-expression-BWrjmY6M.mjs";
 import { i as IndexTypeRegistration } from "./index-types-H1O43iYT-ONvDbszL.mjs";
 import "./index-types-ByX8MLso.mjs";
@@ -13,7 +12,7 @@ import { n as AuthoredIndexMethod } from "./index-naming-C7pme5Pj.mjs";
 import { AuthoringArgumentDescriptor, AuthoringFieldPresetDescriptor, AuthoringTypeConstructorDescriptor, AuthoringWarning } from "@prisma/orm-framework/components/authoring";
 import { StorageType } from "@prisma/orm-framework/components/ir";
 import { CodecLookupWithDescriptors, ColumnTypeDescriptor, DataTypeLookup, ScalarFieldDeclarationBuilder } from "@prisma/orm-framework/components/codec";
-import { ColumnDefault, Contract, ContractEnum, ContractRelation, ContractValueObject, ControlPolicy, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue, NamespaceId, StorageHashBase } from "@prisma/orm-framework/contract/types";
+import { ColumnDefault, Contract, ContractExecutionSection, ContractRelation, ControlPolicy, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue, JsonValue, NamespaceId, ParameterizedOutputTypesFunction, StorageHashBase } from "@prisma/orm-framework/contract/types";
 import { ExtensionPackRef, FamilyPackRef, TargetPackRef } from "@prisma/orm-framework/components/components";
 import { BoundEnumType, CodecInput, CodecInput as CodecInput$1, CodecTypeMap, CodecTypeMap as CodecTypeMap$1, EntityHelpersFromNamespace, EnumMember, EnumTypeHandle, ExtractAuthoringNamespaceFromPack, ForeignKeyDefaultsState, MergeExtensionAuthoringNamespaces, ResolveTemplateValue, TupleFromArgumentDescriptors, bindEnumType, enumType, member } from "@prisma/orm-framework/contract-authoring";
 //#region ../../../2-sql/2-authoring/contract-ts/dist/contract-builder.d.mts
@@ -292,10 +291,16 @@ interface TableNode extends TableProperties {
   readonly tableName: string;
   readonly columns: readonly ColumnNode[];
 }
+/** A component whose capabilities a contract carries, such as an adapter. */
+type CapabilityContributor = {
+  readonly capabilities: Readonly<Record<string, Readonly<Record<string, boolean>>>>;
+};
 interface ContractDefinition {
   readonly target: TargetPackRef<'sql', string>;
   readonly defaultControlPolicy?: ControlPolicy;
   readonly extensions?: Record<string, ExtensionPackRef<'sql', string>>;
+  /** Capabilities of the stack the contract runs with beyond its target's and extensions', such as its adapter's. They join the target's and the extensions', as `prisma contract emit` joins them. */
+  readonly capabilities?: CapabilityContributor['capabilities'];
   /**
    * Test-fixture escape hatch: pins the emitted `storage.storageHash`
    * instead of computing it from content. A pinned hash is not
@@ -356,8 +361,10 @@ type NamedConstraintNameSpec<Name extends string = string> = {
 };
 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 false | {
   readonly elementNullable: boolean;
-} = false> = {
+} = false, Defaults extends FieldDefaultPresence = FieldDefaultPresence> = {
   readonly kind: 'scalar';
+  /** Exists only in types: whether the column has a database default and whether the client generates a value on create. */
+  readonly __defaultPresence?: Defaults;
   readonly descriptor?: Descriptor | undefined;
   readonly typeRef?: TypeRef | undefined;
   readonly nullable: Nullable;
@@ -375,6 +382,15 @@ type ScalarFieldState<Descriptor extends ColumnTypeDescriptor = ColumnTypeDescri
 } : {
   readonly unique?: undefined;
 });
+/** Whether a field's column has a database default, and whether the client generates its value on create. */
+type FieldDefaultPresence = {
+  readonly column: boolean;
+  readonly execution: boolean;
+};
+type WithColumnDefault<State extends AnyScalarFieldState> = State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec, infer Many, infer Defaults> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, UniqueSpec, Many, {
+  readonly column: true;
+  readonly execution: Defaults['execution'];
+}> : State;
 type AnyScalarFieldState = {
   readonly kind: 'scalar';
   readonly descriptor?: ColumnTypeDescriptor | undefined;
@@ -403,7 +419,7 @@ type FieldSqlSpecForState<State extends AnyScalarFieldState> = {
 } : 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 {
+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, infer Defaults> ? ScalarFieldState<Descriptor, TypeRef, Nullable, Spec extends {
   readonly column: infer NextColumn extends string;
 } ? NextColumn : ColumnName, Spec extends {
   readonly id: {
@@ -413,7 +429,7 @@ type ApplyFieldSqlSpec<State extends AnyScalarFieldState, Spec extends FieldSqlS
   readonly unique: {
     readonly name: infer UniqueName extends string;
   };
-} ? UniqueSpec extends NamedConstraintSpec ? NamedConstraintSpec<UniqueName> : UniqueSpec : UniqueSpec, Many> : AnyScalarFieldState;
+} ? UniqueSpec extends NamedConstraintSpec ? NamedConstraintSpec<UniqueName> : UniqueSpec : UniqueSpec, Many, Defaults> : AnyScalarFieldState;
 type GeneratedFieldSpec = {
   readonly type: ColumnTypeDescriptor;
   readonly typeParams?: Record<string, unknown>;
@@ -446,9 +462,9 @@ type DefaultArgumentOf<State> = ([EnumHandleOf<State>] extends [never] ? Default
 } ? null : never);
 type ApplyMany<State extends AnyScalarFieldState, ElementsNullable extends boolean> = State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec, false | {
   readonly elementNullable: boolean;
-}> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, UniqueSpec, {
+}, infer Defaults> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, UniqueSpec, {
   readonly elementNullable: ElementsNullable;
-}> : AnyScalarFieldState;
+}, Defaults> : AnyScalarFieldState;
 type ManyOptions = {
   readonly elementsNullable: true;
 } | {
@@ -465,8 +481,8 @@ declare class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFi
    * `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>;
+  optional(): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, boolean, infer ColumnName, infer IdSpec, infer UniqueSpec, infer Many, infer Defaults> ? ScalarFieldState<Descriptor, TypeRef, true, ColumnName, IdSpec, UniqueSpec, Many, Defaults> : 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, infer Defaults> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, UniqueSpec, Many, Defaults> : AnyScalarFieldState>;
   many(): ScalarFieldBuilder<ApplyMany<State, false>>;
   many(options: {
     readonly elementsNullable: true;
@@ -484,13 +500,13 @@ declare class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFi
   noCheck(...kinds: readonly CheckKind[]): ScalarFieldBuilder<State>;
   default<Self extends {
     readonly __state: AnyScalarFieldState;
-  }>(this: Self, value: DefaultArgumentOf<Self['__state']>): ScalarFieldBuilder<State>;
+  }>(this: Self, value: DefaultArgumentOf<Self['__state']>): ScalarFieldBuilder<WithColumnDefault<State>>;
   /**
    * @deprecated Write `.default(now())` or `.default(autoincrement())`, or `` .default(sql`...`) `` for any other SQL. Removed in 8.0.0.
    */
-  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>;
+  defaultSql(expression: string): ScalarFieldBuilder<WithColumnDefault<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, infer Defaults> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, NamedConstraintSpec<Name>, UniqueSpec, Many, Defaults> : AnyScalarFieldState>;
+  unique<const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, infer ColumnName, infer IdSpec, NamedConstraintSpec | undefined, infer Many, infer Defaults> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, NamedConstraintSpec<Name>, Many, Defaults> : AnyScalarFieldState>;
   sql<const Spec extends FieldSqlSpecForState<State>>(spec: Spec): ScalarFieldBuilder<ApplyFieldSqlSpec<State, Spec>>;
   build(): State;
 }
@@ -499,7 +515,7 @@ declare class EnumScalarFieldBuilder<Handle extends EnumTypeHandle, State extend
   constructor(state: State, handle: Handle);
   default<Self extends {
     readonly __state: AnyScalarFieldState;
-  }>(this: Self, value: DefaultArgumentOf<Self['__state']>): EnumScalarFieldBuilder<Handle, State>;
+  }>(this: Self, value: DefaultArgumentOf<Self['__state']>): EnumScalarFieldBuilder<Handle, WithColumnDefault<State>>;
   defaultSql(_expression: never): never;
 }
 type CodecTypesOfNoPacks = Record<never, never>;
@@ -509,9 +525,16 @@ type NamedTypeFieldHelper<CodecTypes extends CodecTypeMap = CodecTypesOfNoPacks>
   <TypeRef extends AuthoredStorageTypeInstance>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<WithCodecInput<ColumnTypeDescriptor<TypeRef['codecId']>, CodecInput<CodecTypes, TypeRef>>, TypeRef, false, undefined>>;
   <Handle extends EnumTypeHandle>(typeRef: Handle): EnumScalarFieldBuilder<Handle>;
 };
-declare function generatedField<Descriptor extends ColumnTypeDescriptor>(spec: GeneratedFieldSpec & {
+type WithGeneratedTypeParams<Descriptor, TypeParams> = TypeParams extends Record<string, unknown> ? Descriptor & {
+  readonly typeParams: TypeParams;
+} : Descriptor;
+declare function generatedField<Descriptor extends ColumnTypeDescriptor, TypeParams extends Record<string, unknown> | undefined = undefined>(spec: GeneratedFieldSpec & {
   readonly type: Descriptor;
-}): ScalarFieldBuilder<ScalarFieldState<Descriptor, undefined, false, undefined>>;
+  readonly typeParams?: TypeParams;
+}): ScalarFieldBuilder<ScalarFieldState<WithGeneratedTypeParams<Descriptor, TypeParams>, undefined, false, undefined, undefined, undefined, false, {
+  readonly column: false;
+  readonly execution: true;
+}>>;
 type RelationModelRefSource = 'string' | 'token' | 'lazyToken';
 type TargetFieldRefSource = 'string' | 'token';
 type EagerRelationModelName<ModelName extends string = string, Source extends Exclude<RelationModelRefSource, 'lazyToken'> = Exclude<RelationModelRefSource, 'lazyToken'>> = {
@@ -525,8 +548,10 @@ type LazyRelationModelName<ModelName extends string = string> = {
   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> = {
+type BelongsToRelation<ToModel extends string = string, FromField extends string | readonly string[] = string | readonly string[], ToField extends string | readonly string[] = string | readonly string[], SqlSpec extends BelongsToRelationSqlSpec | undefined = undefined, TargetSpaceId extends string = string> = {
   readonly kind: 'belongsTo';
+  /** The contract space of the target model, `'<self>'` for this contract's own models. Type-only. */
+  readonly __targetSpaceId?: TargetSpaceId;
   readonly toModel: RelationModelSource<ToModel>;
   readonly from: FromField;
   readonly to: ToField;
@@ -573,7 +598,7 @@ type ManyToManyRelation<ToModel extends string = string, ThroughModel extends st
 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;
+type ApplyBelongsToRelationSqlSpec<State extends RelationState, SqlSpec extends BelongsToRelationSqlSpec> = State extends BelongsToRelation<infer ToModel, infer FromField, infer ToField, BelongsToRelationSqlSpec | undefined, infer TargetSpaceId> ? BelongsToRelation<ToModel, FromField, ToField, SqlSpec, TargetSpaceId> : never;
 declare class RelationBuilder<State extends RelationState = AnyRelationState> {
   private readonly state;
   readonly __state: State;
@@ -654,6 +679,20 @@ type IndexInput<Name extends string | undefined, IndexTypes extends IndexTypeMap
   readonly type: K;
   readonly options: IndexOptionsInput<IndexTypes[K]['options']>;
 }; }[keyof IndexTypes & string];
+type IndexSpecCapture<Map, Type, Where, Unique, IndexTypes extends IndexTypeMap> = {
+  readonly map?: Map;
+  readonly where?: Where;
+  readonly unique?: Unique;
+} & (keyof IndexTypes extends never ? Record<never, never> : {
+  readonly type?: Type;
+});
+type IndexSpecFrom<Map, Type, Where, Unique, IndexTypes extends IndexTypeMap> = {
+  readonly map: Map;
+  readonly type: Type;
+  readonly options: Type extends keyof IndexTypes ? IndexTypes[Type]['options'] extends (infer Options extends Record<string, unknown>) ? Options : Record<string, unknown> : undefined;
+  readonly partial: [Where] extends [undefined] ? false : true;
+  readonly unique: Unique;
+};
 /**
  * The expression overload's input: the whole CREATE INDEX element list as
  * one opaque `sql` value. `name` or `map` is required — enforced at lowering
@@ -731,12 +770,28 @@ type IndexConstraintMethod = {
   readonly type: string;
   readonly options?: IndexOptionsInput;
 };
-type IndexConstraint<FieldNames extends readonly string[] = readonly string[], Name extends string | undefined = string | undefined> = IndexConstraintElements<FieldNames> & IndexConstraintMethod & {
+/**
+ * An index's options as a function of its model's columns: `options` reads `this['columnOf']`, which maps each field name of the model to its column name. A helper whose options name fields, such as a full-text index's weight groups, declares one so the contract's type states the options with column names, as the build writes them.
+ */
+interface IndexOptionsFunction {
+  readonly columnOf: Record<never, string>;
+  readonly options: unknown;
+}
+/** What an index's type records beyond its fields and name: its exact `map` name, its type, and its options or a function that gives them. Exists only in types. */
+type IndexSpec = {
+  readonly map?: string | undefined;
+  readonly type?: string | undefined;
+  readonly options?: unknown;
+  readonly partial?: boolean;
+  readonly unique?: boolean | undefined;
+};
+type IndexConstraint<FieldNames extends readonly string[] = readonly string[], Name extends string | undefined = string | undefined, Spec extends IndexSpec = IndexSpec> = IndexConstraintElements<FieldNames> & IndexConstraintMethod & {
   readonly kind: 'index';
   readonly where?: SqlExpression;
   readonly unique?: boolean;
   readonly name?: Name;
   readonly map?: string;
+  readonly __spec?: Spec;
 };
 /**
  * An authored check constraint, as returned by {@link check}: `map` adopts an
@@ -750,7 +805,7 @@ type AuthoredCheckConstraint = {
   readonly name?: string;
   readonly map?: string;
 };
-type ForeignKeyConstraint<SourceFieldNames extends readonly string[] = readonly string[], TargetModelName extends string = string, TargetFieldNames extends readonly string[] = readonly string[], Name extends string | undefined = string | undefined> = {
+type ForeignKeyConstraint<SourceFieldNames extends readonly string[] = readonly string[], TargetModelName extends string = string, TargetFieldNames extends readonly string[] = readonly string[], Name extends string | undefined = string | undefined, Index extends boolean | string | undefined = boolean | string | undefined> = {
   readonly kind: 'fk';
   readonly fields: SourceFieldNames;
   readonly targetModel: TargetModelName;
@@ -776,7 +831,7 @@ type ForeignKeyConstraint<SourceFieldNames extends readonly string[] = readonly
   readonly onDelete?: 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
   readonly onUpdate?: 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
   readonly constraint?: boolean;
-  readonly index?: boolean | string;
+  readonly index?: Index;
 };
 declare function createConstraintsDsl<IndexTypes extends IndexTypeMap = Record<never, never>>(): {
   ref: <ModelName extends string, FieldName extends string>(modelName: ModelName, fieldName: FieldName) => TargetFieldRef<ModelName, FieldName>;
@@ -789,12 +844,16 @@ declare function createConstraintsDsl<IndexTypes extends IndexTypeMap = Record<n
     <FieldNames extends readonly string[], const Name extends string | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: ConstraintOptions<Name>): UniqueConstraint<FieldNames, Name>;
   };
   index: {
-    <FieldNames extends readonly string[], const Name extends string | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: IndexInput<Name, IndexTypes>): IndexConstraint<FieldNames, Name>;
-    <const Name extends string | undefined = undefined>(options: ExpressionIndexInput<Name, IndexTypes>): IndexConstraint<never, Name>;
+    <FieldNames extends readonly string[], const Name extends string | undefined = undefined, const Map extends string | undefined = undefined, const Type extends (keyof IndexTypes & string) | undefined = undefined, const Where extends SqlExpression | undefined = undefined, const Unique extends boolean | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: IndexInput<Name, IndexTypes> & IndexSpecCapture<Map, Type, Where, Unique, IndexTypes>): IndexConstraint<FieldNames, NoInfer<Name>, IndexSpecFrom<NoInfer<Map>, NoInfer<Type>, NoInfer<Where>, NoInfer<Unique>, IndexTypes>>;
+    <const Name extends string | undefined = undefined, const Map extends string | undefined = undefined, const Type extends (keyof IndexTypes & string) | undefined = undefined, const Where extends SqlExpression | undefined = undefined, const Unique extends boolean | undefined = undefined>(options: ExpressionIndexInput<Name, IndexTypes> & IndexSpecCapture<Map, Type, Where, Unique, IndexTypes>): IndexConstraint<never, NoInfer<Name>, IndexSpecFrom<NoInfer<Map>, NoInfer<Type>, NoInfer<Where>, NoInfer<Unique>, IndexTypes>>;
   };
   foreignKey: {
-    <SourceFieldName extends string, TargetModelName extends string, TargetFieldName extends string, const Name extends string | undefined = undefined>(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[], const 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>;
+    <SourceFieldName extends string, TargetModelName extends string, TargetFieldName extends string, const Name extends string | undefined = undefined, const Index extends boolean | string | undefined = undefined>(field: ColumnRef<SourceFieldName>, target: TargetFieldRef<TargetModelName, TargetFieldName>, options?: ForeignKeyOptions<Name> & {
+      readonly index?: Index;
+    }): ForeignKeyConstraint<readonly [SourceFieldName], TargetModelName, readonly [TargetFieldName], Name, Index>;
+    <SourceFieldNames extends readonly string[], TargetModelName extends string, TargetFieldNames extends readonly string[], const Name extends string | undefined = undefined, const Index extends boolean | string | undefined = undefined>(fields: { readonly [K in keyof SourceFieldNames]: ColumnRef<SourceFieldNames[K] & string>; }, target: { readonly [K in keyof TargetFieldNames]: TargetFieldRef<TargetModelName, TargetFieldNames[K] & string>; }, options?: ForeignKeyOptions<Name> & {
+      readonly index?: Index;
+    }): ForeignKeyConstraint<SourceFieldNames, TargetModelName, TargetFieldNames, Name, Index>;
   };
 };
 type ConstraintsDsl = ReturnType<typeof createConstraintsDsl>;
@@ -826,8 +885,8 @@ type AttributeContext<Fields extends Record<string, ScalarFieldBuilder>> = {
   readonly constraints: Pick<ConstraintsDsl, 'id' | 'unique'>;
 };
 type PackAwareIndex<IndexTypes extends IndexTypeMap> = {
-  <FieldNames extends readonly string[], const Name extends string | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: IndexInput<Name, IndexTypes>): IndexConstraint<FieldNames, Name>;
-  <const Name extends string | undefined = undefined>(options: ExpressionIndexInput<Name, IndexTypes>): IndexConstraint<never, Name>;
+  <FieldNames extends readonly string[], const Name extends string | undefined = undefined, const Map extends string | undefined = undefined, const Type extends (keyof IndexTypes & string) | undefined = undefined, const Where extends SqlExpression | undefined = undefined, const Unique extends boolean | undefined = undefined>(fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string>; }, options?: IndexInput<Name, IndexTypes> & IndexSpecCapture<Map, Type, Where, Unique, IndexTypes>): IndexConstraint<FieldNames, NoInfer<Name>, IndexSpecFrom<NoInfer<Map>, NoInfer<Type>, NoInfer<Where>, NoInfer<Unique>, IndexTypes>>;
+  <const Name extends string | undefined = undefined, const Map extends string | undefined = undefined, const Type extends (keyof IndexTypes & string) | undefined = undefined, const Where extends SqlExpression | undefined = undefined, const Unique extends boolean | undefined = undefined>(options: ExpressionIndexInput<Name, IndexTypes> & IndexSpecCapture<Map, Type, Where, Unique, IndexTypes>): IndexConstraint<never, NoInfer<Name>, IndexSpecFrom<NoInfer<Map>, NoInfer<Type>, NoInfer<Where>, NoInfer<Unique>, IndexTypes>>;
 };
 type PackAwareSqlConstraints<IndexTypes extends IndexTypeMap> = {
   readonly foreignKey: ConstraintsDsl['foreignKey'];
@@ -931,11 +990,16 @@ type AnyNamedModelToken = NamedModelTokenShape<string, Record<string, ScalarFiel
 type LazyNamedModelToken<Token extends AnyNamedModelToken = AnyNamedModelToken> = () => Token;
 type RelationFieldSelection<FieldName extends string> = FieldName | readonly FieldName[];
 type RelationModelName<Target> = Target extends NamedModelTokenShape<infer ModelName extends string, Record<string, ScalarFieldBuilder>> ? ModelName : Target extends (() => infer Token) ? RelationModelName<Token> : never;
+type RelationSpaceId<Target> = Target extends {
+  readonly __spaceId: infer SpaceId extends string;
+} ? SpaceId : Target extends (() => infer Token) ? RelationSpaceId<Token> : '<self>';
 type RelationModelFieldNames<Target> = Target extends NamedModelTokenShape<string, infer Fields> ? keyof Fields & string : Target extends (() => infer Token) ? RelationModelFieldNames<Token> : never;
 type ContractInput<Family extends FamilyPackRef<string> = FamilyPackRef<string>, Target extends TargetPackRef<'sql', string> = TargetPackRef<'sql', string>, Types extends Record<string, AuthoredStorageTypeInstance> = Record<never, never>, Models extends Record<string, ContractModelBuilder<string | undefined, Record<string, ScalarFieldBuilder>, Record<string, AnyRelationBuilder>, ModelAttributesSpec | undefined, SqlStageSpec | undefined>> = Record<never, never>, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined> = {
   readonly family: Family;
   readonly target: Target;
   readonly extensions?: Extensions;
+  /** The adapter the contract runs with. Its capabilities join the target's and the extensions', as `prisma contract emit` and the runtime join them. The Postgres and SQLite `defineContract` supply it. */
+  readonly adapter?: CapabilityContributor;
   readonly naming?: NamingConfig;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
@@ -1031,34 +1095,34 @@ declare function extensionModel<const ModelName extends string, Fields extends R
   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: {
+declare function belongsTo<Token extends AnyNamedModelToken, const FromField extends string | readonly string[], const ToField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
   readonly from: FromField;
   readonly to: ToField;
   readonly optional?: boolean;
-}): RelationBuilder<BelongsToRelation<RelationModelName<Token>, FromField, ToField>>;
-declare function belongsTo<ToModel extends string, FromField extends string | readonly string[], ToField extends string | readonly string[]>(toModel: ToModel, options: {
+}): RelationBuilder<BelongsToRelation<RelationModelName<Token>, FromField, ToField, undefined, RelationSpaceId<Token>>>;
+declare function belongsTo<ToModel extends string, const FromField extends string | readonly string[], const ToField extends string | readonly string[]>(toModel: ToModel, options: {
   readonly from: FromField;
   readonly to: ToField;
   readonly optional?: boolean;
-}): RelationBuilder<BelongsToRelation<ToModel, FromField, ToField>>;
-declare function hasMany<Token extends AnyNamedModelToken, ByField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
+}): RelationBuilder<BelongsToRelation<ToModel, FromField, ToField, undefined, '<self>'>>;
+declare function hasMany<Token extends AnyNamedModelToken, const ByField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
   readonly by: ByField;
 }): RelationBuilder<HasManyRelation<RelationModelName<Token>, ByField>>;
-declare function hasMany<ToModel extends string, ByField extends string | readonly string[]>(toModel: ToModel, options: {
+declare function hasMany<ToModel extends string, const ByField extends string | readonly string[]>(toModel: ToModel, options: {
   readonly by: ByField;
 }): RelationBuilder<HasManyRelation<ToModel, ByField>>;
-declare function hasOne<Token extends AnyNamedModelToken, ByField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
+declare function hasOne<Token extends AnyNamedModelToken, const ByField extends RelationFieldSelection<RelationModelFieldNames<Token>>>(toModel: Token | LazyNamedModelToken<Token>, options: {
   readonly by: ByField;
 }): RelationBuilder<HasOneRelation<RelationModelName<Token>, ByField>>;
-declare function hasOne<ToModel extends string, ByField extends string | readonly string[]>(toModel: ToModel, options: {
+declare function hasOne<ToModel extends string, const ByField extends string | readonly string[]>(toModel: ToModel, options: {
   readonly by: ByField;
 }): RelationBuilder<HasOneRelation<ToModel, ByField>>;
-declare function manyToMany<ToToken extends AnyNamedModelToken, ThroughToken extends AnyNamedModelToken, FromField extends RelationFieldSelection<RelationModelFieldNames<ThroughToken>>, ToField extends RelationFieldSelection<RelationModelFieldNames<ThroughToken>>>(toModel: ToToken | LazyNamedModelToken<ToToken>, options: {
+declare function manyToMany<ToToken extends AnyNamedModelToken, ThroughToken extends AnyNamedModelToken, const FromField extends RelationFieldSelection<RelationModelFieldNames<ThroughToken>>, const ToField extends RelationFieldSelection<RelationModelFieldNames<ThroughToken>>>(toModel: ToToken | LazyNamedModelToken<ToToken>, options: {
   readonly through: ThroughToken | LazyNamedModelToken<ThroughToken>;
   readonly from: FromField;
   readonly to: ToField;
 }): RelationBuilder<ManyToManyRelation<RelationModelName<ToToken>, RelationModelName<ThroughToken>, FromField, ToField>>;
-declare function manyToMany<ToModel extends string, ThroughModel extends string, FromField extends string | readonly string[], ToField extends string | readonly string[]>(toModel: ToModel, options: {
+declare function manyToMany<ToModel extends string, ThroughModel extends string, const FromField extends string | readonly string[], const ToField extends string | readonly string[]>(toModel: ToModel, options: {
   readonly through: ThroughModel;
   readonly from: FromField;
   readonly to: ToField;
@@ -1093,9 +1157,29 @@ type SupportsNamedConstraintOptions<Descriptor extends AuthoringFieldPresetDescr
   readonly unique: true;
 } ? true : false;
 type PresetCodecId<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[]> = ResolveTemplateValue<Descriptor['output']['codecId'], Args> extends string ? ResolveTemplateValue<Descriptor['output']['codecId'], Args> : string;
-type FieldBuilderFromPresetDescriptor<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[] = readonly [], ConstraintName extends string | undefined = undefined, CodecTypes extends CodecTypeMap = Record<never, never>> = ScalarFieldBuilder<ScalarFieldState<WithCodecInput<ColumnTypeDescriptor<PresetCodecId<Descriptor, Args>>, CodecInput<CodecTypes, {
+type DefinedTypeParams<TypeParams> = { readonly [K in keyof TypeParams as TypeParams[K] extends undefined ? never : K]: TypeParams[K]; };
+type PresetTypeParams<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[]> = Descriptor['output'] extends {
+  readonly typeParams: infer Template;
+} ? DefinedTypeParams<ResolveTemplateValue<Template, Args>> extends (infer TypeParams) ? keyof TypeParams extends never ? Record<never, never> : {
+  readonly typeParams: TypeParams;
+} : Record<never, never> : Record<never, never>;
+type PresetPhaseTemplate<Defaults, Phase extends 'onCreate' | 'onUpdate'> = Defaults extends { readonly [K in Phase]: infer Template; } ? Template : undefined;
+type PresetPhasePresent<Template, Args extends readonly unknown[]> = Template extends {
+  readonly kind: 'select';
+  readonly index: infer Index extends number;
+  readonly cases: infer Cases;
+} ? Args[Index] extends keyof Cases ? true : false : [Template] extends [undefined] ? false : true;
+type PresetHasExecutionDefault<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[]> = Descriptor['output'] extends {
+  readonly executionDefaults: infer Defaults;
+} ? true extends PresetPhasePresent<PresetPhaseTemplate<Defaults, 'onCreate'>, Args> | PresetPhasePresent<PresetPhaseTemplate<Defaults, 'onUpdate'>, Args> ? true : false : false;
+type FieldBuilderFromPresetDescriptor<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[] = readonly [], ConstraintName extends string | undefined = undefined, CodecTypes extends CodecTypeMap = Record<never, never>> = ScalarFieldBuilder<ScalarFieldState<WithCodecInput<ColumnTypeDescriptor<PresetCodecId<Descriptor, Args>> & PresetTypeParams<Descriptor, Args>, CodecInput<CodecTypes, {
   readonly codecId: PresetCodecId<Descriptor, Args>;
-}>>, undefined, ResolveTemplateValue<Descriptor['output']['nullable'], Args> extends true ? true : false, undefined, NamedConstraintState<ResolveTemplateValue<Descriptor['output']['id'], Args> extends true ? true : false, ConstraintName>, NamedConstraintState<ResolveTemplateValue<Descriptor['output']['unique'], Args> extends true ? true : false, ConstraintName>>>;
+}>>, undefined, ResolveTemplateValue<Descriptor['output']['nullable'], Args> extends true ? true : false, undefined, NamedConstraintState<ResolveTemplateValue<Descriptor['output']['id'], Args> extends true ? true : false, ConstraintName>, NamedConstraintState<ResolveTemplateValue<Descriptor['output']['unique'], Args> extends true ? true : false, ConstraintName>, false, {
+  readonly column: Descriptor['output'] extends {
+    readonly default: object;
+  } ? true : false;
+  readonly execution: PresetHasExecutionDefault<Descriptor, Args>;
+}>>;
 type FieldHelperFunctionWithoutNamedConstraint<Descriptor extends AuthoringFieldPresetDescriptor, CodecTypes extends CodecTypeMap = Record<never, never>> = Descriptor extends {
   readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
 } ? <const Params extends TupleFromArgumentDescriptors<Args>>(...args: Params) => FieldBuilderFromPresetDescriptor<Descriptor, Params, undefined, CodecTypes> : () => FieldBuilderFromPresetDescriptor<Descriptor, readonly [], undefined, CodecTypes>;
@@ -1122,9 +1206,9 @@ type ExtractCodecTypesFromPack<P> = P extends {
   __codecTypes?: infer C extends Record<string, {
     readonly output: unknown;
   }>;
-} ? PublicCodecTypes<C> : Record<string, never>;
+} ? PublicCodecTypes<C> : Record<never, 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 MergeExtensionCodecTypesSafe<Packs> = Packs extends Record<string, unknown> ? keyof Packs extends never ? Record<never, never> : MergeExtensionCodecTypes<Packs> : Record<never, never>;
 type ExtractIndexTypesFromPack<P> = P extends {
   readonly indexTypes: IndexTypeRegistration<infer M>;
 } ? M : Record<never, never>;
@@ -1138,9 +1222,36 @@ type DefinitionExtensions<Definition> = Definition extends {
 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 ExtensionCapabilityMatrices<Packs> = Packs extends Record<string, unknown> ? { [K in keyof Packs]: Defaulted<ExtractPackCapabilities<Packs[K]>, Record<never, never>>; }[keyof Packs] : never;
+type KeysOfEach<T> = T extends unknown ? keyof T : never;
+type NamespaceOfEach<Matrices, Namespace> = Matrices extends unknown ? Namespace extends keyof Matrices ? Matrices[Namespace] : never : never;
+type FlagOfEach<Flags, Flag> = Flags extends unknown ? Flag extends keyof Flags ? Flags[Flag] : never : never;
+type MergeExtensionPackCapabilities<Packs> = { readonly [Namespace in KeysOfEach<ExtensionCapabilityMatrices<Packs>>]: { readonly [Flag in KeysOfEach<NamespaceOfEach<ExtensionCapabilityMatrices<Packs>, Namespace>>]: FlagOfEach<NamespaceOfEach<ExtensionCapabilityMatrices<Packs>, Namespace>, Flag> extends true ? true : false; }; };
 type Defaulted<T, Fallback> = [T] extends [never] ? Fallback : T;
-type DerivedCapabilities<Definition> = Defaulted<ExtractPackCapabilities<DefinitionTarget<Definition>>, Record<string, never>> & MergeExtensionPackCapabilities<DefinitionExtensions<Definition>>;
+type DefinitionAdapter<Definition> = Definition extends {
+  readonly adapter?: infer Adapter;
+} ? Present<Adapter> : never;
+type EnabledCapabilityFlags<Flags> = { readonly [Flag in keyof Flags as Flags[Flag] extends true ? Flag : never]: true; };
+type EnabledCapabilities<Capabilities> = { readonly [Namespace in keyof Capabilities as keyof EnabledCapabilityFlags<Capabilities[Namespace]> extends never ? never : Namespace]: EnabledCapabilityFlags<Capabilities[Namespace]>; };
+type OverrideCapabilities<Earlier, Later> = { readonly [Namespace in keyof Earlier | keyof Later]: Namespace extends keyof Later ? Namespace extends keyof Earlier ? Omit<Earlier[Namespace], keyof Later[Namespace]> & Later[Namespace] : Later[Namespace] : Namespace extends keyof Earlier ? Earlier[Namespace] : never; };
+type DerivedCapabilities<Definition> = EnabledCapabilities<OverrideCapabilities<OverrideCapabilities<Defaulted<ExtractPackCapabilities<DefinitionTarget<Definition>>, Record<never, never>>, Defaulted<ExtractPackCapabilities<DefinitionAdapter<Definition>>, Record<never, never>>>, MergeExtensionPackCapabilities<DefinitionExtensions<Definition>>>>;
+type ExtractQueryOperationTypesFromPack<P, CodecTypes extends Record<string, {
+  readonly input: unknown;
+  readonly output: unknown;
+}>> = P extends {
+  readonly __queryOperationTypes?: infer TypeFunction;
+} ? Present<TypeFunction> extends (infer Defined extends QueryOperationTypesFunction) ? ApplyQueryOperationTypes<Defined, CodecTypes> : Record<never, never> : Record<never, never>;
+type PackQueryOperationTypes<Definition> = UnionToIntersection<{ [K in keyof AllPacks<Definition>]: ExtractQueryOperationTypesFromPack<AllPacks<Definition>[K], CodecTypesFromDefinition<Definition>>; }[keyof AllPacks<Definition>]>;
+type QueryOperationTypesFromDefinition<Definition> = PackQueryOperationTypes<Definition> extends (infer Operations extends Record<string, unknown>) ? Operations : Record<string, never>;
+type PackAggregateDescriptors<Pack> = Pack extends {
+  readonly types?: infer Types;
+} ? Present<Types> extends {
+  readonly aggregateDescriptors?: infer Descriptors;
+} ? Present<Descriptors> extends ReadonlyArray<infer Descriptor> ? Descriptor extends {
+  readonly operation: infer Operation;
+} ? string extends Operation ? never : Descriptor : never : never : never : never;
+type ExtensionAggregateDescriptors<Definition> = { [K in keyof DefinitionExtensions<Definition>]: PackAggregateDescriptors<DefinitionExtensions<Definition>[K]>; }[keyof DefinitionExtensions<Definition>];
+type AggregateTypesFromDefinition<Definition> = AggregateTypesFromDescriptors<PackAggregateDescriptors<DefinitionTarget<Definition>> | PackAggregateDescriptors<DefinitionAdapter<Definition>> | ExtensionAggregateDescriptors<Definition>, CodecTypesFromDefinition<Definition>>;
 type DefinitionTargetId<Definition> = Definition extends {
   readonly target: TargetPackRef<'sql', infer Target>;
 } ? Target : never;
@@ -1151,6 +1262,9 @@ type CodecTypesFromDefinition<Definition> = ExtractCodecTypesFromPack<Definition
 type DefinitionTarget<Definition> = Definition extends {
   readonly target: infer Target;
 } ? Target : never;
+type AllPacks<Definition> = DefinitionExtensions<Definition> & {
+  readonly __target: DefinitionTarget<Definition>;
+};
 type DefinitionModels<Definition> = Definition extends {
   readonly models?: unknown;
 } ? Present<Definition['models']> extends Record<string, unknown> ? Present<Definition['models']> : Record<never, never> : Record<never, never>;
@@ -1210,6 +1324,15 @@ type FieldManyOf<FieldState> = FieldState extends {
     readonly elementNullable: boolean;
   };
 } ? Many : false;
+type FieldDefaultPresenceOf<FieldState> = Present<FieldState extends {
+  readonly __defaultPresence?: infer Defaults;
+} ? Defaults : never>;
+type FieldHasColumnDefault<FieldState> = FieldDefaultPresenceOf<FieldState> extends {
+  readonly column: true;
+} ? true : false;
+type FieldHasExecutionDefault<FieldState> = FieldDefaultPresenceOf<FieldState> extends {
+  readonly execution: true;
+} ? true : false;
 type FieldColumnOverrideOf<FieldState> = Present<FieldState extends {
   readonly columnName?: infer ColumnName;
 } ? ColumnName : never>;
@@ -1218,7 +1341,12 @@ type FieldInlineIdSpecOf<FieldState> = Present<FieldState extends {
 } ? IdSpec : never>;
 type DescriptorCodecId<Descriptor> = Descriptor extends {
   readonly codecId: infer CodecId extends string;
-} ? CodecId : string;
+} ? string extends CodecId ? ColumnSpecCodecId<Descriptor> : CodecId : string;
+type ColumnSpecCodecId<Descriptor> = Descriptor extends {
+  readonly codecFactory: (...args: never[]) => {
+    readonly id: infer Id extends string;
+  };
+} ? Id : string;
 type DescriptorTypeParams<Descriptor> = Descriptor extends {
   readonly typeParams: infer TypeParams extends Record<string, unknown>;
 } ? TypeParams : undefined;
@@ -1259,22 +1387,128 @@ type ModelIdFieldNames<Definition, ModelName extends ModelNames<Definition>> = [
 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, TypeRef extends string | undefined = undefined, TypeParams extends Record<string, unknown> | undefined = undefined, Many extends false | {
   readonly elementNullable: boolean;
-} = false> = {
+} = false, HasDefault extends boolean = false> = {
   readonly dataType: string;
   readonly codecId: CodecId;
   readonly nullable: Nullable;
-  readonly default?: ColumnDefault;
-} & (TypeRef extends string ? {
+} & (HasDefault extends true ? {
+  readonly default: ColumnDefault;
+} : Record<never, never>) & (TypeRef extends string ? {
   readonly typeRef: TypeRef;
 } : Record<never, never>) & (TypeParams extends Record<string, unknown> ? {
   readonly typeParams: TypeParams;
 } : Record<never, never>) & {
   readonly many: Many;
 };
-type ModelStorageColumn<Definition, ModelName extends ModelNames<Definition>, FieldName extends string> = FieldName extends ModelFieldNames<Definition, ModelName> ? StorageColumn<DescriptorCodecId<ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName, FieldName>>>, FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>>, ResolveFieldColumnTypeRef<Definition, ModelFieldState<Definition, ModelName, FieldName>>, ResolveFieldColumnTypeParams<Definition, ModelFieldState<Definition, ModelName, FieldName>>, FieldManyOf<ModelFieldState<Definition, ModelName, FieldName>>> : 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>>, ResolveFieldColumnTypeRef<Definition, ModelFieldState<Definition, ModelName, FieldName>>, ResolveFieldColumnTypeParams<Definition, ModelFieldState<Definition, ModelName, FieldName>>, FieldManyOf<ModelFieldState<Definition, ModelName, FieldName>>, FieldHasColumnDefault<ModelFieldState<Definition, ModelName, FieldName>>> : never;
+type StagedRelationState<Definition, ModelName extends ModelNames<Definition>, RelName extends StagedModelRelationNames<Definition, ModelName>> = StagedModelRelations<Definition, ModelName>[RelName] extends {
+  readonly __state: infer State;
+} ? State : never;
+type RelationSourceModelName<Source> = Source extends {
+  readonly modelName: infer Name extends string;
+} ? Name : Source extends {
+  readonly resolve: () => infer Name extends string;
+} ? Name : never;
+type RelationFieldTuple<Fields> = Fields extends readonly string[] ? Fields : readonly [Extract<Fields, string>];
+type RelationFieldUnion<Fields> = Fields extends readonly (infer FieldName)[] ? FieldName : Fields;
+type ModelAnchorFieldNames<Definition, ModelName extends ModelNames<Definition>> = ModelIdFieldNames<Definition, ModelName> extends (infer IdFields extends readonly string[]) ? IdFields : readonly ['id'];
+type AnyFieldNullable<Definition, ModelName extends ModelNames<Definition>, Fields> = true extends (RelationFieldUnion<Fields> extends (infer FieldName) ? FieldName extends ModelFieldNames<Definition, ModelName> ? FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>> : boolean : never) ? true : false;
+type BelongsToNullable<Definition, ModelName extends ModelNames<Definition>, State> = AnyFieldNullable<Definition, ModelName, State extends {
+  readonly from: infer From;
+} ? From : never>;
+type BuiltRelationTarget<Definition, Target extends ModelNames<Definition>> = {
+  readonly namespace: ModelNamespace<Definition, Target> & NamespaceId;
+  readonly model: Target;
+};
+type JunctionTargetColumns<Definition, Target extends ModelNames<Definition>> = ModelIdFieldNames<Definition, Target> extends (infer IdFields extends readonly string[]) ? FieldNamesToColumnNames<Definition, Target, IdFields> : BuiltUnique<Definition, Target>['columns'];
+type BuiltManyToManyRelation<Definition, ModelName extends ModelNames<Definition>, Target extends ModelNames<Definition>, State> = State extends {
+  readonly through: infer ThroughSource;
+  readonly from: infer From;
+  readonly to: infer To;
+} ? RelationSourceModelName<ThroughSource> extends (infer Through extends ModelNames<Definition>) ? {
+  readonly to: BuiltRelationTarget<Definition, Target>;
+  readonly cardinality: 'N:M';
+  readonly on: {
+    readonly localFields: ModelAnchorFieldNames<Definition, ModelName>;
+    readonly targetFields: FieldNamesToColumnNames<Definition, Through, RelationFieldTuple<From>>;
+  };
+  readonly through: {
+    readonly table: ModelTableName<Definition, Through>;
+    readonly namespaceId: ModelNamespace<Definition, Through>;
+    readonly parentColumns: FieldNamesToColumnNames<Definition, Through, RelationFieldTuple<From>>;
+    readonly childColumns: FieldNamesToColumnNames<Definition, Through, RelationFieldTuple<To>>;
+    readonly targetColumns: JunctionTargetColumns<Definition, Target>;
+  };
+} : ContractRelation : ContractRelation;
+type BuiltSameSpaceRelationByKind<Definition, ModelName extends ModelNames<Definition>, Target extends ModelNames<Definition>, State> = State extends {
+  readonly kind: 'belongsTo';
+  readonly from: infer From;
+  readonly to: infer To;
+} ? {
+  readonly to: BuiltRelationTarget<Definition, Target>;
+  readonly cardinality: 'N:1';
+  readonly nullable: BelongsToNullable<Definition, ModelName, State>;
+  readonly on: {
+    readonly localFields: RelationFieldTuple<From>;
+    readonly targetFields: RelationFieldTuple<To>;
+  };
+} : State extends {
+  readonly kind: 'hasMany';
+  readonly by: infer By;
+} ? {
+  readonly to: BuiltRelationTarget<Definition, Target>;
+  readonly cardinality: '1:N';
+  readonly on: {
+    readonly localFields: ModelAnchorFieldNames<Definition, ModelName>;
+    readonly targetFields: RelationFieldTuple<By>;
+  };
+} : State extends {
+  readonly kind: 'hasOne';
+  readonly by: infer By;
+} ? {
+  readonly to: BuiltRelationTarget<Definition, Target>;
+  readonly cardinality: '1:1';
+  readonly nullable: true;
+  readonly on: {
+    readonly localFields: ModelAnchorFieldNames<Definition, ModelName>;
+    readonly targetFields: RelationFieldTuple<By>;
+  };
+} : State extends {
+  readonly kind: 'manyToMany';
+} ? BuiltManyToManyRelation<Definition, ModelName, Target, State> : ContractRelation;
+type IsOtherSpaceTarget<State> = State extends {
+  readonly __targetSpaceId?: infer SpaceId;
+} ? [Present<SpaceId>] extends ['<self>'] ? false : true : false;
+type BuiltRelation<Definition, ModelName extends ModelNames<Definition>, State> = IsOtherSpaceTarget<State> extends true ? ContractRelation : BuiltSameSpaceRelation<Definition, ModelName, State>;
+type BuiltSameSpaceRelation<Definition, ModelName extends ModelNames<Definition>, State> = State extends {
+  readonly toModel: infer Source;
+} ? RelationSourceModelName<Source> extends (infer Target extends ModelNames<Definition>) ? BuiltSameSpaceRelationByKind<Definition, ModelName, Target, State> : ContractRelation : ContractRelation;
+type ExecutionDefaultEntries<Definition> = { [ModelName in ModelNames<Definition>]: { [FieldName in ModelFieldNames<Definition, ModelName>]: FieldHasExecutionDefault<ModelFieldState<Definition, ModelName, FieldName>> extends true ? ContractExecutionSection['mutations']['defaults'][number] & {
+  readonly ref: {
+    readonly namespace: ModelNamespace<Definition, ModelName>;
+    readonly entry: ModelTableName<Definition, ModelName>;
+    readonly field: ModelColumnName<Definition, ModelName, FieldName>;
+  };
+} : never; }[ModelFieldNames<Definition, ModelName>]; }[ModelNames<Definition>];
+type BuiltExecution<Definition> = [ExecutionDefaultEntries<Definition>] extends [never] ? {
+  readonly execution?: ContractExecutionSection;
+} : {
+  readonly execution: ContractExecutionSection & {
+    readonly mutations: {
+      readonly defaults: ReadonlyArray<ExecutionDefaultEntries<Definition>>;
+    };
+  };
+};
+type DomainFieldTypeParams<TypeParams> = TypeParams extends Record<string, unknown> ? keyof TypeParams extends never ? Record<never, never> : {
+  readonly typeParams: TypeParams;
+} : Record<never, never>;
+type DomainFieldMany<Many> = Many extends false ? Record<never, never> : {
+  readonly many: Many;
+};
 type BuiltModels<Definition> = { readonly [ModelName in ModelNames<Definition>]: {
   readonly storage: {
     readonly table: ModelTableName<Definition, ModelName>;
+    readonly namespaceId: ModelNamespace<Definition, ModelName>;
     readonly fields: { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: {
       readonly column: ModelColumnName<Definition, ModelName, FieldName>;
     }; };
@@ -1284,22 +1518,127 @@ type BuiltModels<Definition> = { readonly [ModelName in ModelNames<Definition>]:
     readonly type: {
       readonly kind: 'scalar';
       readonly codecId: ModelStorageColumn<Definition, ModelName, FieldName>['codecId'];
-    };
-  } & {
-    readonly many: FieldManyOf<ModelFieldState<Definition, ModelName, FieldName>>;
-  }; };
-  readonly relations: { readonly [RelName in StagedModelRelationNames<Definition, ModelName>]: ContractRelation; };
+    } & DomainFieldTypeParams<FieldColumnTypeParams<Definition, ModelFieldState<Definition, ModelName, FieldName>>>;
+  } & DomainFieldMany<FieldManyOf<ModelFieldState<Definition, ModelName, FieldName>>>; };
+  readonly relations: { readonly [RelName in StagedModelRelationNames<Definition, ModelName>]: BuiltRelation<Definition, ModelName, StagedRelationState<Definition, ModelName, RelName>>; };
 }; };
 type BuiltModelColumnMappings<Definition, ModelName extends ModelNames<Definition>> = BuiltModels<Definition>[ModelName]['storage']['fields'];
 type BuiltModelTableName<Definition, ModelName extends ModelNames<Definition>> = BuiltModels<Definition>[ModelName]['storage']['table'];
 type BuiltStorageTableColumns<Definition, ModelName extends ModelNames<Definition>> = { readonly [FieldName in keyof BuiltModelColumnMappings<Definition, ModelName> & string as BuiltModelColumnMappings<Definition, ModelName>[FieldName]['column']]: ModelStorageColumn<Definition, ModelName, FieldName>; };
+type FieldUniqueSpecOf<FieldState> = FieldState extends {
+  readonly unique: infer UniqueSpec;
+} ? [UniqueSpec] extends [{
+  readonly name?: infer Name;
+}] ? {
+  readonly name: Name;
+} : never : never;
+type UniqueName$1<Name> = Present<Name> extends (infer Defined extends string) ? Defined : never;
+type InlineUnique<Definition, ModelName extends ModelNames<Definition>> = { [FieldName in ModelFieldNames<Definition, ModelName>]: FieldUniqueSpecOf<ModelFieldState<Definition, ModelName, FieldName>> extends (infer Spec) ? [Spec] extends [never] ? never : Spec extends {
+  readonly name: infer Name;
+} ? {
+  readonly columns: readonly [ModelColumnName<Definition, ModelName, FieldName>];
+  readonly name?: UniqueName$1<Name>;
+} : never : never; }[ModelFieldNames<Definition, ModelName>];
+type AttributeUnique<Definition, ModelName extends ModelNames<Definition>> = ModelAttributes<Definition, ModelName> extends {
+  readonly uniques?: infer Uniques extends readonly unknown[];
+} ? Uniques[number] extends (infer Unique) ? Unique extends {
+  readonly fields: infer Fields extends readonly string[];
+} ? number extends Fields['length'] ? never : {
+  readonly columns: FieldNamesToColumnNames<Definition, ModelName, Fields>;
+  readonly name?: Unique extends {
+    readonly name?: infer Name;
+  } ? UniqueName$1<Name> : never;
+} : never : never : never;
+type BuiltUnique<Definition, ModelName extends ModelNames<Definition>> = InlineUnique<Definition, ModelName> | AttributeUnique<Definition, ModelName>;
+type JoinColumns<Columns> = Columns extends readonly [infer Only extends string] ? Only : Columns extends readonly [infer First extends string, ...infer Rest] ? `${First}_${JoinColumns<Rest>}` : string;
+type SameColumns<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+type ModelColumnOf<Definition, ModelName extends ModelNames<Definition>> = { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: ModelColumnName<Definition, ModelName, FieldName>; };
+type DeclaredIndexConstraints<Definition, ModelName extends ModelNames<Definition>> = ModelSql<Definition, ModelName> extends {
+  readonly indexes?: infer Indexes extends readonly unknown[];
+} ? Indexes : readonly [];
+type IndexColumns<Definition, ModelName extends ModelNames<Definition>, Constraint> = [Constraint] extends [{
+  readonly fields?: infer Fields;
+}] ? Present<Fields> extends (infer Defined extends readonly string[]) ? [Defined] extends [never] ? readonly [] : number extends Defined['length'] ? readonly string[] : FieldNamesToColumnNames<Definition, ModelName, Defined> : readonly [] : readonly [];
+type IndexSpecOfConstraint<Constraint> = [Constraint] extends [{
+  readonly __spec?: infer Spec;
+}] ? Present<Spec> : never;
+type IndexMapOf<Constraint> = IndexSpecOfConstraint<Constraint> extends {
+  readonly map: infer Map extends string;
+} ? Map : never;
+type IndexNameOf<Constraint> = [Constraint] extends [{
+  readonly name?: infer Name;
+}] ? Present<Name> extends (infer Defined extends string) ? Defined : never : never;
+type IndexNaming<Definition, ModelName extends ModelNames<Definition>, Constraint> = [IndexMapOf<Constraint>] extends [never] ? {
+  readonly name: string;
+  readonly prefix: [IndexNameOf<Constraint>] extends [never] ? `${ModelTableName<Definition, ModelName>}_${JoinColumns<IndexColumns<Definition, ModelName, Constraint>>}_idx` : IndexNameOf<Constraint>;
+} : {
+  readonly name: IndexMapOf<Constraint>;
+};
+type IndexMethod<Definition, ModelName extends ModelNames<Definition>, Constraint> = [IndexSpecOfConstraint<Constraint>] extends [never] ? Record<never, never> : IndexMethodOfSpec<Definition, ModelName, IndexSpecOfConstraint<Constraint>>;
+type IndexMethodOfSpec<Definition, ModelName extends ModelNames<Definition>, Spec> = (Spec extends {
+  readonly type: infer Type extends string;
+} ? {
+  readonly type: Type;
+} : Record<never, never>) & (Spec extends {
+  readonly options: infer Options;
+} ? [Options] extends [undefined] ? Record<never, never> : {
+  readonly options: Options extends IndexOptionsFunction ? (Options & {
+    readonly columnOf: ModelColumnOf<Definition, ModelName>;
+  })['options'] : Options;
+} : Record<never, never>);
+type BuiltDeclaredIndexOf<Definition, ModelName extends ModelNames<Definition>, Constraint> = IndexNaming<Definition, ModelName, Constraint> & {
+  readonly columns: IndexColumns<Definition, ModelName, Constraint>;
+  readonly unique: boolean;
+} & IndexMethod<Definition, ModelName, Constraint>;
+type BuiltDeclaredIndexesOf<Definition, ModelName extends ModelNames<Definition>, Constraints extends readonly unknown[]> = { readonly [K in keyof Constraints]: BuiltDeclaredIndexOf<Definition, ModelName, Constraints[K]>; }[number];
+type BuiltDeclaredIndex<Definition, ModelName extends ModelNames<Definition>> = BuiltDeclaredIndexesOf<Definition, ModelName, DeclaredIndexConstraints<Definition, ModelName>>;
+type DefaultForeignKeyIndex<Definition> = Definition extends {
+  readonly foreignKeyDefaults?: infer Defaults;
+} ? [Present<Defaults>] extends [never] ? true : Present<Defaults> extends {
+  readonly index: false;
+} ? false : true : true;
+type DerivesBackingIndex<Definition, Intent> = [Present<Intent>] extends [never] ? DefaultForeignKeyIndex<Definition> : Present<Intent> extends false ? false : Present<Intent> extends true ? true : Present<Intent> extends string ? string extends Present<Intent> ? DefaultForeignKeyIndex<Definition> : false : DefaultForeignKeyIndex<Definition>;
+type RelationForeignKey<RelationSql> = [Present<RelationSql>] extends [never] ? never : Present<RelationSql> extends {
+  readonly fk?: infer ForeignKey;
+} ? Present<ForeignKey> : never;
+type ModelForeignKeyFields<Definition, ModelName extends ModelNames<Definition>> = (ModelSql<Definition, ModelName> extends {
+  readonly foreignKeys?: infer ForeignKeys extends readonly unknown[];
+} ? ForeignKeys[number] extends (infer ForeignKey) ? ForeignKey extends {
+  readonly fields: infer Fields extends readonly string[];
+} ? DerivesBackingIndex<Definition, ForeignKey extends {
+  readonly index?: infer Intent;
+} ? Intent : undefined> extends true ? Fields : never : never : never : never) | { [RelName in StagedModelRelationNames<Definition, ModelName>]: StagedRelationState<Definition, ModelName, RelName> extends {
+  readonly kind: 'belongsTo';
+  readonly from: infer From;
+  readonly sql?: infer RelationSql;
+} ? RelationForeignKey<RelationSql> extends (infer ForeignKey) ? [ForeignKey] extends [never] ? never : DerivesBackingIndex<Definition, ForeignKey extends {
+  readonly index?: infer Intent;
+} ? Intent : undefined> extends true ? RelationFieldTuple<From> : never : never : never; }[StagedModelRelationNames<Definition, ModelName>];
+type BackingIndexIsRedundant<Definition, ModelName extends ModelNames<Definition>, Columns> = true extends SameColumns<Columns, ModelIdFieldNames<Definition, ModelName> extends (infer IdFields extends readonly string[]) ? FieldNamesToColumnNames<Definition, ModelName, IdFields> : never> | (BuiltUnique<Definition, ModelName> extends (infer Unique) ? Unique extends {
+  readonly columns: infer UniqueColumns;
+} ? SameColumns<Columns, UniqueColumns> : never : never) | (PlainDeclaredIndexColumns<Definition, ModelName> extends (infer DeclaredColumns) ? DeclaredColumns extends unknown ? SameColumns<Columns, DeclaredColumns> : never : never) ? true : false;
+type PlainDeclaredIndexColumnsOf<Definition, ModelName extends ModelNames<Definition>, Constraints extends readonly unknown[]> = { readonly [K in keyof Constraints]: IndexSpecOfConstraint<Constraints[K]> extends {
+  readonly type: undefined;
+  readonly options: undefined;
+  readonly partial: false;
+} ? IndexColumns<Definition, ModelName, Constraints[K]> : never; }[number];
+type PlainDeclaredIndexColumns<Definition, ModelName extends ModelNames<Definition>> = PlainDeclaredIndexColumnsOf<Definition, ModelName, DeclaredIndexConstraints<Definition, ModelName>>;
+type AsciiCharacter = ' ' | '!' | '"' | '#' | '$' | '%' | '&' | "'" | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[' | '\\' | ']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~';
+/**
+ * A derived wire-name prefix as the build shortens it: to its first 54 bytes (`WIRE_NAME_PREFIX_MAX_BYTES`). Each ASCII character is one byte. A name with another character before the cut has a byte length the type does not count, so it gives `never` and the index has no name in the type.
+ */
+type DerivedWireNamePrefix<Name extends string, Kept extends string = '', Bytes extends readonly unknown[] = []> = string extends Name ? string : Bytes['length'] extends 54 ? Kept : Name extends `${infer Character}${infer Rest}` ? Character extends AsciiCharacter ? DerivedWireNamePrefix<Rest, `${Kept}${Character}`, [...Bytes, unknown]> : never : Kept;
+type BuiltBackingIndex<Definition, ModelName extends ModelNames<Definition>> = ModelForeignKeyFields<Definition, ModelName> extends (infer Fields) ? Fields extends readonly string[] ? FieldNamesToColumnNames<Definition, ModelName, Fields> extends (infer Columns) ? BackingIndexIsRedundant<Definition, ModelName, Columns> extends true ? never : {
+  readonly name: string;
+  readonly prefix: DerivedWireNamePrefix<`${ModelTableName<Definition, ModelName>}_${JoinColumns<Columns>}_idx`>;
+  readonly columns: Columns;
+  readonly unique: false;
+} : never : never : never;
+type BuiltIndex<Definition, ModelName extends ModelNames<Definition>> = BuiltDeclaredIndex<Definition, ModelName> | BuiltBackingIndex<Definition, ModelName>;
 type BuiltStorageTables<Definition, Ns extends string> = { readonly [ModelName in ModelsInNamespace<Definition, Ns> as BuiltModelTableName<Definition, ModelName>]: {
   readonly columns: BuiltStorageTableColumns<Definition, ModelName>;
-  readonly uniques: ReadonlyArray<{
-    readonly columns: readonly string[];
-    readonly name?: string;
-  }>;
-  readonly indexes: ReadonlyArray<Index>;
+  readonly uniques: ReadonlyArray<BuiltUnique<Definition, ModelName>>;
+  readonly indexes: ReadonlyArray<BuiltIndex<Definition, ModelName>>;
   readonly foreignKeys: ReadonlyArray<{
     readonly source: {
       readonly namespaceId: NamespaceId;
@@ -1322,32 +1661,43 @@ type BuiltStorageTables<Definition, Ns extends string> = { readonly [ModelName i
     readonly columns: FieldNamesToColumnNames<Definition, ModelName, ModelIdFieldNames<Definition, ModelName>>;
     readonly name?: ModelIdName<Definition, ModelName>;
   };
-} : Record<string, never>); };
+} : Record<never, never>); };
 type DefinitionEnums<Definition> = Definition extends {
   readonly enums?: infer E;
 } ? Present<E> extends Record<string, EnumTypeHandle> ? string extends keyof Present<E> ? Record<never, never> : Present<E> : Record<never, never> : Record<never, never>;
-type 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 AuthoredStorageTypeInstance ? K : never]: DefinitionTypes<Definition>[K] & {
   readonly dataType: string;
 }; };
-type BuiltDomain<Definition> = BuiltDocumentScopedTypes<Definition> extends Record<never, never> ? Record<string, never> : {
+type BuiltDomain<Definition> = BuiltDocumentScopedTypes<Definition> extends Record<never, never> ? Record<never, never> : {
   readonly __unbound__: {
     readonly types: BuiltDocumentScopedTypes<Definition>;
   };
 };
+type HandleName<Handle> = Handle extends EnumTypeHandle<infer Name> ? Name : never;
+type StoredEnumValue<Value> = Value extends JsonValue ? Value : JsonValue;
+type EnumHandleMembers<Handle, Stored extends boolean> = Handle extends EnumTypeHandle<string, infer Values, infer Names> ? { readonly [I in keyof Values]: {
+  readonly name: I extends keyof Names ? Names[I] : never;
+  readonly value: Stored extends true ? StoredEnumValue<Values[I]> : Values[I];
+}; } : never;
+type EnumHandleEntries<Enums> = { readonly [K in keyof Enums as HandleName<Enums[K]>]: {
+  readonly codecId: Enums[K] extends {
+    readonly codecId: infer CodecId;
+  } ? CodecId : string;
+  readonly members: EnumHandleMembers<Enums[K], true>;
+}; };
+type EnumHandleMemberTypes<Enums> = { readonly [K in keyof Enums as HandleName<Enums[K]>]: EnumHandleMembers<Enums[K], false>; };
+type EnumHandleValueSets<Enums> = { readonly [K in keyof Enums as HandleName<Enums[K]>]: {
+  readonly kind: 'valueSet';
+  readonly values: Enums[K] extends EnumTypeHandle<string, infer Values> ? { readonly [I in keyof Values]: StoredEnumValue<Values[I]>; } : never;
+}; };
+type DefinitionHasEnums<Definition> = keyof DefinitionEnums<Definition> extends never ? false : true;
+type HoldsDefinitionEnums<Definition, Ns extends string> = DefinitionHasEnums<Definition> extends true ? Ns extends DefaultStorageNamespaceId<Definition> ? true : false : false;
 type BuiltDomainNamespace<Definition, Ns extends string> = {
   readonly models: { readonly [ModelName in ModelsInNamespace<Definition, Ns>]: BuiltModels<Definition>[ModelName]; };
-  readonly valueObjects?: Record<string, ContractValueObject>;
-  readonly enum?: Record<string, ContractEnum>;
-};
+} & (HoldsDefinitionEnums<Definition, Ns> extends true ? {
+  readonly enum: EnumHandleEntries<DefinitionEnums<Definition>>;
+  readonly enumMemberTypes?: EnumHandleMemberTypes<DefinitionEnums<Definition>>;
+} : Record<never, never>);
 type DefaultStorageNamespaceId<Definition> = DefinitionTarget<Definition> extends {
   readonly defaultNamespaceId: infer Id extends string;
 } ? Id : never;
@@ -1367,14 +1717,11 @@ type BuiltStorage<Definition> = {
     readonly kind: string;
     readonly entries: {
       readonly table: BuiltStorageTables<Definition, Ns>;
-    };
+    } & (HoldsDefinitionEnums<Definition, Ns> extends true ? {
+      readonly valueSet: EnumHandleValueSets<DefinitionEnums<Definition>>;
+    } : Record<never, never>);
   }; };
 };
-type StorageColumnManyOf<Col> = Col extends {
-  readonly many: infer Many extends false | {
-    readonly elementNullable: boolean;
-  };
-} ? Many : 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: {
@@ -1384,29 +1731,48 @@ type DescriptorEntityMembers<Descriptor> = Descriptor extends {
   };
 } ? 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 (infer Many) ? Many extends {
-  readonly elementNullable: infer ElementNullable;
-} ? ReadonlyArray<T | (ElementNullable extends true ? null : never)> : T : never : unknown : unknown;
+type FieldColumnTypeParams<Definition, FieldState> = ResolveFieldColumnTypeRef<Definition, FieldState> extends (infer TypeRef extends keyof DefinitionTypes<Definition>) ? DefinitionTypes<Definition>[TypeRef] extends {
+  readonly typeParams: infer TypeParams extends Record<string, unknown>;
+} ? TypeParams : undefined : DescriptorTypeParams<FieldDescriptorOf<FieldState>>;
+type PackParameterizedOutputTypes<Pack> = Pack extends {
+  readonly __parameterizedOutputTypes?: infer TypeFunction;
+} ? Present<TypeFunction> extends (infer Defined extends ParameterizedOutputTypesFunction) ? Defined : never : never;
+type ParameterizedOutputTypesFromDefinition<Definition> = { [K in keyof AllPacks<Definition>]: PackParameterizedOutputTypes<AllPacks<Definition>[K]>; }[keyof AllPacks<Definition>];
+type ColumnSpecCodecOutput<Descriptor> = Descriptor extends {
+  readonly codecFactory: (...args: never[]) => infer Codec;
+} ? Codec extends {
+  decode(...args: never[]): Promise<infer Output>;
+} ? Output : never : never;
 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 (infer Many) ? Many extends {
-  readonly elementNullable: infer ElementNullable;
-} ? ReadonlyArray<FieldValueUnion<ModelFieldState<Definition, ModelName, FieldName>> | (ElementNullable extends true ? null : never)> : FieldValueUnion<ModelFieldState<Definition, ModelName, FieldName>> : never) | (FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>> extends true ? null : never);
-type ModelFieldChannelTypes<Definition, ModelName extends ModelNames<Definition>, Channel extends 'output' | 'input'> = { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldChannelType<Definition, ModelName, FieldName, Channel>; };
-type ClosedWhenEmpty<T> = [keyof T] extends [never] ? Record<string, never> : T;
-type FieldChannelTypes<Definition, Channel extends 'output' | 'input'> = { readonly [Ns in DomainNamespaceIds<Definition>]: { readonly [ModelName in ModelsInNamespace<Definition, Ns>]: Channel extends 'input' ? ClosedWhenEmpty<ModelFieldChannelTypes<Definition, ModelName, Channel>> : ModelFieldChannelTypes<Definition, ModelName, Channel>; }; };
-type StorageColumnChannelTypes<Definition, Channel extends 'output' | 'input'> = { readonly [Ns in StorageNamespaceIds<Definition>]: { readonly [ModelName in ModelsInNamespace<Definition, Ns> as BuiltModelTableName<Definition, ModelName>]: { readonly [FieldName in ModelFieldNames<Definition, ModelName> as BuiltModelColumnMappings<Definition, ModelName>[FieldName]['column']]: FieldChannelType<Definition, ModelName, FieldName, Channel>; }; }; };
-type SqlContractResult<Definition> = ContractWithTypeMaps<Omit<Contract<BuiltStorage<Definition>>, 'domain'> & {
+type FieldTypeOverride<Definition, ModelName extends ModelNames<Definition>, FieldName extends ModelFieldNames<Definition, ModelName>> = ModelFieldState<Definition, ModelName, FieldName> extends (infer FieldState) ? [FieldValueUnion<FieldState>] extends [never] ? [ColumnSpecCodecOutput<FieldDescriptorOf<FieldState>>] extends [never] ? never : {
+  readonly output: ColumnSpecCodecOutput<FieldDescriptorOf<FieldState>>;
+} : {
+  readonly output: FieldValueUnion<FieldState>;
+  readonly input: FieldValueUnion<FieldState>;
+} : never;
+type FieldTypeOverrides<Definition> = { readonly [Ns in DomainNamespaceIds<Definition>]: { readonly [ModelName in ModelsInNamespace<Definition, Ns>]: { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldTypeOverride<Definition, ModelName, FieldName>; }; }; };
+type ColumnTypeOverrides<Definition> = { readonly [Ns in StorageNamespaceIds<Definition>]: { readonly [ModelName in ModelsInNamespace<Definition, Ns> as BuiltModelTableName<Definition, ModelName>]: { readonly [FieldName in ModelFieldNames<Definition, ModelName> as BuiltModelColumnMappings<Definition, ModelName>[FieldName]['column']]: FieldTypeOverride<Definition, ModelName, FieldName>; }; }; };
+type ResolvedTypeMap<Map> = { readonly [Ns in keyof Map]: { readonly [Entity in keyof Map[Ns]]: string extends keyof Map[Ns][Entity] ? Map[Ns][Entity] : { readonly [Name in keyof Map[Ns][Entity]]: Map[Ns][Entity][Name]; }; }; };
+type BuiltDomainNamespaces<Definition> = { readonly [Ns in DomainNamespaceIds<Definition>]: BuiltDomainNamespace<Definition, Ns>; };
+type SqlContractResult<Definition> = ContractWithTypeMaps<Omit<Contract<BuiltStorage<Definition>>, 'domain' | 'execution'> & BuiltExecution<Definition> & {
   readonly target: DefinitionTargetId<Definition>;
   readonly targetFamily: 'sql';
 } & {
   readonly domain: {
-    readonly namespaces: { readonly [Ns in DomainNamespaceIds<Definition>]: BuiltDomainNamespace<Definition, Ns>; };
+    readonly namespaces: BuiltDomainNamespaces<Definition>;
   } & BuiltDomain<Definition>;
 } & {
-  readonly extensions: keyof DefinitionExtensions<Definition> extends never ? Record<string, never> : DefinitionExtensions<Definition>;
+  readonly extensions: 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'>>>;
+}, {
+  readonly codecTypes: CodecTypesFromDefinition<Definition>;
+  readonly queryOperationTypes: QueryOperationTypesFromDefinition<Definition>;
+  readonly fieldOutputTypes: ResolvedTypeMap<FieldTypesFromDomain<BuiltDomainNamespaces<Definition>, CodecTypesFromDefinition<Definition>, ParameterizedOutputTypesFromDefinition<Definition>, FieldTypeOverrides<Definition>, 'output'>>;
+  readonly fieldInputTypes: ResolvedTypeMap<FieldTypesFromDomain<BuiltDomainNamespaces<Definition>, CodecTypesFromDefinition<Definition>, ParameterizedOutputTypesFromDefinition<Definition>, FieldTypeOverrides<Definition>, 'input'>>;
+  readonly storageColumnTypes: ResolvedTypeMap<ColumnTypesFromStorage<BuiltStorage<Definition>, CodecTypesFromDefinition<Definition>, ParameterizedOutputTypesFromDefinition<Definition>, ColumnTypeOverrides<Definition>, 'output'>>;
+  readonly storageColumnInputTypes: ResolvedTypeMap<ColumnTypesFromStorage<BuiltStorage<Definition>, CodecTypesFromDefinition<Definition>, ParameterizedOutputTypesFromDefinition<Definition>, ColumnTypeOverrides<Definition>, 'input'>>;
+  readonly aggregateTypes: AggregateTypesFromDefinition<Definition>;
+}>;
 //#endregion
 //#region src/composed-authoring-helpers.d.ts
 type ExtractTypeNamespaceFromPack<Pack> = ExtractAuthoringNamespaceFromPack<Pack, 'type', Record<never, never>>;
@@ -1463,9 +1829,6 @@ declare function createComposedAuthoringHelpers<Family extends FamilyPackRef<str
 } & AuthoringTypeLookups): ComposedAuthoringHelpers<Family, Target, Extensions>;
 //#endregion
 //#region src/build-contract.d.ts
-/**
- * Builds the contract in two stages. First each model is converted on its own into the table it describes and its domain model, and each table node into the table it describes. Then the tables are merged, each is lowered, and the contract is assembled.
- */
 declare function buildSqlContractFromDefinition(definition: ContractDefinition, codecLookup: CodecLookupWithDescriptors, dataTypeLookup: DataTypeLookup): Contract<SqlStorage>;
 //#endregion
 //#region src/contract-builder.d.ts
@@ -1580,5 +1943,5 @@ declare function now(): ColumnDefault;
 /** A database-assigned sequence value, the same default PSL writes as `@default(autoincrement())`. */
 declare function autoincrement(): ColumnDefault;
 //#endregion
-export { field as $, ModelLike as A, ValueObjectFieldNode as B, ForeignKeyTableReference as C, IndexOptionsInput as D, IndexNode as E, ScalarMemberNode as F, buildBoundContract as G, ValueObjectNode as H, TableNode as I, check as J, buildContractDefinition as K, TableProperties as L, PrimaryKeyNode as M, RelationNode as N, ManyOptions as O, ScalarFieldBuilder as P, extensionModel as Q, TargetFieldRef as R, ForeignKeyNode as S, IndexExpressionInput as T, autoincrement as U, ValueObjectMemberNode as V, bindEnumType as W, defineContract as X, createComposedAuthoringHelpers as Y, enumType as Z, EnumMember as _, CheckNode as a, storedAsListColumn as at, FieldNode as b, ColumnNode as c, ContractDefinition as d, isValueObjectMember as et, ContractInput as f, DeferredIndexOptions as g, DeferredIndexExpression as h, BoundEnumType as i, rel as it, ModelNode as j, MergeEnums as k, ColumnRef as l, DeferredIndexColumn as m, AuthoredColumnDefault as n, model as nt, CodecInput$1 as o, ContractModelBuilder as p, buildSqlContractFromDefinition as q, AuthoredColumnDefaultLiteralValue as r, now as rt, CodecTypeMap$1 as s, AttachedEntities as t, member as tt, ComposedAuthoringHelpers as u, EnumTypeHandle as v, IndexConstraint as w, ForeignKeyModelReference as x, ExtractCodecTypesFromPack as y, UniqueConstraintNode as z };
-//# sourceMappingURL=contract-builder-C4fgERNT.d.mts.map
+export { extensionModel as $, MergeEnums as A, UniqueConstraintNode as B, ForeignKeyTableReference as C, IndexOptionsFunction as D, IndexNode as E, ScalarFieldBuilder as F, bindEnumType as G, ValueObjectMemberNode as H, ScalarMemberNode as I, buildSqlContractFromDefinition as J, buildBoundContract as K, TableNode as L, ModelNode as M, PrimaryKeyNode as N, IndexOptionsInput as O, RelationNode as P, enumType as Q, TableProperties as R, ForeignKeyNode as S, IndexExpressionInput as T, ValueObjectNode as U, ValueObjectFieldNode as V, autoincrement as W, createComposedAuthoringHelpers as X, check as Y, defineContract as Z, EnumMember as _, CheckNode as a, rel as at, FieldNode as b, ColumnNode as c, ContractDefinition as d, field as et, ContractInput as f, DeferredIndexOptions as g, DeferredIndexExpression as h, BoundEnumType as i, now as it, ModelLike as j, ManyOptions as k, ColumnRef as l, DeferredIndexColumn as m, AuthoredColumnDefault as n, member as nt, CodecInput$1 as o, storedAsListColumn as ot, ContractModelBuilder as p, buildContractDefinition as q, AuthoredColumnDefaultLiteralValue as r, model as rt, CodecTypeMap$1 as s, AttachedEntities as t, isValueObjectMember as tt, ComposedAuthoringHelpers as u, EnumTypeHandle as v, IndexConstraint as w, ForeignKeyModelReference as x, ExtractCodecTypesFromPack as y, TargetFieldRef as z };
+//# sourceMappingURL=contract-builder-ClsLO9DI.d.mts.map