@prisma-next/sql-contract-ts 0.3.0-dev.135 → 0.3.0-dev.146

package/dist/contract-builder.d.mts

@@ -1,10 +1,11 @@
-import { BuildModels, BuildStorageColumn, ColumnBuilderState, ColumnTypeDescriptor, ContractBuilder, ContractBuilderState, ExtractColumns, ExtractPrimaryKey, ForeignKeyDefaultsState, ModelBuilder, ModelBuilderState, RelationDefinition, TableBuilder, TableBuilderState } from "@prisma-next/contract-authoring";
-import { AuthoringArgumentDescriptor, AuthoringFieldNamespace, AuthoringFieldPresetDescriptor, AuthoringTypeConstructorDescriptor, AuthoringTypeNamespace, ExtensionPackRef, FamilyPackRef, TargetPackRef } from "@prisma-next/contract/framework-components";
-import { ContractWithTypeMaps, Index as Index$1, ReferentialAction, SqlContract, StorageTypeInstance, TypeMaps } from "@prisma-next/sql-contract/types";
-import { ContractIR } from "@prisma-next/contract/ir";
-import { ColumnDefault, ColumnDefaultLiteralInputValue, ExecutionMutationDefaultValue } from "@prisma-next/contract/types";
+import { ColumnDefault, ColumnDefaultLiteralInputValue, Contract, ContractRelation, ExecutionMutationDefaultValue, StorageHashBase } from "@prisma-next/contract/types";
+import { ContractWithTypeMaps, Index as Index$1, ReferentialAction, SqlStorage, StorageTypeInstance, TypeMaps } from "@prisma-next/sql-contract/types";
+import { AuthoringArgumentDescriptor, AuthoringFieldNamespace, AuthoringFieldPresetDescriptor, AuthoringTypeConstructorDescriptor, AuthoringTypeNamespace } from "@prisma-next/framework-components/authoring";
+import { ColumnTypeDescriptor, ForeignKeyDefaultsState } from "@prisma-next/contract-authoring";
+import { CodecLookup } from "@prisma-next/framework-components/codec";
+import { ExtensionPackRef, FamilyPackRef, TargetPackRef } from "@prisma-next/framework-components/components";
 
-//#region src/staged-contract-dsl.d.ts
+//#region src/contract-dsl.d.ts
 type NamingStrategy = 'identity' | 'snake_case';
 type NamingConfig = {
   readonly tables?: NamingStrategy;
@@ -258,7 +259,7 @@ type SqlForeignKeys<SqlSpec extends SqlStageSpec> = SqlSpec extends {
 type SqlNamedObjects<SqlSpec extends SqlStageSpec> = [...SqlIndexes<SqlSpec>, ...SqlForeignKeys<SqlSpec>];
 type ValidateSqlStageSpec<Fields$1 extends Record<string, ScalarFieldBuilder>, AttributesSpec extends ModelAttributesSpec | undefined, SqlSpec extends SqlStageSpec> = [DuplicateLiteralNames<SqlNamedObjects<SqlSpec>>] extends [never] ? [Extract<ModelIdLiteralName<Fields$1, AttributesSpec>, NamedConstraintLiteralName<SqlNamedObjects<SqlSpec>[number]>>] extends [never] ? SqlSpec : never : never;
 type ValidateAttributesStageSpec<Fields$1 extends Record<string, ScalarFieldBuilder>, SqlSpec extends SqlStageSpec | undefined, AttributesSpec extends ModelAttributesSpec> = SqlSpec extends SqlStageSpec ? [Extract<ModelIdLiteralName<Fields$1, AttributesSpec>, NamedConstraintLiteralName<SqlNamedObjects<SqlSpec>[number]>>] extends [never] ? AttributesSpec : never : AttributesSpec;
-declare class StagedModelBuilder<ModelName$1 extends string | undefined, Fields$1 extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>, AttributesSpec extends ModelAttributesSpec | undefined = undefined, SqlSpec extends SqlStageSpec | undefined = undefined> {
+declare class ContractModelBuilder<ModelName$1 extends string | undefined, Fields$1 extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>, AttributesSpec extends ModelAttributesSpec | undefined = undefined, SqlSpec extends SqlStageSpec | undefined = undefined> {
   readonly stageOne: {
     readonly modelName?: ModelName$1;
     readonly fields: Fields$1;
@@ -277,10 +278,10 @@ declare class StagedModelBuilder<ModelName$1 extends string | undefined, Fields$
     readonly fields: Fields$1;
     readonly relations: Relations;
   }, attributesFactory?: StageInput<AttributeContext<Fields$1>, AttributesSpec> | undefined, sqlFactory?: StageInput<SqlContext<Fields$1>, SqlSpec> | undefined);
-  ref<FieldName$1 extends keyof Fields$1 & string>(this: ModelName$1 extends string ? StagedModelBuilder<ModelName$1, Fields$1, Relations, AttributesSpec, SqlSpec> : never, fieldName: FieldName$1): TargetFieldRef<ModelName$1 & string, FieldName$1>;
-  relations<const NextRelations extends Record<string, AnyRelationBuilder>>(relations: NextRelations): StagedModelBuilder<ModelName$1, Fields$1, Relations & NextRelations, AttributesSpec, SqlSpec>;
-  attributes<const NextAttributesSpec extends ModelAttributesSpec>(specOrFactory: StageInput<AttributeContext<Fields$1>, ValidateAttributesStageSpec<Fields$1, SqlSpec, NextAttributesSpec>>): StagedModelBuilder<ModelName$1, Fields$1, Relations, NextAttributesSpec, SqlSpec>;
-  sql<const NextSqlSpec extends SqlStageSpec>(specOrFactory: StageInput<SqlContext<Fields$1>, NextSqlSpec>): [ValidateSqlStageSpec<Fields$1, AttributesSpec, NextSqlSpec>] extends [never] ? StagedModelBuilder<ModelName$1, Fields$1, Relations, AttributesSpec, never> : StagedModelBuilder<ModelName$1, Fields$1, Relations, AttributesSpec, NextSqlSpec>;
+  ref<FieldName$1 extends keyof Fields$1 & string>(this: ModelName$1 extends string ? ContractModelBuilder<ModelName$1, Fields$1, Relations, AttributesSpec, SqlSpec> : never, fieldName: FieldName$1): TargetFieldRef<ModelName$1 & string, FieldName$1>;
+  relations<const NextRelations extends Record<string, AnyRelationBuilder>>(relations: NextRelations): ContractModelBuilder<ModelName$1, Fields$1, Relations & NextRelations, AttributesSpec, SqlSpec>;
+  attributes<const NextAttributesSpec extends ModelAttributesSpec>(specOrFactory: StageInput<AttributeContext<Fields$1>, ValidateAttributesStageSpec<Fields$1, SqlSpec, NextAttributesSpec>>): ContractModelBuilder<ModelName$1, Fields$1, Relations, NextAttributesSpec, SqlSpec>;
+  sql<const NextSqlSpec extends SqlStageSpec>(specOrFactory: StageInput<SqlContext<Fields$1>, NextSqlSpec>): [ValidateSqlStageSpec<Fields$1, AttributesSpec, NextSqlSpec>] extends [never] ? ContractModelBuilder<ModelName$1, Fields$1, Relations, AttributesSpec, never> : ContractModelBuilder<ModelName$1, Fields$1, Relations, AttributesSpec, NextSqlSpec>;
   buildAttributesSpec(): AttributesSpec;
   buildSqlSpec(): SqlSpec;
 }
@@ -295,7 +296,7 @@ type LazyNamedModelToken<Token$1 extends AnyNamedModelToken = AnyNamedModelToken
 type RelationFieldSelection<FieldName$1 extends string> = FieldName$1 | readonly FieldName$1[];
 type RelationModelName<Target> = Target extends NamedModelTokenShape<infer ModelName extends string, Record<string, ScalarFieldBuilder>> ? ModelName : Target extends (() => infer Token) ? RelationModelName<Token> : never;
 type RelationModelFieldNames<Target> = Target extends NamedModelTokenShape<string, infer Fields> ? keyof Fields & string : Target extends (() => infer Token) ? RelationModelFieldNames<Token> : never;
-type StagedContractInput<Family extends FamilyPackRef<string> = FamilyPackRef<string>, Target extends TargetPackRef<'sql', string> = TargetPackRef<'sql', string>, Types extends Record<string, StorageTypeInstance> = Record<never, never>, Models extends Record<string, StagedModelBuilder<string | undefined, Record<string, ScalarFieldBuilder>, Record<string, AnyRelationBuilder>, ModelAttributesSpec | undefined, SqlStageSpec | undefined>> = Record<never, never>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined> = {
+type ContractInput<Family extends FamilyPackRef<string> = FamilyPackRef<string>, Target extends TargetPackRef<'sql', string> = TargetPackRef<'sql', string>, Types extends Record<string, StorageTypeInstance> = Record<never, never>, Models extends Record<string, ContractModelBuilder<string | undefined, Record<string, ScalarFieldBuilder>, Record<string, AnyRelationBuilder>, ModelAttributesSpec | undefined, SqlStageSpec | undefined>> = Record<never, never>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined> = {
   readonly family: Family;
   readonly target: Target;
   readonly extensionPacks?: ExtensionPacks;
@@ -305,15 +306,16 @@ type StagedContractInput<Family extends FamilyPackRef<string> = FamilyPackRef<st
   readonly capabilities?: Capabilities;
   readonly types?: Types;
   readonly models?: Models;
+  readonly codecLookup?: CodecLookup;
 };
 declare function model<const ModelName$1 extends string, Fields$1 extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>>(modelName: ModelName$1, input: {
   readonly fields: Fields$1;
   readonly relations?: Relations;
-}): StagedModelBuilder<ModelName$1, Fields$1, Relations>;
+}): ContractModelBuilder<ModelName$1, Fields$1, Relations>;
 declare function model<Fields$1 extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>>(input: {
   readonly fields: Fields$1;
   readonly relations?: Relations;
-}): StagedModelBuilder<undefined, Fields$1, Relations>;
+}): ContractModelBuilder<undefined, Fields$1, Relations>;
 declare function belongsTo<Token$1 extends AnyNamedModelToken, FromField$1 extends string | readonly string[], ToField$1 extends RelationFieldSelection<RelationModelFieldNames<Token$1>>>(toModel: Token$1 | LazyNamedModelToken<Token$1>, options: {
   readonly from: FromField$1;
   readonly to: ToField$1;
@@ -439,83 +441,7 @@ type ComposedAuthoringHelpers<Family extends FamilyPackRef<string>, Target exten
   readonly type: TypeHelpersFromNamespace<ExtractTypeNamespaceFromPack<Family> & ExtractTypeNamespaceFromPack<Target> & MergeExtensionTypeNamespaces<ExtensionPacks>>;
 };
 //#endregion
-//#region src/semantic-contract.d.ts
-interface SqlSemanticFieldNode {
-  readonly fieldName: string;
-  readonly columnName: string;
-  readonly descriptor: ColumnTypeDescriptor;
-  readonly nullable: boolean;
-  readonly default?: ColumnDefault;
-  readonly executionDefault?: ExecutionMutationDefaultValue;
-}
-interface SqlSemanticPrimaryKeyNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-}
-interface SqlSemanticUniqueConstraintNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-}
-interface SqlSemanticIndexNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly using?: string;
-  readonly config?: Record<string, unknown>;
-}
-interface SqlSemanticForeignKeyNode {
-  readonly columns: readonly string[];
-  readonly references: {
-    readonly model: string;
-    readonly table: string;
-    readonly columns: readonly string[];
-  };
-  readonly name?: string;
-  readonly onDelete?: ReferentialAction;
-  readonly onUpdate?: ReferentialAction;
-  readonly constraint?: boolean;
-  readonly index?: boolean;
-}
-interface SqlSemanticRelationNode {
-  readonly fieldName: string;
-  readonly toModel: string;
-  readonly toTable: string;
-  readonly cardinality: '1:1' | '1:N' | 'N:1' | 'N:M';
-  readonly on: {
-    readonly parentTable: string;
-    readonly parentColumns: readonly string[];
-    readonly childTable: string;
-    readonly childColumns: readonly string[];
-  };
-  readonly through?: {
-    readonly table: string;
-    readonly parentColumns: readonly string[];
-    readonly childColumns: readonly string[];
-  };
-}
-interface SqlSemanticModelNode {
-  readonly modelName: string;
-  readonly tableName: string;
-  readonly fields: readonly SqlSemanticFieldNode[];
-  readonly id?: SqlSemanticPrimaryKeyNode;
-  readonly uniques?: readonly SqlSemanticUniqueConstraintNode[];
-  readonly indexes?: readonly SqlSemanticIndexNode[];
-  readonly foreignKeys?: readonly SqlSemanticForeignKeyNode[];
-  readonly relations?: readonly SqlSemanticRelationNode[];
-}
-interface SqlSemanticContractDefinition {
-  readonly target: TargetPackRef<'sql', string>;
-  readonly extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
-  readonly capabilities?: Record<string, Record<string, boolean>>;
-  readonly storageHash?: string;
-  readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
-  readonly storageTypes?: Record<string, StorageTypeInstance>;
-  readonly models: readonly SqlSemanticModelNode[];
-}
-//#endregion
-//#region src/contract-ir-builder.d.ts
-declare function buildSqlContractFromSemanticDefinition(definition: SqlSemanticContractDefinition): ContractIR;
-//#endregion
-//#region src/staged-contract-types.d.ts
+//#region src/contract-types.d.ts
 type ExtractCodecTypesFromPack<P> = P extends {
   __codecTypes?: infer C;
 } ? C extends Record<string, {
@@ -523,35 +449,31 @@ type ExtractCodecTypesFromPack<P> = P extends {
 }> ? C : Record<string, never> : Record<string, never>;
 type MergeExtensionCodecTypes<Packs extends Record<string, unknown>> = UnionToIntersection<{ [K in keyof Packs]: ExtractCodecTypesFromPack<Packs[K]> }[keyof Packs]>;
 type MergeExtensionCodecTypesSafe<Packs> = Packs extends Record<string, unknown> ? keyof Packs extends never ? Record<string, never> : MergeExtensionCodecTypes<Packs> : Record<string, never>;
-type MergeExtensionPackRefs<Existing extends Record<string, unknown> | undefined, Added extends Record<string, ExtensionPackRef<'sql', string>>> = Existing extends Record<string, unknown> ? Existing & Added : Added;
-type StagedDefinitionExtensionPacks<Definition> = Definition extends {
+type DefinitionExtensionPacks<Definition> = Definition extends {
   readonly extensionPacks?: infer Packs extends Record<string, ExtensionPackRef<'sql', string>>;
 } ? Packs : Record<never, never>;
-type StagedDefinitionCapabilities<Definition> = Definition extends {
+type DefinitionCapabilities<Definition> = Definition extends {
   readonly capabilities?: infer Capabilities extends Record<string, Record<string, boolean>>;
 } ? Capabilities : undefined;
-type StagedDefinitionTargetId<Definition> = Definition extends {
+type DefinitionTargetId<Definition> = Definition extends {
   readonly target: TargetPackRef<'sql', infer Target>;
 } ? Target : never;
-type StagedDefinitionStorageHash<Definition> = Definition extends {
-  readonly storageHash?: infer StorageHash extends string;
-} ? StorageHash : undefined;
 type Present<T> = Exclude<T, undefined>;
-type CodecTypesFromStagedDefinition<Definition> = ExtractCodecTypesFromPack<Definition extends {
+type CodecTypesFromDefinition<Definition> = ExtractCodecTypesFromPack<Definition extends {
   readonly target: infer Target;
-} ? Target : never> & MergeExtensionCodecTypesSafe<StagedDefinitionExtensionPacks<Definition>>;
-type StagedDefinitionModels<Definition> = Definition extends {
+} ? Target : never> & MergeExtensionCodecTypesSafe<DefinitionExtensionPacks<Definition>>;
+type DefinitionModels<Definition> = Definition extends {
   readonly models?: unknown;
 } ? Present<Definition['models']> extends Record<string, unknown> ? Present<Definition['models']> : Record<never, never> : Record<never, never>;
-type StagedDefinitionTypes<Definition> = Definition extends {
+type DefinitionTypes<Definition> = Definition extends {
   readonly types?: unknown;
 } ? Present<Definition['types']> extends Record<string, StorageTypeInstance> ? Present<Definition['types']> : Record<never, never> : Record<never, never>;
-type StagedDefinitionTableNaming<Definition> = Definition extends {
+type DefinitionTableNaming<Definition> = Definition extends {
   readonly naming?: {
     readonly tables?: infer Strategy extends string;
   };
 } ? Strategy : undefined;
-type StagedDefinitionColumnNaming<Definition> = Definition extends {
+type DefinitionColumnNaming<Definition> = Definition extends {
   readonly naming?: {
     readonly columns?: infer Strategy extends string;
   };
@@ -562,18 +484,24 @@ type ShouldInsertSnakeUnderscore<PrevKind extends 'start' | 'lower' | 'upper' |
 type SnakeCaseInternal<S extends string, PrevKind extends 'start' | 'lower' | 'upper' | 'other' | 'end' = 'start'> = S extends `${infer Current}${infer Rest}` ? `${ShouldInsertSnakeUnderscore<PrevKind, Current, FirstChar<Rest>> extends true ? '_' : ''}${Lowercase<Current>}${SnakeCaseInternal<Rest, CharKind<Current>>}` : '';
 type SnakeCase<S extends string> = string extends S ? string : SnakeCaseInternal<S>;
 type ApplyNamingType<Name$1 extends string, Strategy extends string | undefined> = string extends Name$1 ? string : Strategy extends 'snake_case' ? SnakeCase<Name$1> : Name$1;
-type StagedModelNames<Definition> = keyof StagedDefinitionModels<Definition> & string;
-type StagedModelFields<Definition, ModelName$1 extends StagedModelNames<Definition>> = StagedDefinitionModels<Definition>[ModelName$1] extends {
+type ModelNames<Definition> = keyof DefinitionModels<Definition> & string;
+type ModelFields<Definition, ModelName$1 extends ModelNames<Definition>> = DefinitionModels<Definition>[ModelName$1] extends {
   readonly stageOne: {
     readonly fields: Record<string, ScalarFieldBuilder>;
   };
-} ? StagedDefinitionModels<Definition>[ModelName$1]['stageOne']['fields'] : Record<never, never>;
-type StagedModelFieldNames<Definition, ModelName$1 extends StagedModelNames<Definition>> = keyof StagedModelFields<Definition, ModelName$1> & string;
-type StagedModelFieldState<Definition, ModelName$1 extends StagedModelNames<Definition>, FieldName$1 extends StagedModelFieldNames<Definition, ModelName$1>> = FieldStateOf<StagedModelFields<Definition, ModelName$1>[FieldName$1]>;
-type StagedModelSql<Definition, ModelName$1 extends StagedModelNames<Definition>> = StagedDefinitionModels<Definition>[ModelName$1] extends {
+} ? DefinitionModels<Definition>[ModelName$1]['stageOne']['fields'] : Record<never, never>;
+type ModelFieldNames<Definition, ModelName$1 extends ModelNames<Definition>> = keyof ModelFields<Definition, ModelName$1> & string;
+type StagedModelRelations<Definition, ModelName$1 extends ModelNames<Definition>> = DefinitionModels<Definition>[ModelName$1] extends {
+  readonly stageOne: {
+    readonly relations: infer R;
+  };
+} ? R extends Record<string, unknown> ? R : Record<never, never> : Record<never, never>;
+type StagedModelRelationNames<Definition, ModelName$1 extends ModelNames<Definition>> = keyof StagedModelRelations<Definition, ModelName$1> & string;
+type ModelFieldState<Definition, ModelName$1 extends ModelNames<Definition>, FieldName$1 extends ModelFieldNames<Definition, ModelName$1>> = FieldStateOf<ModelFields<Definition, ModelName$1>[FieldName$1]>;
+type ModelSql<Definition, ModelName$1 extends ModelNames<Definition>> = DefinitionModels<Definition>[ModelName$1] extends {
   readonly __sql: infer SqlSpec;
 } ? SqlSpec : undefined;
-type StagedModelAttributes<Definition, ModelName$1 extends StagedModelNames<Definition>> = StagedDefinitionModels<Definition>[ModelName$1] extends {
+type ModelAttributes<Definition, ModelName$1 extends ModelNames<Definition>> = DefinitionModels<Definition>[ModelName$1] extends {
   readonly __attributes: infer AttributesSpec;
 } ? AttributesSpec : undefined;
 type FieldDescriptorOf<FieldState> = Present<FieldState extends {
@@ -603,33 +531,33 @@ type DescriptorTypeParams<Descriptor> = Descriptor extends {
 type DescriptorTypeRef<Descriptor> = Descriptor extends {
   readonly typeRef: infer TypeRef extends string;
 } ? TypeRef : undefined;
-type LookupNamedStorageTypeKeyByValue<Definition, TypeRef$1 extends StorageTypeInstance> = { [TypeName in keyof StagedDefinitionTypes<Definition> & string]: [TypeRef$1] extends [StagedDefinitionTypes<Definition>[TypeName]] ? [StagedDefinitionTypes<Definition>[TypeName]] extends [TypeRef$1] ? TypeName : never : never }[keyof StagedDefinitionTypes<Definition> & string];
+type LookupNamedStorageTypeKeyByValue<Definition, TypeRef$1 extends StorageTypeInstance> = { [TypeName in keyof DefinitionTypes<Definition> & string]: [TypeRef$1] extends [DefinitionTypes<Definition>[TypeName]] ? [DefinitionTypes<Definition>[TypeName]] extends [TypeRef$1] ? TypeName : never : never }[keyof DefinitionTypes<Definition> & string];
 type ResolveNamedStorageTypeKey<Definition, TypeRef$1> = TypeRef$1 extends string ? TypeRef$1 : TypeRef$1 extends StorageTypeInstance ? [LookupNamedStorageTypeKeyByValue<Definition, TypeRef$1>] extends [never] ? string : LookupNamedStorageTypeKeyByValue<Definition, TypeRef$1> : never;
-type ResolveNamedStorageType<Definition, TypeRef$1> = ResolveNamedStorageTypeKey<Definition, TypeRef$1> extends infer TypeName extends string ? TypeName extends keyof StagedDefinitionTypes<Definition> ? StagedDefinitionTypes<Definition>[TypeName] : StorageTypeInstance : StorageTypeInstance;
+type ResolveNamedStorageType<Definition, TypeRef$1> = ResolveNamedStorageTypeKey<Definition, TypeRef$1> 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>>;
 type ResolveFieldColumnTypeParams<Definition, FieldState> = [ResolveFieldColumnTypeRef<Definition, FieldState>] extends [string] ? undefined : DescriptorTypeParams<FieldDescriptorOf<FieldState>>;
-type StagedModelTableName<Definition, ModelName$1 extends StagedModelNames<Definition>> = [Present<StagedModelSql<Definition, ModelName$1> extends {
+type ModelTableName<Definition, ModelName$1 extends ModelNames<Definition>> = [Present<ModelSql<Definition, ModelName$1> extends {
   readonly table?: infer TableName;
-} ? TableName : never>] extends [never] ? ApplyNamingType<ModelName$1, StagedDefinitionTableNaming<Definition>> : Present<StagedModelSql<Definition, ModelName$1> extends {
+} ? TableName : never>] extends [never] ? ApplyNamingType<ModelName$1, DefinitionTableNaming<Definition>> : Present<ModelSql<Definition, ModelName$1> extends {
   readonly table?: infer TableName;
-} ? TableName : never> extends infer ExplicitTableName extends string ? ExplicitTableName : ApplyNamingType<ModelName$1, StagedDefinitionTableNaming<Definition>>;
-type StagedModelColumnName<Definition, ModelName$1 extends StagedModelNames<Definition>, FieldName$1 extends StagedModelFieldNames<Definition, ModelName$1>> = [FieldColumnOverrideOf<StagedModelFieldState<Definition, ModelName$1, FieldName$1>>] extends [never] ? ApplyNamingType<FieldName$1, StagedDefinitionColumnNaming<Definition>> : FieldColumnOverrideOf<StagedModelFieldState<Definition, ModelName$1, FieldName$1>> extends infer ExplicitColumnName extends string ? ExplicitColumnName : ApplyNamingType<FieldName$1, StagedDefinitionColumnNaming<Definition>>;
-type StagedFieldNamesToColumnNames<Definition, ModelName$1 extends StagedModelNames<Definition>, FieldNames extends readonly string[]> = FieldNames extends readonly [] ? readonly [] : FieldNames extends readonly [infer First extends StagedModelFieldNames<Definition, ModelName$1>, ...infer Rest extends readonly string[]] ? readonly [StagedModelColumnName<Definition, ModelName$1, First>, ...StagedFieldNamesToColumnNames<Definition, ModelName$1, Rest>] : readonly string[];
-type StagedInlineIdFieldName<Definition, ModelName$1 extends StagedModelNames<Definition>> = { [FieldName in StagedModelFieldNames<Definition, ModelName$1>]: [FieldInlineIdSpecOf<StagedModelFieldState<Definition, ModelName$1, FieldName>>] extends [never] ? never : FieldName }[StagedModelFieldNames<Definition, ModelName$1>];
-type StagedInlineIdFieldNames<Definition, ModelName$1 extends StagedModelNames<Definition>> = [StagedInlineIdFieldName<Definition, ModelName$1>] extends [never] ? undefined : readonly [StagedInlineIdFieldName<Definition, ModelName$1>];
-type StagedInlineIdName<Definition, ModelName$1 extends StagedModelNames<Definition>> = { [FieldName in StagedModelFieldNames<Definition, ModelName$1>]: FieldInlineIdSpecOf<StagedModelFieldState<Definition, ModelName$1, FieldName>> extends {
+} ? TableName : never> extends infer ExplicitTableName extends string ? ExplicitTableName : ApplyNamingType<ModelName$1, DefinitionTableNaming<Definition>>;
+type ModelColumnName<Definition, ModelName$1 extends ModelNames<Definition>, FieldName$1 extends ModelFieldNames<Definition, ModelName$1>> = [FieldColumnOverrideOf<ModelFieldState<Definition, ModelName$1, FieldName$1>>] extends [never] ? ApplyNamingType<FieldName$1, DefinitionColumnNaming<Definition>> : FieldColumnOverrideOf<ModelFieldState<Definition, ModelName$1, FieldName$1>> extends infer ExplicitColumnName extends string ? ExplicitColumnName : ApplyNamingType<FieldName$1, DefinitionColumnNaming<Definition>>;
+type FieldNamesToColumnNames<Definition, ModelName$1 extends ModelNames<Definition>, FieldNames extends readonly string[]> = FieldNames extends readonly [] ? readonly [] : FieldNames extends readonly [infer First extends ModelFieldNames<Definition, ModelName$1>, ...infer Rest extends readonly string[]] ? readonly [ModelColumnName<Definition, ModelName$1, First>, ...FieldNamesToColumnNames<Definition, ModelName$1, Rest>] : readonly string[];
+type InlineIdFieldName<Definition, ModelName$1 extends ModelNames<Definition>> = { [FieldName in ModelFieldNames<Definition, ModelName$1>]: [FieldInlineIdSpecOf<ModelFieldState<Definition, ModelName$1, FieldName>>] extends [never] ? never : FieldName }[ModelFieldNames<Definition, ModelName$1>];
+type InlineIdFieldNames<Definition, ModelName$1 extends ModelNames<Definition>> = [InlineIdFieldName<Definition, ModelName$1>] extends [never] ? undefined : readonly [InlineIdFieldName<Definition, ModelName$1>];
+type InlineIdName<Definition, ModelName$1 extends ModelNames<Definition>> = { [FieldName in ModelFieldNames<Definition, ModelName$1>]: FieldInlineIdSpecOf<ModelFieldState<Definition, ModelName$1, FieldName>> extends {
   readonly name?: infer Name extends string;
-} ? Name : never }[StagedModelFieldNames<Definition, ModelName$1>];
-type StagedAttributeIdFieldNames<Definition, ModelName$1 extends StagedModelNames<Definition>> = AttributeStageIdFieldNames<StagedModelAttributes<Definition, ModelName$1>>;
-type StagedAttributeIdName<Definition, ModelName$1 extends StagedModelNames<Definition>> = Present<StagedModelAttributes<Definition, ModelName$1> extends {
+} ? Name : never }[ModelFieldNames<Definition, ModelName$1>];
+type AttributeIdFieldNames<Definition, ModelName$1 extends ModelNames<Definition>> = AttributeStageIdFieldNames<ModelAttributes<Definition, ModelName$1>>;
+type AttributeIdName<Definition, ModelName$1 extends ModelNames<Definition>> = Present<ModelAttributes<Definition, ModelName$1> extends {
   readonly id?: {
     readonly name?: infer Name extends string;
   };
 } ? Name : never>;
-type StagedModelIdFieldNames<Definition, ModelName$1 extends StagedModelNames<Definition>> = [StagedAttributeIdFieldNames<Definition, ModelName$1>] extends [undefined] ? StagedInlineIdFieldNames<Definition, ModelName$1> : StagedAttributeIdFieldNames<Definition, ModelName$1>;
-type StagedModelIdName<Definition, ModelName$1 extends StagedModelNames<Definition>> = [StagedAttributeIdName<Definition, ModelName$1>] extends [never] ? Present<StagedInlineIdName<Definition, ModelName$1>> : StagedAttributeIdName<Definition, ModelName$1>;
-type StagedStorageColumn<CodecId$1 extends string, Nullable$1 extends boolean, NativeType extends string, TypeRef$1 extends string | undefined = undefined, TypeParams$1 extends Record<string, unknown> | undefined = undefined> = {
+type ModelIdFieldNames<Definition, ModelName$1 extends ModelNames<Definition>> = [AttributeIdFieldNames<Definition, ModelName$1>] extends [undefined] ? InlineIdFieldNames<Definition, ModelName$1> : AttributeIdFieldNames<Definition, ModelName$1>;
+type ModelIdName<Definition, ModelName$1 extends ModelNames<Definition>> = [AttributeIdName<Definition, ModelName$1>] extends [never] ? Present<InlineIdName<Definition, ModelName$1>> : AttributeIdName<Definition, ModelName$1>;
+type StorageColumn<CodecId$1 extends string, Nullable$1 extends boolean, NativeType extends string, TypeRef$1 extends string | undefined = undefined, TypeParams$1 extends Record<string, unknown> | undefined = undefined> = {
   readonly nativeType: NativeType;
   readonly codecId: CodecId$1;
   readonly nullable: Nullable$1;
@@ -639,20 +567,28 @@ type StagedStorageColumn<CodecId$1 extends string, Nullable$1 extends boolean, N
 } : Record<string, never>) & (TypeParams$1 extends Record<string, unknown> ? {
   readonly typeParams: TypeParams$1;
 } : Record<string, never>);
-type StagedModelStorageColumn<Definition, ModelName$1 extends StagedModelNames<Definition>, FieldName$1 extends string> = FieldName$1 extends StagedModelFieldNames<Definition, ModelName$1> ? StagedStorageColumn<DescriptorCodecId<ResolveFieldDescriptor<Definition, StagedModelFieldState<Definition, ModelName$1, FieldName$1>>>, FieldNullableOf<StagedModelFieldState<Definition, ModelName$1, FieldName$1>>, DescriptorNativeType<ResolveFieldDescriptor<Definition, StagedModelFieldState<Definition, ModelName$1, FieldName$1>>>, ResolveFieldColumnTypeRef<Definition, StagedModelFieldState<Definition, ModelName$1, FieldName$1>>, ResolveFieldColumnTypeParams<Definition, StagedModelFieldState<Definition, ModelName$1, FieldName$1>>> : never;
-type StagedBuiltModels<Definition> = { readonly [ModelName in StagedModelNames<Definition>]: {
+type ModelStorageColumn<Definition, ModelName$1 extends ModelNames<Definition>, FieldName$1 extends string> = FieldName$1 extends ModelFieldNames<Definition, ModelName$1> ? StorageColumn<DescriptorCodecId<ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName$1, FieldName$1>>>, FieldNullableOf<ModelFieldState<Definition, ModelName$1, FieldName$1>>, DescriptorNativeType<ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName$1, FieldName$1>>>, ResolveFieldColumnTypeRef<Definition, ModelFieldState<Definition, ModelName$1, FieldName$1>>, ResolveFieldColumnTypeParams<Definition, ModelFieldState<Definition, ModelName$1, FieldName$1>>> : never;
+type BuiltModels<Definition> = { readonly [ModelName in ModelNames<Definition>]: {
   readonly storage: {
-    readonly table: StagedModelTableName<Definition, ModelName>;
+    readonly table: ModelTableName<Definition, ModelName>;
+    readonly fields: { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: {
+      readonly column: ModelColumnName<Definition, ModelName, FieldName>;
+    } };
   };
-  readonly fields: { readonly [FieldName in StagedModelFieldNames<Definition, ModelName>]: {
-    readonly column: StagedModelColumnName<Definition, ModelName, FieldName>;
+  readonly fields: { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: {
+    readonly nullable: ModelStorageColumn<Definition, ModelName, FieldName>['nullable'];
+    readonly type: {
+      readonly kind: 'scalar';
+      readonly codecId: ModelStorageColumn<Definition, ModelName, FieldName>['codecId'];
+    };
   } };
+  readonly relations: { readonly [RelName in StagedModelRelationNames<Definition, ModelName>]: ContractRelation };
 } };
-type StagedBuiltModelFields<Definition, ModelName$1 extends StagedModelNames<Definition>> = StagedBuiltModels<Definition>[ModelName$1]['fields'];
-type StagedBuiltModelTableName<Definition, ModelName$1 extends StagedModelNames<Definition>> = StagedBuiltModels<Definition>[ModelName$1]['storage']['table'];
-type StagedBuiltStorageTableColumns<Definition, ModelName$1 extends StagedModelNames<Definition>> = { readonly [FieldName in keyof StagedBuiltModelFields<Definition, ModelName$1> & string as StagedBuiltModelFields<Definition, ModelName$1>[FieldName]['column']]: StagedModelStorageColumn<Definition, ModelName$1, FieldName> };
-type StagedBuiltStorageTables<Definition> = { readonly [ModelName in StagedModelNames<Definition> as StagedBuiltModelTableName<Definition, ModelName>]: {
-  readonly columns: StagedBuiltStorageTableColumns<Definition, ModelName>;
+type BuiltModelColumnMappings<Definition, ModelName$1 extends ModelNames<Definition>> = BuiltModels<Definition>[ModelName$1]['storage']['fields'];
+type BuiltModelTableName<Definition, ModelName$1 extends ModelNames<Definition>> = BuiltModels<Definition>[ModelName$1]['storage']['table'];
+type BuiltStorageTableColumns<Definition, ModelName$1 extends ModelNames<Definition>> = { readonly [FieldName in keyof BuiltModelColumnMappings<Definition, ModelName$1> & string as BuiltModelColumnMappings<Definition, ModelName$1>[FieldName]['column']]: ModelStorageColumn<Definition, ModelName$1, FieldName> };
+type BuiltStorageTables<Definition> = { readonly [ModelName in ModelNames<Definition> as BuiltModelTableName<Definition, ModelName>]: {
+  readonly columns: BuiltStorageTableColumns<Definition, ModelName>;
   readonly uniques: ReadonlyArray<{
     readonly columns: readonly string[];
     readonly name?: string;
@@ -670,62 +606,126 @@ type StagedBuiltStorageTables<Definition> = { readonly [ModelName in StagedModel
     readonly constraint: boolean;
     readonly index: boolean;
   }>;
-} & (StagedModelIdFieldNames<Definition, ModelName> extends readonly string[] ? {
+} & (ModelIdFieldNames<Definition, ModelName> extends readonly string[] ? {
   readonly primaryKey: {
-    readonly columns: StagedFieldNamesToColumnNames<Definition, ModelName, StagedModelIdFieldNames<Definition, ModelName>>;
-    readonly name?: StagedModelIdName<Definition, ModelName>;
+    readonly columns: FieldNamesToColumnNames<Definition, ModelName, ModelIdFieldNames<Definition, ModelName>>;
+    readonly name?: ModelIdName<Definition, ModelName>;
   };
 } : Record<string, never>) };
-type StagedBuiltStorage<Definition> = {
-  readonly tables: StagedBuiltStorageTables<Definition>;
-  readonly types: StagedDefinitionTypes<Definition>;
-};
-type SqlContractResult<Definition> = ContractWithTypeMaps<SqlContract<StagedBuiltStorage<Definition>, StagedBuiltModels<Definition>> & {
-  readonly schemaVersion: '1';
-  readonly target: StagedDefinitionTargetId<Definition>;
+type BuiltStorage<Definition> = {
+  readonly storageHash: StorageHashBase<string>;
+  readonly tables: BuiltStorageTables<Definition>;
+  readonly types: DefinitionTypes<Definition>;
+};
+type FieldOutputType<Definition, ModelName$1 extends ModelNames<Definition>, FieldName$1 extends ModelFieldNames<Definition, ModelName$1>> = ModelStorageColumn<Definition, ModelName$1, FieldName$1> extends infer Col ? Col extends {
+  readonly codecId: infer Id extends string;
+} ? Id extends keyof CodecTypesFromDefinition<Definition> ? CodecTypesFromDefinition<Definition>[Id] extends {
+  readonly output: infer O;
+} ? Col extends {
+  readonly nullable: true;
+} ? O | null : O : unknown : unknown : unknown : unknown;
+type FieldOutputTypes<Definition> = { readonly [ModelName in ModelNames<Definition>]: { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldOutputType<Definition, ModelName, FieldName> } };
+type SqlContractResult<Definition> = ContractWithTypeMaps<Contract<BuiltStorage<Definition>, BuiltModels<Definition>> & {
+  readonly target: DefinitionTargetId<Definition>;
   readonly targetFamily: 'sql';
-  readonly storageHash: StagedDefinitionStorageHash<Definition> extends string ? StagedDefinitionStorageHash<Definition> : string;
 } & {
-  readonly extensionPacks: keyof StagedDefinitionExtensionPacks<Definition> extends never ? Record<string, never> : StagedDefinitionExtensionPacks<Definition>;
-  readonly capabilities: StagedDefinitionCapabilities<Definition> extends Record<string, Record<string, boolean>> ? StagedDefinitionCapabilities<Definition> : Record<string, Record<string, boolean>>;
-}, TypeMaps<CodecTypesFromStagedDefinition<Definition>, Record<string, never>>>;
+  readonly extensionPacks: keyof DefinitionExtensionPacks<Definition> extends never ? Record<string, never> : DefinitionExtensionPacks<Definition>;
+  readonly capabilities: DefinitionCapabilities<Definition> extends Record<string, Record<string, boolean>> ? DefinitionCapabilities<Definition> : Record<string, Record<string, boolean>>;
+}, TypeMaps<CodecTypesFromDefinition<Definition>, Record<string, never>, Record<string, never>, FieldOutputTypes<Definition>>>;
 //#endregion
-//#region src/contract-builder.d.ts
-type BuildStorageTable<_TableName extends string, Columns extends Record<string, ColumnBuilderState<string, boolean, string>>, PK extends readonly string[] | undefined> = {
-  readonly columns: { readonly [K in keyof Columns]: Columns[K] extends ColumnBuilderState<string, infer Null, infer TType> ? BuildStorageColumn<Null & boolean, TType> : never };
-  readonly uniques: ReadonlyArray<{
-    readonly columns: readonly string[];
-    readonly name?: string;
-  }>;
-  readonly indexes: ReadonlyArray<Index$1>;
-  readonly foreignKeys: ReadonlyArray<{
+//#region src/contract-definition.d.ts
+interface FieldNode {
+  readonly fieldName: string;
+  readonly columnName: string;
+  readonly descriptor: ColumnTypeDescriptor;
+  readonly nullable: boolean;
+  readonly default?: ColumnDefault;
+  readonly executionDefault?: ExecutionMutationDefaultValue;
+  readonly many?: boolean;
+}
+interface PrimaryKeyNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+interface UniqueConstraintNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+interface IndexNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  readonly using?: string;
+  readonly config?: Record<string, unknown>;
+}
+interface ForeignKeyNode {
+  readonly columns: readonly string[];
+  readonly references: {
+    readonly model: string;
+    readonly table: string;
     readonly columns: readonly string[];
-    readonly references: {
-      readonly table: string;
-      readonly columns: readonly string[];
-    };
-    readonly name?: string;
-    readonly onDelete?: ReferentialAction;
-    readonly onUpdate?: ReferentialAction;
-    readonly constraint: boolean;
-    readonly index: boolean;
-  }>;
-} & (PK extends readonly string[] ? {
-  readonly primaryKey: {
-    readonly columns: PK;
-    readonly name?: string;
   };
-} : Record<string, never>);
-type BuildStorage<Tables extends Record<string, TableBuilderState<string, Record<string, ColumnBuilderState<string, boolean, string>>, readonly string[] | undefined>>, Types extends Record<string, StorageTypeInstance>> = {
-  readonly tables: { readonly [K in keyof Tables]: BuildStorageTable<K & string, ExtractColumns<Tables[K]>, ExtractPrimaryKey<Tables[K]>> };
-  readonly types: Types;
-};
-interface ColumnBuilder<Name$1 extends string, Nullable$1 extends boolean, Type extends string> {
-  nullable<Value extends boolean>(value?: Value): ColumnBuilder<Name$1, Value, Type>;
-  type<Id extends string>(id: Id): ColumnBuilder<Name$1, Nullable$1, Id>;
-  build(): ColumnBuilderState<Name$1, Nullable$1, Type>;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  readonly constraint?: boolean;
+  readonly index?: boolean;
+}
+interface RelationNode {
+  readonly fieldName: string;
+  readonly toModel: string;
+  readonly toTable: string;
+  readonly cardinality: '1:1' | '1:N' | 'N:1' | 'N:M';
+  readonly on: {
+    readonly parentTable: string;
+    readonly parentColumns: readonly string[];
+    readonly childTable: string;
+    readonly childColumns: readonly string[];
+  };
+  readonly through?: {
+    readonly table: string;
+    readonly parentColumns: readonly string[];
+    readonly childColumns: readonly string[];
+  };
+}
+interface ValueObjectFieldNode {
+  readonly fieldName: string;
+  readonly columnName: string;
+  readonly valueObjectName: string;
+  readonly nullable: boolean;
+  readonly default?: ColumnDefault;
+  readonly executionDefault?: ExecutionMutationDefaultValue;
+  readonly many?: boolean;
 }
-type StagedModelLike = {
+interface ValueObjectNode {
+  readonly name: string;
+  readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
+}
+interface ModelNode {
+  readonly modelName: string;
+  readonly tableName: string;
+  readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
+  readonly id?: PrimaryKeyNode;
+  readonly uniques?: readonly UniqueConstraintNode[];
+  readonly indexes?: readonly IndexNode[];
+  readonly foreignKeys?: readonly ForeignKeyNode[];
+  readonly relations?: readonly RelationNode[];
+}
+interface ContractDefinition {
+  readonly target: TargetPackRef<'sql', string>;
+  readonly extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
+  readonly capabilities?: Record<string, Record<string, boolean>>;
+  readonly storageHash?: string;
+  readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
+  readonly storageTypes?: Record<string, StorageTypeInstance>;
+  readonly models: readonly ModelNode[];
+  readonly valueObjects?: readonly ValueObjectNode[];
+}
+//#endregion
+//#region src/build-contract.d.ts
+declare function buildSqlContractFromDefinition(definition: ContractDefinition, codecLookup?: CodecLookup): Contract<SqlStorage>;
+//#endregion
+//#region src/contract-builder.d.ts
+type ModelLike = {
   readonly stageOne: {
     readonly modelName?: string;
     readonly fields: Record<string, ScalarFieldBuilder>;
@@ -736,50 +736,7 @@ type StagedModelLike = {
   buildAttributesSpec(): ModelAttributesSpec | undefined;
   buildSqlSpec(): SqlStageSpec | undefined;
 };
-declare class SqlContractBuilder<CodecTypes extends Record<string, {
-  output: unknown;
-}> = Record<string, never>, Target extends string | undefined = undefined, Tables extends Record<string, TableBuilderState<string, Record<string, ColumnBuilderState<string, boolean, string>>, readonly string[] | undefined>> = Record<never, never>, Models extends Record<string, ModelBuilderState<string, string, Record<string, string>, Record<string, RelationDefinition>>> = Record<never, never>, Types extends Record<string, StorageTypeInstance> = Record<never, never>, StorageHash extends string | undefined = undefined, ExtensionPacks extends Record<string, unknown> | undefined = undefined, Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined> extends ContractBuilder<Target, Tables, Models, StorageHash, ExtensionPacks, Capabilities> {
-  protected readonly state: ContractBuilderState<Target, Tables, Models, StorageHash, ExtensionPacks, Capabilities> & {
-    readonly storageTypes?: Types;
-  };
-  /**
-   * This method is responsible for normalizing the contract IR by setting default values
-   * for all required fields:
-   * - `nullable`: defaults to `false` if not provided
-   * - `uniques`: defaults to `[]` (empty array)
-   * - `indexes`: defaults to `[]` (empty array)
-   * - `foreignKeys`: defaults to `[]` (empty array)
-   * - model `relations`: defaults to `{}` (empty object) when not populated by the builder
-   * - `nativeType`: required field set from column type descriptor when columns are defined
-   *
-   * The contract builder is the **only** place where normalization should occur.
-   * Validators, parsers, and emitters should assume the contract is already normalized.
-   *
-   * **Required**: Use column type descriptors (e.g., `int4Column`, `textColumn`) when defining columns.
-   * This ensures `nativeType` is set correctly at build time.
-   *
-   * @returns A normalized SqlContract with all required fields present
-   */
-  build(): Target extends string ? ContractWithTypeMaps<SqlContract<BuildStorage<Tables, Types>, BuildModels<Models>> & {
-    readonly schemaVersion: '1';
-    readonly target: Target;
-    readonly targetFamily: 'sql';
-    readonly storageHash: StorageHash extends string ? StorageHash : string;
-  } & (ExtensionPacks extends Record<string, unknown> ? {
-    readonly extensionPacks: ExtensionPacks;
-  } : Record<string, never>) & (Capabilities extends Record<string, Record<string, boolean>> ? {
-    readonly capabilities: Capabilities;
-  } : Record<string, never>), TypeMaps<CodecTypes, Record<string, never>>> : never;
-  target<T extends string, TPack extends TargetPackRef<string, T> = TargetPackRef<string, T>>(packRef: TPack & TargetPackRef<string, T>): SqlContractBuilder<ExtractCodecTypesFromPack<TPack> extends Record<string, never> ? CodecTypes : ExtractCodecTypesFromPack<TPack>, T, Tables, Models, Types, StorageHash, ExtensionPacks, Capabilities>;
-  extensionPacks<const Packs extends Record<string, ExtensionPackRef<'sql', string>>>(packs: Packs): SqlContractBuilder<CodecTypes & MergeExtensionCodecTypes<Packs>, Target, Tables, Models, Types, StorageHash, MergeExtensionPackRefs<ExtensionPacks, Packs>, Capabilities>;
-  capabilities<C extends Record<string, Record<string, boolean>>>(capabilities: C): SqlContractBuilder<CodecTypes, Target, Tables, Models, Types, StorageHash, ExtensionPacks, C>;
-  storageHash<H extends string>(hash: H): SqlContractBuilder<CodecTypes, Target, Tables, Models, Types, H, ExtensionPacks, Capabilities>;
-  table<TableName extends string, T extends TableBuilder<TableName, Record<string, ColumnBuilderState<string, boolean, string>>, readonly string[] | undefined>>(name: TableName, callback: (t: TableBuilder<TableName>) => T | undefined): SqlContractBuilder<CodecTypes, Target, Tables & Record<TableName, ReturnType<T['build']>>, Models, Types, StorageHash, ExtensionPacks, Capabilities>;
-  model<ModelName$1 extends string, TableName extends string, M extends ModelBuilder<ModelName$1, TableName, Record<string, string>, Record<string, RelationDefinition>>>(name: ModelName$1, table: TableName, callback: (m: ModelBuilder<ModelName$1, TableName, Record<never, never>, Record<never, never>>) => M | undefined): SqlContractBuilder<CodecTypes, Target, Tables, Models & Record<ModelName$1, ReturnType<M['build']>>, Types, StorageHash, ExtensionPacks, Capabilities>;
-  foreignKeyDefaults(config: ForeignKeyDefaultsState): SqlContractBuilder<CodecTypes, Target, Tables, Models, Types, StorageHash, ExtensionPacks, Capabilities>;
-  storageType<Name$1 extends string, Type extends StorageTypeInstance>(name: Name$1, typeInstance: Type): SqlContractBuilder<CodecTypes, Target, Tables, Models, Types & Record<Name$1, Type>, StorageHash, ExtensionPacks, Capabilities>;
-}
-type StagedContractDefinition<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Types extends Record<string, StorageTypeInstance>, Models extends Record<string, StagedModelLike>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Capabilities extends Record<string, Record<string, boolean>> | undefined, Naming extends StagedContractInput['naming'] | undefined, StorageHash extends string | undefined, ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined> = {
+type ContractDefinition$1<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Types extends Record<string, StorageTypeInstance>, Models extends Record<string, ModelLike>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Capabilities extends Record<string, Record<string, boolean>> | undefined, Naming extends ContractInput['naming'] | undefined, StorageHash extends string | undefined, ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined> = {
   readonly family: Family;
   readonly target: Target;
   readonly extensionPacks?: ExtensionPacks;
@@ -789,8 +746,9 @@ type StagedContractDefinition<Family extends FamilyPackRef<string>, Target exten
   readonly capabilities?: Capabilities;
   readonly types?: Types;
   readonly models?: Models;
+  readonly codecLookup?: CodecLookup;
 };
-type StagedContractScaffold<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Capabilities extends Record<string, Record<string, boolean>> | undefined, Naming extends StagedContractInput['naming'] | undefined, StorageHash extends string | undefined, ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined> = {
+type ContractScaffold<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Capabilities extends Record<string, Record<string, boolean>> | undefined, Naming extends ContractInput['naming'] | undefined, StorageHash extends string | undefined, ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined> = {
   readonly family: Family;
   readonly target: Target;
   readonly extensionPacks?: ExtensionPacks;
@@ -798,16 +756,14 @@ type StagedContractScaffold<Family extends FamilyPackRef<string>, Target extends
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
   readonly capabilities?: Capabilities;
+  readonly codecLookup?: CodecLookup;
 };
-type StagedContractFactory<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Types extends Record<string, StorageTypeInstance>, Models extends Record<string, StagedModelLike>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined> = (helpers: ComposedAuthoringHelpers<Family, Target, ExtensionPacks>) => {
+type ContractFactory<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Types extends Record<string, StorageTypeInstance>, Models extends Record<string, ModelLike>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined> = (helpers: ComposedAuthoringHelpers<Family, Target, ExtensionPacks>) => {
   readonly types?: Types;
   readonly models?: Models;
 };
-declare function defineContract<CodecTypes extends Record<string, {
-  output: unknown;
-}> = Record<string, never>>(): SqlContractBuilder<CodecTypes>;
-declare function defineContract<const Family extends FamilyPackRef<string>, const Target extends TargetPackRef<'sql', string>, const Types extends Record<string, StorageTypeInstance> = Record<never, never>, const Models extends Record<string, StagedModelLike> = Record<never, never>, const ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, const Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined, const Naming extends StagedContractInput['naming'] | undefined = undefined, const StorageHash extends string | undefined = undefined, const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined>(definition: StagedContractDefinition<Family, Target, Types, Models, ExtensionPacks, Capabilities, Naming, StorageHash, ForeignKeyDefaults>): SqlContractResult<StagedContractDefinition<Family, Target, Types, Models, ExtensionPacks, Capabilities, Naming, StorageHash, ForeignKeyDefaults>>;
-declare function defineContract<const Family extends FamilyPackRef<string>, const Target extends TargetPackRef<'sql', string>, const Types extends Record<string, StorageTypeInstance> = Record<never, never>, const Models extends Record<string, StagedModelLike> = Record<never, never>, const ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, const Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined, const Naming extends StagedContractInput['naming'] | undefined = undefined, const StorageHash extends string | undefined = undefined, const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined>(definition: StagedContractScaffold<Family, Target, ExtensionPacks, Capabilities, Naming, StorageHash, ForeignKeyDefaults>, factory: StagedContractFactory<Family, Target, Types, Models, ExtensionPacks>): SqlContractResult<StagedContractDefinition<Family, Target, Types, Models, ExtensionPacks, Capabilities, Naming, StorageHash, ForeignKeyDefaults>>;
+declare function defineContract<const Family extends FamilyPackRef<string>, const Target extends TargetPackRef<'sql', string>, const Types extends Record<string, StorageTypeInstance> = Record<never, never>, const Models extends Record<string, ModelLike> = Record<never, never>, const ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, const Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined, const Naming extends ContractInput['naming'] | undefined = undefined, const StorageHash extends string | undefined = undefined, const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined>(definition: ContractDefinition$1<Family, Target, Types, Models, ExtensionPacks, Capabilities, Naming, StorageHash, ForeignKeyDefaults>): SqlContractResult<ContractDefinition$1<Family, Target, Types, Models, ExtensionPacks, Capabilities, Naming, StorageHash, ForeignKeyDefaults>>;
+declare function defineContract<const Family extends FamilyPackRef<string>, const Target extends TargetPackRef<'sql', string>, const Types extends Record<string, StorageTypeInstance> = Record<never, never>, const Models extends Record<string, ModelLike> = Record<never, never>, const ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, const Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined, const Naming extends ContractInput['naming'] | undefined = undefined, const StorageHash extends string | undefined = undefined, const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined>(definition: ContractScaffold<Family, Target, ExtensionPacks, Capabilities, Naming, StorageHash, ForeignKeyDefaults>, factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks>): SqlContractResult<ContractDefinition$1<Family, Target, Types, Models, ExtensionPacks, Capabilities, Naming, StorageHash, ForeignKeyDefaults>>;
 //#endregion
-export { type ColumnBuilder, type ComposedAuthoringHelpers, type ScalarFieldBuilder, type SqlSemanticContractDefinition, type SqlSemanticFieldNode, type SqlSemanticForeignKeyNode, type SqlSemanticIndexNode, type SqlSemanticModelNode, type SqlSemanticPrimaryKeyNode, type SqlSemanticRelationNode, type SqlSemanticUniqueConstraintNode, type StagedContractInput, type StagedModelBuilder, buildSqlContractFromSemanticDefinition, defineContract, field, model, rel };
+export { type ComposedAuthoringHelpers, type ContractDefinition, type ContractInput, type ContractModelBuilder, type FieldNode, type ForeignKeyNode, type IndexNode, type ModelNode, type PrimaryKeyNode, type RelationNode, type ScalarFieldBuilder, type UniqueConstraintNode, buildSqlContractFromDefinition, defineContract, field, model, rel };
 //# sourceMappingURL=contract-builder.d.mts.map