orchid-orm 1.76.5 → 1.77.1

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { Adapter, AfterCommitStandaloneHook, AfterHook, Column, ColumnSchemaConfig, ColumnsShape, ComputedOptionsConfig, ComputedOptionsFactory, CreateData, CreateManyMethodsNames, CreateMethodsNames, CreateSelf, DbSharedOptions, DbSqlMethod, DbTableOptionScopes, DefaultColumnTypes, DefaultSchemaConfig, DeleteMethodsNames, EmptyObject, FromArg, FromResult, Grant, IsQuery, IsolationLevel, MaybeArray, MergeQuery, PickQuerySelectableRelations, QueryAfterHook, QueryBeforeActionHook, QueryBeforeHook, QueryData, QueryHasWhere, QueryReturnType, QuerySchema, QueryScopes, RawSqlBase, RecordUnknown, RelationConfigBase, Rls, SelectableFromShape, ShallowSimplify, StorageOptions, TableData, TableDataFn, TableDataItem, TransactionOptions, UpdateData, WhereArg } from "pqb/internal";
+import { Adapter, AfterCommitStandaloneHook, AfterHook, Column, ColumnSchemaConfig, ColumnsShape, ComputedOptionsConfig, ComputedOptionsFactory, CreateData, CreateManyMethodsNames, CreateMethodsNames, CreateSelf, DbSharedOptions, DbSqlMethod, DbTableOptionScopes, DefaultColumnTypes, DefaultSchemaConfig, DeleteMethodsNames, EmptyObject, FromArg, FromResult, Grant, IsQuery, IsolationLevel, MaybeArray, MergeQuery, PickQuerySelectableRelations, QueryAfterHook, QueryBeforeActionHook, QueryBeforeHook, QueryData, QueryHasWhere, QueryOrExpression, QueryReturnType, QuerySchema, QueryScopes, RawSqlBase, RecordUnknown, RelationConfigBase, Rls, RlsPolicy, SelectableFromShape, StorageOptions, TableData, TableDataFn, TableDataItem, TransactionOptions, UpdateData, WhereArg } from "pqb/internal";
 import { Db, Query } from "pqb";
 export * from "pqb";
-interface BelongsTo extends RelationThunkBase {
+interface BelongsTo$1 extends RelationThunkBase {
   type: 'belongsTo';
   options: BelongsToOptions;
 }
@@ -12,20 +12,20 @@ interface BelongsToOptions<Columns extends Column.Shape.QueryInit = Column.Shape
   foreignKey?: boolean | TableData.References.Options;
   on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
 }
-type BelongsToParams<T extends RelationConfigSelf, FK extends string> = { [Name in FK]: T['columns']['shape'][Name]['__type'] };
-type BelongsToDefaultRequired<T extends RelationConfigSelf, Rel extends BelongsTo, Related> = Related extends {
+type BelongsToParams<T extends RelationConfigSelf, FK extends string> = { [Name in FK]: T['columns']['shape'][Name]['__type']; };
+type BelongsToDefaultRequired<T extends RelationConfigSelf, Rel extends BelongsTo$1, Related> = Related extends {
   softDelete: true;
 } ? false : BelongsToDefaultRequiredFromColumns<T, Rel>;
-type BelongsToDefaultRequiredFromColumns<T extends RelationConfigSelf, Rel extends BelongsTo> = BelongsToColumnRequired<T['columns']['shape'][Rel['options']['columns'][number] & string]> extends true ? true : false;
+type BelongsToDefaultRequiredFromColumns<T extends RelationConfigSelf, Rel extends BelongsTo$1> = BelongsToColumnRequired<T['columns']['shape'][Rel['options']['columns'][number] & string]> extends true ? true : false;
 type BelongsToColumnRequired<Column> = Column extends {
   data: {
     isNullable: true;
   };
 } ? false : true;
-type BelongsToQuery<T extends Query, Name extends string> = { [P in keyof T]: P extends '__selectable' ? SelectableFromShape<T['shape'], Name> : P extends '__as' ? Name : P extends CreateMethodsNames | DeleteMethodsNames ? never : T[P] } & QueryHasWhere;
+type BelongsToQuery<T extends Query, Name extends string> = { [P in keyof T]: P extends '__selectable' ? SelectableFromShape<T['shape'], Name> : P extends '__as' ? Name : P extends CreateMethodsNames | DeleteMethodsNames ? never : T[P]; } & QueryHasWhere;
 interface BelongsToDataForCreate<Name extends string, FK extends string, Required, Q extends Query> {
   columns: FK;
-  nested: Q extends Query.Pick.IsNotReadOnly ? Required extends true ? { [Key in Name]: RelationToOneDataForCreateSameQuery<Q> } : { [Key in Name]?: RelationToOneDataForCreateSameQuery<Q> } : { [Key in Name]?: never };
+  nested: Q extends Query.Pick.IsNotReadOnly ? Required extends true ? { [Key in Name]: RelationToOneDataForCreateSameQuery<Q>; } : { [Key in Name]?: RelationToOneDataForCreateSameQuery<Q>; } : { [Key in Name]?: never; };
 }
 interface BelongsToInfo<T extends RelationConfigSelf, FK extends string, Required, Q extends Query> extends RelationConfigBase {
   returnsOne: true;
@@ -61,35 +61,36 @@ interface BelongsToInfo<T extends RelationConfigSelf, FK extends string, Require
     };
   } : never);
 }
-interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends Column.Shape.QueryInit = Column.Shape.QueryInit> {
+interface RelationRefsOptions$1<Column extends PropertyKey = string, Shape extends Column.Shape.QueryInit = Column.Shape.QueryInit> {
   required?: boolean;
   columns: Column[];
   references: (keyof Shape)[];
   foreignKey?: boolean | TableData.References.Options;
   on?: ColumnsShape.InputPartial<Shape>;
 }
-interface RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> {
+interface RelationThroughOptions$1<Through extends PropertyKey = string> {
   through: Through;
-  source: Source;
+  source: string;
+  on?: ColumnsShape.InputPartial<Column.Shape.QueryInit>;
 }
-interface HasMany extends RelationThunkBase {
+interface HasMany$1 extends RelationThunkBase {
   type: 'hasMany';
   options: HasOneOptions;
 }
-type HasManyQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? { [K in keyof TableQuery]: K extends '__defaults' ? { [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K] } & QueryHasWhere : HasOneQueryThrough<Name, TableQuery>;
-interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasMany, Q extends Query> extends RelationConfigBase {
+type HasManyQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions$1 ? { [K in keyof TableQuery]: K extends '__defaults' ? { [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true; } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K]; } & QueryHasWhere : HasOneQueryThrough<Name, TableQuery>;
+interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasMany$1, Q extends Query> extends RelationConfigBase {
   returnsOne: false;
   query: Q;
   params: HasOneParams<T, Rel['options']>;
   omitForeignKeyInCreate: never;
-  dataForCreate: { [K in Name]?: Q extends Query.Pick.IsNotReadOnly ? T['relations'][Name]['options'] extends RelationThroughOptions ? never : {
+  dataForCreate: { [K in Name]?: Q extends Query.Pick.IsNotReadOnly ? Rel['options'] extends RelationThroughOptions$1 ? never : {
     create?: CreateData<Q>[];
     connect?: WhereArg<Q>[];
     connectOrCreate?: {
       where: WhereArg<Q>;
       create: CreateData<Q>;
     }[];
-  } : never };
+  } : never; };
   dataForUpdate: Q extends Query.Pick.IsNotReadOnly ? {
     disconnect?: MaybeArray<WhereArg<Q>>;
     delete?: MaybeArray<WhereArg<Q>>;
@@ -115,27 +116,27 @@ interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel ext
     };
   } : never;
 }
-interface HasOne extends RelationThunkBase {
+interface HasOne$1 extends RelationThunkBase {
   type: 'hasOne';
   options: HasOneOptions;
 }
-interface RelationHasOneThroughOptions<Through extends string, Source extends string> extends RelationThroughOptions<Through, Source> {
+interface RelationHasOneThroughOptions<Through extends string> extends RelationThroughOptions$1<Through> {
   required?: boolean;
 }
-type HasOneOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput, Through extends string = string, Source extends string = string> = RelationRefsOptions<keyof Columns, Related['columns']['shape']> | RelationHasOneThroughOptions<Through, Source>;
-type HasOneParams<T extends RelationConfigSelf, Options> = Options extends RelationRefsOptions ? { [Name in Options['columns'][number]]: T['columns']['shape'][Name]['__type'] } : Options extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Options['through']]> : never;
-type HasOneQueryThrough<Name extends string, TableQuery extends Query> = { [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateMethodsNames ? never : TableQuery[K] } & QueryHasWhere;
-type HasOneQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? { [K in keyof TableQuery]: K extends '__defaults' ? { [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateManyMethodsNames ? never : TableQuery[K] } & QueryHasWhere : HasOneQueryThrough<Name, TableQuery>;
-interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasOne, Q extends Query> extends RelationConfigBase {
+type HasOneOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput, Through extends string = string> = RelationRefsOptions$1<keyof Columns, Related['columns']['shape']> | RelationHasOneThroughOptions<Through>;
+type HasOneParams<T extends RelationConfigSelf, Options> = Options extends RelationRefsOptions$1 ? { [Name in Options['columns'][number]]: T['columns']['shape'][Name]['__type']; } : Options extends RelationThroughOptions$1 ? RelationConfigParams<T, T['relations'][Options['through']]> : never;
+type HasOneQueryThrough<Name extends string, TableQuery extends Query> = { [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateMethodsNames ? never : TableQuery[K]; } & QueryHasWhere;
+type HasOneQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions$1 ? { [K in keyof TableQuery]: K extends '__defaults' ? { [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true; } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateManyMethodsNames ? never : TableQuery[K]; } & QueryHasWhere : HasOneQueryThrough<Name, TableQuery>;
+interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasOne$1, Q extends Query> extends RelationConfigBase {
   returnsOne: true;
-  required: T['relations'][Name]['options']['required'];
+  required: Rel['options']['required'];
   query: Q;
   params: HasOneParams<T, Rel['options']>;
   omitForeignKeyInCreate: never;
-  dataForCreate: { [K in Name]?: Q extends Query.Pick.IsNotReadOnly ? T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : RelationToOneDataForCreate<{
+  dataForCreate: { [K in Name]?: Q extends Query.Pick.IsNotReadOnly ? Rel['options'] extends RelationThroughOptions$1 ? EmptyObject : RelationToOneDataForCreate<{
     nestedCreateQuery: CreateData<Q>;
     table: Q;
-  }> : never };
+  }> : never; };
   dataForUpdate: Q extends Query.Pick.IsNotReadOnly ? {
     disconnect: boolean;
   } | {
@@ -160,11 +161,11 @@ interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Rel exte
     create: CreateData<Q>;
   } : never;
 }
-interface HasAndBelongsToMany extends RelationThunkBase {
+interface HasAndBelongsToMany$1 extends RelationThunkBase {
   type: 'hasAndBelongsToMany';
-  options: HasAndBelongsToManyOptions;
+  options: HasAndBelongsToManyOptions$1;
 }
-interface HasAndBelongsToManyOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput> {
+interface HasAndBelongsToManyOptions$1<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput> {
   required?: boolean;
   columns: (keyof Columns)[];
   references: string[];
@@ -172,14 +173,15 @@ interface HasAndBelongsToManyOptions<Columns extends Column.Shape.QueryInit = Co
   through: {
     schema?: QuerySchema;
     table: string;
+    snakeCase?: boolean;
     columns: string[];
     references: (keyof Related['columns']['shape'])[];
     foreignKey?: boolean | TableData.References.Options;
   };
   on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
 }
-type HasAndBelongsToManyParams<T extends RelationConfigSelf, FK extends string> = { [Name in FK]: T['columns']['shape'][Name]['__type'] };
-type HasAndBelongsToManyQuery<Name extends string, TableQuery extends Query> = { [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K] } & QueryHasWhere;
+type HasAndBelongsToManyParams<T extends RelationConfigSelf, FK extends string> = { [Name in FK]: T['columns']['shape'][Name]['__type']; };
+type HasAndBelongsToManyQuery<Name extends string, TableQuery extends Query> = { [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K]; } & QueryHasWhere;
 interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends string, FK extends string, Q extends Query> extends RelationConfigBase {
   returnsOne: false;
   query: Q;
@@ -194,7 +196,7 @@ interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends str
     }[];
   } : {
     connect?: WhereArg<Q>[];
-  } };
+  }; };
   dataForUpdate: Q extends Query.Pick.IsNotReadOnly ? {
     disconnect?: MaybeArray<WhereArg<Q>>;
     set?: MaybeArray<WhereArg<Q>>;
@@ -231,72 +233,678 @@ interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends str
     add?: MaybeArray<WhereArg<Q>>;
   };
 }
-type RelationToOneDataForCreate<Rel extends {
-  nestedCreateQuery: unknown;
-  table: Query;
-}> = {
-  create: Rel['nestedCreateQuery'];
-  connect?: never;
-  connectOrCreate?: never;
-} | {
-  create?: never;
-  connect: WhereArg<Rel['table']>;
-  connectOrCreate?: never;
-} | {
-  create?: never;
-  connect?: never;
-  connectOrCreate: {
-    where: WhereArg<Rel['table']>;
-    create: Rel['nestedCreateQuery'];
+interface TableFactoryOptions<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> {
+  schemaConfig?: () => SchemaConfig;
+  columnTypes?: ColumnTypes | ((t: DefaultColumnTypes<SchemaConfig>) => ColumnTypes);
+  snakeCase?: boolean;
+  filePath?: string;
+  nowSQL?: string;
+  exportAs?: string;
+  defineTableExportAs?: string;
+  language?: string;
+  autoForeignKeys?: boolean | TableData.References.BaseOptions;
+}
+interface OrmTable<Id extends string, Table extends string, Columns extends ColumnsShape, Relations, ColumnTypes = unknown, Computed = undefined, Scopes extends RecordUnknown | undefined = undefined, SoftDelete extends true | string | undefined = undefined, SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, Data extends MaybeArray<TableDataItem> = never, ReadOnly extends boolean | undefined = boolean | undefined> {
+  data: {
+    id: Id;
+    name: undefined;
+    table: Table;
+    relations: Relations;
+    columns: Columns;
+    types: ColumnTypes;
+    computed: Computed;
+    scopes: Scopes;
+    softDelete: SoftDelete;
+    readOnly: ReadOnly;
+    materialized: undefined;
+    tableData: Data extends unknown[] ? Data : [Data];
   };
-};
-interface RelationToOneDataForCreateSameQuerySelf extends CreateSelf, PickQuerySelectableRelations {}
-type RelationToOneDataForCreateSameQuery<Q extends RelationToOneDataForCreateSameQuerySelf> = {
-  create: CreateData<Q>;
-  connect?: never;
-  connectOrCreate?: never;
-} | {
-  create?: never;
-  connect: WhereArg<Q>;
-  connectOrCreate?: never;
-} | {
-  create?: never;
-  connect?: never;
-  connectOrCreate: {
-    where: WhereArg<Q>;
-    create: CreateData<Q>;
+  prototype: {
+    columns: {
+      shape: Columns;
+    };
   };
-};
-interface RelationThunkBase {
-  type: string;
-  id: string;
-  options: unknown;
-}
-type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
-interface RelationThunks {
-  [K: string]: RelationThunk;
+  inputSchema: SchemaConfig['inputSchema'];
+  outputSchema: SchemaConfig['outputSchema'];
+  querySchema: SchemaConfig['querySchema'];
+  pkeySchema: SchemaConfig['pkeySchema'];
+  createSchema: SchemaConfig['createSchema'];
+  updateSchema: SchemaConfig['updateSchema'];
+  instance(): ORMTableInput;
+  exportAs: string;
+  nowSQL?: string;
+  <C extends (keyof Columns & string)[]>(...columns: C): OrmTable.Relations.Endpoint<Id, C, ColumnsShape.InputPartial<Columns>>;
+  where<T>(this: T, conditions: ColumnsShape.InputPartial<Columns>): T;
+  through<Through extends string>(through: Through, source: string): OrmTable.Relations.Through<Id, Through, ColumnsShape.InputPartial<Columns>>;
+  primaryKey<Column extends keyof Columns & string, PrimaryKeyColumns extends [Column, ...Column[]], Name extends string>(columns: PrimaryKeyColumns, name?: Name): OrmTable<Id, Table, Columns, Relations, ColumnTypes, Computed, Scopes, SoftDelete, SchemaConfig, Data | OrmTable.DataItemWithColumns<PrimaryKeyColumns, Name>, ReadOnly>;
+  index(columns: OrmTable.IndexColumn<Columns>[], options?: TableData.Index.OptionsArg): this;
+  searchIndex(columns: OrmTable.IndexColumn<Columns>[], options?: TableData.Index.TsVectorArg): this;
+  unique<Items extends [OrmTable.IndexColumn<Columns>, ...OrmTable.IndexColumn<Columns>[]], Name extends string>(columns: Items, options?: TableData.Index.UniqueOptionsArg<Name>): OrmTable<Id, Table, Columns, Relations, ColumnTypes, Computed, Scopes, SoftDelete, SchemaConfig, Data | OrmTable.DataItemWithColumns<Items, Name>, ReadOnly>;
+  exclude(columns: OrmTable.ExcludeColumn<Columns>[], options?: TableData.Exclude.Options): this;
+  check(check: RawSqlBase, name?: string): this;
+  softDelete(): OrmTable<Id, Table, Columns, Relations, ColumnTypes, Computed, Scopes, true, SchemaConfig, Data, ReadOnly>;
+  softDelete<Column extends keyof Columns & string>(column: Column): OrmTable<Id, Table, Columns, Relations, ColumnTypes, Computed, Scopes, Column, SchemaConfig, Data, ReadOnly>;
+  computed<Fn extends ComputedOptionsFactory<ColumnTypes, Columns>>(computed: Fn): OrmTable<Id, Table, Columns, Relations, ColumnTypes, Fn, Scopes, SoftDelete, SchemaConfig, Data, ReadOnly>;
+  scopes<Keys extends string>(scopes: DbTableOptionScopes<Table, Columns, Keys>): OrmTable<Id, Table, Columns, Relations, ColumnTypes, Computed, DbTableOptionScopes<Table, Columns, Keys>, SoftDelete, SchemaConfig, Data, ReadOnly>;
+  grants(grants: readonly Grant.TableClassGrant[]): this;
+  rls(rls: OrmTable.RlsConfig): this;
+  init(fn: OrmTable.Init<Columns>): this;
+  foreignKey<Column extends keyof Columns, ForeignTable extends {
+    data: {
+      columns: ColumnsShape;
+    };
+  }, ForeignColumn extends keyof ForeignTable['data']['columns']>(columns: [Column, ...Column[]], fnOrTable: () => ForeignTable, foreignColumns: [ForeignColumn, ...ForeignColumn[]], options?: TableData.References.Options): this;
+  foreignKey<Column extends keyof Columns>(columns: [Column, ...Column[]], fnOrTable: string, foreignColumns: [string, ...string[]], options?: TableData.References.Options): this;
+  relations<Fn extends (self: OrmTable.Relations.Arg<keyof Columns>) => any>(fn: Fn): OrmTable<Id, Table, Columns, Fn, ColumnTypes, Computed, Scopes, SoftDelete, SchemaConfig, Data, ReadOnly>;
 }
-type TableClassInstances<T extends TableClasses> = InstanceType<T[keyof T]>;
-type RelationToTableInputById<Tables, Id extends string> = Extract<Tables, {
-  id: Id;
-}>;
-type RelationToTableInputByKey<T extends TableClasses, Id extends string> = Id extends keyof T ? InstanceType<T[Id]> : never;
-type RelationToTableInputByName<Tables, Id extends string> = Extract<Tables, {
-  table: Id;
-} | {
-  name: Id;
-}>;
-type RelationToTableInputByKeyOrName<T extends TableClasses, Id extends string> = Id extends keyof T ? RelationToTableInputByKey<T, Id> : RelationToTableInputByName<TableClassInstances<T>, Id>;
-type RelationToTableInputFromClasses<T extends TableClasses, Id extends string> = RelationToTableInputById<TableClassInstances<T>, Id> extends infer Result ? [Result] extends [never] ? RelationToTableInputByKeyOrName<T, Id> : Result : never;
-type RelationToTableInput<TC extends TableClasses, VC extends TableClasses, Rel extends RelationThunkBase> = RelationToTableInputFromClasses<TC, Rel['id']> extends infer Result ? [Result] extends [never] ? RelationToTableInputFromClasses<VC, Rel['id']> extends infer Result ? [Result] extends [never] ? false : Result : never : Result : never;
-type RelationTableToQuery<TC extends TableClasses, VC extends TableClasses, Rel extends RelationThunkBase> = RelationToTableInput<TC, VC, Rel> extends infer Result extends ORMTableInput ? TableQueryBuilder<TC, VC, Result> : never;
-interface RelationConfigSelf {
-  columns: {
-    shape: Column.Shape.QueryInit;
-  };
-  relations: RelationThunks;
+declare namespace OrmTable {
+  export interface RlsConfig extends Rls.TableConfigBase {
+    permit: RlsPolicy.Policy[];
+    restrict?: RlsPolicy.Policy[];
+  }
+  type DataKey<Columns extends ColumnsShape> = keyof Columns & string;
+  export type IndexColumn<Columns extends ColumnsShape> = DataKey<Columns> | TableData.Index.ColumnOrExpressionOptions<DataKey<Columns>>;
+  export type ExcludeColumn<Columns extends ColumnsShape> = TableData.Exclude.ColumnOrExpressionOptions<DataKey<Columns>>;
+  export interface DataItemWithColumns<Columns extends unknown[], Name extends string> {
+    tableDataItem: true;
+    columns: Columns;
+    name: string extends Name ? never : Name;
+  }
+  export interface RelationEndpointData {
+    id: string;
+    data?: {
+      id: string;
+    };
+    columns: string[];
+    on?: RecordUnknown;
+    through?: string;
+    source?: string;
+    relationThrough?: string;
+    relationSource?: string;
+  }
+  export interface Input<Id extends string, Table extends string | undefined, Name extends string | undefined, Columns extends ColumnsShape, ColumnTypes, Relations, Computed, Scopes extends RecordUnknown | undefined, SoftDelete extends true | string | undefined, ReadOnly extends boolean | undefined, Materialized extends true | undefined = true | undefined, TableDataItems extends MaybeArray<TableDataItem> = MaybeArray<TableDataItem>> extends ORMTableInput {
+    id: Id;
+    table: Table;
+    name: Name;
+    types: ColumnTypes;
+    readonly readOnly: ReadOnly;
+    readonly materialized: Materialized;
+    readonly softDelete: SoftDelete;
+    columns: {
+      shape: Columns;
+      data: TableDataItems extends unknown[] ? TableDataItems : [TableDataItems];
+    };
+    relations: Relations;
+    computed: Computed extends ComputedOptionsFactory<never, never> ? Computed : undefined;
+    scopes: Scopes extends undefined ? undefined : Scopes;
+  }
+  export interface TableFactoryKit<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> {
+    defineTable: DefineTable<SchemaConfig, ColumnTypes>;
+    defineView: DefineView<SchemaConfig, ColumnTypes>;
+    sql: DbSqlMethod<ColumnTypes>;
+    exportAs: string;
+  }
+  export interface BeforeActionHookUtils<Columns extends ColumnsShape> {
+    /**
+     * Sets column values before a create, update, or save action.
+     */
+    set(data: { [K in keyof ColumnsShape.InputPartial<Columns>]?: ColumnsShape.InputPartial<Columns>[K] | (() => QueryOrExpression<ColumnsShape.InputPartial<Columns>[K]>); }): void;
+  }
+  export interface InitHooks<Columns extends ColumnsShape> {
+    /**
+     * Registers a hook to run before every query.
+     */
+    beforeQuery(cb: QueryBeforeHook): void;
+    /**
+     * Registers a hook to run after every query.
+     */
+    afterQuery(cb: QueryAfterHook): void;
+    /**
+     * Registers a hook to run before create actions.
+     */
+    beforeCreate(cb: (utils: BeforeActionHookUtils<Columns>) => void | Promise<void>): void;
+    /**
+     * Registers a hook to run after create actions.
+     */
+    afterCreate<S extends (keyof Columns & string)[]>(select: S, cb: AfterHook<S, Columns>): void;
+    /**
+     * Registers a hook to run after create commits.
+     */
+    afterCreateCommit<S extends (keyof Columns & string)[]>(select: S, cb: AfterHook<S, Columns>): void;
+    /**
+     * Registers a hook to run before update actions.
+     */
+    beforeUpdate(cb: (utils: BeforeActionHookUtils<Columns>) => void | Promise<void>): void;
+    /**
+     * Registers a hook to run after update actions.
+     */
+    afterUpdate<S extends (keyof Columns & string)[]>(select: S, cb: AfterHook<S, Columns>): void;
+    /**
+     * Registers a hook to run after update commits.
+     */
+    afterUpdateCommit<S extends (keyof Columns & string)[]>(select: S, cb: AfterHook<S, Columns>): void;
+    /**
+     * Registers a hook to run before create or update actions.
+     */
+    beforeSave(cb: (utils: BeforeActionHookUtils<Columns>) => void | Promise<void>): void;
+    /**
+     * Registers a hook to run after create or update actions.
+     */
+    afterSave<S extends (keyof Columns & string)[]>(select: S, cb: AfterHook<S, Columns>): void;
+    /**
+     * Registers a hook to run after create or update commits.
+     */
+    afterSaveCommit<S extends (keyof Columns & string)[]>(select: S, cb: AfterHook<S, Columns>): void;
+    /**
+     * Registers a hook to run before delete actions.
+     */
+    beforeDelete(cb: QueryBeforeHook): void;
+    /**
+     * Registers a hook to run after delete actions.
+     */
+    afterDelete<S extends (keyof Columns & string)[]>(select: S, cb: AfterHook<S, Columns>): void;
+    /**
+     * Registers a hook to run after delete commits.
+     */
+    afterDeleteCommit<S extends (keyof Columns & string)[]>(select: S, cb: AfterHook<S, Columns>): void;
+  }
+  export type Init<Columns extends ColumnsShape> = (orm: unknown, hooks: InitHooks<Columns>) => void;
+  export interface DefineTableOptions {
+    /**
+     * Stable table identity used when resolving relation targets.
+     */
+    id?: string;
+    /**
+     * Database table name used when it differs from the query-facing table name.
+     */
+    nameInDb?: string;
+    /**
+     * Database schema containing this table.
+     */
+    schema?: QuerySchema;
+    /**
+     * Suppress the no-primary-key error for this table.
+     */
+    noPrimaryKey?: boolean;
+    /**
+     * Override the table factory snake-case setting for this table.
+     */
+    snakeCase?: boolean;
+    /**
+     * Table comment.
+     */
+    comment?: string;
+    /**
+     * Exclude this table from generated migration DDL reconciliation.
+     */
+    generatorIgnore?: true;
+    /**
+     * Auto-create foreign keys for relations of this table.
+     */
+    autoForeignKeys?: TableData.References.BaseOptions | boolean;
+    /**
+     * Mark this table as read-only to prevent mutations.
+     */
+    readOnly?: boolean;
+  }
+  type DefineTableId<Table extends string, Options extends DefineTableOptions> = Options extends {
+    id: infer Id extends string;
+  } ? Id : Table;
+  type DefineTableReadOnly<Options extends DefineTableOptions> = Options extends {
+    readOnly: true;
+  } ? true : undefined;
+  export interface DefineTable<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> {
+    <Table extends string, Columns extends ColumnsShape>(table: Table, t: (columnTypes: ColumnTypes) => Columns): OrmTable<Table, Table, Columns, undefined, ColumnTypes, undefined, undefined, undefined, SchemaConfig, never, undefined>;
+    <Table extends string, const Options extends DefineTableOptions, Columns extends ColumnsShape>(table: Table, options: Options, t: (columnTypes: ColumnTypes) => Columns): OrmTable<DefineTableId<Table, Options>, Table, Columns, undefined, ColumnTypes, undefined, undefined, undefined, SchemaConfig, never, DefineTableReadOnly<Options>>;
+    /**
+     * Returns the file path where the table factory was defined.
+     * Uses stack trace analysis to determine the caller's file path.
+     * @throws Error if file path cannot be determined and `filePath` option was not provided to `createTableFactory`
+     */
+    getFilePath(): string;
+    /**
+     * Column types configured for this table factory.
+     */
+    types: ColumnTypes;
+    /**
+     * Export name configured for this table factory.
+     */
+    exportAs: string;
+    /**
+     * Custom timestamp SQL configured for this table factory.
+     */
+    nowSQL?: string;
+    /**
+     * Whether this table factory maps columns and table names to snake case.
+     */
+    snakeCase?: boolean;
+    /**
+     * Default full text search language configured for this table factory.
+     */
+    language?: string;
+  }
+  export interface DefineViewOptions {
+    /**
+     * Stable view identity used when resolving relation targets.
+     * Defaults to the view name when not provided.
+     */
+    id?: string;
+    /**
+     * Database schema containing this view.
+     */
+    schema?: QuerySchema;
+    /**
+     * Database view name used when it differs from the query-facing view name.
+     */
+    nameInDb?: string;
+    /**
+     * Override the table factory snake-case setting for this view.
+     */
+    snakeCase?: boolean;
+    /**
+     * Default language for full text search columns in this view.
+     */
+    language?: string;
+    /**
+     * Exclude this view from generated migration DDL reconciliation.
+     */
+    generatorIgnore?: true;
+    /**
+     * SQL expression that defines this view.
+     */
+    sql?: string | RawSqlBase;
+    /**
+     * Set to false to expose mutation methods on a regular view.
+     */
+    readOnly?: boolean;
+    /**
+     * Mark this definition as a materialized view.
+     */
+    materialized?: true;
+    /**
+     * CREATE MATERIALIZED VIEW WITH DATA / WITH NO DATA option.
+     */
+    withData?: boolean;
+    /**
+     * CREATE VIEW RECURSIVE option used by migration generation.
+     */
+    recursive?: boolean;
+    /**
+     * CREATE VIEW CHECK OPTION used by migration generation.
+     */
+    checkOption?: 'LOCAL' | 'CASCADED';
+    /**
+     * CREATE VIEW security_barrier option used by migration generation.
+     */
+    securityBarrier?: boolean;
+    /**
+     * CREATE VIEW security_invoker option used by migration generation.
+     */
+    securityInvoker?: boolean;
+  }
+  type DefineViewId<Options, Name extends string> = Options extends {
+    id: infer Id extends string;
+  } ? Id : Name;
+  type DefineViewReadOnly<Options> = Options extends {
+    readOnly: false;
+  } ? Options extends {
+    materialized: true;
+  } ? true : false : true;
+  type DefineViewMaterialized<Options> = Options extends {
+    materialized: true;
+  } ? true : undefined;
+  export interface View<Id extends string, Name extends string, Columns extends ColumnsShape, ColumnTypes, Relations, Computed = undefined, Scopes extends RecordUnknown | undefined = undefined, SoftDelete extends true | string | undefined = undefined, ReadOnly extends boolean | undefined = true, Materialized extends true | undefined = undefined, SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig> {
+    data: {
+      id: Id;
+      table: undefined;
+      name: Name;
+      relations: Relations;
+      columns: Columns;
+      types: ColumnTypes;
+      computed: Computed;
+      scopes: Scopes;
+      softDelete: SoftDelete;
+      readOnly: ReadOnly;
+      materialized: Materialized;
+      tableData: TableDataItem[];
+    };
+    prototype: {
+      columns: {
+        shape: Columns;
+      };
+    };
+    inputSchema: SchemaConfig['inputSchema'];
+    outputSchema: SchemaConfig['outputSchema'];
+    querySchema: SchemaConfig['querySchema'];
+    pkeySchema: SchemaConfig['pkeySchema'];
+    createSchema: SchemaConfig['createSchema'];
+    updateSchema: SchemaConfig['updateSchema'];
+    <C extends (keyof Columns & string)[]>(...columns: C): OrmTable.Relations.Endpoint<Id, C, ColumnsShape.InputPartial<Columns>>;
+    instance(): ORMTableInput;
+    nowSQL?: string;
+    query(fn: (orm: OrchidORM) => Query): this;
+    through<Through extends string>(through: Through, source: string): OrmTable.Relations.Through<Id, Through, ColumnsShape.InputPartial<Columns>>;
+    softDelete(): View<Id, Name, Columns, ColumnTypes, Relations, Computed, Scopes, true, ReadOnly, Materialized, SchemaConfig>;
+    softDelete<Column extends keyof Columns & string>(column: Column): View<Id, Name, Columns, ColumnTypes, Relations, Computed, Scopes, Column, ReadOnly, Materialized, SchemaConfig>;
+    computed<Fn extends ComputedOptionsFactory<unknown, Columns>>(computed: Fn): View<Id, Name, Columns, ColumnTypes, Relations, Fn, Scopes, SoftDelete, ReadOnly, Materialized, SchemaConfig>;
+    scopes<Keys extends string>(scopes: DbTableOptionScopes<Name, Columns, Keys>): View<Id, Name, Columns, ColumnTypes, Relations, Computed, DbTableOptionScopes<Name, Columns, Keys>, SoftDelete, ReadOnly, Materialized, SchemaConfig>;
+    grants(grants: readonly Grant.TableClassGrant[]): this;
+    init(fn: OrmTable.Init<Columns>): this;
+    relations<Fn extends (self: OrmTable.Relations.Arg<keyof Columns>) => any>(fn: Fn): View<Id, Name, Columns, ColumnTypes, Fn, Computed, Scopes, SoftDelete, ReadOnly, Materialized, SchemaConfig>;
+  }
+  export interface DefineView<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> {
+    <Name extends string, Columns extends ColumnsShape>(name: Name, t: (columnTypes: ColumnTypes) => Columns): View<Name, Name, Columns, ColumnTypes, undefined, undefined, undefined, undefined, true, undefined, SchemaConfig>;
+    <Name extends string, const Options extends DefineViewOptions, Columns extends ColumnsShape>(name: Name, options: Options, t: (columnTypes: ColumnTypes) => Columns): View<DefineViewId<Options, Name>, Name, Columns, ColumnTypes, undefined, undefined, undefined, undefined, DefineViewReadOnly<Options>, DefineViewMaterialized<Options>, SchemaConfig>;
+  }
+  export namespace Relations {
+    type Resolve<Relations> = Relations extends ((...args: never[]) => infer Result) ? ResolveMany<Result> : Relations;
+    type ResolveMany<Relations> = { [K in keyof Relations]: ResolveOne<Relations[K]>; };
+    type ResolveOne<Relation> = Relation extends BelongsTo<infer C, infer Fn, infer Required> ? ResolvedBelongsTo<TargetId<Fn>, C, TargetReferences<Fn>, Required> : Relation extends HasOne<infer C, infer Fn, infer Required> ? ResolvedHasOne<TargetId<Fn>, C, TargetReferences<Fn>, Required> : Relation extends HasMany<infer C, infer Fn> ? ResolvedHasMany<TargetId<Fn>, C, TargetReferences<Fn>> : Relation extends HasAndBelongsToMany<infer C, infer Fn, infer Options> ? ResolveHasAndBelongsToMany<C, Fn, Options> : Relation extends HasOneThrough<infer Fn, infer Required> ? ResolvedHasOneThrough<TargetId<Fn>, ResolveHasOneThroughOptions<RelationThroughOptions<TargetThrough<Fn>>, Required>> : Relation extends HasManyThrough<infer Fn> ? ResolvedHasManyThrough<TargetId<Fn>, RelationThroughOptions<TargetThrough<Fn>>> : Relation;
+    type ResolveHasAndBelongsToMany<C extends string[], Fn extends Function, Options, References extends string[] = TargetReferences<Fn>> = ResolvedHasAndBelongsToMany<TargetId<Fn>, C, References, ResolveHasAndBelongsToManyOptions<C, References, Options>>;
+    type TargetResult<Fn extends Function> = Fn extends (() => infer Result) ? Result : never;
+    type TargetId<Fn extends Function> = TargetResult<Fn> extends {
+      id: infer Id extends string;
+    } ? Id : TargetResult<Fn> extends {
+      data: {
+        id: infer Id extends string;
+      };
+    } ? Id : string;
+    type TargetReferences<Fn extends Function> = TargetResult<Fn> extends {
+      columns: infer References extends string[];
+    } ? References : string[];
+    type TargetThrough<Fn extends Function> = TargetResult<Fn> extends {
+      through: infer Through extends string;
+    } ? Through : string;
+    interface Arg<ColumnKeys> {
+      <C extends (ColumnKeys & string)[]>(...columns: C): Fns<C>;
+      hasOne<Fn extends Function>(fn: Fn): HasOneThrough<Fn>;
+      hasMany<Fn extends Function>(fn: Fn): HasManyThrough<Fn>;
+    }
+    interface Through<Id extends string, Through extends string, Conditions> {
+      id: Id;
+      through: Through;
+      source: string;
+      where<T>(this: T, conditions: Conditions): T;
+    }
+    interface Endpoint<Id extends string, C, Conditions> {
+      id: Id;
+      columns: C;
+      where<T>(this: T, conditions: Conditions): T;
+      through<Through extends string>(through: Through, source: string): OrmTable.Relations.Through<Id, Through, Conditions>;
+    }
+    interface Fns<C extends string[]> {
+      belongsTo<Fn extends Function>(fn: Fn): BelongsTo<C, Fn>;
+      hasOne<Fn extends Function>(fn: Fn): HasOne<C, Fn>;
+      hasMany<Fn extends Function>(fn: Fn): HasMany<C, Fn>;
+      hasAndBelongsToMany<Fn extends Function>(fn: Fn): HasAndBelongsToMany<C, Fn>;
+    }
+    interface LazyRelationRefsOptions<C extends string[]> {
+      columns: C;
+    }
+    interface LazyRelationRefsOptionsWithRequired<C extends string[], Required extends boolean> extends LazyRelationRefsOptions<C> {
+      required: Required;
+    }
+    type LazyRelationRefsOptionsForRequired<C extends string[], Required extends boolean | undefined> = Required extends boolean ? LazyRelationRefsOptionsWithRequired<C, Required> : LazyRelationRefsOptions<C>;
+    interface RelationRefsOptions<C extends string[], References extends string[]> extends LazyRelationRefsOptions<C> {
+      references: References;
+    }
+    interface RelationRefsOptionsWithRequired<C extends string[], References extends string[], Required extends boolean> extends RelationRefsOptions<C, References> {
+      required: Required;
+    }
+    type RelationRefsOptionsForRequired<C extends string[], References extends string[], Required extends boolean | undefined> = Required extends boolean ? RelationRefsOptionsWithRequired<C, References, Required> : RelationRefsOptions<C, References>;
+    interface BelongsTo<C extends string[], Fn extends Function, Required extends boolean | undefined = undefined> {
+      type: 'belongsTo';
+      fn: Fn;
+      options: LazyRelationRefsOptionsForRequired<C, Required>;
+      __required?: Required;
+      required(): BelongsTo<C, Fn, true>;
+      required(value: false): BelongsTo<C, Fn, false>;
+      /**
+       * Controls whether a foreign key constraint is auto-created on the
+       * **owning table** (the table this relation is defined on).
+       *
+       * - `true` (default when autoForeignKeys is enabled) — create FK with DB defaults.
+       * - `false` — skip FK creation entirely.
+       * - `{ onUpdate: 'CASCADE', onDelete: 'SET NULL' }` — create FK with these options.
+       *
+       * Only needed when `autoForeignKeys` is enabled on the table config;
+       * otherwise no FK is created by default.
+       *
+       * @example
+       * // disable FK for this relation
+       * user('Id').belongsTo(() => ProfileTable('UserId')).foreignKey(false)
+       *
+       * @example
+       * // custom FK options
+       * user('Id').belongsTo(() => ProfileTable('UserId')).foreignKey({ onDelete: 'CASCADE' })
+       */
+      foreignKey(value?: boolean | TableData.References.BaseOptions): BelongsTo<C, Fn, Required>;
+    }
+    interface HasOne<C extends string[], Fn extends Function, Required extends boolean | undefined = undefined> {
+      type: 'hasOne';
+      fn: Fn;
+      options: LazyRelationRefsOptionsForRequired<C, Required>;
+      __required?: Required;
+      required(): HasOne<C, Fn, true>;
+      required(value: false): HasOne<C, Fn, false>;
+      /**
+       * Controls whether a foreign key constraint is auto-created on the
+       * **related table** (the table pointed to by this relation).
+       *
+       * - `true` (default when autoForeignKeys is enabled) — create FK with DB defaults.
+       * - `false` — skip FK creation entirely.
+       * - `{ onUpdate: 'CASCADE', onDelete: 'SET NULL' }` — create FK with these options.
+       *
+       * Only needed when `autoForeignKeys` is enabled on the table config;
+       * otherwise no FK is created by default.
+       *
+       * @example
+       * // disable FK for this relation
+       * user('Id').hasOne(() => ProfileTable('UserId')).foreignKey(false)
+       *
+       * @example
+       * // custom FK options
+       * user('Id').hasOne(() => ProfileTable('UserId')).foreignKey({ onDelete: 'CASCADE' })
+       */
+      foreignKey(value?: boolean | TableData.References.BaseOptions): HasOne<C, Fn, Required>;
+    }
+    interface HasMany<C extends string[], Fn extends Function> {
+      type: 'hasMany';
+      fn: Fn;
+      options: LazyRelationRefsOptions<C>;
+      /**
+       * Controls whether a foreign key constraint is auto-created on the
+       * **related table** (the table pointed to by this relation).
+       *
+       * - `true` (default when autoForeignKeys is enabled) — create FK with DB defaults.
+       * - `false` — skip FK creation entirely.
+       * - `{ onUpdate: 'CASCADE', onDelete: 'SET NULL' }` — create FK with these options.
+       *
+       * Only needed when `autoForeignKeys` is enabled on the table config;
+       * otherwise no FK is created by default.
+       *
+       * @example
+       * // disable FK for this relation
+       * user('Id').hasMany(() => PostTable('UserId')).foreignKey(false)
+       *
+       * @example
+       * // custom FK options
+       * user('Id').hasMany(() => PostTable('UserId')).foreignKey({ onDelete: 'CASCADE' })
+       */
+      foreignKey(value?: boolean | TableData.References.BaseOptions): HasMany<C, Fn>;
+    }
+    interface HasAndBelongsToManyOptions<C extends string[]> {
+      columns: C;
+    }
+    interface HasAndBelongsToManyForeignKeyOptions {
+      forThisTable?: boolean | TableData.References.BaseOptions;
+      forRelatedTable?: boolean | TableData.References.BaseOptions;
+      forBothTables?: boolean | TableData.References.BaseOptions;
+    }
+    interface LazyHasAndBelongsToManyThroughOptions<C extends string[]> extends HasAndBelongsToManyOptions<C> {
+      references: string[];
+      through: {
+        schema?: QuerySchema;
+        table: string;
+        snakeCase?: boolean;
+        columns: string[];
+        references: string[];
+      };
+      foreignKeys?: HasAndBelongsToManyForeignKeyOptions;
+    }
+    interface HasAndBelongsToManyThroughOptions<C extends string[], References extends string[]> extends HasAndBelongsToManyOptions<C> {
+      references: string[];
+      through: {
+        schema?: QuerySchema;
+        table: string;
+        snakeCase?: boolean;
+        columns: string[];
+        references: References;
+      };
+      foreignKeys?: HasAndBelongsToManyForeignKeyOptions;
+    }
+    interface HasAndBelongsToManyThroughConfig {
+      /**
+       * Database schema containing this join table.
+       */
+      schema?: QuerySchema;
+      /**
+       * Set to false to preserve the join table name when the owning table
+       * uses snake-case mode.
+       */
+      joinTableSnakeCase?: boolean;
+    }
+    type ResolveHasAndBelongsToManyOptions<C extends string[], References extends string[], Options = HasAndBelongsToManyOptions<C>> = Options extends LazyHasAndBelongsToManyThroughOptions<C> ? HasAndBelongsToManyThroughOptions<C, References> : Options;
+    type ResolveHasOneThroughOptions<Options, Required extends boolean | undefined> = Required extends boolean ? Options & {
+      required: Required;
+    } : Options;
+    interface HasAndBelongsToMany<C extends string[], Fn extends Function, Options = HasAndBelongsToManyOptions<C>> {
+      type: 'hasAndBelongsToMany';
+      fn: Fn;
+      options: Options;
+      through(joinTable: string, selfColumns: string | (string[] & {
+        length: C['length'];
+      }), relColumns: string | string[], options?: HasAndBelongsToManyThroughConfig): HasAndBelongsToMany<C, Fn, LazyHasAndBelongsToManyThroughOptions<C>>;
+      /**
+       * Controls foreign key constraints on the **join table**. Unlike other
+       * relation kinds, hasAndBelongsToMany creates FKs on both sides of the
+       * join, so this method accepts a richer options object.
+       *
+       * - `true` (default) — create all join-table FKs with DB defaults.
+       * - `false` — skip all join-table FK creation.
+       * - `{ forThisTable, forRelatedTable, forBothTables }` — fine-grained control:
+       *   - `forThisTable` — FK from join table → **owning table** (this table).
+       *   - `forRelatedTable` — FK from join table → **related table**.
+       *   - `forBothTables` — shorthand: applies to both FKs at once.
+       *
+       * Each sub-value can be `false` (skip), `true` (default), or
+       * `{ onUpdate: 'CASCADE', onDelete: 'SET NULL' }` (custom options).
+       *
+       * Must be called **after** `.through()`.
+       *
+       * @example
+       * // disable all join-table FKs
+       * post('Id')
+       *   .hasAndBelongsToMany(() => TagTable('Id'))
+       *   .through('postTag', ['postId'], ['tagId'])
+       *   .foreignKey(false)
+       *
+       * @example
+       * // custom FK on both sides
+       * post('Id')
+       *   .hasAndBelongsToMany(() => TagTable('Id'))
+       *   .through('postTag', ['postId'], ['tagId'])
+       *   .foreignKey({
+       *     forThisTable: { onDelete: 'CASCADE' },
+       *     forRelatedTable: { onDelete: 'CASCADE' },
+       *   })
+       *
+       * @example
+       * // same custom FK via shorthand
+       * post('Id')
+       *   .hasAndBelongsToMany(() => TagTable('Id'))
+       *   .through('postTag', ['postId'], ['tagId'])
+       *   .foreignKey({ forBothTables: { onDelete: 'CASCADE' } })
+       */
+      foreignKey(value?: boolean | HasAndBelongsToManyForeignKeyOptions): HasAndBelongsToMany<C, Fn, Options>;
+    }
+    interface ResolvedBelongsTo<Id extends string, C extends string[], References extends string[], Required extends boolean | undefined = undefined> {
+      type: 'belongsTo';
+      id: Id;
+      options: RelationRefsOptionsForRequired<C, References, Required>;
+      __required?: Required;
+      required(): ResolvedBelongsTo<Id, C, References, true>;
+      required(value: false): ResolvedBelongsTo<Id, C, References, false>;
+      /** @see BelongsTo.foreignKey */
+      foreignKey(value?: boolean | TableData.References.BaseOptions): ResolvedBelongsTo<Id, C, References, Required>;
+    }
+    interface ResolvedHasOne<Id extends string, C extends string[], References extends string[], Required extends boolean | undefined = undefined> {
+      type: 'hasOne';
+      id: Id;
+      options: RelationRefsOptionsForRequired<C, References, Required>;
+      __required?: Required;
+      required(): ResolvedHasOne<Id, C, References, true>;
+      required(value: false): ResolvedHasOne<Id, C, References, false>;
+      /** @see HasOne.foreignKey */
+      foreignKey(value?: boolean | TableData.References.BaseOptions): ResolvedHasOne<Id, C, References, Required>;
+    }
+    interface ResolvedHasMany<Id extends string, C extends string[], References extends string[]> {
+      type: 'hasMany';
+      id: Id;
+      options: RelationRefsOptions<C, References>;
+      /** @see HasMany.foreignKey */
+      foreignKey(value?: boolean | TableData.References.BaseOptions): ResolvedHasMany<Id, C, References>;
+    }
+    interface ResolvedHasAndBelongsToMany<Id extends string, C extends string[], References extends string[], Options = HasAndBelongsToManyOptions<C>> {
+      type: 'hasAndBelongsToMany';
+      id: Id;
+      options: Options;
+      through(joinTable: string, selfColumns: string | (string[] & {
+        length: C['length'];
+      }), relColumns: string | string[], options?: HasAndBelongsToManyThroughConfig): ResolvedHasAndBelongsToMany<Id, C, References, HasAndBelongsToManyThroughOptions<C, References>>;
+    }
+    interface RelationThroughOptions<Through extends string = string> {
+      through: Through;
+      source: string;
+      on?: RecordUnknown;
+      required?: boolean;
+    }
+    interface HasOneThrough<Fn extends Function, Required extends boolean | undefined = undefined> {
+      type: 'hasOne';
+      fn: Fn;
+      options: ResolveHasOneThroughOptions<RelationThroughOptions<TargetThrough<Fn>>, Required>;
+      __required?: Required;
+      required(): HasOneThrough<Fn, true>;
+      required(value: false): HasOneThrough<Fn, false>;
+    }
+    interface HasManyThrough<Fn extends Function> {
+      type: 'hasMany';
+      fn: Fn;
+      options: RelationThroughOptions<TargetThrough<Fn>>;
+    }
+    interface ResolvedHasOneThrough<Id extends string, Options> {
+      type: 'hasOne';
+      id: Id;
+      options: Options;
+      __required?: Options extends {
+        required?: infer Required;
+      } ? Required : undefined;
+      required(): ResolvedHasOneThrough<Id, Options & {
+        required: true;
+      }>;
+      required(value: false): ResolvedHasOneThrough<Id, Options & {
+        required: false;
+      }>;
+    }
+    interface ResolvedHasManyThrough<Id extends string, Options> {
+      type: 'hasMany';
+      id: Id;
+      options: Options;
+    }
+  }
+  export {};
 }
-type RelationConfigParams<T extends RelationConfigSelf, Relation extends RelationThunk> = Relation extends BelongsTo ? BelongsToParams<T, Relation['options']['columns'][number] & string> : Relation extends HasOne | HasMany ? HasOneParams<T, Relation['options']> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyParams<T, Relation['options']['columns'][number] & string> : never;
+declare const createTableFactory: <SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>(options?: TableFactoryOptions<SchemaConfig, ColumnTypes>) => OrmTable.TableFactoryKit<SchemaConfig, ColumnTypes>;
 declare function transaction<Result>(this: {
   $qb: Db;
 }, fn: () => Promise<Result>): Promise<Result>;
@@ -334,17 +942,62 @@ interface OrchidORMTableHelper<T extends Query> {
    */
   makeHelper<Args extends unknown[], Result>(fn: (q: T, ...args: Args) => Result): OrchidORMQueryHelper<T, Args, Result>;
 }
-type OrchidORMTables<TC extends TableClasses = TableClasses, VC extends TableClasses = TableClasses> = { [K in keyof TC]: TC[K] extends {
+/**
+ * Table definitions accepted by ORM setup.
+ */
+interface OrmTableThunks {
+  /**
+   * ORM table or view definition keyed by the db instance property name.
+   */
+  [K: string]: TableClass | {
+    data: {
+      id: string;
+      name: string | undefined;
+      table: string | undefined;
+      relations: unknown;
+      columns: ColumnsShape;
+      types: unknown;
+      computed: unknown;
+      scopes: RecordUnknown | undefined;
+      softDelete?: true | string | undefined;
+      readOnly?: boolean | undefined;
+      materialized?: true | undefined;
+      tableData: unknown;
+    };
+    prototype: {
+      columns: {
+        shape: ColumnsShape;
+      };
+    };
+    instance(): ORMTableInput;
+  };
+}
+type OrmTableInstance<T> = T extends {
+  data: {
+    id: infer Id extends string;
+    table: infer Table extends string | undefined;
+    name: infer Name extends string | undefined;
+    columns: infer Columns extends ColumnsShape;
+    types: infer ColumnTypes;
+    relations: infer Relations;
+    computed: infer Computed;
+    scopes: infer Scopes extends RecordUnknown | undefined;
+    softDelete: infer SoftDelete extends true | string | undefined;
+    readOnly: infer ReadOnly extends boolean | undefined;
+    materialized: infer Materialized extends true | undefined;
+    tableData: infer Data extends TableDataItem[];
+  };
+} ? OrmTable.Input<Id, Table, Name, Columns, ColumnTypes, OrmTable.Relations.Resolve<Relations>, Computed, Scopes, SoftDelete, ReadOnly, Materialized, Data[number]> : never;
+type TableInstance<T> = T extends {
   new (): infer R extends ORMTableInput;
-} ? OrchidORMTableHelper<TableQueryBuilder<TC, VC, R>> : never };
-type OrchidORMBundle<TC extends TableClasses = TableClasses, VC extends TableClasses = TableClasses> = OrchidORMTables<TC> & {
-  $views: OrchidORMTables<VC, TC>;
+} ? R : OrmTableInstance<T>;
+type OrchidORMTables<TT extends OrmTableThunks = OrmTableThunks, VT extends OrmTableThunks = OrmTableThunks> = { [K in keyof TT]: OrchidORMTableHelper<TableQueryBuilder<TT, VT, TableInstance<TT[K]>>>; };
+type OrchidORMBundle<TT extends OrmTableThunks = OrmTableThunks, VT extends OrmTableThunks = OrmTableThunks> = OrchidORMTables<TT, VT> & {
+  $views: OrchidORMTables<VT, TT>;
 };
-type OrchidORMDbTables<TC extends TableClasses = TableClasses, VC extends TableClasses = TableClasses> = { [K in keyof TC]: TC[K] extends {
-  new (): infer R extends ORMTableInput;
-} ? TableQueryBuilder<TC, VC, R> : never };
-type OrchidORM<TC extends TableClasses = TableClasses, VC extends TableClasses = TableClasses> = OrchidORMDbTables<TC, VC> & {
-  $views: OrchidORMDbTables<VC, TC>;
+type OrchidORMDbTables<TT extends OrmTableThunks = OrmTableThunks, VT extends OrmTableThunks = OrmTableThunks> = { [K in keyof TT]: TableQueryBuilder<TT, VT, TableInstance<TT[K]>>; };
+type OrchidORM<TT extends OrmTableThunks = OrmTableThunks, VT extends OrmTableThunks = OrmTableThunks> = OrchidORMDbTables<TT, VT> & {
+  $views: OrchidORMDbTables<VT, TT>;
 } & OrchidORMMethods;
 /**
  * Identity helper for table row-level security configuration.
@@ -501,58 +1154,118 @@ interface OrchidORMMethods {
   $close(): Promise<void>;
 }
 type OrchidOrmParam<Options> = true | null extends true ? 'Set strict: true to tsconfig' : Options;
-interface OrchidORMSetupOptions<V extends TableClasses = TableClasses> extends DbSharedOptions {
+interface OrchidORMSetupOptions<V extends OrmTableThunks = OrmTableThunks> extends DbSharedOptions {
   /**
    * First-class regular views exposed under db.$views.
    */
   views?: V;
 }
-declare const bundleOrchidORM: <T extends TableClasses = EmptyObject, V extends TableClasses = EmptyObject>({
-  tables,
-  views
-}: {
+declare const bundleOrchidORM: <T extends OrmTableThunks = EmptyObject, V extends OrmTableThunks = EmptyObject>({ tables, views }: {
   tables?: T;
   views?: V;
 }) => OrchidORMBundle<T, V>;
-declare const bundleOrchidORMTables: <T extends TableClasses>(tables: T) => OrchidORMBundle<T, EmptyObject>;
-declare const makeOrchidOrmDbWithAdapter: <T extends TableClasses, V extends TableClasses>(orm: OrchidORMBundle<T, V>, options: OrchidOrmParam<({
+declare const bundleOrchidORMTables: <T extends OrmTableThunks>(tables: T) => OrchidORMBundle<T, EmptyObject>;
+declare const makeOrchidOrmDbWithAdapter: <T extends OrmTableThunks, V extends OrmTableThunks>(orm: OrchidORMBundle<T, V>, options: OrchidOrmParam<({
   db: Query;
 } | {
   adapter: Adapter;
 }) & DbSharedOptions>) => OrchidORM<T, V>;
-declare const orchidORMWithAdapter: <T extends TableClasses, V extends TableClasses = EmptyObject>(options: OrchidOrmParam<({
+declare const orchidORMWithAdapter: <T extends OrmTableThunks, V extends OrmTableThunks = EmptyObject>(options: OrchidOrmParam<({
   db: Query;
 } | {
   adapter: Adapter;
 }) & OrchidORMSetupOptions<V>>, tables: T) => OrchidORM<T, V>;
+type RelationToOneDataForCreate<Rel extends {
+  nestedCreateQuery: unknown;
+  table: Query;
+}> = {
+  create: Rel['nestedCreateQuery'];
+  connect?: never;
+  connectOrCreate?: never;
+} | {
+  create?: never;
+  connect: WhereArg<Rel['table']>;
+  connectOrCreate?: never;
+} | {
+  create?: never;
+  connect?: never;
+  connectOrCreate: {
+    where: WhereArg<Rel['table']>;
+    create: Rel['nestedCreateQuery'];
+  };
+};
+interface RelationToOneDataForCreateSameQuerySelf extends CreateSelf, PickQuerySelectableRelations {}
+type RelationToOneDataForCreateSameQuery<Q extends RelationToOneDataForCreateSameQuerySelf> = {
+  create: CreateData<Q>;
+  connect?: never;
+  connectOrCreate?: never;
+} | {
+  create?: never;
+  connect: WhereArg<Q>;
+  connectOrCreate?: never;
+} | {
+  create?: never;
+  connect?: never;
+  connectOrCreate: {
+    where: WhereArg<Q>;
+    create: CreateData<Q>;
+  };
+};
+interface RelationThunkBase {
+  type: string;
+  id: string;
+  options: unknown;
+}
+type RelationThunk = BelongsTo$1 | HasOne$1 | HasMany$1 | HasAndBelongsToMany$1;
+interface RelationThunks {
+  [K: string]: RelationThunk;
+}
+type TableInstances<T extends OrmTableThunks> = { [K in keyof T]: TableInstance<T[K]>; };
+type TableClassInstances<T extends OrmTableThunks> = TableInstances<T>[keyof T];
+type RelationToTableInputById<Tables, Id extends string> = Tables extends {
+  id: Id;
+} ? Tables : never;
+type RelationToTableInputByName<T extends OrmTableThunks, Id extends string> = { [K in keyof TableInstances<T>]: TableInstances<T>[K] extends {
+  table: Id;
+} | {
+  name: Id;
+} ? TableInstances<T>[K] : never; }[keyof T];
+type RelationToTableInputFromClasses<T extends OrmTableThunks, Id extends string> = RelationToTableInputById<TableClassInstances<T>, Id> extends (infer Result) ? [Result] extends [never] ? RelationToTableInputByName<T, Id> : Result : never;
+type RelationToTableInput<TT extends OrmTableThunks, VT extends OrmTableThunks, Rel extends RelationThunkBase> = RelationToTableInputFromClasses<TT, Rel['id']> extends (infer Result) ? [Result] extends [never] ? RelationToTableInputFromClasses<VT, Rel['id']> extends (infer Result) ? [Result] extends [never] ? false : Result : never : Result : never;
+type RelationTableToQuery<TT extends OrmTableThunks, VT extends OrmTableThunks, Rel extends RelationThunkBase> = RelationToTableInput<TT, VT, Rel> extends (infer Result extends ORMTableInput) ? TableQueryBuilder<TT, VT, Result> : never;
+interface RelationConfigSelf {
+  columns: {
+    shape: Column.Shape.QueryInit;
+  };
+  relations: RelationThunks;
+}
+type RelationConfigParams<T extends RelationConfigSelf, Relation extends RelationThunk> = Relation extends BelongsTo$1 ? BelongsToParams<T, Relation['options']['columns'][number] & string> : Relation extends HasOne$1 | HasMany$1 ? HasOneParams<T, Relation['options']> : Relation extends HasAndBelongsToMany$1 ? HasAndBelongsToManyParams<T, Relation['options']['columns'][number] & string> : never;
 interface TableClass<T extends ORMTableInput = ORMTableInput> {
   new (): T;
 }
-interface TableClasses {
-  [K: string]: TableClass;
-}
 interface TableInfo {
   definedAs: string;
   db: OrchidORM;
   getFilePath(): string;
   name: string;
 }
-interface Table extends Query, TableInfo {}
-type BelongsToRequired<T extends RelationConfigSelf, Rel extends BelongsTo, Related> = Rel['options'] extends {
+interface Table$1 extends Query, TableInfo {}
+type BelongsToRequired<T extends RelationConfigSelf, Rel extends BelongsTo$1, Related> = Rel['options'] extends {
   required: infer Required extends boolean;
 } ? Required : Rel['options'] extends {
   on: unknown;
 } ? false : BelongsToDefaultRequired<T, Rel, Related>;
-type BelongsToRelationInfo<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf, Name extends string, Rel extends BelongsTo> = RelationToTableInput<TC, VC, Rel> extends infer Related extends ORMTableInput ? BelongsToInfo<T, Rel['options']['columns'][number] & string, BelongsToRequired<T, Rel, Related>, BelongsToQuery<TableQueryBuilder<TC, VC, Related>, Name>> : never;
-type BelongsToCreateData<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf, Name extends string, Rel extends BelongsTo> = RelationToTableInput<TC, VC, Rel> extends infer Related extends ORMTableInput ? BelongsToDataForCreate<Name, Rel['options']['columns'][number] & string, BelongsToRequired<T, Rel, Related>, BelongsToQuery<TableQueryBuilder<TC, VC, Related>, Name>> : never;
-type BelongsToCreateDataColumns<T extends RelationConfigSelf> = { [K in keyof T['relations']]: T['relations'][K] extends BelongsTo ? T['relations'][K]['options']['columns'][number] & string : never }[keyof T['relations']];
-type BelongsToCreateDataForColumn<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf, Column extends string> = { [K in keyof T['relations']]: T['relations'][K] extends BelongsTo ? Column extends T['relations'][K]['options']['columns'][number] ? BelongsToCreateData<TC, VC, T, K & string, T['relations'][K]> : never : never }[keyof T['relations']];
-type RelationDataForCreate<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf, Name extends keyof T['relations'] & string> = T['relations'][Name] extends HasOne ? HasOneInfo<T, Name, T['relations'][Name], HasOneQuery<T, Name, RelationTableToQuery<TC, VC, T['relations'][Name]>>>['dataForCreate'] : T['relations'][Name] extends HasMany ? HasManyInfo<T, Name, T['relations'][Name], HasManyQuery<T, Name, RelationTableToQuery<TC, VC, T['relations'][Name]>>>['dataForCreate'] : T['relations'][Name] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Name, T['relations'][Name]['options']['columns'][number] & string, HasAndBelongsToManyQuery<Name, RelationTableToQuery<TC, VC, T['relations'][Name]>>>['dataForCreate'] : never;
-type RelationDataForCreateOptionalNames<T extends RelationConfigSelf> = { [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo ? never : K }[keyof T['relations'] & string];
-type BelongsToRelationsDataForCreate<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf> = { [Column in BelongsToCreateDataColumns<T>]: BelongsToCreateDataForColumn<TC, VC, T, Column> };
-type RelationsDataForCreateOptional<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf> = RelationDataForCreateOptionalNames<T> extends never ? EmptyObject : { [K in RelationDataForCreateOptionalNames<T>]: (u: RelationDataForCreate<TC, VC, T, K>) => void }[RelationDataForCreateOptionalNames<T>] extends ((u: infer Obj) => void) ? Obj : EmptyObject;
-interface TableQueryBuilder<TC extends TableClasses, VC extends TableClasses, T extends ORMTableInput> extends TableInfo, Db<T['table'] extends string ? T['table'] : T['name'], T['columns']['shape'], T['columns']['data'], T['types'], T['table'] extends string ? T['readOnly'] extends true ? true : undefined : T['readOnly'] extends false ? undefined : true, T> {
-  relations: T extends RelationConfigSelf ? { [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo ? BelongsToRelationInfo<TC, VC, T, K, T['relations'][K]> : T['relations'][K] extends HasOne ? HasOneInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationTableToQuery<TC, VC, T['relations'][K]>>> : T['relations'][K] extends HasMany ? HasManyInfo<T, K, T['relations'][K], HasManyQuery<T, K, RelationTableToQuery<TC, VC, T['relations'][K]>>> : T['relations'][K] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, K, T['relations'][K]['options']['columns'][number] & string, HasAndBelongsToManyQuery<K, RelationTableToQuery<TC, VC, T['relations'][K]>>> : never } : EmptyObject;
+type BelongsToRelationInfo<TC extends OrmTableThunks, VC extends OrmTableThunks, T extends RelationConfigSelf, Name extends string, Rel extends BelongsTo$1> = RelationToTableInput<TC, VC, Rel> extends (infer Related extends ORMTableInput) ? BelongsToInfo<T, Rel['options']['columns'][number] & string, BelongsToRequired<T, Rel, Related>, BelongsToQuery<TableQueryBuilder<TC, VC, Related>, Name>> : never;
+type BelongsToCreateData<TC extends OrmTableThunks, VC extends OrmTableThunks, T extends RelationConfigSelf, Name extends string, Rel extends BelongsTo$1> = RelationToTableInput<TC, VC, Rel> extends (infer Related extends ORMTableInput) ? BelongsToDataForCreate<Name, Rel['options']['columns'][number] & string, BelongsToRequired<T, Rel, Related>, BelongsToQuery<TableQueryBuilder<TC, VC, Related>, Name>> : never;
+type RelationDataForCreate<TC extends OrmTableThunks, VC extends OrmTableThunks, T extends RelationConfigSelf, Name extends keyof T['relations'] & string, Rel> = Rel extends HasOne$1 ? HasOneInfo<T, Name, Rel, HasOneQuery<T, Name, RelationTableToQuery<TC, VC, Rel>>>['dataForCreate'] : Rel extends HasMany$1 ? HasManyInfo<T, Name, Rel, HasManyQuery<T, Name, RelationTableToQuery<TC, VC, Rel>>>['dataForCreate'] : Rel extends HasAndBelongsToMany$1 ? HasAndBelongsToManyInfo<T, Name, Rel['options']['columns'][number] & string, HasAndBelongsToManyQuery<Name, RelationTableToQuery<TC, VC, Rel>>>['dataForCreate'] : never;
+type RelationInfoForName<TC extends OrmTableThunks, VC extends OrmTableThunks, T extends RelationConfigSelf, Name extends keyof T['relations'] & string, Rel> = Rel extends BelongsTo$1 ? BelongsToRelationInfo<TC, VC, T, Name, Rel> : Rel extends HasOne$1 ? HasOneInfo<T, Name, Rel, HasOneQuery<T, Name, RelationTableToQuery<TC, VC, Rel>>> : Rel extends HasMany$1 ? HasManyInfo<T, Name, Rel, HasManyQuery<T, Name, RelationTableToQuery<TC, VC, Rel>>> : Rel extends HasAndBelongsToMany$1 ? HasAndBelongsToManyInfo<T, Name, Rel['options']['columns'][number] & string, HasAndBelongsToManyQuery<Name, RelationTableToQuery<TC, VC, Rel>>> : never;
+type RelationDataForCreateOptionalNames<T extends RelationConfigSelf> = { [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo$1 ? never : K; }[keyof T['relations'] & string];
+type RelationDataForCreateValue<TC extends OrmTableThunks, VC extends OrmTableThunks, T extends RelationConfigSelf, Name extends keyof T['relations'] & string> = RelationDataForCreate<TC, VC, T, Name, T['relations'][Name]>[Name];
+type BelongsToRelationCreateData<TC extends OrmTableThunks, VC extends OrmTableThunks, T extends RelationConfigSelf, Name extends keyof T['relations']> = Name extends keyof T['relations'] & string ? T['relations'][Name] extends BelongsTo$1 ? BelongsToCreateData<TC, VC, T, Name, T['relations'][Name]> : never : never;
+type BelongsToRelationsDataForCreate<TC extends OrmTableThunks, VC extends OrmTableThunks, T extends RelationConfigSelf> = { [K in keyof T['relations'] as T['relations'][K] extends BelongsTo$1 ? T['relations'][K]['options']['columns'][number] & string : never]: BelongsToRelationCreateData<TC, VC, T, K>; };
+type RelationsDataForCreateOptional<TC extends OrmTableThunks, VC extends OrmTableThunks, T extends RelationConfigSelf, Names extends keyof T['relations'] & string = RelationDataForCreateOptionalNames<T>> = [Names] extends [never] ? EmptyObject : { [K in Names]?: RelationDataForCreateValue<TC, VC, T, K>; };
+interface TableQueryBuilder<TC extends OrmTableThunks, VC extends OrmTableThunks, T extends ORMTableInput> extends TableInfo, Db<T['table'] extends string ? T['table'] : T['name'], T['columns']['shape'], T['columns']['data'], T['types'], T['table'] extends string ? T['readOnly'] extends true ? true : undefined : T['readOnly'] extends false ? undefined : true, T> {
+  relations: T extends RelationConfigSelf ? { [K in keyof T['relations'] & string]: RelationInfoForName<TC, VC, T, K, T['relations'][K]>; } : EmptyObject;
   relationsDataForCreate: T extends RelationConfigSelf ? BelongsToRelationsDataForCreate<TC, VC, T> : EmptyObject;
   relationsDataForCreateOptional: T extends RelationConfigSelf ? RelationsDataForCreateOptional<TC, VC, T> : EmptyObject;
 }
@@ -574,6 +1287,7 @@ interface ORMTableInput extends PickORMTableInputColumnsAndComputed {
   autoForeignKeys?: TableData.References.BaseOptions | boolean;
   schema?: QuerySchema;
   nameInDb?: string;
+  snakeCase?: boolean;
   types: unknown;
   filePath: string;
   language?: string;
@@ -603,9 +1317,30 @@ interface ORMTableInput extends PickORMTableInputColumnsAndComputed {
   securityInvoker?: boolean;
   withData?: boolean;
 }
-type Queryable<T extends PickORMTableInputColumns> = ShallowSimplify<{ [K in keyof T['columns']['shape']]?: T['columns']['shape'][K]['__queryType'] }>;
-type DefaultSelect<T extends PickORMTableInputColumns> = ShallowSimplify<ColumnsShape.DefaultOutput<T['columns']['shape']>>;
-type Selectable<T extends PickORMTableInputColumnsAndComputed> = T['computed'] extends ((t: never) => infer R extends ComputedOptionsConfig) ? ShallowSimplify<ColumnsShape.Output<T['columns']['shape']> & { [K in keyof R]: R[K] extends {
+interface OrmLegacyTableForTypeHelpers {
+  columns: {
+    shape: Column.Shape.QueryInit;
+  };
+  computed?: ComputedOptionsFactory<never, never>;
+}
+interface OrmTableForTypeHelpers {
+  data: {
+    columns: Column.Shape.QueryInit;
+    computed?: ComputedOptionsFactory<never, never>;
+  };
+}
+type AnyTableForTypeHelpers = OrmLegacyTableForTypeHelpers | OrmTableForTypeHelpers;
+type Queryable<T extends AnyTableForTypeHelpers> = T extends {
+  columns: {
+    shape: infer Shape extends Column.Shape.QueryInit;
+  };
+} | {
+  data: {
+    columns: infer Shape extends Column.Shape.QueryInit;
+  };
+} ? { [K in keyof Shape]?: Shape[K]['__queryType']; } : never;
+type DefaultSelect<T extends AnyTableForTypeHelpers> = T extends OrmTableForTypeHelpers ? ColumnsShape.DefaultOutput<T['data']['columns']> : T extends OrmLegacyTableForTypeHelpers ? ColumnsShape.DefaultOutput<T['columns']['shape']> : never;
+type SelectableFromShapeAndComputed<Shape extends Column.Shape.QueryInit, Computed> = Computed extends undefined ? ColumnsShape.Output<Shape> : Computed extends ((t: never) => infer R extends ComputedOptionsConfig) ? ColumnsShape.Output<Shape> & { [K in keyof R]: R[K] extends {
   result: {
     value: infer Value extends Column.Pick.QueryColumn;
   };
@@ -613,9 +1348,18 @@ type Selectable<T extends PickORMTableInputColumnsAndComputed> = T['computed'] e
   result: {
     value: infer Value extends Column.Pick.QueryColumn;
   };
-}) ? Value['__outputType'] : never }> : ShallowSimplify<ColumnsShape.Output<T['columns']['shape']>>;
-type Insertable<T extends PickORMTableInputColumns> = ShallowSimplify<ColumnsShape.Input<T['columns']['shape']>>;
-type Updatable<T extends PickORMTableInputColumns> = ShallowSimplify<ColumnsShape.InputPartial<T['columns']['shape']>>;
+}) ? Value['__outputType'] : never; } : ColumnsShape.Output<Shape>;
+type Selectable<T extends AnyTableForTypeHelpers> = T extends OrmTableForTypeHelpers ? SelectableFromShapeAndComputed<T['data']['columns'], T['data']['computed']> : T extends OrmLegacyTableForTypeHelpers ? SelectableFromShapeAndComputed<T['columns']['shape'], T['computed']> : never;
+type Insertable<T extends AnyTableForTypeHelpers> = T extends {
+  columns: {
+    shape: infer Shape extends Column.Shape.QueryInit;
+  };
+} | {
+  data: {
+    columns: infer Shape extends Column.Shape.QueryInit;
+  };
+} ? ColumnsShape.Input<Shape> : never;
+type Updatable<T extends AnyTableForTypeHelpers> = T extends OrmTableForTypeHelpers ? ColumnsShape.InputPartial<T['data']['columns']> : T extends OrmLegacyTableForTypeHelpers ? ColumnsShape.InputPartial<T['columns']['shape']> : never;
 type BeforeHookMethod = (cb: QueryBeforeHook) => void;
 type BeforeActionHookMethod = (cb: QueryBeforeActionHook) => void;
 type AfterHookMethod = (cb: QueryAfterHook) => void;
@@ -773,7 +1517,7 @@ interface BaseTableInstance<ColumnTypes> {
     id: Related['id'] extends string ? Related['id'] : Related['table'] extends string ? Related['table'] : Related['name'];
     options: Options;
   };
-  hasOne<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
+  hasOne<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Options extends HasOneOptions<Columns, Related, Through>>(this: {
     columns: {
       shape: Columns;
     };
@@ -784,7 +1528,7 @@ interface BaseTableInstance<ColumnTypes> {
     id: Related['id'] extends string ? Related['id'] : Related['table'] extends string ? Related['table'] : Related['name'];
     options: Options;
   };
-  hasMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
+  hasMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Options extends HasOneOptions<Columns, Related, Through>>(this: {
     columns: {
       shape: Columns;
     };
@@ -795,7 +1539,7 @@ interface BaseTableInstance<ColumnTypes> {
     id: Related['id'] extends string ? Related['id'] : Related['table'] extends string ? Related['table'] : Related['name'];
     options: Options;
   };
-  hasAndBelongsToMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends HasAndBelongsToManyOptions<Columns, Related>>(this: {
+  hasAndBelongsToMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends HasAndBelongsToManyOptions$1<Columns, Related>>(this: {
     columns: {
       shape: Columns;
     };
@@ -876,27 +1620,9 @@ interface BaseMaterializedViewInstance<ColumnTypes> extends BaseTableInstance<Co
   readonly materialized: true;
   withData?: boolean;
 }
-declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({
-  schemaConfig,
-  columnTypes: columnTypesArg,
-  snakeCase,
-  filePath: filePathArg,
-  nowSQL,
-  exportAs,
-  language,
-  autoForeignKeys
-}?: {
-  schemaConfig?: () => SchemaConfig;
-  columnTypes?: ColumnTypes | ((t: DefaultColumnTypes<SchemaConfig>) => ColumnTypes);
-  snakeCase?: boolean;
-  filePath?: string;
-  nowSQL?: string;
-  exportAs?: string;
-  language?: string;
-  autoForeignKeys?: boolean | TableData.References.BaseOptions;
-}): BaseTableClass<SchemaConfig, ColumnTypes>;
+declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ schemaConfig, columnTypes: columnTypesArg, snakeCase, filePath: filePathArg, nowSQL, exportAs, language, autoForeignKeys }?: TableFactoryOptions<SchemaConfig, ColumnTypes>): BaseTableClass<SchemaConfig, ColumnTypes>;
 type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;
-type QueryOne<T extends Query> = { [K in keyof T]: K extends 'returnType' ? Exclude<QueryReturnType, 'all' | undefined> : T[K] };
+type QueryOne<T extends Query> = { [K in keyof T]: K extends 'returnType' ? Exclude<QueryReturnType, 'all' | undefined> : T[K]; };
 interface MethodsBase<T extends Query> {
   queryMethods?: QueryMethods<T>;
   queryOneMethods?: QueryMethods<QueryOne<T>>;
@@ -905,10 +1631,10 @@ interface MethodsBase<T extends Query> {
   methods?: RecordUnknown;
 }
 type MapQueryMethods<BaseQuery extends Query, Method> = Method extends ((q: any, ...args: infer Args) => infer Result) ? <T extends BaseQuery>(this: T, ...args: Args) => Result extends Query ? MergeQuery<T, Result> : Result : never;
-type MapMethods<T extends Query, Methods extends MethodsBase<T>> = { [K in keyof Methods['queryMethods'] | keyof Methods['queryOneMethods'] | keyof Methods['queryWithWhereMethods'] | keyof Methods['queryOneWithWhereMethods'] | keyof Methods['methods']]: K extends keyof Methods['methods'] ? Methods['methods'][K] : K extends keyof Methods['queryOneWithWhereMethods'] ? MapQueryMethods<QueryOne<Query & QueryHasWhere>, Methods['queryOneWithWhereMethods'][K]> : K extends keyof Methods['queryWithWhereMethods'] ? MapQueryMethods<Query & QueryHasWhere, Methods['queryWithWhereMethods'][K]> : K extends keyof Methods['queryOneMethods'] ? MapQueryMethods<QueryOne<Query>, Methods['queryOneMethods'][K]> : K extends keyof Methods['queryMethods'] ? MapQueryMethods<Query, Methods['queryMethods'][K]> : never };
+type MapMethods<T extends Query, Methods extends MethodsBase<T>> = { [K in keyof Methods['queryMethods'] | keyof Methods['queryOneMethods'] | keyof Methods['queryWithWhereMethods'] | keyof Methods['queryOneWithWhereMethods'] | keyof Methods['methods']]: K extends keyof Methods['methods'] ? Methods['methods'][K] : K extends keyof Methods['queryOneWithWhereMethods'] ? MapQueryMethods<QueryOne<Query & QueryHasWhere>, Methods['queryOneWithWhereMethods'][K]> : K extends keyof Methods['queryWithWhereMethods'] ? MapQueryMethods<Query & QueryHasWhere, Methods['queryWithWhereMethods'][K]> : K extends keyof Methods['queryOneMethods'] ? MapQueryMethods<QueryOne<Query>, Methods['queryOneMethods'][K]> : K extends keyof Methods['queryMethods'] ? MapQueryMethods<Query, Methods['queryMethods'][K]> : never; };
 type Repo<T extends Query, Methods extends MethodsBase<T>> = T & MapMethods<T, Methods>;
 declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(table: T, methods: Methods) => Repo<(<Q extends {
-  table: T["table"];
-  shape: T["shape"];
+  table: T['table'];
+  shape: T['shape'];
 }>(q: Q) => Query & Q & MapMethods<T, Methods>) & T, Methods>;
-export { BaseMaterializedViewInstance, BaseTableClass, BaseTableInstance, BaseViewInstance, DefaultSelect, FromQuery, Insertable, MapMethods, MapQueryMethods, MethodsBase, ORMTableInput, OrchidORM, OrchidORMBundle, OrchidORMDbTables, OrchidORMTables, OrchidOrmParam, PickORMTableComputed, PickORMTableInputColumns, PickORMTableInputColumnsAndComputed, Queryable, Repo, Selectable, SetColumnsResult, Table, TableClass, TableClasses, TableInfo, TableQueryBuilder, Updatable, bundleOrchidORM, bundleOrchidORMTables, createBaseTable, createRepo, defineRls, makeOrchidOrmDbWithAdapter, orchidORMWithAdapter, setGrants };
+export { BaseMaterializedViewInstance, BaseTableClass, BaseTableInstance, BaseViewInstance, DefaultSelect, FromQuery, Insertable, MapMethods, MapQueryMethods, MethodsBase, ORMTableInput, OrchidORM, OrchidORMBundle, OrchidORMDbTables, OrchidORMSetupOptions, OrchidORMTables, OrchidOrmParam, OrmLegacyTableForTypeHelpers, OrmTable, OrmTableForTypeHelpers, OrmTableThunks, PickORMTableComputed, PickORMTableInputColumns, PickORMTableInputColumnsAndComputed, Queryable, Repo, Selectable, SetColumnsResult, Table$1 as Table, TableClass, TableInfo, TableInstance, TableQueryBuilder, Updatable, bundleOrchidORM, bundleOrchidORMTables, createBaseTable, createRepo, createTableFactory, defineRls, makeOrchidOrmDbWithAdapter, orchidORMWithAdapter, setGrants };