pqb 0.71.4 → 0.72.1

package/dist/index.d.ts

@@ -21,7 +21,7 @@ interface RecordOptionalString {
 interface RecordUnknown {
   [K: string]: unknown;
 }
-type ShallowSimplify<T> = T extends any ? { [K in keyof T]: T[K] } : T;
+type ShallowSimplify<T> = T extends any ? { [K in keyof T]: T[K]; } : T;
 /**
  * Merge methods from multiple class into another class.
  * @param derivedCtor - target class to merge methods into
@@ -241,7 +241,7 @@ declare abstract class QueryError<T extends PickQueryShape = PickQueryShape> ext
   line: string | undefined;
   routine: string | undefined;
   get isUnique(): boolean;
-  get columns(): { [K in keyof T["shape"]]?: true | undefined };
+  get columns(): { [K in keyof T["shape"]]?: true | undefined; };
 }
 interface QueryLogObject {
   colors: boolean;
@@ -265,7 +265,7 @@ declare const logColors: {
   boldMagenta: (message: string) => string;
   boldRed: (message: string) => string;
 };
-declare const logParamToLogObject: (logger: QueryLogger, log: QueryLogOptions["log"]) => QueryLogObject | undefined;
+declare const logParamToLogObject: (logger: QueryLogger, log: QueryLogOptions['log']) => QueryLogObject | undefined;
 declare class QueryLog {
   /**
    * Override the `log` option, which can also be set in `createDb` or when creating a table instance:
@@ -909,7 +909,7 @@ interface TableDataMethods<Key extends PropertyKey> {
   };
   unique<Columns extends [Key | TableData.Index.ColumnOrExpressionOptions<Key>, ...(Key | TableData.Index.ColumnOrExpressionOptions<Key>)[]], Name extends string>(columns: Columns, options?: TableData.Index.UniqueOptionsArg<Name>): {
     tableDataItem: true;
-    columns: Columns extends (Key | TableData.Index.ColumnOptionsForColumn<Key>)[] ? { [I in keyof Columns]: 'column' extends keyof Columns[I] ? Columns[I]['column'] : Columns[I] } : never;
+    columns: Columns extends (Key | TableData.Index.ColumnOptionsForColumn<Key>)[] ? { [I in keyof Columns]: 'column' extends keyof Columns[I] ? Columns[I]['column'] : Columns[I]; } : never;
     name: string extends Name ? never : Name;
   };
   index(columns: (Key | TableData.Index.ColumnOrExpressionOptions<Key>)[], options?: TableData.Index.OptionsArg): NonUniqDataItem;
@@ -984,17 +984,22 @@ interface TableDataMethods<Key extends PropertyKey> {
    * ```
    */
   exclude(columns: TableData.Exclude.ColumnOrExpressionOptions<Key>[], options?: TableData.Exclude.Options): NonUniqDataItem;
-  foreignKey<Shape>(columns: [string, ...string[]], fnOrTable: () => new () => {
-    columns: {
+  foreignKey<Shape>(columns: [string, ...string[]], fnOrTable: () => Column.ForeignKey.TableParam & {
+    columns?: {
       shape: Shape;
     };
+    instance?: () => {
+      columns: {
+        shape: Shape;
+      };
+    };
   }, foreignColumns: [keyof Shape, ...(keyof Shape)[]], options?: TableData.References.Options): NonUniqDataItem;
   foreignKey(columns: [string, ...string[]], fnOrTable: string, foreignColumns: [string, ...string[]], options?: TableData.References.Options): NonUniqDataItem;
   check(check: RawSqlBase, name?: string): NonUniqDataItem;
   sql: SqlFn;
 }
-type TableDataItemsUniqueColumns<Shape extends Column.QueryColumns, T extends MaybeArray<TableDataItem>> = MaybeArray<TableDataItem> extends T ? never : T extends UniqueTableDataItem<Shape> ? ItemUniqueColumns<Shape, T> : T extends unknown[] ? { [Item in T[number] as PropertyKey]: Item extends UniqueTableDataItem<Shape> ? ItemUniqueColumns<Shape, Item> : never }[PropertyKey] : never;
-type ItemUniqueColumns<Shape extends Column.QueryColumns, T extends UniqueTableDataItem<Shape>> = { [Column in T['columns'][number]]: UniqueQueryTypeOrExpression<Shape[Column]['__queryType']> };
+type TableDataItemsUniqueColumns<Shape extends Column.QueryColumns, T extends MaybeArray<TableDataItem>> = MaybeArray<TableDataItem> extends T ? never : T extends UniqueTableDataItem<Shape> ? ItemUniqueColumns<Shape, T> : T extends unknown[] ? { [Item in T[number] as PropertyKey]: Item extends UniqueTableDataItem<Shape> ? ItemUniqueColumns<Shape, Item> : never; }[PropertyKey] : never;
+type ItemUniqueColumns<Shape extends Column.QueryColumns, T extends UniqueTableDataItem<Shape>> = { [Column in T['columns'][number]]: UniqueQueryTypeOrExpression<Shape[Column]['__queryType']>; };
 type TableDataItemsUniqueColumnTuples<Shape extends Column.QueryColumns, T extends MaybeArray<TableDataItem>> = MaybeArray<TableDataItem> extends T ? never : T extends UniqueTableDataItem<Shape> ? T['columns'] : T extends TableDataItem[] ? Exclude<T[number]['columns'], []> : never;
 type UniqueQueryTypeOrExpression<T> = T | Expression<Column.Pick.QueryColumnOfType<T>>;
 type TableDataItemsUniqueConstraints<T extends MaybeArray<TableDataItem>> = MaybeArray<TableDataItem> extends T ? never : T extends UniqueTableDataItem ? T['name'] : T extends UniqueTableDataItem[] ? T[number]['name'] : never;
@@ -1059,6 +1064,8 @@ interface ColumnToCodeCtx {
   currentSchema: string;
   migration?: boolean;
   snakeCase?: boolean;
+  sql?: string;
+  isSqlUsed?: boolean;
 }
 /**
  * Push code: this will append a code string to the last code array element when possible.
@@ -1078,14 +1085,12 @@ declare const columnsShapeToCode: (ctx: ColumnToCodeCtx, shape: Column.Shape.Que
 declare const pushTableDataCode: (code: Codes, ast: TableData) => Codes;
 declare const primaryKeyInnerToCode: (primaryKey: TableData.PrimaryKey, t: string) => string;
 declare const indexInnerToCode: (index: TableData.Index, t: string) => Codes;
+declare const indexToCode: (item: TableData.Index, t: string, prefix?: string) => Codes;
 declare const excludeInnerToCode: (item: TableData.Exclude, t: string) => Codes;
-declare const constraintInnerToCode: (item: TableData.Constraint, t: string, m?: boolean) => Codes;
-declare const referencesArgsToCode: ({
-  columns,
-  fnOrTable,
-  foreignColumns,
-  options
-}: Exclude<TableData.Constraint["references"], undefined>, name?: string | false, m?: boolean) => Codes;
+declare const excludeToCode: (item: TableData.Exclude, t: string, prefix?: string) => Codes;
+declare const constraintToCode: (item: TableData.Constraint, t: string, m?: boolean, prefix?: string, ctx?: ColumnToCodeCtx) => Codes;
+declare const constraintInnerToCode: (item: TableData.Constraint, t: string, m?: boolean, ctx?: ColumnToCodeCtx) => Codes;
+declare const referencesArgsToCode: ({ columns, fnOrTable, foreignColumns, options }: Exclude<TableData.Constraint['references'], undefined>, name?: string | false, m?: boolean) => Codes;
 interface NumberColumnData extends BaseNumberData, Column.Data {
   identity?: TableData.Identity;
 }
@@ -1130,46 +1135,46 @@ declare class DecimalColumn<Schema extends ColumnSchemaConfig> extends NumberAsS
   data: DecimalColumnData;
   querySchema: ReturnType<Schema['stringSchema']>;
   operators: OperatorsNumber;
-  dataType: "numeric";
+  dataType: 'numeric';
   constructor(schema: Schema, numericPrecision?: number, numericScale?: number);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
   toSQL(): string;
 }
 declare class SmallIntColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
-  dataType: "int2";
+  dataType: 'int2';
   querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
-  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): Column.Modifiers.HasDefault<T>;
+  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): Column.HasDefault<T>;
 }
 declare class IntegerColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
-  dataType: "int4";
+  dataType: 'int4';
   querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
-  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): Column.Modifiers.HasDefault<T>;
+  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): Column.HasDefault<T>;
 }
 declare class BigIntColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema, string | number | bigint> {
-  dataType: "int8";
+  dataType: 'int8';
   querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
-  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): Column.Modifiers.HasDefault<T>;
+  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): Column.HasDefault<T>;
 }
 declare class RealColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['number']>> {
-  dataType: "float4";
+  dataType: 'float4';
   querySchema: ReturnType<Schema['number']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class DoublePrecisionColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
-  dataType: "float8";
+  dataType: 'float8';
   querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class SmallSerialColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
-  dataType: "int2";
+  dataType: 'int2';
   data: SerialColumnData;
   querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
@@ -1177,7 +1182,7 @@ declare class SmallSerialColumn<Schema extends ColumnSchemaConfig> extends Integ
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class SerialColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
-  dataType: "int4";
+  dataType: 'int4';
   data: SerialColumnData;
   querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
@@ -1185,7 +1190,7 @@ declare class SerialColumn<Schema extends ColumnSchemaConfig> extends IntegerBas
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class BigSerialColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
-  dataType: "int8";
+  dataType: 'int8';
   data: SerialColumnData;
   querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
@@ -1193,14 +1198,16 @@ declare class BigSerialColumn<Schema extends ColumnSchemaConfig> extends NumberA
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 type DateColumnInput = string | number | Date;
+declare const parseStringOrDateToNumber: (value: unknown) => number;
 declare const getDateAsNumberFn: (column: {
   data: Column.Data;
   dateParsedByDriver?: boolean;
-}) => (value: unknown) => number;
+}) => typeof parseStringOrDateToNumber;
+declare const parseDateToDate: (value: unknown) => Date;
 declare const getDateAsDateFn: (column: {
   data: Column.Data;
   dateParsedByDriver?: boolean;
-}) => (value: unknown) => Date;
+}) => typeof parseDateToDate;
 declare abstract class DateBaseColumn<Schema extends ColumnSchemaConfig> extends Column {
   dateParsedByDriver?: boolean | undefined;
   __schema: Schema;
@@ -1218,7 +1225,7 @@ declare abstract class DateBaseColumn<Schema extends ColumnSchemaConfig> extends
   constructor(schema: Schema, dateParsedByDriver?: boolean | undefined);
 }
 declare class DateColumn<Schema extends ColumnSchemaConfig> extends DateBaseColumn<Schema> {
-  dataType: "date";
+  dataType: 'date';
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare abstract class DateTimeBaseClass<Schema extends ColumnSchemaConfig> extends DateBaseColumn<Schema> {
@@ -1233,12 +1240,12 @@ declare abstract class DateTimeTzBaseClass<Schema extends ColumnSchemaConfig> ex
   toSQL(): string;
 }
 declare class TimestampColumn<Schema extends ColumnSchemaConfig> extends DateTimeBaseClass<Schema> {
-  dataType: "timestamp";
+  dataType: 'timestamp';
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class TimestampTZColumn<Schema extends ColumnSchemaConfig> extends DateTimeTzBaseClass<Schema> {
-  dataType: "timestamptz";
-  baseDataType: "timestamp";
+  dataType: 'timestamptz';
+  baseDataType: 'timestamp';
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class TimeColumn<Schema extends ColumnSchemaConfig> extends Column {
@@ -1253,7 +1260,7 @@ declare class TimeColumn<Schema extends ColumnSchemaConfig> extends Column {
   outputSchema: ReturnType<Schema['stringSchema']>;
   __queryType: string;
   querySchema: ReturnType<Schema['stringSchema']>;
-  dataType: "time";
+  dataType: 'time';
   operators: OperatorsTime;
   constructor(schema: Schema, dateTimePrecision?: number);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
@@ -1271,7 +1278,7 @@ declare class IntervalColumn<Schema extends ColumnSchemaConfig> extends Column {
   outputSchema: ReturnType<Schema['timeInterval']>;
   __queryType: PostgresInterval;
   querySchema: ReturnType<Schema['timeInterval']>;
-  dataType: "interval";
+  dataType: 'interval';
   operators: OperatorsDate;
   constructor(schema: Schema, fields?: string, precision?: number, parse?: (input: string) => PostgresInterval);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
@@ -1312,8 +1319,8 @@ interface ArrayData<Item extends ArrayColumnValue> extends Column.Data, ArrayMet
 }
 declare class ArrayColumn<Schema extends ColumnTypeSchemaArg, Item extends ArrayColumnValue, InputType, OutputType, QueryType> extends Column {
   __schema: Schema;
-  dataType: "array";
-  operators: OperatorsArray<Item["__queryType"]>;
+  dataType: 'array';
+  operators: OperatorsArray<Item['__queryType']>;
   data: ArrayData<Item>;
   __type: Item['__type'][];
   __inputType: Item['__type'][];
@@ -1328,7 +1335,7 @@ declare class ArrayColumn<Schema extends ColumnTypeSchemaArg, Item extends Array
 }
 declare class JSONColumn<T, Schema extends ColumnTypeSchemaArg, InputSchema = Schema['__schemaType']> extends Column {
   __schema: Schema;
-  dataType: "jsonb";
+  dataType: 'jsonb';
   __type: T;
   __inputType: T;
   inputSchema: InputSchema;
@@ -1342,7 +1349,7 @@ declare class JSONColumn<T, Schema extends ColumnTypeSchemaArg, InputSchema = Sc
 }
 declare class JSONTextColumn<T, Schema extends ColumnTypeSchemaArg, InputSchema = Schema['__schemaType']> extends Column {
   __schema: Schema;
-  dataType: "json";
+  dataType: 'json';
   __type: T;
   __inputType: T;
   inputSchema: InputSchema;
@@ -1357,10 +1364,10 @@ declare class JSONTextColumn<T, Schema extends ColumnTypeSchemaArg, InputSchema
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 interface DefaultSchemaConfig extends ColumnSchemaConfig<Column> {
-  nullable<T extends Column.Pick.ForNullable>(this: T): Column.Modifiers.Nullable<T>;
-  parse<T extends Column.Pick.ForParse, Output>(this: T, fn: (input: T['__type']) => Output): Column.Modifiers.Parse<T, unknown, Output>;
-  parseNull<T extends Column.Pick.ForParseNull, Output>(this: T, fn: () => Output): Column.Modifiers.ParseNull<T, unknown, Output>;
-  encode<T extends Column.Pick.Type, Input>(this: T, fn: (input: Input) => unknown): Column.Modifiers.Encode<T, unknown, Input>;
+  nullable<T extends Column.Pick.ForNullable>(this: T): Column.Nullable<T>;
+  parse<T extends Column.Pick.ForParse, Output>(this: T, fn: (input: T['__type']) => Output): Column.Parse<T, unknown, Output>;
+  parseNull<T extends Column.Pick.ForParseNull, Output>(this: T, fn: () => Output): Column.ParseNull<T, unknown, Output>;
+  encode<T extends Column.Pick.Type, Input>(this: T, fn: (input: Input) => unknown): Column.Encode<T, unknown, Input>;
   /**
    * @deprecated use narrowType instead
    */
@@ -1374,12 +1381,12 @@ interface DefaultSchemaConfig extends ColumnSchemaConfig<Column> {
     __inputType: Input;
     __outputType: Output;
     __queryType: Query;
-  }) => Types): { [K in keyof T]: K extends '__type' ? Types['type'] : K extends keyof Types ? Types[K] : T[K] };
-  narrowType<T extends Column.InputOutputQueryTypes, Types extends Column.InputOutputQueryTypes>(this: T, _fn: (type: <Type extends (T['__inputType'] extends T['__outputType'] & T['__queryType'] ? T['__outputType'] & T['__queryType'] : T['__inputType'] & T['__outputType'] & T['__queryType'])>() => {
+  }) => Types): { [K in keyof T]: K extends '__type' ? Types['type'] : K extends keyof Types ? Types[K] : T[K]; };
+  narrowType<T extends Column.InputOutputQueryTypes, Types extends Column.InputOutputQueryTypes>(this: T, _fn: (type: <Type extends T['__inputType'] extends T['__outputType'] & T['__queryType'] ? T['__outputType'] & T['__queryType'] : T['__inputType'] & T['__outputType'] & T['__queryType']>() => {
     __inputType: T['__inputType'] extends never ? never : Type;
     __outputType: Type;
     __queryType: Type;
-  }) => Types): { [K in keyof T]: K extends keyof Types ? Types[K] : T[K] };
+  }) => Types): { [K in keyof T]: K extends keyof Types ? Types[K] : T[K]; };
   narrowAllTypes<T extends Column.InputOutputQueryTypes, Types extends Column.InputOutputQueryTypes>(this: T, _fn: (type: <Types extends {
     input?: T['__inputType'];
     output?: T['__outputType'];
@@ -1388,9 +1395,9 @@ interface DefaultSchemaConfig extends ColumnSchemaConfig<Column> {
     __inputType: undefined extends Types['input'] ? T['__inputType'] : Types['input'];
     __outputType: undefined extends Types['output'] ? T['__outputType'] : Types['output'];
     __queryType: undefined extends Types['query'] ? T['__queryType'] : Types['query'];
-  }) => Types): { [K in keyof T]: K extends keyof Types ? Types[K] : T[K] };
-  dateAsNumber<T extends Column.Pick.ForParse>(this: T): Column.Modifiers.Parse<T, unknown, number>;
-  dateAsDate<T extends Column.Pick.ForParse>(this: T): Column.Modifiers.Parse<T, unknown, Date>;
+  }) => Types): { [K in keyof T]: K extends keyof Types ? Types[K] : T[K]; };
+  dateAsNumber<T extends Column.Pick.ForParse>(this: T): Column.Parse<T, unknown, number>;
+  dateAsDate<T extends Column.Pick.ForParse>(this: T): Column.Parse<T, unknown, Date>;
   enum<const T extends readonly [string, ...string[]]>(dataType: string, type: T): EnumColumn<DefaultSchemaConfig, unknown, T>;
   array<Item extends ArrayColumnValue>(item: Item): ArrayColumn<DefaultSchemaConfig, Item, unknown, unknown, unknown>;
   json<T>(): JSONColumn<unknown extends T ? MaybeArray<string | number | boolean | object> : T, DefaultSchemaConfig>;
@@ -1443,7 +1450,7 @@ declare abstract class LimitedTextBaseColumn<Schema extends ColumnSchemaConfig>
   toSQL(): string;
 }
 declare class VarCharColumn<Schema extends ColumnSchemaConfig> extends LimitedTextBaseColumn<Schema> {
-  dataType: "varchar";
+  dataType: 'varchar';
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class StringColumn<Schema extends ColumnSchemaConfig> extends VarCharColumn<Schema> {
@@ -1451,7 +1458,7 @@ declare class StringColumn<Schema extends ColumnSchemaConfig> extends VarCharCol
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 declare class TextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColumn<Schema, OperatorsOrdinalText> {
-  dataType: "text";
+  dataType: 'text';
   data: TextColumnData & {
     minArg?: number;
     maxArg?: number;
@@ -1465,7 +1472,7 @@ declare class TextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColu
 }
 declare class ByteaColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "bytea";
+  dataType: 'bytea';
   operators: OperatorsOrdinalText;
   __type: string;
   __inputType: Buffer;
@@ -1479,7 +1486,7 @@ declare class ByteaColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class PointColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "point";
+  dataType: 'point';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1493,7 +1500,7 @@ declare class PointColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class LineColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "line";
+  dataType: 'line';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1507,7 +1514,7 @@ declare class LineColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class LsegColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "lseg";
+  dataType: 'lseg';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1521,7 +1528,7 @@ declare class LsegColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class BoxColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "box";
+  dataType: 'box';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1535,7 +1542,7 @@ declare class BoxColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class PathColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "path";
+  dataType: 'path';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1549,7 +1556,7 @@ declare class PathColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class PolygonColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "polygon";
+  dataType: 'polygon';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1563,7 +1570,7 @@ declare class PolygonColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class CircleColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "circle";
+  dataType: 'circle';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1577,7 +1584,7 @@ declare class CircleColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class MoneyColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "money";
+  dataType: 'money';
   __type: string;
   data: NumberColumnData;
   __inputType: string | number;
@@ -1592,7 +1599,7 @@ declare class MoneyColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class CidrColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "cidr";
+  dataType: 'cidr';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1606,7 +1613,7 @@ declare class CidrColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class InetColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "inet";
+  dataType: 'inet';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1620,7 +1627,7 @@ declare class InetColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class MacAddrColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "macaddr";
+  dataType: 'macaddr';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1634,7 +1641,7 @@ declare class MacAddrColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class MacAddr8Column<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "macaddr8";
+  dataType: 'macaddr8';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1648,7 +1655,7 @@ declare class MacAddr8Column<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class BitColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "bit";
+  dataType: 'bit';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['bit']>;
@@ -1666,7 +1673,7 @@ declare class BitColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class BitVaryingColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "varbit";
+  dataType: 'varbit';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['bit']>;
@@ -1686,7 +1693,7 @@ type TsVectorGeneratedColumns = string[] | SearchWeightRecord;
 declare class TsVectorColumn<Schema extends ColumnSchemaConfig> extends Column {
   defaultLanguage: string;
   __schema: Schema;
-  dataType: "tsvector";
+  dataType: 'tsvector';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1721,11 +1728,11 @@ declare class TsVectorColumn<Schema extends ColumnSchemaConfig> extends Column {
    *
    * @param args
    */
-  generated<T extends Column.Pick.Data>(this: T, ...args: StaticSQLArgs | [language: string, columns: TsVectorGeneratedColumns] | [columns: TsVectorGeneratedColumns]): Column.Modifiers.Generated<T>;
+  generated<T extends Column.Pick.Data>(this: T, ...args: StaticSQLArgs | [language: string, columns: TsVectorGeneratedColumns] | [columns: TsVectorGeneratedColumns]): Column.Generated<T>;
 }
 declare class TsQueryColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "tsquery";
+  dataType: 'tsquery';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1739,7 +1746,7 @@ declare class TsQueryColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "uuid";
+  dataType: 'uuid';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['uuid']>;
@@ -1752,7 +1759,8 @@ declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends Column {
   /**
    * see {@link Column.primaryKey}
    */
-  primaryKey<T extends Column.Pick.Data, Name extends string>(this: T, name?: Name): // using & bc otherwise the return type doesn't match `primaryKey` in ColumnType and TS complains
+  primaryKey<T extends Column.Pick.Data, Name extends string>(this: T, name?: Name):
+  // using & bc otherwise the return type doesn't match `primaryKey` in ColumnType and TS complains
   T & {
     data: {
       primaryKey: Name;
@@ -1763,7 +1771,7 @@ declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class XMLColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "xml";
+  dataType: 'xml';
   __type: string;
   __inputType: string;
   inputSchema: ReturnType<Schema['stringSchema']>;
@@ -1779,7 +1787,7 @@ declare class XMLColumn<Schema extends ColumnSchemaConfig> extends Column {
 }
 declare class CitextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColumn<Schema, OperatorsOrdinalText> {
   __schema: Schema;
-  dataType: "citext";
+  dataType: 'citext';
   data: TextColumnData & {
     minArg?: number;
     maxArg?: number;
@@ -1791,7 +1799,7 @@ declare class CitextColumn<Schema extends ColumnSchemaConfig> extends TextBaseCo
 }
 declare class BooleanColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
-  dataType: "bool";
+  dataType: 'bool';
   operators: OperatorsBoolean;
   __type: boolean;
   __inputType: boolean;
@@ -1808,8 +1816,8 @@ declare class BooleanColumn<Schema extends ColumnSchemaConfig> extends Column {
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 interface Timestamps<T extends Column.Pick.Data> {
-  createdAt: Column.Modifiers.HasDefault<T>;
-  updatedAt: Column.Modifiers.HasDefault<T>;
+  createdAt: Column.HasDefault<T>;
+  updatedAt: Column.HasDefault<T>;
 }
 interface TimestampHelpers {
   /**
@@ -1858,6 +1866,7 @@ interface PostgisPoint {
   lat: number;
   srid?: number;
 }
+declare const encode: ({ srid, lon, lat }: PostgisPoint) => string;
 declare class PostgisGeographyPointColumn<Schema extends ColumnSchemaConfig> extends Column {
   __schema: Schema;
   dataType: string;
@@ -1869,11 +1878,7 @@ declare class PostgisGeographyPointColumn<Schema extends ColumnSchemaConfig> ext
   __queryType: PostgisPoint;
   querySchema: ReturnType<Schema['geographyPointSchema']>;
   operators: OperatorsAny;
-  static encode: ({
-    srid,
-    lon,
-    lat
-  }: PostgisPoint) => string;
+  static encode: typeof encode;
   static isDefaultPoint(typmod: number): boolean;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
@@ -1892,7 +1897,7 @@ interface DefaultColumnTypes<SchemaConfig extends ColumnSchemaConfig> extends Ti
   decimal: SchemaConfig['decimal'];
   real: SchemaConfig['real'];
   doublePrecision: SchemaConfig['doublePrecision'];
-  identity(options?: TableData.Identity): Column.Modifiers.HasDefault<ReturnType<SchemaConfig['integer']>>;
+  identity(options?: TableData.Identity): Column.HasDefault<ReturnType<SchemaConfig['integer']>>;
   smallSerial: SchemaConfig['smallSerial'];
   serial: SchemaConfig['serial'];
   bigSerial: SchemaConfig['bigSerial'];
@@ -2003,7 +2008,7 @@ interface BatchParser {
     rows: unknown[];
   }) => MaybePromise<void>;
 }
-type ColumnsParsers = { [K in string]?: ColumnParser };
+type ColumnsParsers = { [K in string]?: ColumnParser; };
 type BatchParsers = BatchParser[];
 interface QueryThen<T> {
   <TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
@@ -2028,7 +2033,7 @@ type WithSelectable<W extends WithDataItem> = keyof W['shape'] | `${W['table']}.
  * The first argument of all `join` and `joinLateral` methods.
  * See argument of {@link join}.
  */
-type JoinFirstArg<T extends PickQueryRelationsWithData> = PickQueryResultAs | keyof T['relations'] | keyof T['withData'] | ((q: { [K in keyof T['relations']]: T['relations'][K]['query'] }) => PickQueryResultAs) | FnPickQueryResultAs;
+type JoinFirstArg<T extends PickQueryRelationsWithData> = PickQueryResultAs | keyof T['relations'] | keyof T['withData'] | ((q: { [K in keyof T['relations']]: T['relations'][K]['query']; }) => PickQueryResultAs) | FnPickQueryResultAs;
 interface FnPickQueryResultAs {
   (): PickQueryResultAs;
 }
@@ -2036,7 +2041,7 @@ interface FnPickQueryResultAs {
  * Arguments of `join` methods (not `joinLateral`).
  * See {@link join}
  */
-type JoinArgs<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>> = Arg extends PickQueryResultAs ? [conditions: { [K in JoinSelectable<Arg>]: keyof T['__selectable'] | Expression } | Expression] | [leftColumn: JoinSelectable<Arg> | Expression, rightColumn: keyof T['__selectable'] | Expression] | [leftColumn: JoinSelectable<Arg> | Expression, op: string, rightColumn: keyof T['__selectable'] | Expression] : Arg extends keyof T['withData'] ? JoinWithArgs<T, T['withData'][Arg]> : EmptyTuple;
+type JoinArgs<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>> = Arg extends PickQueryResultAs ? [conditions: { [K in JoinSelectable<Arg>]: keyof T['__selectable'] | Expression; } | Expression] | [leftColumn: JoinSelectable<Arg> | Expression, rightColumn: keyof T['__selectable'] | Expression] | [leftColumn: JoinSelectable<Arg> | Expression, op: string, rightColumn: keyof T['__selectable'] | Expression] : Arg extends keyof T['withData'] ? JoinWithArgs<T, T['withData'][Arg]> : EmptyTuple;
 /**
  * Column names of the joined table that can be used to join.
  * Derived from 'result', not from 'shape',
@@ -2047,16 +2052,16 @@ type JoinArgs<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends
  * And the selection becomes available to use in the `ON` and to select from the joined table.
  */
 type JoinSelectable<Q extends PickQueryResultAs> = keyof Q['result'] | `${Q['__as']}.${keyof Q['result'] & string}`;
-type JoinWithArgs<T extends PickQuerySelectable, Arg extends WithDataItem> = [conditions: { [K in WithSelectable<Arg>]: keyof T['__selectable'] | Expression } | Expression] | [leftColumn: WithSelectable<Arg> | Expression, rightColumn: keyof T['__selectable'] | Expression] | [leftColumn: WithSelectable<Arg> | Expression, op: string, rightColumn: keyof T['__selectable'] | Expression];
-type JoinResultRequireMain<T extends PickQuerySelectable, JoinedSelectable> = { [K in keyof T]: K extends '__selectable' ? T['__selectable'] & JoinedSelectable : T[K] };
+type JoinWithArgs<T extends PickQuerySelectable, Arg extends WithDataItem> = [conditions: { [K in WithSelectable<Arg>]: keyof T['__selectable'] | Expression; } | Expression] | [leftColumn: WithSelectable<Arg> | Expression, rightColumn: keyof T['__selectable'] | Expression] | [leftColumn: WithSelectable<Arg> | Expression, op: string, rightColumn: keyof T['__selectable'] | Expression];
+type JoinResultRequireMain<T extends PickQuerySelectable, JoinedSelectable> = { [K in keyof T]: K extends '__selectable' ? T['__selectable'] & JoinedSelectable : T[K]; };
 /**
  * Result of all `join` methods, not `joinLateral`.
  * Adds joined table columns from its 'result' to the '__selectable' of the query.
  */
-type JoinResult<T extends PickQuerySelectableRelationsResultReturnType, Joined extends PickQuerySelectableRelations, RequireMain> = RequireMain extends true ? { [K in keyof T]: K extends '__selectable' ? T['__selectable'] & Joined['__selectable'] : K extends 'relations' ? { [K in keyof T['relations'] | keyof Joined['relations']]: K extends keyof Joined['relations'] ? Joined['relations'][K] : T['relations'][K] } : T[K] } : { [K in keyof T]: K extends '__selectable' ? { [K in keyof T['__selectable']]: {
+type JoinResult<T extends PickQuerySelectableRelationsResultReturnType, Joined extends PickQuerySelectableRelations, RequireMain> = RequireMain extends true ? { [K in keyof T]: K extends '__selectable' ? T['__selectable'] & Joined['__selectable'] : K extends 'relations' ? { [K in keyof T['relations'] | keyof Joined['relations']]: K extends keyof Joined['relations'] ? Joined['relations'][K] : T['relations'][K]; } : T[K]; } : { [K in keyof T]: K extends '__selectable' ? { [K in keyof T['__selectable']]: {
   as: T['__selectable'][K]['as'];
-  column: Column.Modifiers.QueryColumnToNullable<T['__selectable'][K]['column']>;
-} } & Joined['__selectable'] : K extends 'result' ? { [K in keyof T['result']]: Column.Modifiers.QueryColumnToNullable<T['result'][K]> } : K extends 'then' ? QueryThenByQuery<T, { [K in keyof T['result']]: Column.Modifiers.QueryColumnToNullable<T['result'][K]> }> : K extends 'relations' ? { [K in keyof T['relations'] | keyof Joined['relations']]: K extends keyof Joined['relations'] ? Joined['relations'][K] : T['relations'][K] } : T[K] };
+  column: Column.QueryColumnToNullable<T['__selectable'][K]['column']>;
+}; } & Joined['__selectable'] : K extends 'result' ? { [K in keyof T['result']]: Column.QueryColumnToNullable<T['result'][K]>; } : K extends 'then' ? QueryThenByQuery<T, { [K in keyof T['result']]: Column.QueryColumnToNullable<T['result'][K]>; }> : K extends 'relations' ? { [K in keyof T['relations'] | keyof Joined['relations']]: K extends keyof Joined['relations'] ? Joined['relations'][K] : T['relations'][K]; } : T[K]; };
 /**
  * Calls {@link JoinResult} with either callback result, if join has a callback,
  * or with a query derived from the first join argument.
@@ -2095,19 +2100,19 @@ type JoinResultSelectable<Result extends Column.QueryColumns, As extends string,
   } : {
     as: K;
     column: Result[K];
-  } };
-  relations: { [K in keyof JoinedRelations & string as `${As}.${K}`]: JoinedRelations[K] };
+  }; };
+  relations: { [K in keyof JoinedRelations & string as `${As}.${K}`]: JoinedRelations[K]; };
 } : {
   __selectable: { [K in '*' | (keyof Result & string) as `${As}.${K}`]: K extends '*' ? {
     as: As;
     column: ColumnsShape.MapToNullableObjectColumn<Result>;
   } : {
     as: K;
-    column: Column.Modifiers.QueryColumnToNullable<Result[K]>;
-  } };
-  relations: { [K in keyof JoinedRelations & string as `${As}.${K}`]: JoinedRelations[K] };
+    column: Column.QueryColumnToNullable<Result[K]>;
+  }; };
+  relations: { [K in keyof JoinedRelations & string as `${As}.${K}`]: JoinedRelations[K]; };
 };
-type JoinAddSelectable<T extends PickQuerySelectable, Joined extends PickQuerySelectableRelations> = { [K in keyof T]: K extends '__selectable' ? T['__selectable'] & Joined['__selectable'] : T[K] };
+type JoinAddSelectable<T extends PickQuerySelectable, Joined extends PickQuerySelectableRelations> = { [K in keyof T]: K extends '__selectable' ? T['__selectable'] & Joined['__selectable'] : T[K]; };
 /**
  * Map the first argument of `join` or `joinLateral` to a query type.
  *
@@ -2118,7 +2123,7 @@ type JoinAddSelectable<T extends PickQuerySelectable, Joined extends PickQuerySe
 type JoinArgToQuery<T extends PickQueryRelationsWithData, Arg extends JoinFirstArg<T>> = Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? { [K in 'result' | '__as' | keyof T]: K extends '__as' ? T['withData'][Arg]['table'] : K extends '__selectable' ? { [K in keyof T['withData'][Arg]['shape'] & string as `${T['withData'][Arg]['table']}.${K}`]: {
   as: K;
   column: T['withData'][Arg]['shape'][K];
-} } : K extends 'result' ? T['withData'][Arg]['shape'] : K extends keyof T ? T[K] : never } : never : Arg extends PickQuerySelectableResultAs ? Arg : Arg extends keyof T['relations'] ? T['relations'][Arg]['query'] : Arg extends JoinArgToQueryCallback ? ReturnType<Arg> : never;
+}; } : K extends 'result' ? T['withData'][Arg]['shape'] : K extends keyof T ? T[K] : never; } : never : Arg extends PickQuerySelectableResultAs ? Arg : Arg extends keyof T['relations'] ? T['relations'][Arg]['query'] : Arg extends JoinArgToQueryCallback ? ReturnType<Arg> : never;
 interface JoinArgToQueryCallback {
   (...args: any[]): IsQuery;
 }
@@ -2199,36 +2204,21 @@ declare class QueryJoin {
    * For the following examples, imagine you have a `User` table with `id` and `name`, and `Message` table with `id`, `text`, messages belongs to user via `userId` column:
    *
    * ```ts
-   * export class UserTable extends BaseTable {
-   *   readonly table = 'user';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.identity().primaryKey(),
-   *     name: t.text(),
-   *   }));
-   *
-   *   relations = {
-   *     messages: this.hasMany(() => MessageTable, {
-   *       primaryKey: 'id',
-   *       foreignKey: 'userId',
-   *     }),
-   *   };
-   * }
-   *
-   * export class MessageTable extends BaseTable {
-   *   readonly table = 'message';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.identity().primaryKey(),
-   *     text: t.text(),
-   *     ...t.timestamps(),
-   *   }));
+   * export const UserTable = defineTable('user', (t) => ({
+   *   id: t.identity().primaryKey(),
+   *   name: t.text(),
+   * })).relations((user) => ({
+   *   messages: user('id').hasMany(() => MessageTable('userId')),
+   * }));
    *
-   *   relations = {
-   *     user: this.belongsTo(() => UserTable, {
-   *       primaryKey: 'id',
-   *       foreignKey: 'userId',
-   *     }),
-   *   };
-   * }
+   * export const MessageTable = defineTable('message', (t) => ({
+   *   id: t.identity().primaryKey(),
+   *   userId: t.integer(),
+   *   text: t.text(),
+   *   ...t.timestamps(),
+   * })).relations((message) => ({
+   *   user: message('userId').belongsTo(() => UserTable('id')),
+   * }));
    * ```
    *
    * `join` is a method for SQL `JOIN`, which is equivalent to `INNER JOIN`, `LEFT INNERT JOIN`.
@@ -2425,7 +2415,7 @@ declare class QueryJoin {
    * ```ts
    * db.user.join(
    *   db.message,
-   *   // `sql` can be imported from your `BaseTable` file
+   *   // `sql` can be imported from your table factory file
    *   sql`lower("message"."text") = lower("user"."name")`,
    * );
    * ```
@@ -2766,7 +2756,7 @@ declare class QueryJoin {
   joinData<T extends PickQuerySelectableColumnTypes, As extends string, RecordType extends Column.QueryColumnsInit, Item extends ColumnsShape.Input<RecordType>>(this: T, as: As, fn: (types: T['columnTypes']) => RecordType, data: Item[]): { [K in keyof T]: K extends '__selectable' ? T['__selectable'] & { [K in keyof RecordType & string as `${As}.${K}`]: {
     as: K;
     column: RecordType[K];
-  } } : T[K] };
+  }; } : T[K]; };
 }
 type OnArgs<S extends QuerySelectable> = [leftColumn: keyof S, rightColumn: keyof S] | [leftColumn: keyof S, op: string, rightColumn: keyof S];
 declare const pushQueryOnForOuter: <T extends PickQuerySelectable>(q: T, joinFrom: PickQuerySelectable, joinTo: PickQuerySelectable, leftColumn: string, rightColumn: string) => T;
@@ -2774,13 +2764,13 @@ type OnJsonPathEqualsArgs<S extends QuerySelectable> = [leftColumn: keyof S, lef
 /**
  * Mutative {@link OnMethods.prototype.on}
  */
-declare const _queryJoinOn: <T extends PickQuerySelectable>(q: T, args: OnArgs<T["__selectable"]>) => T;
+declare const _queryJoinOn: <T extends PickQuerySelectable>(q: T, args: OnArgs<T['__selectable']>) => T;
 /**
  * Argument of join callback.
  * It is a query object of table that you're joining, with ability to select main table's columns.
  * Adds {@link OnMethods.prototype.on} method and similar to the query.
  */
-type JoinQueryBuilder<T extends PickQuerySelectableShape, J extends PickQuerySelectableResultAs> = { [K in keyof J | keyof OnMethods]: K extends '__selectable' ? SelectableFromShape<J['result'], J['__as']> & Omit<T['__selectable'], keyof T['shape']> : K extends keyof OnMethods ? OnMethods[K] : K extends keyof J ? J[K] : never };
+type JoinQueryBuilder<T extends PickQuerySelectableShape, J extends PickQuerySelectableResultAs> = { [K in keyof J | keyof OnMethods]: K extends '__selectable' ? SelectableFromShape<J['result'], J['__as']> & Omit<T['__selectable'], keyof T['shape']> : K extends keyof OnMethods ? OnMethods[K] : K extends keyof J ? J[K] : never; };
 declare class OnMethods {
   /**
    * Use `on` to specify columns to join records.
@@ -2897,10 +2887,10 @@ interface QueryDataSources {
 }
 declare namespace Order {
   export interface ArgThis extends PickQuerySelectable, PickQueryResult, PickQueryTsQuery {}
-  export type Arg<T extends ArgThis> = ArgKey<T> | ArgTsQuery<T> | { [K in ArgKey<T> | ArgTsQuery<T>]?: K extends ArgTsQuery<T> ? OrderTsQueryConfig : SortDir } | Expression;
+  export type Arg<T extends ArgThis> = ArgKey<T> | ArgTsQuery<T> | { [K in ArgKey<T> | ArgTsQuery<T>]?: K extends ArgTsQuery<T> ? OrderTsQueryConfig : SortDir; } | Expression;
   export type Args<T extends ArgThis> = Arg<T>[];
   type ArgTsQuery<T extends ArgThis> = string | undefined extends T['__tsQuery'] ? never : Exclude<T['__tsQuery'], undefined>;
-  type ArgKey<T extends ArgThis> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['__queryType'] extends undefined ? never : K }[keyof T['__selectable']] | { [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K }[keyof T['result']];
+  type ArgKey<T extends ArgThis> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['__queryType'] extends undefined ? never : K; }[keyof T['__selectable']] | { [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K; }[keyof T['result']];
   export {};
 }
 declare class QueryOrder {
@@ -2961,7 +2951,7 @@ interface WindowArgDeclaration<T extends Order.ArgThis = Order.ArgThis> {
   order?: Order.Arg<T>;
 }
 type WindowResult<T, W extends RecordUnknown> = T & {
-  windows: { [K in keyof W]: true };
+  windows: { [K in keyof W]: true; };
 };
 declare class QueryWindow {
   /**
@@ -3089,9 +3079,9 @@ type SearchArg<T extends PickQuerySelectable, As extends string> = {
 }) & ({
   text: string | Expression;
 } | {
-  in: MaybeArray<keyof T['__selectable']> | { [K in keyof T['__selectable']]?: SearchWeight };
+  in: MaybeArray<keyof T['__selectable']> | { [K in keyof T['__selectable']]?: SearchWeight; };
 } | {
-  vector: { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['dataType'] extends 'tsvector' ? K : never }[keyof T['__selectable']];
+  vector: { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['dataType'] extends 'tsvector' ? K : never; }[keyof T['__selectable']];
 }) & ({
   query: string | Expression;
 } | {
@@ -3110,12 +3100,12 @@ declare class SearchMethods {
    *
    * By default, the search language is English.
    *
-   * You can set a different default language in the `createBaseTable` config:
+   * You can set a different default language in the `createTableFactory` config:
    *
    * ```ts
-   * import { createBaseTable } from 'orchid-orm';
+   * import { createTableFactory } from 'orchid-orm';
    *
-   * export const BaseTable = createBaseTable({
+   * export const { defineTable, defineView, sql } = createTableFactory({
    *   language: 'swedish',
    * });
    * ```
@@ -3300,7 +3290,7 @@ interface OperatorsCount extends OperatorsNumber {
 }
 type CountColumn = Column.Pick.QueryColumnOfTypeAndOps<'int8', number, OperatorsCount>;
 type CountReturn<T> = SetQueryReturnsColumnOrThrow<T, CountColumn> & OperatorsCount;
-type SelectableDataType<T extends PickQuerySelectable, DataType extends string> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['dataType'] extends DataType ? K : never }[keyof T['__selectable']] | Expression<Column.Pick.QueryColumnOfDataType<DataType>>;
+type SelectableDataType<T extends PickQuerySelectable, DataType extends string> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['dataType'] extends DataType ? K : never; }[keyof T['__selectable']] | Expression<Column.Pick.QueryColumnOfDataType<DataType>>;
 type NumericReturn<T extends PickQuerySelectable, Arg> = Arg extends keyof T['__selectable'] ? SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<T['__selectable'][Arg]['column']['dataType'], T['__selectable'][Arg]['column']['__type'] | null, OperatorsNumber>> & OperatorsNumber : Arg extends Expression ? SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<Arg['result']['value']['dataType'], Arg['result']['value']['__type'] | null, OperatorsNumber>> & OperatorsNumber : never;
 type NullableNumberReturn<T, DataType> = SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<DataType, number | null, OperatorsNumber>> & OperatorsNumber;
 type BooleanQueryColumn = Column.Pick.QueryColumnOfTypeAndOps<'bool', boolean, OperatorsBoolean>;
@@ -3318,9 +3308,9 @@ interface RecordSelectableOrExpression<T extends PickQuerySelectable> {
 }
 type NullableJSONObjectReturn<T extends PickQuerySelectable, Obj extends RecordSelectableOrExpression<T>> = SetQueryReturnsColumnOrThrow<T, {
   dataType: 'json';
-  __type: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['__type'] } | null;
-  __outputType: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['__outputType'] } | null;
-  __queryType: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['__queryType'] } | null;
+  __type: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['__type']; } | null;
+  __outputType: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['__outputType']; } | null;
+  __queryType: { [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['__queryType']; } | null;
   operators: OperatorsAny;
 }> & OperatorsAny;
 type StringColumn$1 = Column.Pick.QueryColumnOfTypeAndOps<string, string, OperatorsText>;
@@ -3329,7 +3319,8 @@ type NullableStringReturn<T> = SetQueryReturnsColumnOrThrow<T, StringNullable> &
 interface AggregateArgTypes {
   minMax: 'citext' | 'date' | 'float4' | 'float8' | 'inet' | 'int2' | 'int4' | 'int8' | 'interval' | 'money' | 'numeric' | 'text' | 'time' | 'timestamp' | 'timestamptz';
   sum: 'float4' | 'float8' | 'int2' | 'int4' | 'int8' | 'interval' | 'money' | 'numeric';
-  avg: // unlike sum, avg has no money
+  avg:
+  // unlike sum, avg has no money
   'float4' | 'float8' | 'int2' | 'int4' | 'int8' | 'interval' | 'numeric';
   bit: 'bit' | 'int2' | 'int4' | 'int8';
   bool: 'bool';
@@ -3747,11 +3738,11 @@ declare class OrExpression extends Expression<BooleanQueryColumn> {
 interface QueryReturnsFnAdd<T extends PickQueryColumTypes> extends PickQueryHasSelect {
   type<C extends Column.Pick.QueryColumn>(fn: (types: T['columnTypes']) => C): { [K in keyof T]: K extends 'result' ? {
     value: C;
-  } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['__outputType']> : T[K] } & C['operators'];
+  } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['__outputType']> : T[K]; } & C['operators'];
 }
 type SetQueryReturnsFn<T extends PickQueryColumTypes, C extends Column.Pick.OutputType> = { [K in keyof T]: K extends 'result' ? {
   value: C;
-} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['__outputType']> : T[K] } & QueryReturnsFnAdd<T>;
+} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['__outputType']> : T[K]; } & QueryReturnsFnAdd<T>;
 declare class QueryExpressions {
   /**
    * `column` references a table column, this can be used in raw SQL or when building a column expression.
@@ -3844,7 +3835,7 @@ declare class QueryExpressions {
 type WhereArg<T extends PickQuerySelectableRelations> = { [K in keyof T['__selectable'] | 'NOT' | 'OR' | 'IN']?: K extends 'NOT' ? WhereArg<T> | WhereArgs<T> : K extends 'OR' ? (WhereArg<T> | WhereArgs<T>)[] : K extends 'IN' ? MaybeArray<{
   columns: (keyof T['__selectable'])[];
   values: unknown[][] | IsQuery | Expression;
-}> : T['__selectable'][K]['column']['__queryType'] | null | { [O in keyof T['__selectable'][K]['column']['operators']]?: T['__selectable'][K]['column']['operators'][O]['_opType'] } | {
+}> : T['__selectable'][K]['column']['__queryType'] | null | { [O in keyof T['__selectable'][K]['column']['operators']]?: T['__selectable'][K]['column']['operators'][O]['_opType']; } | {
   result: {
     value: {
       __queryType: T['__selectable'][K]['column']['__queryType'] | null;
@@ -3856,7 +3847,7 @@ type WhereArg<T extends PickQuerySelectableRelations> = { [K in keyof T['__selec
       __queryType: T['__selectable'][K]['column']['__queryType'] | null;
     };
   };
-}) } | ((q: WhereQueryBuilder<T>) => QueryOrExpressionBooleanOrNullResult | WhereQueryBuilder<T>);
+}); } | ((q: WhereQueryBuilder<T>) => QueryOrExpressionBooleanOrNullResult | WhereQueryBuilder<T>);
 /**
  * Callback argument of `where`.
  * It has `where` methods (`where`, `whereNot`, `whereExists`, etc.),
@@ -3865,16 +3856,16 @@ type WhereArg<T extends PickQuerySelectableRelations> = { [K in keyof T['__selec
  * db.table.where((q) => q.relation.count().equals(10))
  * ```
  */
-type WhereQueryBuilder<T extends PickQueryRelations> = EmptyObject extends T['relations'] ? { [K in keyof T]: K extends keyof Where | keyof QueryExpressions | 'table' | 'get' | 'columnTypes' | '__selectable' | 'relations' | 'useHelper' | 'modify' | 'result' | 'returnType' | 'withData' | 'windows' | 'then' ? T[K] : never } : { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T & (keyof Where | keyof QueryExpressions | 'table' | 'get' | 'columnTypes' | '__selectable' | 'relations' | 'useHelper' | 'modify' | 'result' | 'returnType' | 'withData' | 'windows' | 'then') ? T[K] : never };
+type WhereQueryBuilder<T extends PickQueryRelations> = EmptyObject extends T['relations'] ? { [K in keyof T]: K extends keyof Where | keyof QueryExpressions | 'table' | 'get' | 'columnTypes' | '__selectable' | 'relations' | 'useHelper' | 'modify' | 'result' | 'returnType' | 'withData' | 'windows' | 'then' ? T[K] : never; } : { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T & (keyof Where | keyof QueryExpressions | 'table' | 'get' | 'columnTypes' | '__selectable' | 'relations' | 'useHelper' | 'modify' | 'result' | 'returnType' | 'withData' | 'windows' | 'then') ? T[K] : never; };
 type WhereArgs<T extends PickQuerySelectableRelations> = WhereArg<T>[];
 type WhereNotArgs<T extends PickQuerySelectableRelations> = [WhereArg<T>];
 type WhereInColumn<T extends PickQuerySelectableRelations> = keyof T['__selectable'] | [keyof T['__selectable'], ...(keyof T['__selectable'])[]];
-type WhereInValues<T extends PickQuerySelectableRelations, Column> = Column extends keyof T['__selectable'] ? Iterable<T['__selectable'][Column]['column']['__queryType']> | IsQuery | Expression : ({ [I in keyof Column]: Column[I] extends keyof T['__selectable'] ? T['__selectable'][Column[I]]['column']['__queryType'] : never } & {
+type WhereInValues<T extends PickQuerySelectableRelations, Column> = Column extends keyof T['__selectable'] ? Iterable<T['__selectable'][Column]['column']['__queryType']> | IsQuery | Expression : ({ [I in keyof Column]: Column[I] extends keyof T['__selectable'] ? T['__selectable'][Column[I]]['column']['__queryType'] : never; } & {
   length: Column extends {
     length: number;
   } ? Column['length'] : never;
 })[] | IsQuery | Expression;
-type WhereInArg<T extends PickQuerySelectableRelations> = { [K in keyof T['__selectable']]?: Iterable<T['__selectable'][K]['column']['__queryType']> | IsQuery | Expression };
+type WhereInArg<T extends PickQuerySelectableRelations> = { [K in keyof T['__selectable']]?: Iterable<T['__selectable'][K]['column']['__queryType']> | IsQuery | Expression; };
 interface QueryHasWhere {
   __hasWhere: true;
 }
@@ -3900,7 +3891,7 @@ declare class Where {
    * Constructing `WHERE` conditions:
    *
    * ```ts
-   * import { sql } from './baseTable'
+   * import { sql } from './table-factory';
    *
    * db.table.where({
    *   // column of the current table
@@ -3916,7 +3907,7 @@ declare class Where {
    *   },
    *
    *   // where column equals to raw SQL
-   *   // import `sql` from your `BaseTable`
+   *   // import `sql` from your table factory
    *   column: sql`sql expression`,
    *   // or use `(q) => sql` for the same
    *   column2: (q) => sql`sql expression`,
@@ -4513,7 +4504,7 @@ declare class Where {
    */
   orWhereNotExists<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): T & QueryHasWhere;
 }
-type QueryScopes<Keys extends string> = { [K in Keys]: unknown };
+type QueryScopes<Keys extends string> = { [K in Keys]: unknown; };
 interface ScopeArgumentQuery<Table extends string | undefined, Shape extends Column.QueryColumns> extends Where, PickQuerySelectableShapeRelationsWithData {
   __isQuery: true;
   table: Table;
@@ -4526,21 +4517,16 @@ interface ScopeArgumentQuery<Table extends string | undefined, Shape extends Col
  * If you define a scope with name `default`, it will be applied for all table queries by default.
  *
  * ```ts
- * import { BaseTable } from './baseTable';
- *
- * export class SomeTable extends BaseTable {
- *   readonly table = 'some';
- *   columns = this.setColumns((t) => ({
- *     id: t.identity().primaryKey(),
- *     hidden: t.boolean(),
- *     active: t.boolean(),
- *   }));
+ * import { defineTable } from './table-factory';
  *
- *   scopes = this.setScopes({
- *     default: (q) => q.where({ hidden: false }),
- *     active: (q) => q.where({ active: true }),
- *   });
- * }
+ * export const SomeTable = defineTable('some', (t) => ({
+ *   id: t.identity().primaryKey(),
+ *   hidden: t.boolean(),
+ *   active: t.boolean(),
+ * })).scopes({
+ *   default: (q) => q.where({ hidden: false }),
+ *   active: (q) => q.where({ active: true }),
+ * });
  *
  * const db = orchidORM(
  *   { databaseURL: '...' },
@@ -4660,20 +4646,20 @@ interface NonDeletedScope {
  * All queries on such table will filter out deleted records by default.
  *
  * ```ts
- * import { BaseTable } from './baseTable';
- *
- * export class SomeTable extends BaseTable {
- *   readonly table = 'some';
- *   columns = this.setColumns((t) => ({
- *     id: t.identity().primaryKey(),
- *     deletedAt: t.timestamp().nullable(),
- *   }));
+ * import { defineTable } from './table-factory';
  *
+ * export const SomeTable = defineTable('some', (t) => ({
+ *   id: t.identity().primaryKey(),
+ *   deletedAt: t.timestamp().nullable(),
+ * }))
  *   // true is for using `deletedAt` column
- *   readonly softDelete = true;
- *   // or provide a different column name
- *   readonly softDelete = 'myDeletedAt';
- * }
+ *   .softDelete();
+ *
+ * // or provide a different column name
+ * export const OtherTable = defineTable('other', (t) => ({
+ *   id: t.identity().primaryKey(),
+ *   myDeletedAt: t.timestamp().nullable(),
+ * })).softDelete('myDeletedAt');
  *
  * const db = orchidORM(
  *   { databaseURL: '...' },
@@ -4733,9 +4719,11 @@ declare namespace RlsPolicy {
   export {};
 }
 declare namespace Rls {
-  interface TableConfig {
+  interface TableConfigBase {
     enable?: boolean;
     force?: boolean;
+  }
+  interface TableConfig extends TableConfigBase {
     permit: [RlsPolicy.Policy, ...RlsPolicy.Policy[]];
     restrict?: RlsPolicy.Policy[];
   }
@@ -4801,14 +4789,14 @@ declare namespace DefaultPrivileges {
   export {};
 }
 declare const DEFAULT_PRIVILEGE: {
-  OBJECT_TYPES: readonly ["TABLES", "SEQUENCES", "FUNCTIONS", "TYPES", "SCHEMAS", "LARGE_OBJECTS"];
+  OBJECT_TYPES: readonly ['TABLES', 'SEQUENCES', 'FUNCTIONS', 'TYPES', 'SCHEMAS', 'LARGE_OBJECTS'];
   PRIVILEGES: {
-    TABLE: readonly ["ALL", "SELECT", "INSERT", "UPDATE", "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER", "MAINTAIN"];
-    SEQUENCE: readonly ["ALL", "USAGE", "SELECT", "UPDATE"];
-    FUNCTION: readonly ["ALL", "EXECUTE"];
-    TYPE: readonly ["ALL", "USAGE"];
-    SCHEMA: readonly ["ALL", "USAGE", "CREATE"];
-    LARGE_OBJECT: readonly ["ALL", "SELECT", "UPDATE"];
+    TABLE: readonly ['ALL', 'SELECT', 'INSERT', 'UPDATE', 'DELETE', 'TRUNCATE', 'REFERENCES', 'TRIGGER', 'MAINTAIN'];
+    SEQUENCE: readonly ['ALL', 'USAGE', 'SELECT', 'UPDATE'];
+    FUNCTION: readonly ['ALL', 'EXECUTE'];
+    TYPE: readonly ['ALL', 'USAGE'];
+    SCHEMA: readonly ['ALL', 'USAGE', 'CREATE'];
+    LARGE_OBJECT: readonly ['ALL', 'SELECT', 'UPDATE'];
   };
 };
 declare function getSupportedDefaultPrivileges(version: number): DefaultPrivileges.SupportedDefaultPrivileges;
@@ -4987,10 +4975,10 @@ interface QueryInternal<SinglePrimaryKey = any, UniqueColumns = any, UniqueColum
    */
   nestedCreateBatchMax: number;
 }
-type ShapeHasPrimaryKeys<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? K : never }[keyof Shape];
-type TablePrimaryKeys<Shape extends Column.QueryColumnsInit> = ShapeHasPrimaryKeys<Shape> extends never ? never : { [K in ShapeHasPrimaryKeys<Shape>]: UniqueQueryTypeOrExpression<Shape[K]['__queryType']> };
-type ShapeUniqueColumns<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['unique'] extends string ? { [C in K]: UniqueQueryTypeOrExpression<Shape[K]['__queryType']> } : never }[keyof Shape];
-type UniqueConstraints<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? string extends Shape[K]['data']['primaryKey'] ? never : Shape[K]['data']['primaryKey'] : Shape[K]['data']['unique'] extends string ? string extends Shape[K]['data']['unique'] ? never : Shape[K]['data']['unique'] : never }[keyof Shape];
+type ShapeHasPrimaryKeys<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? K : never; }[keyof Shape];
+type TablePrimaryKeys<Shape extends Column.QueryColumnsInit> = ShapeHasPrimaryKeys<Shape> extends never ? never : { [K in ShapeHasPrimaryKeys<Shape>]: UniqueQueryTypeOrExpression<Shape[K]['__queryType']>; };
+type ShapeUniqueColumns<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['unique'] extends string ? { [C in K]: UniqueQueryTypeOrExpression<Shape[K]['__queryType']>; } : never; }[keyof Shape];
+type UniqueConstraints<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? string extends Shape[K]['data']['primaryKey'] ? never : Shape[K]['data']['primaryKey'] : Shape[K]['data']['unique'] extends string ? string extends Shape[K]['data']['unique'] ? never : Shape[K]['data']['unique'] : never; }[keyof Shape];
 type NoPrimaryKeyOption = 'error' | 'warning' | 'ignore';
 interface DbSharedOptions extends QueryLogOptions {
   autoPreparedStatements?: boolean;
@@ -5077,7 +5065,7 @@ interface DbTableOptions<ColumnTypes, Table extends string | undefined, Shape ex
    */
   nowSQL?: string;
 }
-type DbTableOptionScopes<Table extends string | undefined, Shape extends Column.QueryColumns, Keys extends string = string> = { [K in Keys]: (q: ScopeArgumentQuery<Table, Shape>) => IsQuery };
+type DbTableOptionScopes<Table extends string | undefined, Shape extends Column.QueryColumns, Keys extends string = string> = { [K in Keys]: (q: ScopeArgumentQuery<Table, Shape>) => IsQuery; };
 interface QueryBuilder extends Query.NotReadOnlyQuery {
   returnType: undefined;
 }
@@ -5096,14 +5084,14 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
   } ? true : undefined;
   __hasSelect: boolean;
   __hasWhere: boolean;
-  __defaults: { [K in { [K in keyof Shape]: Shape[K]['data']['default'] extends true ? K : never }[keyof Shape]]: true };
-  __scopes: { [K in keyof MapTableScopesOption<Options>]: true };
+  __defaults: { [K in { [K in keyof Shape]: Shape[K]['data']['default'] extends true ? K : never; }[keyof Shape]]: true; };
+  __scopes: { [K in keyof MapTableScopesOption<Options>]: true; };
   __defaultSelect: ColumnsShape.DefaultSelectKeys<Shape>;
   baseQuery: Query;
   columns: (keyof Shape)[];
   __outputType: ColumnsShape.DefaultSelectOutput<Shape>;
   __inputType: ColumnsShape.Input<Shape>;
-  result: { [K in ColumnsShape.DefaultSelectKeys<Shape>]: Shape[K] };
+  result: { [K in ColumnsShape.DefaultSelectKeys<Shape>]: Shape[K]; };
   returnType: undefined;
   then: QueryThenShallowSimplifyArr<ColumnsShape.DefaultOutput<Shape>>;
   windows: EmptyObject;
@@ -5113,7 +5101,7 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
   relationQueries: EmptyObject;
   withData: EmptyObject;
   error: new (message: string, length: number, name: QueryErrorName) => QueryError<this>;
-  internal: QueryInternal<TablePrimaryKeys<Shape> extends never ? never : { [K in keyof TablePrimaryKeys<Shape>]: (keyof TablePrimaryKeys<Shape> extends K ? never : keyof TablePrimaryKeys<Shape>) extends never ? TablePrimaryKeys<Shape>[K] : never }[keyof TablePrimaryKeys<Shape>], TablePrimaryKeys<Shape> | ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, { [K in keyof Shape]: Shape[K]['data']['unique'] extends string ? K : never }[keyof Shape] | keyof TablePrimaryKeys<Shape>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>>;
+  internal: QueryInternal<TablePrimaryKeys<Shape> extends never ? never : { [K in keyof TablePrimaryKeys<Shape>]: (keyof TablePrimaryKeys<Shape> extends K ? never : keyof TablePrimaryKeys<Shape>) extends never ? TablePrimaryKeys<Shape>[K] : never; }[keyof TablePrimaryKeys<Shape>], TablePrimaryKeys<Shape> | ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, { [K in keyof Shape]: Shape[K]['data']['unique'] extends string ? K : never; }[keyof Shape] | keyof TablePrimaryKeys<Shape>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>>;
   catch: QueryCatch;
   shape: ComputedColumnsFromOptions<Shape, Options>;
   constructor(adapterNotInTransaction: Adapter, qb: QueryBuilder, table: Table | undefined, shape: ComputedColumnsFromOptions<Shape, Options>, columnTypes: ColumnTypes, asyncStorage: AsyncLocalStorage<AsyncState>, options: DbTableOptions<ColumnTypes, Table, ComputedColumnsFromOptions<Shape, Options>>, tableData?: TableData, viewData?: QueryInternal['viewData']);
@@ -5287,15 +5275,7 @@ interface DbResult<ColumnTypes> extends Db<undefined, EmptyObject, never, Column
  * })
  * ```
  */
-declare const createDbWithAdapter: <SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({
-  log,
-  logger,
-  snakeCase,
-  schemaConfig: schemaConfigFn,
-  columnTypes,
-  schema,
-  ...options
-}: DbOptionsWithAdapter<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
+declare const createDbWithAdapter: <SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ log, logger, snakeCase, schemaConfig: schemaConfigFn, columnTypes, schema, ...options }: DbOptionsWithAdapter<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
 declare function _createDbSqlMethod<ColumnTypes>(columnTypes: ColumnTypes): DbSqlMethod<ColumnTypes>;
 declare const _initQueryBuilder: (adapter: Adapter, columnTypes: unknown, asyncStorage: AsyncLocalStorage<AsyncState>, commonOptions: DbTableOptions<unknown, undefined, Column.QueryColumns>, options: DbSharedOptions) => Db;
 type SQLQueryArgs = TemplateLiteralArgs | [RawSqlBase];
@@ -5379,7 +5359,12 @@ declare class RawSql<T extends Column.Pick.QueryColumn = Column.Pick.QueryColumn
   makeSQL(ctx: ToSqlValues, quotedAs?: string): string;
 }
 declare const isRawSQL: (arg: unknown) => arg is RawSqlBase;
-declare const rawSqlToCode: (rawSql: RawSqlBase, t: string) => string;
+interface RawSqlToCodeCtx {
+  t: string;
+  sql?: string;
+  isSqlUsed?: boolean;
+}
+declare const rawSqlToCode: (rawSql: RawSqlBase, ctx: string | RawSqlToCodeCtx) => string;
 interface DynamicRawSQL<T extends Column.Pick.QueryColumn> extends Expression<T>, ExpressionTypeMethod {}
 declare class DynamicRawSQL<T extends Column.Pick.QueryColumn, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>> extends Expression<T> {
   fn: DynamicSQLArg<T>;
@@ -5501,14 +5486,14 @@ declare const rawSqlToSql: (sql: string | RawSqlBase) => SingleSql;
 declare const sqlToRawSql: (sql: SingleSql) => RawSqlBase;
 declare class QuerySql<ColumnTypes> {
   /**
-   * @deprecated: use `sql` exported from the `createBaseTable` (see "define a base table" in the docs)
+   * @deprecated: use `sql` exported from the table factory file.
    *
-   * When there is a need to use a piece of raw SQL, use the `sql` exported from the `BaseTable` file, it is also attached to query objects for convenience.
+   * When there is a need to use a piece of raw SQL, use the `sql` exported from the table factory file, it is also attached to query objects for convenience.
    *
    * When selecting a custom SQL, specify a resulting type with `<generic>` syntax:
    *
    * ```ts
-   * import { sql } from './baseTable';
+   * import { sql } from './table-factory';
    *
    * const result: { num: number }[] = await db.table.select({
    *   num: sql<number>`random() * 100`,
@@ -5520,7 +5505,7 @@ declare class QuerySql<ColumnTypes> {
    * This example assumes that the `timestamp` column was overridden with `asDate` as shown in [Override column types](/guide/columns-overview#override-column-types).
    *
    * ```ts
-   * import { sql } from './baseTable';
+   * import { sql } from './table-factory';
    *
    * const result: { timestamp: Date }[] = await db.table.select({
    *   timestamp: sql`now()`.type((t) => t.timestamp()),
@@ -5670,7 +5655,7 @@ interface TopCTE {
   append: string[][];
 }
 declare const addTopCteSql: (ctx: ToSQLCtx, as: string | undefined, sql: string) => string;
-declare const addTopCte: (place: "before" | "after", ctx: ToSQLCtx, q: SubQueryForSql, type: QueryData["type"], as?: string | ((as: string) => void), dontAddTableHook?: boolean) => string;
+declare const addTopCte: (place: 'before' | 'after', ctx: ToSQLCtx, q: SubQueryForSql, type: QueryData['type'], as?: string | ((as: string) => void), dontAddTableHook?: boolean) => string;
 /**
  * Function to turn the operator expression into SQL.
  *
@@ -5685,7 +5670,7 @@ interface OperatorToSQL {
 interface Operator<Value, Column extends Column.Pick.OutputTypeAndOperators = Column.Pick.OutputTypeAndOperators> {
   <T extends PickQueryResult>(this: T, arg: Value): { [K in Exclude<keyof T, keyof T['result']['value']['operators']>]: K extends 'result' ? {
     value: Column;
-  } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['__outputType']> : T[K] } & Column['operators'];
+  } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['__outputType']> : T[K]; } & Column['operators'];
   _opType: Value;
 }
 interface Base$1<Value> {
@@ -5905,7 +5890,7 @@ interface OperatorsArray<T> extends Ord<T[]> {
   hasSome: Operator<T[] | IsQuery | Expression, BooleanQueryColumn>;
   containedIn: Operator<T[] | IsQuery | Expression, BooleanQueryColumn>;
   length: {
-    _opType: number | { [K in Exclude<keyof OperatorsNumber, '__hasSelect'>]?: OperatorsNumber[K]['_opType'] };
+    _opType: number | { [K in Exclude<keyof OperatorsNumber, '__hasSelect'>]?: OperatorsNumber[K]['_opType']; };
   };
 }
 declare const Operators: {
@@ -5923,24 +5908,24 @@ interface ColumnsShape {
   [K: string]: Column;
 }
 declare namespace ColumnsShape {
-  export type DefaultSelectKeys<S extends Column.QueryColumnsInit> = { [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof S];
-  export type DefaultOutput<Set extends Column.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['__outputType'] };
-  export type Input<Shape extends Column.QueryColumnsInit, AppReadOnly = { [K in keyof Shape]: Shape[K]['data']['appReadOnly'] extends true ? K : never }[keyof Shape], Optional extends keyof Shape = { [K in keyof Shape]: Shape[K]['data']['optional'] extends true ? K : never }[keyof Shape]> = { [K in Exclude<keyof Shape, AppReadOnly | Optional>]: Shape[K]['__inputType'] } & { [K in Exclude<Optional, AppReadOnly>]?: Shape[K]['__inputType'] };
-  export type InputPartial<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['__inputType'] };
-  export type Output<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
-  export type DefaultSelectOutput<Shape extends Column.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof Shape]]: Shape[K]['__outputType'] };
+  export type DefaultSelectKeys<S extends Column.QueryColumnsInit> = { [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K; }[keyof S];
+  export type DefaultOutput<Set extends Column.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['__outputType']; };
+  export type Input<Shape extends Column.QueryColumnsInit, AppReadOnly = { [K in keyof Shape]: Shape[K]['data']['appReadOnly'] extends true ? K : never; }[keyof Shape], Optional extends keyof Shape = { [K in keyof Shape]: Shape[K]['data']['optional'] extends true ? K : never; }[keyof Shape]> = { [K in Exclude<keyof Shape, AppReadOnly | Optional>]: Shape[K]['__inputType']; } & { [K in Exclude<Optional, AppReadOnly>]?: Shape[K]['__inputType']; };
+  export type InputPartial<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['__inputType']; };
+  export type Output<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType']; };
+  export type DefaultSelectOutput<Shape extends Column.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K; }[keyof Shape]]: Shape[K]['__outputType']; };
   export interface MapToObjectColumn<Shape extends Column.QueryColumns> {
     dataType: 'object';
-    __type: { [K in keyof Shape]: Shape[K]['__type'] };
+    __type: { [K in keyof Shape]: Shape[K]['__type']; };
     __outputType: ShallowSimplify<ObjectOutput<Shape>>;
-    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] };
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType']; };
     operators: OperatorsAny;
   }
   export interface MapToNullableObjectColumn<Shape extends Column.QueryColumns> {
     dataType: 'object';
-    __type: { [K in keyof Shape]: Shape[K]['__type'] };
+    __type: { [K in keyof Shape]: Shape[K]['__type']; };
     __outputType: ShallowSimplify<ObjectOutput<Shape>> | undefined;
-    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] } | null;
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType']; } | null;
     operators: OperatorsAny;
   }
   export interface MapToPluckColumn<Shape extends Column.QueryColumns> {
@@ -5952,12 +5937,12 @@ declare namespace ColumnsShape {
   }
   export interface MapToObjectArrayColumn<Shape extends Column.QueryColumns> {
     dataType: 'array';
-    __type: { [K in keyof Shape]: Shape[K]['__type'] }[];
+    __type: { [K in keyof Shape]: Shape[K]['__type']; }[];
     __outputType: ShallowSimplify<ObjectOutput<Shape>>[];
-    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] }[];
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType']; }[];
     operators: OperatorsAny;
   }
-  type ObjectOutput<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
+  type ObjectOutput<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType']; };
   export {};
 }
 interface SelectSelf extends PickQuerySelectable, PickQueryHasSelect, PickQueryDefaultSelect, PickQueryShape, PickQueryRelations, PickQueryResult, PickQueryReturnType, PickQueryWithData {}
@@ -5965,7 +5950,7 @@ type SelectArgs<T extends SelectSelf> = ('*' | keyof T['__selectable'])[];
 interface SubQueryAddition<T extends PickQueryWithData> extends IsSubQuery {
   withData: T['withData'];
 }
-type SelectAsFnArg<T extends PickQueryRelationsWithData> = EmptyObject extends T['relations'] ? T : { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? RelationQueryMaybeSingle<T['relations'][K]> & SubQueryAddition<T> : K extends keyof T ? T[K] : never };
+type SelectAsFnArg<T extends PickQueryRelationsWithData> = EmptyObject extends T['relations'] ? T : { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? RelationQueryMaybeSingle<T['relations'][K]> & SubQueryAddition<T> : K extends keyof T ? T[K] : never; };
 interface SelectAsArg<T extends SelectSelf> {
   [K: string]: keyof T['__selectable'] | Expression | ((q: SelectAsFnArg<T>) => unknown);
 }
@@ -5977,10 +5962,10 @@ interface SelectAsCheckReturnTypes {
   [K: string]: PropertyKey | Expression | ((q: never) => SelectAsFnReturnType);
 }
 type SelectReturnType<T extends PickQueryReturnType> = T['returnType'] extends 'valueOrThrow' ? 'oneOrThrow' : T extends 'value' ? 'one' : T['returnType'] extends 'pluck' ? 'all' : T['returnType'];
-type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K] };
-type SelectResultObj<T extends SelectSelf, Obj> = Obj extends SelectAsCheckReturnTypes ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never } : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never }> : T[K] } : `Invalid return type of ${{ [K in keyof Obj]: Obj[K] extends ((...args: any[]) => any) ? ReturnType<Obj[K]> extends SelectAsFnReturnType ? never : K : never }[keyof Obj] & string}`;
-type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
-{ [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K] };
+type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column']; } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column']; } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K]; };
+type SelectResultObj<T extends SelectSelf, Obj> = Obj extends SelectAsCheckReturnTypes ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never; } : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never; }> : T[K]; } : `Invalid return type of ${{ [K in keyof Obj]: Obj[K] extends ((...args: any[]) => any) ? ReturnType<Obj[K]> extends SelectAsFnReturnType ? never : K : never; }[keyof Obj] & string}`;
+type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' // Combine previously selected items, all columns if * was provided,
+ ? { [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column']; } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column']; } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K]; };
 interface AllowedRelationOneQueryForSelectable extends IsSubQuery {
   result: Column.QueryColumns;
   returnType: 'value' | 'valueOrThrow' | 'one' | 'oneOrThrow';
@@ -5988,7 +5973,7 @@ interface AllowedRelationOneQueryForSelectable extends IsSubQuery {
 type SelectAsSelectable<Obj> = UnionToIntersection<{ [K in keyof Obj]: Obj[K] extends ((q: never) => infer R extends AllowedRelationOneQueryForSelectable) ? { [C in R['returnType'] extends 'value' | 'valueOrThrow' ? K : keyof R['result'] as R['returnType'] extends 'value' | 'valueOrThrow' ? K : `${K & string}.${C & string}`]: {
   as: C;
   column: R['returnType'] extends 'value' | 'valueOrThrow' ? R['result']['value'] : R['result'][C & keyof R['result']];
-} } : never }[keyof Obj]>;
+}; } : never; }[keyof Obj]>;
 type SelectAsValueResult<T extends SelectSelf, Arg> = Arg extends keyof T['__selectable'] ? T['__selectable'][Arg]['column'] : Arg extends Expression ? Arg['result']['value'] : Arg extends ((q: never) => IsQuery) ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends ((q: never) => Expression) ? ReturnType<Arg>['result']['value'] : Arg extends ((q: never) => IsQuery | Expression) ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression>> | Exclude<ReturnType<Arg>, IsQuery>['result']['value'] : never;
 type SelectSubQueryResult<Arg extends SelectSelf> = Arg['returnType'] extends undefined | 'all' ? ColumnsShape.MapToObjectArrayColumn<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShape.MapToPluckColumn<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShape.MapToNullableObjectColumn<Arg['result']> : ColumnsShape.MapToObjectColumn<Arg['result']>;
 declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>>(q: T, columns: Columns): SelectResult<T, Columns>;
@@ -6094,15 +6079,6 @@ type QueryDataTransform = QueryDataTransformFn | {
 interface QueryDataTransformFn {
   (data: unknown, queryData: unknown): unknown;
 }
-/**
- * See `transform` query method.
- * This helper applies all transform functions to a result.
- *
- * @param queryData - query data
- * @param returnType - return type of the query, for proper `map` handling
- * @param fns - array of transform functions, can be undefined
- * @param result - query result to transform
- */
 declare class QueryTransform {
   /**
    * Transform the result of the query right after loading it.
@@ -6161,7 +6137,7 @@ declare class QueryTransform {
     then: QueryThen<infer Data>;
   } ? Data : never, queryData: QueryData) => Result): { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
     value: Column.Pick.QueryColumnOfType<Result>;
-  } : K extends 'then' ? QueryThen<Result> : T[K] };
+  } : K extends 'then' ? QueryThen<Result> : T[K]; };
 }
 type SelectableOrExpression<T extends PickQuerySelectable = PickQuerySelectable, C extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> = '*' | keyof T['__selectable'] | Expression<C>;
 type SelectableOrExpressions<T extends PickQuerySelectable = PickQuerySelectable, C extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> = ('*' | keyof T['__selectable'] | Expression<C>)[];
@@ -6219,7 +6195,8 @@ declare abstract class ExpressionTypeMethod {
       expr?: Expression;
     };
     columnTypes: unknown;
-  }, C extends Column.Pick.QueryColumn>(this: T, fn: (types: T['columnTypes']) => C): // Omit is optimal
+  }, C extends Column.Pick.QueryColumn>(this: T, fn: (types: T['columnTypes']) => C):
+  // Omit is optimal
   Omit<T, 'result'> & {
     result: {
       value: C;
@@ -6297,24 +6274,19 @@ type AfterCommitErrorResult = AfterCommitErrorFulfilledResult | AfterCommitError
  * so later they can be identified when handling after commit errors.
  *
  * ```ts
- * class SomeTable extends BaseTable {
- *   readonly table = 'someTable';
- *   columns = this.setColumns((t) => ({
- *     ...someColumns,
- *   }));
- *
- *   init(orm: typeof db) {
- *     // anonymous funciton - has no name
- *     this.afterCreateCommit([], async () => {
- *       // ...
- *     });
+ * export const SomeTable = defineTable('someTable', (t) => ({
+ *   ...someColumns,
+ * })).init((orm: typeof db, hooks) => {
+ *   // anonymous funciton - has no name
+ *   hooks.afterCreateCommit([], async () => {
+ *     // ...
+ *   });
  *
- *     // named function
- *     this.afterCreateCommit([], function myHook() => {
- *       // ...
- *     });
- *   }
- * }
+ *   // named function
+ *   hooks.afterCreateCommit([], function myHook() {
+ *     // ...
+ *   });
+ * });
  * ```
  */
 declare class AfterCommitError extends OrchidOrmError {
@@ -6553,7 +6525,7 @@ declare class QueryTransaction {
    */
   recoverable<T>(this: T): T;
 }
-type AfterHook<Select extends PropertyKey[], Shape extends Column.QueryColumns> = QueryAfterHook<{ [K in Select[number]]: K extends keyof Shape ? Shape[K]['__outputType'] : never }[]>;
+type AfterHook<Select extends PropertyKey[], Shape extends Column.QueryColumns> = QueryAfterHook<{ [K in Select[number]]: K extends keyof Shape ? Shape[K]['__outputType'] : never; }[]>;
 type HookSelectArg<T extends PickQueryShape> = (keyof T['shape'] & string)[];
 declare const _hookSelectColumns: (query: Query, columns: string[], asFn: (as: string[]) => void) => void;
 declare class QueryHookUtils<T extends PickQueryInputType> {
@@ -6561,10 +6533,10 @@ declare class QueryHookUtils<T extends PickQueryInputType> {
   columns: string[];
   private key;
   constructor(query: IsQuery, columns: string[], key: 'hookCreateSet' | 'hookUpdateSet');
-  set: (data: { [K in keyof T["__inputType"]]?: T["__inputType"][K] | (() => QueryOrExpression<T["__inputType"][K]>) }) => void;
+  set: (data: { [K in keyof T['__inputType']]?: T['__inputType'][K] | (() => QueryOrExpression<T['__inputType'][K]>); }) => void;
 }
-declare const _queryHookAfterCreate: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T["shape"]>) => T;
-declare const _queryHookAfterUpdate: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T["shape"]>) => T;
+declare const _queryHookAfterCreate: (q: PickQueryShape, select: HookSelectArg<PickQueryShape>, cb: AfterHook<HookSelectArg<PickQueryShape>, Column.QueryColumns>) => PickQueryShape;
+declare const _queryHookAfterUpdate: (q: PickQueryShape, select: HookSelectArg<PickQueryShape>, cb: AfterHook<HookSelectArg<PickQueryShape>, PickQueryShape['shape']>) => PickQueryShape;
 declare abstract class QueryHooks {
   /**
    * Run the function before any kind of query.
@@ -6714,47 +6686,44 @@ interface ColumnDataSelectSqlProp {
 interface SelectSqlCallback {
   (column: ColumnRefExpression<Column.Pick.QueryColumn>): Expression;
 }
-type SelectSqlColumn<T extends Column.Pick.DataAndDataType, Expr extends Expression> = unknown extends Expr['result']['value']['__outputType'] ? T : { [K in keyof T]: K extends '__outputType' ? Expr['result']['value']['__outputType'] : T[K] };
+type SelectSqlColumn<T extends Column.Pick.DataAndDataType, Expr extends Expression> = unknown extends Expr['result']['value']['__outputType'] ? T : { [K in keyof T]: K extends '__outputType' ? Expr['result']['value']['__outputType'] : T[K]; };
 declare namespace Column {
-  export namespace Modifiers {
-    export interface IsPrimaryKey<Name extends string> {
-      data: {
-        primaryKey: Name;
-      };
-    }
-    export type IsUnique<Name extends string> = {
-      data: {
-        unique: Name;
-      };
+  export interface IsPrimaryKey<Name extends string> {
+    data: {
+      primaryKey: Name;
     };
-    export type Nullable<T extends Column.Pick.ForNullable> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends '__queryType' ? T['__queryType'] | null : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K] } : T[K] };
-    export type NullableWithSchema<T extends Column.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends 'inputSchema' ? InputSchema : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends 'outputSchema' ? OutputSchema : K extends '__queryType' ? T['__queryType'] | null : K extends 'querySchema' ? QuerySchema : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K] } : T[K] };
-    export type QueryColumnToNullable<C> = { [K in keyof C]: K extends '__outputType' | '__queryType' ? C[K] | null : C[K] };
-    export type QueryColumnToOptional<C> = { [K in keyof C]: K extends '__outputType' ? C[K] | undefined : C[K] };
-    interface DataNullable {
-      isNullable: true;
-      optional: true;
-    }
-    export interface OperatorsNullable<Column extends Column.Pick.QueryColumn> {
-      equals: Operator<Column['__queryType'] | null, Column>;
-      not: Operator<Column['__queryType'] | null, Column>;
-      isDistinctFrom: Operator<Column['__queryType'] | null, Column>;
-      isNotDistinctFrom: Operator<Column['__queryType'] | null, Column>;
-    }
-    export type Encode<T, InputSchema, Input> = { [K in keyof T]: K extends '__inputType' ? Input : K extends 'inputSchema' ? InputSchema : T[K] };
-    export type Parse<T extends Pick.ForParse, OutputSchema, Output> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? (Output extends null ? never : Output) | (unknown extends T['__nullType'] ? null : T['__nullType']) : Output : K extends 'outputSchema' ? null extends T['__type'] ? OutputSchema | T['nullSchema'] : OutputSchema : T[K] };
-    export type ParseNull<T extends Column.Pick.ForParseNull, NullSchema, NullType> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? Exclude<T['__outputType'], null> | NullType : T['__outputType'] : K extends '__nullType' ? NullType : K extends 'outputSchema' ? null extends T['__type'] ? T['outputSchema'] | NullSchema : T['outputSchema'] : K extends 'nullSchema' ? NullSchema : T[K] };
-    export type HasDefault<T extends Column.Pick.Data> = T & Column.Data.Default;
-    type DefaultSelectData<T extends Column.Data, Value> = { [K in keyof T]: K extends 'explicitSelect' ? Value extends true ? false : true : T[K] };
-    export type DefaultSelect<T extends Column.Pick.Data, Value extends boolean> = { [K in keyof T]: K extends 'data' ? DefaultSelectData<T['data'], Value> : T[K] };
-    export interface IsAppReadOnly {
-      data: {
-        appReadOnly: true;
-      };
-    }
-    export type Generated<T extends Column.Pick.Data> = { [K in keyof T]: K extends 'data' ? { [K in keyof T['data']]: K extends 'default' ? true : T['data'][K] } : K extends '__inputType' ? never : T[K] };
-    export {};
   }
+  export type IsUnique<Name extends string> = {
+    data: {
+      unique: Name;
+    };
+  };
+  export type Nullable<T extends Column.Pick.ForNullable> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends '__queryType' ? T['__queryType'] | null : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K]; } : T[K]; };
+  export type NullableWithSchema<T extends Column.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends 'inputSchema' ? InputSchema : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends 'outputSchema' ? OutputSchema : K extends '__queryType' ? T['__queryType'] | null : K extends 'querySchema' ? QuerySchema : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K]; } : T[K]; };
+  export type QueryColumnToNullable<C> = { [K in keyof C]: K extends '__outputType' | '__queryType' ? C[K] | null : C[K]; };
+  export type QueryColumnToOptional<C> = { [K in keyof C]: K extends '__outputType' ? C[K] | undefined : C[K]; };
+  interface DataNullable {
+    isNullable: true;
+    optional: true;
+  }
+  export interface OperatorsNullable<Column extends Column.Pick.QueryColumn> {
+    equals: Operator<Column['__queryType'] | null, Column>;
+    not: Operator<Column['__queryType'] | null, Column>;
+    isDistinctFrom: Operator<Column['__queryType'] | null, Column>;
+    isNotDistinctFrom: Operator<Column['__queryType'] | null, Column>;
+  }
+  export type Encode<T, InputSchema, Input> = { [K in keyof T]: K extends '__inputType' ? Input : K extends 'inputSchema' ? InputSchema : T[K]; };
+  export type Parse<T extends Pick.ForParse, OutputSchema, Output> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? (Output extends null ? never : Output) | (unknown extends T['__nullType'] ? null : T['__nullType']) : Output : K extends 'outputSchema' ? null extends T['__type'] ? OutputSchema | T['nullSchema'] : OutputSchema : T[K]; };
+  export type ParseNull<T extends Column.Pick.ForParseNull, NullSchema, NullType> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? Exclude<T['__outputType'], null> | NullType : T['__outputType'] : K extends '__nullType' ? NullType : K extends 'outputSchema' ? null extends T['__type'] ? T['outputSchema'] | NullSchema : T['outputSchema'] : K extends 'nullSchema' ? NullSchema : T[K]; };
+  export type HasDefault<T extends Column.Pick.Data> = T & Column.Data.Default;
+  type DefaultSelectData<T extends Column.Data, Value> = { [K in keyof T]: K extends 'explicitSelect' ? Value extends true ? false : true : T[K]; };
+  export type DefaultSelect<T extends Column.Pick.Data, Value extends boolean> = { [K in keyof T]: K extends 'data' ? DefaultSelectData<T['data'], Value> : T[K]; };
+  export interface IsAppReadOnly {
+    data: {
+      appReadOnly: true;
+    };
+  }
+  export type Generated<T extends Column.Pick.Data> = { [K in keyof T]: K extends 'data' ? { [K in keyof T['data']]: K extends 'default' ? true : T['data'][K]; } : K extends '__inputType' ? never : T[K]; };
   export namespace Pick {
     interface Data {
       data: Column.Data;
@@ -6845,12 +6814,39 @@ declare namespace Column {
       schema?: string;
       table: string;
       nameInDb?: string;
-      columns: PickQueryShape;
+      columns: {
+        shape: unknown;
+      };
+    }
+    interface TableParamInstanceInput {
+      schema?: QuerySchema;
+      table?: string;
+      nameInDb?: string;
+      columns: {
+        shape: unknown;
+      };
     }
-    interface TableParam {
-      new (): TableParamInstance;
+    interface TableParamWithInstance {
+      instance(): TableParamInstanceInput;
     }
-    type ColumnNameOfTable<Table extends Column.ForeignKey.TableParam> = Table extends (new () => {
+    interface TableParamWithData {
+      data: {
+        columns: unknown;
+      };
+      instance(): TableParamInstanceInput;
+    }
+    type TableParam = (new () => TableParamInstance) | TableParamWithInstance | TableParamWithData;
+    type ColumnNameOfTable<Table extends Column.ForeignKey.TableParam> = Table extends {
+      data: {
+        columns: infer R;
+      };
+    } ? keyof R : Table extends {
+      instance(): {
+        columns: {
+          shape: infer R;
+        };
+      };
+    } ? keyof R : Table extends (new () => {
       columns: {
         shape: infer R;
       };
@@ -6968,8 +6964,8 @@ declare namespace Column {
   export type AsTypeArg<Schema> = AsTypeArgWithType<Schema> | AsTypeArgWithoutType<Schema>;
   export {};
 }
-declare function makeColumnNullable<T extends Column.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema>(column: T, inputSchema: InputSchema, outputSchema: OutputSchema, querySchema: QuerySchema): Column.Modifiers.NullableWithSchema<T, InputSchema, OutputSchema, QuerySchema>;
-declare const setColumnData: <T extends Column.Pick.Data, K extends keyof T["data"]>(q: T, key: K, value: T["data"][K]) => T;
+declare function makeColumnNullable<T extends Column.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema>(column: T, inputSchema: InputSchema, outputSchema: OutputSchema, querySchema: QuerySchema): Column.NullableWithSchema<T, InputSchema, OutputSchema, QuerySchema>;
+declare const setColumnData: <T extends Column.Pick.Data, K extends keyof T['data']>(q: T, key: K, value: T['data'][K]) => T;
 declare const setDataValue: <T extends Column.Pick.Data, Key extends string, Value>(item: T, key: Key, value: Value, params?: Column.Error.StringOrMessage) => T;
 declare function setCurrentColumnName(name: string): void;
 declare const consumeColumnName: () => string | undefined;
@@ -7000,31 +6996,28 @@ declare abstract class Column {
    * Or you can specify a callback that returns a value. This function will be called for each creating record. Such a default won't be applied to a database.
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     // values as defaults:
-   *     int: t.integer().default(123),
-   *     text: t.text().default('text'),
+   * export const Table = defineTable('table', (t) => ({
+   *   // values as defaults:
+   *   int: t.integer().default(123),
+   *   text: t.text().default('text'),
    *
-   *     // raw SQL default:
-   *     timestamp: t.timestamp().default(t.sql`now()`),
+   *   // raw SQL default:
+   *   timestamp: t.timestamp().default(t.sql`now()`),
    *
-   *     // runtime default, each new records gets a new random value:
-   *     random: t.numeric().default(() => Math.random()),
-   *   }));
-   * }
+   *   // runtime default, each new records gets a new random value:
+   *   random: t.numeric().default(() => Math.random()),
+   * }));
    * ```
    *
    * @param value - default value or a function returning a value
    */
-  default<T extends Column.Pick.DataAndInputType, Value extends T['__inputType'] | null | RawSqlBase | (() => T['__inputType'])>(this: T, value: Value): Column.Modifiers.HasDefault<T>;
+  default<T extends Column.Pick.DataAndInputType, Value extends T['__inputType'] | null | RawSqlBase | (() => T['__inputType'])>(this: T, value: Value): Column.HasDefault<T>;
   /**
    * Use `hasDefault` to let the column be omitted when creating records.
    *
    * It's better to use {@link default} instead so the value is explicit and serves as a hint.
    */
-  hasDefault<T extends Column.Pick.Data>(this: T): Column.Modifiers.HasDefault<T>;
+  hasDefault<T extends Column.Pick.Data>(this: T): Column.HasDefault<T>;
   /**
    * Set a database-level validation check to a column. `check` accepts a raw SQL.
    *
@@ -7056,12 +7049,9 @@ declare abstract class Column {
    * Nullable columns are optional when creating records.
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     name: t.integer().nullable(),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   name: t.integer().nullable(),
+   * }));
    * ```
    */
   nullable: this['__schema']['nullable'];
@@ -7076,21 +7066,18 @@ declare abstract class Column {
    * ```ts
    * import { z } from 'zod';
    *
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     // encode boolean, number, or string to text before saving
-   *     column: t
-   *       .string()
-   *       // when having validation library, the first argument is a validation schema
-   *       .encode(
-   *         z.boolean().or(z.number()).or(z.string()),
-   *         (input: boolean | number | string) => String(input),
-   *       )
-   *       // no schema argument otherwise
-   *       .encode((input: boolean | number | string) => String(input)),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   // encode boolean, number, or string to text before saving
+   *   column: t
+   *     .string()
+   *     // when having validation library, the first argument is a validation schema
+   *     .encode(
+   *       z.boolean().or(z.number()).or(z.string()),
+   *       (input: boolean | number | string) => String(input),
+   *     )
+   *     // no schema argument otherwise
+   *     .encode((input: boolean | number | string) => String(input)),
+   * }));
    *
    * // numbers and booleans will be converted to a string:
    * await db.table.create({ column: 123 });
@@ -7115,22 +7102,19 @@ declare abstract class Column {
    * import { z } from 'zod';
    * import { number, integer } from 'valibot';
    *
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     columnZod: t
-   *       .string()
-   *       // when having validation library, the first argument is a schema
-   *       .parse(z.number().int(), (input) => parseInt(input))
-   *       // no schema argument otherwise
-   *       .parse((input) => parseInt(input)),
-   *
-   *     columnValibot: t
-   *       .string()
-   *       .parse(number([integer()]), (input) => parseInt(input))
-   *       .parse((input) => parseInt(input)),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   columnZod: t
+   *     .string()
+   *     // when having validation library, the first argument is a schema
+   *     .parse(z.number().int(), (input) => parseInt(input))
+   *     // no schema argument otherwise
+   *     .parse((input) => parseInt(input)),
+   *
+   *   columnValibot: t
+   *     .string()
+   *     .parse(number([integer()]), (input) => parseInt(input))
+   *     .parse((input) => parseInt(input)),
+   * }));
    *
    * // column will be parsed to a number
    * const value: number = await db.table.get('column');
@@ -7145,16 +7129,13 @@ declare abstract class Column {
    * The `parseNull` function is only triggered for `nullable` columns.
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     column: t
-   *       .integer()
-   *       .parse(String) // parse non-nulls to string
-   *       .parseNull(() => false), // replace nulls with false
-   *       .nullable(),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   column: t
+   *     .integer()
+   *     .parse(String) // parse non-nulls to string
+   *     .parseNull(() => false), // replace nulls with false
+   *     .nullable(),
+   * }));
    *
    * const record = await db.table.take()
    * record.column // can be a string or boolean, not null
@@ -7164,23 +7145,20 @@ declare abstract class Column {
    * first argument is a schema for validating the output.
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     column: t
-   *       .integer()
-   *       .parse(z.string(), String) // parse non-nulls to string
-   *       .parseNull(z.literal(false), () => false), // replace nulls with false
+   * export const Table = defineTable('table', (t) => ({
+   *   column: t
+   *     .integer()
+   *     .parse(z.string(), String) // parse non-nulls to string
+   *     .parseNull(z.literal(false), () => false) // replace nulls with false
    *     .nullable(),
-   *   }));
-   * }
+   * }));
    *
-   * const record = await db.table.take()
-   * record.column // can be a string or boolean, not null
+   * const record = await db.table.take();
+   * record.column; // can be a string or boolean, not null
    *
    * Table.outputSchema().parse({
    *   column: false, // the schema expects strings or `false` literals, not nulls
-   * })
+   * });
    * ```
    */
   parseNull: this['__schema']['parseNull'];
@@ -7222,12 +7200,9 @@ declare abstract class Column {
    * When _not_ integrating with [validation libraries](/guide/columns-validation-methods), `narrowType` has the following syntax:
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     size: t.string().narrowType((t) => t<'small' | 'medium' | 'large'>()),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   size: t.string().narrowType((t) => t<'small' | 'medium' | 'large'>()),
+   * }));
    *
    * // size will be typed as 'small' | 'medium' | 'large'
    * const size = await db.table.get('size');
@@ -7246,12 +7221,9 @@ declare abstract class Column {
    *   z.literal('large'),
    * ]);
    *
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     size: t.text().narrowType(sizeSchema),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   size: t.text().narrowType(sizeSchema),
+   * }));
    *
    * // size will be typed as 'small' | 'medium' | 'large'
    * const size = await db.table.get('size');
@@ -7268,21 +7240,18 @@ declare abstract class Column {
    * When _not_ integrating with [validation libraries](/guide/columns-validation-methods), `narrowAllTypes` has the following syntax:
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     size: t.string().narrowAllTypes((t) =>
-   *       t<{
-   *         // what types are accepted when creating/updating
-   *         input: 'small' | 'medium' | 'large';
-   *         // how types are retured from a database
-   *         output: 'small' | 'medium' | 'large';
-   *         // what types the column accepts in `where` and similar
-   *         query: 'small' | 'medium' | 'large';
-   *       }>(),
-   *     ),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   size: t.string().narrowAllTypes((t) =>
+   *     t<{
+   *       // what types are accepted when creating/updating
+   *       input: 'small' | 'medium' | 'large';
+   *       // how types are retured from a database
+   *       output: 'small' | 'medium' | 'large';
+   *       // what types the column accepts in `where` and similar
+   *       query: 'small' | 'medium' | 'large';
+   *     }>(),
+   *   ),
+   * }));
    *
    * // size will be typed as 'small' | 'medium' | 'large'
    * const size = await db.table.get('size');
@@ -7301,16 +7270,13 @@ declare abstract class Column {
    *   z.literal('large'),
    * ]);
    *
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     size: t.text().narrowAllTypes({
-   *       input: sizeSchema,
-   *       output: sizeSchema,
-   *       query: sizeSchema,
-   *     }),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   size: t.text().narrowAllTypes({
+   *     input: sizeSchema,
+   *     output: sizeSchema,
+   *     query: sizeSchema,
+   *   }),
+   * }));
    *
    * // size will be typed as 'small' | 'medium' | 'large'
    * const size = await db.table.get('size');
@@ -7321,13 +7287,13 @@ declare abstract class Column {
   narrowAllTypes: this['__schema']['narrowAllTypes'];
   input<T extends {
     inputSchema: unknown;
-  }, InputSchema extends this['__schema']['__schemaType']>(this: T, fn: (schema: T['inputSchema']) => InputSchema): { [K in keyof T]: K extends 'inputSchema' ? InputSchema : T[K] };
+  }, InputSchema extends this['__schema']['__schemaType']>(this: T, fn: (schema: T['inputSchema']) => InputSchema): { [K in keyof T]: K extends 'inputSchema' ? InputSchema : T[K]; };
   output<T extends {
     outputSchema: unknown;
-  }, OutputSchema extends this['__schema']['__schemaType']>(this: T, fn: (schema: T['outputSchema']) => OutputSchema): { [K in keyof T]: K extends 'outputSchema' ? OutputSchema : T[K] };
+  }, OutputSchema extends this['__schema']['__schemaType']>(this: T, fn: (schema: T['outputSchema']) => OutputSchema): { [K in keyof T]: K extends 'outputSchema' ? OutputSchema : T[K]; };
   query<T extends {
     querySchema: unknown;
-  }, QuerySchema extends this['__schema']['__schemaType']>(this: T, fn: (schema: T['querySchema']) => QuerySchema): { [K in keyof T]: K extends 'querySchema' ? QuerySchema : T[K] };
+  }, QuerySchema extends this['__schema']['__schemaType']>(this: T, fn: (schema: T['querySchema']) => QuerySchema): { [K in keyof T]: K extends 'querySchema' ? QuerySchema : T[K]; };
   /**
    * Set a database column name.
    *
@@ -7339,14 +7305,11 @@ declare abstract class Column {
    * It won't be selected with `selectAll` or `select('*')` as well.
    *
    * ```ts
-   * export class UserTable extends BaseTable {
-   *   readonly table = 'user';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.identity().primaryKey(),
-   *     name: t.string(),
-   *     password: t.string().select(false),
-   *   }));
-   * }
+   * export const UserTable = defineTable('user', (t) => ({
+   *   id: t.identity().primaryKey(),
+   *   name: t.string(),
+   *   password: t.string().select(false),
+   * }));
    *
    * // only id and name are selected, without password
    * const user = await db.user.find(123);
@@ -7369,7 +7332,7 @@ declare abstract class Column {
    * const userWithPassword = await db.user.find(123).select('*', 'password');
    * ```
    */
-  select<T extends Column.Pick.Data, Value extends boolean>(this: T, value: Value): Column.Modifiers.DefaultSelect<T, Value>;
+  select<T extends Column.Pick.Data, Value extends boolean>(this: T, value: Value): Column.DefaultSelect<T, Value>;
   /**
    * Set SQL to use when selecting this column.
    *
@@ -7385,26 +7348,23 @@ declare abstract class Column {
    * `readOnly` column can be used together with a `default`.
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.identity().primaryKey(),
-   *     column: t.string().default(() => 'default value'),
-   *     another: t.string().readOnly(),
-   *   }));
-   *
-   *   init(orm: typeof db) {
-   *     this.beforeSave(({ set }) => {
+   * export const Table = defineTable('table', (t) => ({
+   *   id: t.identity().primaryKey(),
+   *   column: t.string().default(() => 'default value'),
+   *   another: t.string().nullable().readOnly(),
+   * })).init((orm: typeof db, hooks) => {
+   *   hooks.beforeSave(({ columns, set }) => {
+   *     if (columns.include('column')) {
    *       set({ another: 'value' });
-   *     });
-   *   }
-   * }
+   *     }
+   *   });
+   * });
    *
    * // later in the code
    * db.table.create({ column: 'value' }); // TS error, runtime error
    * ```
    */
-  readOnly<T>(this: T): T & Column.Modifiers.IsAppReadOnly;
+  readOnly<T>(this: T): T & Column.IsAppReadOnly;
   /**
    * Set a column value when creating a record.
    * This works for [readOnly](#readonly) columns as well.
@@ -7412,13 +7372,15 @@ declare abstract class Column {
    * If no value or undefined is returned, the hook won't have any effect.
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.identity().primaryKey(),
-   *     column: t.string().setOnCreate(() => 'value'),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   id: t.identity().primaryKey(),
+   *   some: t.number(),
+   *   column: t
+   *     .string()
+   *     .setOnCreate(({ columns }) =>
+   *       columns.include('some') ? 'value' : undefined,
+   *     ),
+   * }));
    * ```
    */
   setOnCreate<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['__inputType'] | void): T;
@@ -7429,13 +7391,15 @@ declare abstract class Column {
    * If no value or undefined is returned, the hook won't have any effect.
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.identity().primaryKey(),
-   *     column: t.string().setOnUpdate(() => 'value'),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   id: t.identity().primaryKey(),
+   *   some: t.number(),
+   *   column: t
+   *     .string()
+   *     .setOnUpdate(({ columns }) =>
+   *       columns.include('some') ? 'value' : undefined,
+   *     ),
+   * }));
    * ```
    */
   setOnUpdate<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['__inputType'] | void): T;
@@ -7446,13 +7410,15 @@ declare abstract class Column {
    * If no value or undefined is returned, the hook won't have any effect.
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.identity().primaryKey(),
-   *     column: t.string().setOnSave(() => 'value'),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   id: t.identity().primaryKey(),
+   *   some: t.number(),
+   *   column: t
+   *     .string()
+   *     .setOnSave(({ columns }) =>
+   *       columns.include('some') ? 'value' : undefined,
+   *     ),
+   * }));
    * ```
    */
   setOnSave<T extends Column.Pick.QueryInit>(this: T, fn: (arg: QueryHookUtils<PickQueryInputType>) => T['__inputType'] | void): T;
@@ -7465,14 +7431,11 @@ declare abstract class Column {
    * Using `primaryKey` on a `uuid` column will automatically add a [gen_random_uuid](https://www.postgresql.org/docs/current/functions-uuid.html) default.
    *
    * ```ts
-   * export class Table extends BaseTable {
-   *   readonly table = 'table';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.uuid().primaryKey(),
-   *     // database-level name can be passed:
-   *     id: t.uuid().primaryKey('primary_key_name'),
-   *   }));
-   * }
+   * export const Table = defineTable('table', (t) => ({
+   *   id: t.uuid().primaryKey(),
+   *   // optionally, specify a database-level constraint name:
+   *   id: t.uuid().primaryKey('primary_key_name'),
+   * }));
    *
    * // primary key can be used by `find` later:
    * db.table.find('97ba9e78-7510-415a-9c03-23d440aec443');
@@ -7480,7 +7443,7 @@ declare abstract class Column {
    *
    * @param name - to specify a constraint name
    */
-  primaryKey<T extends Column.Pick.Data, Name extends string>(this: T, name?: Name): T & Column.Modifiers.IsPrimaryKey<Name>;
+  primaryKey<T extends Column.Pick.Data, Name extends string>(this: T, name?: Name): T & Column.IsPrimaryKey<Name>;
   /**
    * Defines a reference between different tables to enforce data integrity.
    *
@@ -7499,12 +7462,9 @@ declare abstract class Column {
    * In the migration it's different from OrchidORM table code where a callback with a table is expected:
    *
    * ```ts
-   * export class SomeTable extends BaseTable {
-   *   readonly table = 'someTable';
-   *   columns = this.setColumns((t) => ({
-   *     otherTableId: t.integer().foreignKey(() => OtherTable, 'id'),
-   *   }));
-   * }
+   * export const SomeTable = defineTable('someTable', (t) => ({
+   *   otherTableId: t.integer().foreignKey(() => OtherTable, 'id'),
+   * }));
    * ```
    *
    * Optionally you can pass the third argument to `foreignKey` with options:
@@ -7555,11 +7515,7 @@ declare abstract class Column {
    * @param column - column in the foreign table to connect with
    * @param options - {@link ForeignKeyOptions}
    */
-  foreignKey<T, Shape>(this: T, fn: () => new () => {
-    columns: {
-      shape: Shape;
-    };
-  }, column: keyof Shape, options?: TableData.References.Options): T;
+  foreignKey<T, Table extends Column.ForeignKey.TableParam>(this: T, fn: () => Table, column: Column.ForeignKey.ColumnNameOfTable<Table>, options?: TableData.References.Options): T;
   foreignKey<T, Table extends string, Column extends string>(this: T, table: Table, column: Column, options?: TableData.References.Options): T;
   toSQL(): string;
   /**
@@ -7717,7 +7673,7 @@ declare abstract class Column {
     data: Column['data'];
     dataType: string;
   }>(this: T, ...args: [options?: TableData.Index.TsVectorColumnArg]): T;
-  unique<T extends Column.Pick.Data, const Options extends TableData.Index.UniqueColumnArg>(this: T, ...args: [options?: Options]): T & Column.Modifiers.IsUnique<Options['name'] & string>;
+  unique<T extends Column.Pick.Data, const Options extends TableData.Index.UniqueColumnArg>(this: T, ...args: [options?: Options]): T & Column.IsUnique<Options['name'] & string>;
   /**
    * Add [EXCLUDE constraint](https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-EXCLUDE) to the column.
    *
@@ -7783,7 +7739,7 @@ declare abstract class Column {
    *
    * @param args - raw SQL
    */
-  generated<T extends Column.Pick.Data>(this: T, ...args: StaticSQLArgs): Column.Modifiers.Generated<T>;
+  generated<T extends Column.Pick.Data>(this: T, ...args: StaticSQLArgs): Column.Generated<T>;
 }
 interface ColumnFromDbParams {
   isNullable?: boolean;
@@ -7812,15 +7768,7 @@ type CreateManyFromResult<T extends CreateSelf> = T extends {
   isCount: true;
 } ? T : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAll<T> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetValueQueryReturnsPluckColumn<T> : T;
 type InsertManyFromResult<T extends CreateSelf> = T['__hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAll<T> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetValueQueryReturnsPluckColumn<T> : T : SetQueryReturnsRowCountMany<T>;
-/**
- * Function to collect column names from the inner query of create `from` methods.
- *
- * @param q - the creating query
- * @param from - inner query to grab the columns from.
- * @param obj - optionally passed object with specific data, only available when creating a single record.
- * @param many - whether it's for `createForEachFrom`. If no, throws if the inner query returns multiple records.
- */
-declare const _queryCreateManyFrom: <T extends CreateSelf, Q extends QueryReturningOne>(q: T, query: Q, data: Omit<CreateData<T>, keyof Q["result"]>[]) => CreateManyFromResult<T>;
+declare const _queryCreateManyFrom: <T extends CreateSelf, Q extends QueryReturningOne>(q: T, query: Q, data: Omit<CreateData<T>, keyof Q['result']>[]) => CreateManyFromResult<T>;
 declare class QueryCreateFrom {
   /**
    * Inserts a single record based on a query that selects a single record.
@@ -7873,14 +7821,14 @@ declare class QueryCreateFrom {
    * @param query - query to create new records from
    * @param data - additionally you can set some columns
    */
-  createOneFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data?: Omit<CreateData<T>, Q['result'] extends infer R ? keyof R : never>): CreateRawOrFromResult<T>;
+  createOneFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data?: CreateDataOmit<T, Q['result'] extends never ? never : keyof Q['result']>): CreateRawOrFromResult<T>;
   /**
    * Works exactly as {@link createOneFrom}, except that it returns inserted row count by default.
    *
    * @param query - query to create new records from
    * @param data - additionally you can set some columns
    */
-  insertOneFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data?: Omit<CreateData<T>, Q['result'] extends infer R ? keyof R : never>): InsertRawOrFromResult<T>;
+  insertOneFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data?: CreateDataOmit<T, Q['result'] extends never ? never : keyof Q['result']>): InsertRawOrFromResult<T>;
   /**
    * Inserts multiple records based on a query that selects a single record.
    *
@@ -7940,14 +7888,14 @@ declare class QueryCreateFrom {
    * @param query - query to create new records from
    * @param data - array of records to create
    */
-  createManyFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data: Omit<CreateData<T>, Q['result'] extends infer R ? keyof R : never>[]): CreateManyFromResult<T>;
+  createManyFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data: CreateDataOmit<T, Q['result'] extends never ? never : keyof Q['result']>[]): CreateManyFromResult<T>;
   /**
    * Works exactly as {@link createManyFrom}, except that it returns inserted row count by default.
    *
    * @param query - query to create new records from
    * @param data - array of records to create
    */
-  insertManyFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data: Omit<CreateData<T>, Q['result'] extends infer R ? keyof R : never>[]): InsertManyFromResult<T>;
+  insertManyFrom<T extends CreateSelf, Q extends QueryReturningOne>(this: T, query: Q, data: CreateDataOmit<T, Q['result'] extends never ? never : keyof Q['result']>[]): InsertManyFromResult<T>;
   /**
    * Inserts a single record per every record found in a given query.
    *
@@ -7975,12 +7923,19 @@ declare class QueryCreateFrom {
 }
 interface CreateSelf extends PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations, PickQueryRelationsDataForCreate, PickQueryRelationsDataForCreateOptional, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryUniqueProperties, PickQueryInputType, Query.Pick.IsNotReadOnly {}
 type CreateData<T extends CreateSelf> = EmptyObject extends T['relations'] ? CreateDataWithDefaults<T, keyof T['__defaults']> : CreateRelationsData<T>;
-type CreateDataWithDefaults<T extends CreateSelf, Defaults extends PropertyKey> = { [K in keyof T['__inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T, K> } & { [K in Defaults]?: K extends keyof T['__inputType'] ? CreateColumn<T, K> : never };
-type CreateDataWithDefaultsForRelations<T extends CreateSelf, Defaults extends keyof T['__inputType'], OmitFKeys extends PropertyKey> = { [K in keyof T['__inputType'] as K extends Defaults | OmitFKeys ? never : K]: K extends Defaults | OmitFKeys ? never : CreateColumn<T, K> } & { [K in Defaults as K extends OmitFKeys ? never : K]?: CreateColumn<T, K> };
+type CreateDataOmit<T extends CreateSelf, OmitKeys> = EmptyObject extends T['relations'] ? CreateDataWithDefaultsOmit<T, keyof T['__defaults'], OmitKeys> : CreateRelationsDataOmit<T, OmitKeys>;
+type CreateDataWithDefaults<T extends CreateSelf, Defaults extends PropertyKey> = { [K in keyof T['__inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T, K>; } & { [K in Defaults]?: K extends keyof T['__inputType'] ? CreateColumn<T, K> : never; };
+type CreateDataWithDefaultsOmit<T extends CreateSelf, Defaults extends PropertyKey, OmitKeys> = { [K in keyof T['__inputType'] as K extends Defaults | OmitKeys ? never : K]: K extends Defaults ? never : CreateColumn<T, K>; } & { [K in Defaults as K extends OmitKeys ? never : K]?: K extends keyof T['__inputType'] ? CreateColumn<T, K> : never; };
+type WritableForeignKeys<T extends CreateSelf, AllFKeys extends PropertyKey> = AllFKeys extends (infer K) ? K extends keyof T['shape'] ? T['shape'][K] extends {
+  data: {
+    makeColumnWritable: true;
+  };
+} ? K : never : never : never;
 type CreateColumn<T extends CreateSelf, K extends keyof T['__inputType']> = T['__inputType'][K] | ((q: T) => QueryOrExpression<T['__inputType'][K]>);
-type CreateRelationsData<T extends CreateSelf> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateRelationsDataOmittingFKeys<T, T['relationsDataForCreate']> & T['relationsDataForCreateOptional'];
-type CreateRelationsDataOmittingFKeys<T extends CreateSelf, Data> = EmptyObject extends Data ? EmptyObject : { [K in keyof Data]: CreateRelationDataOmittingFKeys<T, Data[K]> }[keyof Data] extends ((u: infer Obj) => void) ? Obj : never;
-type CreateRelationDataOmittingFKeys<T extends CreateSelf, Union> = (u: Union extends RelationConfigDataForCreate ? Union['columns'] extends keyof T['__defaults'] ? Pick<CreateDataWithDefaults<T, keyof T['__defaults']>, Union['columns']> & Partial<Union['nested']> : (Pick<{ [P in keyof T['__inputType']]: CreateColumn<T, P> }, Union['columns'] & keyof T['__inputType']> & { [K in keyof Union['nested']]?: never }) | Union['nested'] : Union) => void;
+type CreateRelationsData<T extends CreateSelf> = CreateDataWithDefaultsOmit<T, keyof T['__defaults'], Exclude<T['relations'][keyof T['relations']]['omitForeignKeyInCreate'], WritableForeignKeys<T, T['relations'][keyof T['relations']]['omitForeignKeyInCreate']>>> & CreateRelationsDataOmittingFKeys<T, T['relationsDataForCreate']> & T['relationsDataForCreateOptional'];
+type CreateRelationsDataOmit<T extends CreateSelf, OmitKeys> = CreateDataWithDefaultsOmit<T, keyof T['__defaults'], Exclude<T['relations'][keyof T['relations']]['omitForeignKeyInCreate'], WritableForeignKeys<T, T['relations'][keyof T['relations']]['omitForeignKeyInCreate']>> | OmitKeys> & CreateRelationsDataOmittingFKeys<T, T['relationsDataForCreate']> & T['relationsDataForCreateOptional'];
+type CreateRelationsDataOmittingFKeys<T extends CreateSelf, Data> = EmptyObject extends Data ? EmptyObject : { [K in keyof Data]: CreateRelationDataOmittingFKeys<T, Data[K]>; }[keyof Data] extends ((u: infer Obj) => void) ? Obj : never;
+type CreateRelationDataOmittingFKeys<T extends CreateSelf, Union> = (u: Union extends RelationConfigDataForCreate ? Union['columns'] extends keyof T['__defaults'] ? Pick<CreateDataWithDefaults<T, keyof T['__defaults']>, Union['columns']> & Partial<Union['nested']> : (Pick<{ [P in keyof T['__inputType']]: CreateColumn<T, P>; }, Union['columns'] & keyof T['__inputType']> & { [K in keyof Union['nested']]?: never; }) | Union['nested'] : Union) => void;
 type CreateResult<T extends CreateSelf, Data> = T extends {
   isCount: true;
 } ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneResult<T, NarrowCreateResult<T, Data>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnResult<T, NarrowCreateResult<T, Data>> : SetQueryResult<T, NarrowCreateResult<T, Data>>;
@@ -7995,12 +7950,12 @@ type InsertManyResult<T extends CreateSelf> = T['__hasSelect'] extends true ? T[
  *
  * The same should work as well with any non-null columns passed to `create`, but it's to be implemented later.
  */
-type NarrowCreateResult<T extends CreateSelf, Data> = EmptyObject extends T['relations'] ? T['result'] : { [K in keyof T['result']]: true extends { [R in keyof T['relations']]: K extends T['relations'][R]['omitForeignKeyInCreate'] ? R extends keyof Data ? true : T['relations'][R]['omitForeignKeyInCreate'] extends keyof Data ? null | undefined extends Data[T['relations'][R]['omitForeignKeyInCreate']] ? never : true : never : never }[keyof T['relations']] ? Column.Pick.QueryColumnOfTypeAndOps<string, Exclude<T['result'][K]['__outputType'], null>, T['result'][K]['operators']> : T['result'][K] };
+type NarrowCreateResult<T extends CreateSelf, Data> = EmptyObject extends T['relations'] ? T['result'] : { [K in keyof T['result']]: true extends { [R in keyof T['relations']]: K extends T['relations'][R]['omitForeignKeyInCreate'] ? R extends keyof Data ? true : T['relations'][R]['omitForeignKeyInCreate'] extends keyof Data ? null | undefined extends Data[T['relations'][R]['omitForeignKeyInCreate']] ? never : true : never : never; }[keyof T['relations']] ? Column.Pick.QueryColumnOfTypeAndOps<string, Exclude<T['result'][K]['__outputType'], null>, T['result'][K]['operators']> : T['result'][K]; };
 type IgnoreResult<T extends CreateSelf> = T['returnType'] extends 'oneOrThrow' ? QueryTakeOptional<T> : T['returnType'] extends 'valueOrThrow' ? SetQueryReturnsColumnOptional<T, T['result']['value']> : T;
 type OnConflictArg<T extends PickQueryUniqueProperties> = T['internal']['uniqueColumnNames'] | T['internal']['uniqueColumnTuples'] | Expression | {
   constraint: T['internal']['uniqueConstraints'];
 };
-type AddQueryDefaults<T extends CreateSelf, DefaultKeys extends PropertyKey> = { [K in keyof T]: K extends '__defaults' ? { [K in keyof T['__defaults'] | DefaultKeys]: true } : T[K] };
+type AddQueryDefaults<T extends CreateSelf, DefaultKeys extends PropertyKey> = { [K in keyof T]: K extends '__defaults' ? { [K in keyof T['__defaults'] | DefaultKeys]: true; } : T[K]; };
 /**
  * Used by ORM to access the context of current create query.
  * Is passed to the `create` method of a {@link VirtualColumn}
@@ -8196,31 +8151,26 @@ declare class QueryCreate {
    * A primary key or a unique index for a **single** column can be fined on a column:
    *
    * ```ts
-   * export class MyTable extends BaseTable {
-   *   columns = this.setColumns((t) => ({
-   *     pkey: t.uuid().primaryKey(),
-   *     unique: t.string().unique(),
-   *   }));
-   * }
+   * export const MyTable = defineTable('myTable', (t) => ({
+   *   pkey: t.uuid().primaryKey(),
+   *   unique: t.string().unique(),
+   * }));
    * ```
    *
    * But for composite primary keys or indexes (having multiple columns), define it in a separate function:
    *
    * ```ts
-   * export class MyTable extends BaseTable {
-   *   columns = this.setColumns(
-   *     (t) => ({
-   *       one: t.integer(),
-   *       two: t.string(),
-   *       three: t.boolean(),
-   *     }),
-   *     (t) => [t.primaryKey(['one', 'two']), t.unique(['two', 'three'])],
-   *   );
-   * }
+   * export const MyTable = defineTable('myTable', (t) => ({
+   *   one: t.integer(),
+   *   two: t.string(),
+   *   three: t.boolean(),
+   * }))
+   *   .primaryKey(['one', 'two'])
+   *   .unique(['two', 'three']);
    * ```
    * :::
    *
-   * You can use the `sql` function exported from your `BaseTable` file in onConflict.
+   * You can use the `sql` function exported from your table factory file in onConflict.
    * It can be useful to specify a condition when you have a partial index:
    *
    * ```ts
@@ -8296,7 +8246,7 @@ declare class QueryCreate {
    */
   onConflictDoNothing<T extends CreateSelf, Arg extends OnConflictArg<T>>(this: T, arg?: Arg): IgnoreResult<T>;
 }
-type OnConflictSet$1<T extends CreateSelf> = { [K in keyof T['__inputType']]?: T['__inputType'][K] | (() => QueryOrExpression<T['__inputType'][K]>) };
+type OnConflictSet$1<T extends CreateSelf> = { [K in keyof T['__inputType']]?: T['__inputType'][K] | (() => QueryOrExpression<T['__inputType'][K]>); };
 declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflictArg<T> | undefined> {
   private query;
   private onConflict;
@@ -8365,11 +8315,11 @@ declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflic
   }): T;
 }
 interface UpdateSelf extends PickQuerySelectable, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryInputType, PickQueryAs, PickQueryHasSelect, PickQueryHasWhere, Query.Pick.IsNotReadOnly {}
-type UpdateData<T extends UpdateSelf> = { [K in keyof T['__inputType'] | keyof T['relations']]?: K extends keyof T['__inputType'] ? T['__inputType'][K] | ((q: { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T ? T[K] : never }) => QueryOrExpression<T['__inputType'][K]>) : T['returnType'] extends undefined | 'all' ? T['relations'][K]['dataForUpdate'] : T['relations'][K]['dataForUpdateOne'] };
+type UpdateData<T extends UpdateSelf> = { [K in keyof T['__inputType'] | keyof T['relations']]?: K extends keyof T['__inputType'] ? T['__inputType'][K] | ((q: { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T ? T[K] : never; }) => QueryOrExpression<T['__inputType'][K]>) : T['returnType'] extends undefined | 'all' ? T['relations'][K]['dataForUpdate'] : T['relations'][K]['dataForUpdateOne']; };
 type UpdateArg<T extends UpdateSelf> = T['__hasWhere'] extends true ? UpdateData<T> : 'Update statement must have where conditions. To update all prefix `update` with `all()`';
 type UpdateResult<T extends UpdateSelf> = T['__hasSelect'] extends true ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsRowCountMany<T> : SetQueryReturnsRowCount<T>;
-type NumericColumns<T extends UpdateSelf> = { [K in keyof T['__inputType']]: Exclude<T['shape'][K]['__queryType'], string> extends number | bigint | null ? K : never }[keyof T['__inputType']];
-type ChangeCountArg<T extends UpdateSelf> = NumericColumns<T> | { [K in NumericColumns<T>]?: T['shape'][K]['__type'] extends number | null ? number : number | string | bigint };
+type NumericColumns<T extends UpdateSelf> = { [K in keyof T['__inputType']]: Exclude<T['shape'][K]['__queryType'], string> extends number | bigint | null ? K : never; }[keyof T['__inputType']];
+type ChangeCountArg<T extends UpdateSelf> = NumericColumns<T> | { [K in NumericColumns<T>]?: T['shape'][K]['__type'] extends number | null ? number : number | string | bigint; };
 interface UpdateManyBySelf extends UpdateSelf {
   internal: {
     uniqueColumns: unknown;
@@ -8378,10 +8328,10 @@ interface UpdateManyBySelf extends UpdateSelf {
     uniqueConstraints: unknown;
   };
 }
-type UpdateManyData<T extends UpdateSelf> = ({ [K in keyof T['shape'] as T['shape'][K] extends Column.Modifiers.IsPrimaryKey<string> ? K : never]: T['shape'][K]['__queryType'] | Expression } & { [P in keyof T['__inputType']]?: T['__inputType'][P] | Expression })[];
+type UpdateManyData<T extends UpdateSelf> = ({ [K in keyof T['shape'] as T['shape'][K] extends Column.IsPrimaryKey<string> ? K : never]: T['shape'][K]['__queryType'] | Expression; } & { [P in keyof T['__inputType']]?: T['__inputType'][P] | Expression; })[];
 type UpdateManyByKeys<T extends UpdateManyBySelf> = T['internal']['uniqueColumnNames'] | T['internal']['uniqueColumnTuples'];
 type UpdateManyByKeyColumns<K> = K extends string[] ? K[number] : K;
-type UpdateManyByData<T extends UpdateSelf, K> = ({ [P in K & keyof T['__inputType']]: T['__inputType'][P] } & { [P in keyof T['__inputType']]?: P extends K ? T['__inputType'][P] : T['__inputType'][P] | Expression })[];
+type UpdateManyByData<T extends UpdateSelf, K> = ({ [P in K & keyof T['__inputType']]: T['__inputType'][P]; } & { [P in keyof T['__inputType']]?: P extends K ? T['__inputType'][P] : T['__inputType'][P] | Expression; })[];
 type UpdateManyResult<T extends UpdateSelf> = T['__hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllResult<T, T['result']> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnResult<T, T['result']> : SetQueryResult<T, T['result']> : SetQueryReturnsRowCountMany<T>;
 declare const _queryUpdate: <T extends UpdateSelf>(updateSelf: T, arg: UpdateArg<T>) => UpdateResult<T>;
 declare const _queryUpdateOrThrow: <T extends UpdateSelf>(q: T, arg: UpdateArg<T>) => UpdateResult<T>;
@@ -8869,7 +8819,7 @@ type ComputedColumnsFromOptions<Shape, Options> = Options extends {
   result: {
     value: infer Value extends Column.Pick.QueryColumn;
   };
-}) ? Value : never : never } : Shape;
+}) ? Value : never : never; } : Shape;
 interface ComputedOptionsConfig {
   [K: string]: QueryOrExpression<unknown> | ReturnsQueryOrExpression<unknown>;
 }
@@ -8884,12 +8834,12 @@ interface RuntimeComputedQueryColumn<OutputType> extends Column.Pick.QueryColumn
   };
 }
 interface ComputedMethods<ColumnTypes, Shape extends Column.QueryColumns> extends QueryComputedArg<ColumnTypes, Shape> {
-  computeAtRuntime<Deps extends keyof Shape, OutputType>(dependsOn: Deps[], fn: (record: { [K in keyof Shape & Deps]: Shape[K]['__outputType'] }) => OutputType): {
+  computeAtRuntime<Deps extends keyof Shape, OutputType>(dependsOn: Deps[], fn: (record: { [K in keyof Shape & Deps]: Shape[K]['__outputType']; }) => OutputType): {
     result: {
       value: RuntimeComputedQueryColumn<OutputType>;
     };
   };
-  computeBatchAtRuntime<Deps extends keyof Shape, OutputType>(dependsOn: Deps[], fn: (record: { [K in keyof Shape & Deps]: Shape[K]['__outputType'] }[]) => MaybePromise<OutputType[]>): {
+  computeBatchAtRuntime<Deps extends keyof Shape, OutputType>(dependsOn: Deps[], fn: (record: { [K in keyof Shape & Deps]: Shape[K]['__outputType']; }[]) => MaybePromise<OutputType[]>): {
     result: {
       value: RuntimeComputedQueryColumn<OutputType>;
     };
@@ -8913,7 +8863,7 @@ interface QueryComputedArg<ColumnTypes, Shape extends Column.QueryColumns> exten
   __selectable: { [K in keyof Shape]: {
     as: string;
     column: Column.Pick.QueryColumn;
-  } };
+  }; };
 }
 type WhereItem = {
   [K: string]: unknown | {
@@ -9023,6 +8973,7 @@ interface QueryData extends QueryDataAliases, PickQueryDataParsers, HasHookSelec
   returningMany?: boolean;
   wrapInTransaction?: boolean;
   throwOnNotFound?: boolean;
+  cteThrowOnNotFound?: boolean;
   ensureCount?: number;
   with?: WithItems;
   withShapes?: WithConfigs;
@@ -9135,6 +9086,8 @@ interface QueryData extends QueryDataAliases, PickQueryDataParsers, HasHookSelec
   /** upsert **/
   upsertUpdate?: boolean;
   upsertSecond?: boolean;
+  upsertUpdateAsFns?: AsFn[];
+  upsertCreateWith?: WithItems;
   upsertCreateAppendQueries?: SubQueryForSql[];
   upsertCreateAsFns?: AsFn[];
   upsertInsert?(): unknown;
@@ -9220,13 +9173,13 @@ interface ToSQLQuery extends IsQuery {
 }
 interface FromQuerySelf extends PickQuerySelectable, PickQueryShape, PickQueryReturnType, PickQueryWithData, PickQueryAs, PickQueryHasSelect {}
 type FromArg<T extends FromQuerySelf> = IsQuery | Exclude<keyof T['withData'], symbol | number>;
-type FromResult<T extends FromQuerySelf, Arg extends MaybeArray<FromArg<T>>> = Arg extends string ? T['withData'] extends WithDataItems ? { [K in keyof T]: K extends '__selectable' ? SelectableFromShape<T['withData'][Arg]['shape'], Arg> : K extends 'result' ? T['withData'][Arg]['shape'] : K extends 'then' ? QueryThenByQuery<T, T['withData'][Arg]['shape']> : T[K] } : SetQueryTableAlias<T, Arg> : Arg extends PickQuerySelectableResultInputTypeAs ? { [K in keyof T]: K extends '__defaultSelect' ? keyof Arg['result'] : K extends '__selectable' ? SelectableFromShape<Arg['result'], Arg['__as']> : K extends '__as' ? Arg['__as'] : K extends 'result' ? Arg['result'] : K extends 'shape' ? Arg['result'] : K extends '__inputType' ? Arg['__inputType'] : K extends 'then' ? QueryThenByQuery<T, Arg['result']> : T[K] } : Arg extends (infer A)[] ? { [K in keyof T]: K extends '__selectable' ? UnionToIntersection<A extends string ? T['withData'] extends WithDataItems ? { [K in keyof T['withData'][A]['shape'] & string as `${A}.${K}`]: {
+type FromResult<T extends FromQuerySelf, Arg extends MaybeArray<FromArg<T>>> = Arg extends string ? T['withData'] extends WithDataItems ? { [K in keyof T]: K extends '__selectable' ? SelectableFromShape<T['withData'][Arg]['shape'], Arg> : K extends 'result' ? T['withData'][Arg]['shape'] : K extends 'then' ? QueryThenByQuery<T, T['withData'][Arg]['shape']> : T[K]; } : SetQueryTableAlias<T, Arg> : Arg extends PickQuerySelectableResultInputTypeAs ? { [K in keyof T]: K extends '__defaultSelect' ? keyof Arg['result'] : K extends '__selectable' ? SelectableFromShape<Arg['result'], Arg['__as']> : K extends '__as' ? Arg['__as'] : K extends 'result' ? Arg['result'] : K extends 'shape' ? Arg['result'] : K extends '__inputType' ? Arg['__inputType'] : K extends 'then' ? QueryThenByQuery<T, Arg['result']> : T[K]; } : Arg extends (infer A)[] ? { [K in keyof T]: K extends '__selectable' ? UnionToIntersection<A extends string ? T['withData'] extends WithDataItems ? { [K in keyof T['withData'][A]['shape'] & string as `${A}.${K}`]: {
   as: K;
   column: T['withData'][A]['shape'][K];
-} } : never : A extends PickQueryResultAs ? { [K in keyof A['result'] & string as `${A['__as']}.${K}`]: K extends string ? {
+}; } : never : A extends PickQueryResultAs ? { [K in keyof A['result'] & string as `${A['__as']}.${K}`]: K extends string ? {
   as: K;
   column: A['result'][K];
-} : never } : never> : T[K] } : T;
+} : never; } : never> : T[K]; } : T;
 declare class FromMethods {
   /**
    * Set the `FROM` value, by default the table name is used.
@@ -9303,11 +9256,11 @@ interface CteQueryBuilder<T extends PickQueryWithDataColumnTypes> extends Query
 type CteResult<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends PickQueryResult> = { [K in keyof T]: K extends 'withData' ? { [K in keyof T['withData'] | Name]: K extends Name ? {
   table: Name;
   shape: Q['result'];
-} : K extends keyof T['withData'] ? T['withData'][K] : never } : T[K] };
+} : K extends keyof T['withData'] ? T['withData'][K] : never; } : T[K]; };
 type CteSqlResult<T extends PickQueryWithDataColumnTypes, Name extends string, Shape extends Column.QueryColumns> = { [K in keyof T]: K extends 'withData' ? { [K in Name | keyof T['withData']]: K extends Name ? {
   table: Name;
   shape: Shape;
-} : K extends keyof T['withData'] ? T['withData'][K] : never } : T[K] };
+} : K extends keyof T['withData'] ? T['withData'][K] : never; } : T[K]; };
 declare const _prependWith: (q: Query, name: string | ((as: string) => void), queryArg: PickQueryResult | ((q: CteQueryBuilder<PickQueryWithDataColumnTypes>) => PickQueryResult)) => Query;
 declare class CteQuery {
   /**
@@ -9428,14 +9381,11 @@ declare class CteQuery {
    * For the first example, consider the employee table, an employee may or may not have a manager.
    *
    * ```ts
-   * class Employee extends BaseTable {
-   *   readonly table = 'employee';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.identity().primaryKey(),
-   *     name: t.string(),
-   *     managerId: t.integer().nullable(),
-   *   }));
-   * }
+   * export const Employee = defineTable('employee', (t) => ({
+   *   id: t.identity().primaryKey(),
+   *   name: t.string(),
+   *   managerId: t.integer().nullable(),
+   * }));
    * ```
    *
    * The task is to load all subordinates of the manager with the id 1.
@@ -9501,8 +9451,8 @@ declare class CteQuery {
    *   .where({ n: { gt: 10 } });
    * ```
    */
-  withRecursive<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends PickQueryResult, Result = CteResult<T, Name, Q>>(this: T, name: Name, base: Q | ((qb: CteQueryBuilder<T>) => Q), recursive: (qb: { [K in keyof Result]: K extends 'result' ? Q['result'] : Result[K] }) => PickQueryResult): Result;
-  withRecursive<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends PickQueryResult, Result = CteResult<T, Name, Q>>(this: T, name: Name, options: CteRecursiveOptions, base: Q | ((qb: CteQueryBuilder<T>) => Q), recursive: (qb: { [K in keyof Result]: K extends 'result' ? Q['result'] : Result[K] }) => PickQueryResult): Result;
+  withRecursive<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends PickQueryResult, Result = CteResult<T, Name, Q>>(this: T, name: Name, base: Q | ((qb: CteQueryBuilder<T>) => Q), recursive: (qb: { [K in keyof Result]: K extends 'result' ? Q['result'] : Result[K]; }) => PickQueryResult): Result;
+  withRecursive<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends PickQueryResult, Result = CteResult<T, Name, Q>>(this: T, name: Name, options: CteRecursiveOptions, base: Q | ((qb: CteQueryBuilder<T>) => Q), recursive: (qb: { [K in keyof Result]: K extends 'result' ? Q['result'] : Result[K]; }) => PickQueryResult): Result;
   /**
    * Use `withSql` to add a Common Table Expression (CTE) based on a custom SQL.
    *
@@ -9562,7 +9512,7 @@ declare class CteQuery {
 type UnionArgs<T extends PickQueryResult> = ({
   result: { [K in keyof T['result']]: {
     __queryType: T['result'][K]['__queryType'];
-  } };
+  }; };
 } | ((q: T) => Expression))[];
 declare class Union {
   /**
@@ -9754,7 +9704,7 @@ declare class Having {
    */
   havingSql<T>(this: T, ...args: SQLQueryArgs): T;
 }
-type UpsertCreate<DataKey extends PropertyKey, CD> = { [K in keyof CD as K extends DataKey ? never : K]: CD[K] } & { [K in DataKey]?: K extends keyof CD ? CD[K] : never };
+type UpsertCreate<DataKey extends PropertyKey, CD> = { [K in keyof CD as K extends DataKey ? never : K]: CD[K]; } & { [K in DataKey]?: K extends keyof CD ? CD[K] : never; };
 type UpsertResult<T extends PickQueryHasSelectResultReturnType> = T['__hasSelect'] extends true ? T['returnType'] extends 'value' | 'valueOrThrow' ? SetValueQueryReturnsValueOrThrow<T> : SetQueryReturnsOne<T> : SetQueryReturnsVoid<T>;
 interface UpsertThis extends UpdateSelf, CreateSelf {
   __hasWhere: true;
@@ -9921,7 +9871,7 @@ interface QueryPluckSelf extends PickQuerySelectable, PickQueryRelationsWithData
 type PluckArg<T extends QueryPluckSelf> = SelectableOrExpression<T> | ((q: SelectAsFnArg<T>) => Expression | Query.Pick.SingleValueResult);
 type PluckResult<T extends QueryPluckSelf, S extends PluckArg<T>> = S extends ((q: never) => infer R) ? R extends Expression ? SetQueryReturnsPluck<T, R> : R extends Query.Pick.SingleValueResult ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
   pluck: R['result']['value'];
-} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<R['result']['value']['__outputType'][]> : T[K] } : never : S extends SelectableOrExpression<T> ? SetQueryReturnsPluck<T, S> : never;
+} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<R['result']['value']['__outputType'][]> : T[K]; } : never : S extends SelectableOrExpression<T> ? SetQueryReturnsPluck<T, S> : never;
 declare class QueryPluck {
   /**
    * `.pluck` returns a single array of a single selected column values:
@@ -9935,7 +9885,7 @@ declare class QueryPluck {
   pluck<T extends QueryPluckSelf, S extends PluckArg<T>>(this: T, select: S): PluckResult<T, S>;
 }
 interface MergeQueryArg extends PickQueryTable, PickQuerySelectable, PickQueryResult, PickQueryReturnType, PickQueryWithData, PickQueryWindows, PickQueryThen, PickQueryHasSelect, PickQueryHasWhere {}
-type MergeQuery<T extends MergeQueryArg, Q extends MergeQueryArg> = { [K in keyof T]: K extends '__hasWhere' | '__hasSelect' ? T[K] & Q[K] : K extends '__selectable' | 'windows' | 'withData' ? Q[K] & Omit<T[K], keyof Q[K]> : K extends 'result' ? MergeQueryResult<T, Q> : K extends 'returnType' ? Q['returnType'] extends undefined ? T['returnType'] : Q['returnType'] : K extends 'then' ? Q['returnType'] extends undefined ? QueryThenByQuery<T, MergeQueryResult<T, Q>> : Q['returnType'] extends 'all' | 'one' | 'oneOrThrow' | 'rows' ? QueryThenByQuery<Q, MergeQueryResult<T, Q>> : Q['__hasSelect'] extends true ? Q['then'] : T['__hasSelect'] extends true ? T['then'] : Q['then'] : T[K] };
+type MergeQuery<T extends MergeQueryArg, Q extends MergeQueryArg> = { [K in keyof T]: K extends '__hasWhere' | '__hasSelect' ? T[K] & Q[K] : K extends '__selectable' | 'windows' | 'withData' ? Q[K] & Omit<T[K], keyof Q[K]> : K extends 'result' ? MergeQueryResult<T, Q> : K extends 'returnType' ? Q['returnType'] extends undefined ? T['returnType'] : Q['returnType'] : K extends 'then' ? Q['returnType'] extends undefined ? QueryThenByQuery<T, MergeQueryResult<T, Q>> : Q['returnType'] extends 'all' | 'one' | 'oneOrThrow' | 'rows' ? QueryThenByQuery<Q, MergeQueryResult<T, Q>> : Q['__hasSelect'] extends true ? Q['then'] : T['__hasSelect'] extends true ? T['then'] : Q['then'] : T[K]; };
 type MergeQueryResult<T extends PickQueryHasSelectResult, Q extends PickQueryHasSelectResult> = T['__hasSelect'] extends true ? Q['__hasSelect'] extends true ? Omit<T['result'], keyof Q['result']> & Q['result'] : T['result'] : Q['result'];
 declare class MergeQueryMethods {
   merge<T extends MergeQueryArg, Q extends MergeQueryArg>(this: T, q: Q): MergeQuery<T, Q>;
@@ -9989,7 +9939,7 @@ declare class QueryMap {
     then: QueryThen<(infer Data)[]>;
   } ? (input: Data, index: number, arr: Data[]) => Result : never : T extends {
     then: QueryThen<(infer Data) | undefined>;
-  } ? (input: Data, index: number, value: Data) => Result : never, thisArg?: unknown): Result extends RecordUnknown ? { [K in keyof T]: K extends 'result' ? { [K in keyof Result]: Column.Pick.QueryColumnOfType<Result[K]> } : K extends 'then' ? QueryThen<T['returnType'] extends QueryReturnTypeAll | 'pluck' ? Result[] : T['returnType'] extends QueryReturnTypeOptional ? Result | undefined : Result> : T[K] } : { [K in keyof T]: K extends 'returnType' ? T['returnType'] extends QueryReturnTypeAll | 'pluck' ? 'pluck' : T['returnType'] extends 'one' ? 'value' : 'valueOrThrow' : K extends 'result' ? T['returnType'] extends QueryReturnTypeAll | 'pluck' ? {
+  } ? (input: Data, index: number, value: Data) => Result : never, thisArg?: unknown): Result extends RecordUnknown ? { [K in keyof T]: K extends 'result' ? { [K in keyof Result]: Column.Pick.QueryColumnOfType<Result[K]>; } : K extends 'then' ? QueryThen<T['returnType'] extends QueryReturnTypeAll | 'pluck' ? Result[] : T['returnType'] extends QueryReturnTypeOptional ? Result | undefined : Result> : T[K]; } : { [K in keyof T]: K extends 'returnType' ? T['returnType'] extends QueryReturnTypeAll | 'pluck' ? 'pluck' : T['returnType'] extends 'one' ? 'value' : 'valueOrThrow' : K extends 'result' ? T['returnType'] extends QueryReturnTypeAll | 'pluck' ? {
     pluck: Column.Pick.QueryColumnOfType<Result>;
   } : T['returnType'] extends QueryReturnTypeOptional ? {
     value: Column.Pick.QueryColumnOfType<Result | undefined>;
@@ -10001,7 +9951,7 @@ declare class QueryMap {
   } : K extends 'then' ? QueryThen<T['returnType'] extends QueryReturnTypeAll | 'pluck' ? Result[] : T['returnType'] extends QueryReturnTypeOptional ? Result | undefined : T extends {
     returnType: 'valueOrThrow';
     then: QueryThen<unknown | null>;
-  } ? Result | null : Result> : T[K] };
+  } ? Result | null : Result> : T[K]; };
 }
 type OrCreateArg<Data> = Data | (() => Data);
 declare function _orCreate<T extends PickQueryHasSelectResultReturnType>(query: T, data: unknown | FnUnknownToUnknown, updateData?: unknown, mergeData?: unknown): UpsertResult<T>;
@@ -10187,7 +10137,7 @@ declare class QueryExistsMethods {
    */
   notExists<T extends QueryGetSelf>(this: T): SetQueryReturnsColumnOrThrow<T, BooleanQueryColumn>;
 }
-type GroupArgs<T extends PickQueryResult> = ({ [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K }[keyof T['result']] | Expression)[];
+type GroupArgs<T extends PickQueryResult> = ({ [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K; }[keyof T['result']] | Expression)[];
 interface QueryHelperQuery<T extends PickQuerySelectableShapeAs> extends MergeQueryArg {
   returnType: QueryReturnType;
   __selectable: Omit<T['__selectable'], `${T['__as']}.${Extract<keyof T['shape'], string>}`>;
@@ -10216,15 +10166,15 @@ type QueryHelperResult<T extends IsQueryHelper> = T['__result'];
 interface NarrowTypeSelf extends PickQueryResultReturnType {
   returnType: undefined | 'all' | 'one' | 'oneOrThrow' | 'value' | 'valueOrThrow' | 'pluck';
 }
-type NarrowInvalidKeys<T extends PickQueryResult, Narrow> = { [K in keyof Narrow]: K extends keyof T['result'] ? Narrow[K] extends T['result'][K]['__outputType'] ? never : K : K }[keyof Narrow];
+type NarrowInvalidKeys<T extends PickQueryResult, Narrow> = { [K in keyof Narrow]: K extends keyof T['result'] ? Narrow[K] extends T['result'][K]['__outputType'] ? never : K : K; }[keyof Narrow];
 interface NarrowValueTypeResult<T extends PickQueryResultReturnType, Narrow> extends Column.QueryColumns {
-  value: { [K in keyof T['result']['value']]: K extends '__outputType' ? Narrow : T['result']['value'][K] };
+  value: { [K in keyof T['result']['value']]: K extends '__outputType' ? Narrow : T['result']['value'][K]; };
 }
 interface NarrowPluckTypeResult<T extends PickQueryResultReturnType, Narrow> extends Column.QueryColumns {
-  pluck: { [K in keyof T['result']['pluck']]: K extends '__outputType' ? Narrow extends unknown[] ? Narrow[number] : Narrow : T['result']['pluck'][K] };
+  pluck: { [K in keyof T['result']['pluck']]: K extends '__outputType' ? Narrow extends unknown[] ? Narrow[number] : Narrow : T['result']['pluck'][K]; };
 }
-type QueryIfResult<T extends PickQueryResultReturnType, R extends PickQueryResult> = { [K in keyof T]: K extends 'result' ? { [K in keyof T['result'] | keyof R['result']]: K extends keyof T['result'] ? K extends keyof R['result'] ? R['result'][K] | T['result'][K] : T['result'][K] : Column.Modifiers.QueryColumnToOptional<R['result'][K]> } : K extends 'then' ? QueryIfResultThen<T, R> : T[K] };
-type QueryIfResultThen<T extends PickQueryResultReturnType, R extends PickQueryResult> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType'] }> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType'] }> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType'] }> : T['returnType'] extends 'value' ? QueryThen<T['result']['value']['__outputType'] | R['result']['value']['__outputType'] | undefined> : T['returnType'] extends 'valueOrThrow' ? QueryThen<T['result']['value']['__outputType'] | R['result']['value']['__outputType']> : T['returnType'] extends 'rows' ? QueryThen<(T['result'][keyof T['result']]['__outputType'] | R['result'][keyof R['result']]['__outputType'])[][]> : T['returnType'] extends 'pluck' ? QueryThen<(T['result']['pluck']['__outputType'] | R['result']['pluck']['__outputType'])[]> : QueryThen<void>;
+type QueryIfResult<T extends PickQueryResultReturnType, R extends PickQueryResult> = { [K in keyof T]: K extends 'result' ? { [K in keyof T['result'] | keyof R['result']]: K extends keyof T['result'] ? K extends keyof R['result'] ? R['result'][K] | T['result'][K] : T['result'][K] : Column.QueryColumnToOptional<R['result'][K]>; } : K extends 'then' ? QueryIfResultThen<T, R> : T[K]; };
+type QueryIfResultThen<T extends PickQueryResultReturnType, R extends PickQueryResult> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType']; } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType']; }> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType']; } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType']; }> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType']; } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType']; }> : T['returnType'] extends 'value' ? QueryThen<T['result']['value']['__outputType'] | R['result']['value']['__outputType'] | undefined> : T['returnType'] extends 'valueOrThrow' ? QueryThen<T['result']['value']['__outputType'] | R['result']['value']['__outputType']> : T['returnType'] extends 'rows' ? QueryThen<(T['result'][keyof T['result']]['__outputType'] | R['result'][keyof R['result']]['__outputType'])[][]> : T['returnType'] extends 'pluck' ? QueryThen<(T['result']['pluck']['__outputType'] | R['result']['pluck']['__outputType'])[]> : QueryThen<void>;
 interface QueryMethods<ColumnTypes> extends QueryClone, QueryAsMethods, AggregateMethods, QueryDistinct, Select, FromMethods, QueryJoin, QueryLimitOffset, CteQuery, Union, QueryJsonMethods, QueryCreate, QueryCreateFrom, QueryUpdate, QueryDelete, QueryStorage, QueryTransaction, QueryTruncate, For, Where, SearchMethods, Clear, Having, QueryCatchers, QueryLog, QueryOrder, QueryWithSchema, QueryHooks, QueryUpsert, QueryOrCreate, QueryGet, QueryPluck, MergeQueryMethods, QuerySql<ColumnTypes>, QueryTransform, QueryMap, QueryScope, SoftDeleteMethods, QueryExpressions, QueryWrap, QueryWindow, QueryExistsMethods {}
 declare class QueryMethods<ColumnTypes> {
   /**
@@ -10665,14 +10615,14 @@ declare class QueryMethods<ColumnTypes> {
    */
   narrowType<T extends NarrowTypeSelf>(this: T): <Narrow>() => T['returnType'] extends undefined | 'all' | 'one' | 'oneOrThrow' ? [NarrowInvalidKeys<T, Narrow>] extends [never] ? { [K in keyof T]: K extends 'result' ? T['result'] & { [K in keyof Narrow]: {
     __outputType: Narrow[K];
-  } } : K extends 'then' ? QueryThenByQuery<T, T['result'] & { [K in keyof Narrow]: {
+  }; } : K extends 'then' ? QueryThenByQuery<T, T['result'] & { [K in keyof Narrow]: {
     __outputType: Narrow[K];
-  } }> : T[K] } : `narrowType() error: provided type does not extend the '${NarrowInvalidKeys<T, Narrow> & string}' column type` : (T['returnType'] extends 'pluck' ? Narrow extends unknown[] ? Narrow[number] : Narrow : Narrow) extends (T['returnType'] extends 'pluck' ? T['result']['pluck']['__outputType'] : T['result']['value']['__outputType']) ? { [K in keyof T]: K extends 'result' ? T['returnType'] extends 'value' | 'valueOrThrow' ? NarrowValueTypeResult<T, Narrow> : NarrowPluckTypeResult<T, Narrow> : K extends 'then' ? QueryThenByQuery<T, T['returnType'] extends 'value' | 'valueOrThrow' ? NarrowValueTypeResult<T, Narrow> : NarrowPluckTypeResult<T, Narrow>> : T[K] } : 'narrowType() error: provided type does not extend the returning column column type';
+  }; }> : T[K]; } : `narrowType() error: provided type does not extend the '${NarrowInvalidKeys<T, Narrow> & string}' column type` : (T['returnType'] extends 'pluck' ? Narrow extends unknown[] ? Narrow[number] : Narrow : Narrow) extends (T['returnType'] extends 'pluck' ? T['result']['pluck']['__outputType'] : T['result']['value']['__outputType']) ? { [K in keyof T]: K extends 'result' ? T['returnType'] extends 'value' | 'valueOrThrow' ? NarrowValueTypeResult<T, Narrow> : NarrowPluckTypeResult<T, Narrow> : K extends 'then' ? QueryThenByQuery<T, T['returnType'] extends 'value' | 'valueOrThrow' ? NarrowValueTypeResult<T, Narrow> : NarrowPluckTypeResult<T, Narrow>> : T[K]; } : 'narrowType() error: provided type does not extend the returning column column type';
   if<T extends PickQueryResultReturnType, R extends PickQueryResult>(this: T, condition: boolean | null | undefined, fn: (q: T) => R & {
     returnType: T['returnType'];
   }): QueryIfResult<T, R>;
   queryRelated<T extends PickQueryRelations, RelName extends keyof T['relations']>(this: T, relName: RelName, params: T['relations'][RelName]['params']): RelationQueryMaybeSingle<T['relations'][RelName]>;
-  chain<T extends PickQuerySelectableShapeRelationsReturnTypeIsSubQuery, RelName extends keyof T['relations']>(this: T, relName: RelName): T['__subQuery'] extends true | undefined ? [T['returnType'], T['relations'][RelName]['returnsOne']] extends ['one' | 'oneOrThrow', true] ? { [K in keyof RelationQueryMaybeSingle<T['relations'][RelName]>]: K extends '__selectable' ? RelationQueryMaybeSingle<T['relations'][RelName]>['__selectable'] & Omit<T['__selectable'], keyof T['shape']> : RelationQueryMaybeSingle<T['relations'][RelName]>[K] } & IsSubQuery : JoinResultRequireMain<T['relations'][RelName]['query'], Omit<T['__selectable'], keyof T['shape']>> : T['relations'][RelName]['query'];
+  chain<T extends PickQuerySelectableShapeRelationsReturnTypeIsSubQuery, RelName extends keyof T['relations']>(this: T, relName: RelName): T['__subQuery'] extends true | undefined ? [T['returnType'], T['relations'][RelName]['returnsOne']] extends ['one' | 'oneOrThrow', true] ? { [K in keyof RelationQueryMaybeSingle<T['relations'][RelName]>]: K extends '__selectable' ? RelationQueryMaybeSingle<T['relations'][RelName]>['__selectable'] & Omit<T['__selectable'], keyof T['shape']> : RelationQueryMaybeSingle<T['relations'][RelName]>[K]; } & IsSubQuery : JoinResultRequireMain<T['relations'][RelName]['query'], Omit<T['__selectable'], keyof T['shape']>> : T['relations'][RelName]['query'];
 }
 interface DbExtension {
   name: string;
@@ -10697,10 +10647,10 @@ interface DbDomainArgRecord {
 type SelectableFromShape<Shape extends Column.QueryColumns, Table extends string | undefined> = { [K in keyof Shape]: {
   as: K;
   column: Shape[K];
-} } & { [K in keyof Shape & string as `${Table}.${K}`]: {
+}; } & { [K in keyof Shape & string as `${Table}.${K}`]: {
   as: K;
   column: Shape[K];
-} };
+}; };
 type QueryReturnType = QueryReturnTypeAll | 'one' | 'oneOrThrow' | 'rows' | 'pluck' | 'value' | 'valueOrThrow' | 'void';
 type QueryReturnTypeAll = undefined | 'all';
 type QueryReturnTypeOptional = 'one' | 'value';
@@ -10783,52 +10733,52 @@ declare namespace Query {
     }
   }
 }
-type SelectableOfType<T extends PickQuerySelectable, Type> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['__type'] extends Type | null ? K : never }[keyof T['__selectable']];
+type SelectableOfType<T extends PickQuerySelectable, Type> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['__type'] extends Type | null ? K : never; }[keyof T['__selectable']];
 type SelectableOrExpressionOfType<T extends PickQuerySelectable, C extends Column.Pick.Type> = SelectableOfType<T, C['__type']> | Expression<Column.Pick.QueryColumnOfType<C['__type'] | null>>;
-type SetQueryReturnsAll<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'then' ? QueryThenShallowSimplifyArr<ColumnsShape.Output<T['result']>> : T[K] } & QueryHasWhere;
-type SetQueryReturnsAllResult<T extends PickQueryResult, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplifyArr<T['result']> : T[K] } & QueryHasWhere;
-type QueryTakeOptional<T extends PickQueryResultReturnType> = T['returnType'] extends 'value' | 'pluck' | 'void' ? T : T['returnType'] extends 'valueOrThrow' ? { [K in keyof T]: K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<T['result']['value']['__outputType'] | undefined> : T[K] } : { [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<T['result']>> : T[K] };
-type QueryManyTakeOptional<T extends PickQueryResultReturnType> = { [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<T['result']>> : T[K] };
-type QueryRequire<T extends PickQueryResultReturnType> = T['returnType'] extends QueryReturnTypeAll | 'valueOrThrow' | 'pluck' | 'void' ? T : T['returnType'] extends 'value' ? { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Exclude<T['result']['value']['__outputType'], undefined>> : T[K] } : { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K] };
-type QueryTake<T extends PickQueryResultReturnType> = T['returnType'] extends 'valueOrThrow' | 'pluck' | 'void' ? T : T['returnType'] extends 'value' ? { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Exclude<T['result']['value']['__outputType'], undefined>> : T[K] } : { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K] };
-type QueryManyTake<T extends PickQueryResultReturnType> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K] };
-type SetQueryReturnsOne<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K] };
-type SetQueryReturnsOneResult<T extends PickQueryResult, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<Result>> : T[K] };
-type SetQueryReturnsRows<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'rows' : K extends 'then' ? QueryThen<ColumnsShape.Output<T['result']>[keyof T['result']][][]> : T[K] };
+type SetQueryReturnsAll<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'then' ? QueryThenShallowSimplifyArr<ColumnsShape.Output<T['result']>> : T[K]; } & QueryHasWhere;
+type SetQueryReturnsAllResult<T extends PickQueryResult, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplifyArr<T['result']> : T[K]; } & QueryHasWhere;
+type QueryTakeOptional<T extends PickQueryResultReturnType> = T['returnType'] extends 'value' | 'pluck' | 'void' ? T : T['returnType'] extends 'valueOrThrow' ? { [K in keyof T]: K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<T['result']['value']['__outputType'] | undefined> : T[K]; } : { [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<T['result']>> : T[K]; };
+type QueryManyTakeOptional<T extends PickQueryResultReturnType> = { [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<T['result']>> : T[K]; };
+type QueryRequire<T extends PickQueryResultReturnType> = T['returnType'] extends QueryReturnTypeAll | 'valueOrThrow' | 'pluck' | 'void' ? T : T['returnType'] extends 'value' ? { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Exclude<T['result']['value']['__outputType'], undefined>> : T[K]; } : { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K]; };
+type QueryTake<T extends PickQueryResultReturnType> = T['returnType'] extends 'valueOrThrow' | 'pluck' | 'void' ? T : T['returnType'] extends 'value' ? { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Exclude<T['result']['value']['__outputType'], undefined>> : T[K]; } : { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K]; };
+type QueryManyTake<T extends PickQueryResultReturnType> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K]; };
+type SetQueryReturnsOne<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K]; };
+type SetQueryReturnsOneResult<T extends PickQueryResult, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<Result>> : T[K]; };
+type SetQueryReturnsRows<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'rows' : K extends 'then' ? QueryThen<ColumnsShape.Output<T['result']>[keyof T['result']][][]> : T[K]; };
 type SetQueryReturnsPluck<T extends PickQuerySelectable, S extends keyof T['__selectable'] | Expression> = S extends keyof T['__selectable'] ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
   pluck: T['__selectable'][S]['column'];
-} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['__selectable'][S]['column']['__outputType'][]> : T[K] } : { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
+} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['__selectable'][S]['column']['__outputType'][]> : T[K]; } : { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
   pluck: S extends Expression ? S['result']['value'] : never;
-} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<(S extends Expression ? S['result']['value']['__outputType'] : never)[]> : T[K] };
+} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<(S extends Expression ? S['result']['value']['__outputType'] : never)[]> : T[K]; };
 type SetValueQueryReturnsPluckColumn<T extends PickQueryResult> = { [K in keyof T]: K extends 'result' ? {
   pluck: T['result']['value'];
-} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['result']['value']['__outputType'][]> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['result']['value']['__outputType'][]> : T[K]; } & QueryHasSelect;
 type SetQueryReturnsPluckColumnResult<T extends PickQueryResult, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'result' ? {
   pluck: T['result']['value'];
-} : K extends 'returnType' ? 'pluck' : K extends 'result' ? Result : K extends 'then' ? QueryThen<T['result']['value']['__outputType'][]> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'pluck' : K extends 'result' ? Result : K extends 'then' ? QueryThen<T['result']['value']['__outputType'][]> : T[K]; } & QueryHasSelect;
 type SetQueryReturnsValueOrThrow<T extends PickQuerySelectable, Arg extends keyof T['__selectable']> = SetQueryReturnsColumnOrThrow<T, T['__selectable'][Arg]['column']> & T['__selectable'][Arg]['column']['operators'];
-type SetValueQueryReturnsValueOrThrow<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['value']['__outputType']> : T[K] };
-type SetQueryReturnsValueOptional<T extends PickQuerySelectable, Arg extends GetStringArg<T>> = SetQueryReturnsColumnOptional<T, { [K in keyof T['__selectable'][Arg]['column']]: K extends '__outputType' ? T['__selectable'][Arg]['column'][K] | undefined : T['__selectable'][Arg]['column'][K] }> & Omit<T['__selectable'][Arg]['column']['operators'], 'equals' | 'not'> & Column.Modifiers.OperatorsNullable<T['__selectable'][Arg]['column']>;
+type SetValueQueryReturnsValueOrThrow<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['value']['__outputType']> : T[K]; };
+type SetQueryReturnsValueOptional<T extends PickQuerySelectable, Arg extends GetStringArg<T>> = SetQueryReturnsColumnOptional<T, { [K in keyof T['__selectable'][Arg]['column']]: K extends '__outputType' ? T['__selectable'][Arg]['column'][K] | undefined : T['__selectable'][Arg]['column'][K]; }> & Omit<T['__selectable'][Arg]['column']['operators'], 'equals' | 'not'> & Column.OperatorsNullable<T['__selectable'][Arg]['column']>;
 type SetQueryReturnsColumnOrThrow<T, Column extends Column.Pick.OutputType> = { [K in keyof T]: K extends 'result' ? {
   value: Column;
-} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['__outputType']> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['__outputType']> : T[K]; } & QueryHasSelect;
 type SetQueryReturnsColumnOptional<T, Column extends Column.Pick.OutputType> = { [K in keyof T]: K extends 'result' ? {
   value: Column;
-} : K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<Column['__outputType'] | undefined> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<Column['__outputType'] | undefined> : T[K]; } & QueryHasSelect;
 type SetQueryReturnsColumn<T extends PickQueryResult> = { [K in keyof T]: K extends 'result' ? {
   value: T['result']['pluck'];
-} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['pluck']['__outputType']> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['pluck']['__outputType']> : T[K]; } & QueryHasSelect;
 type SetQueryReturnsColumnResult<T extends PickQueryResult, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'result' ? {
   value: T['result']['pluck'];
-} : K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThen<Result['pluck']['__outputType']> : T[K] } & QueryHasSelect;
+} : K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThen<Result['pluck']['__outputType']> : T[K]; } & QueryHasSelect;
 type SetQueryReturnsRowCount<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
   value: Column.Pick.QueryColumnOfType<number>;
-} : K extends 'then' ? QueryThen<number> : T[K] };
+} : K extends 'then' ? QueryThen<number> : T[K]; };
 type SetQueryReturnsRowCountMany<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'pluck' : K extends 'result' ? {
   pluck: Column.Pick.QueryColumnOfType<number>;
-} : K extends 'then' ? QueryThen<number> : T[K] };
-type SetQueryReturnsVoid<T> = { [K in keyof T]: K extends 'returnType' ? 'void' : K extends 'then' ? QueryThen<void> : T[K] };
-type SetQueryResult<T extends PickQueryReturnType, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'result' ? Result : K extends 'then' ? QueryThenByQuery<T, Result> : T[K] };
+} : K extends 'then' ? QueryThen<number> : T[K]; };
+type SetQueryReturnsVoid<T> = { [K in keyof T]: K extends 'returnType' ? 'void' : K extends 'then' ? QueryThen<void> : T[K]; };
+type SetQueryResult<T extends PickQueryReturnType, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'result' ? Result : K extends 'then' ? QueryThenByQuery<T, Result> : T[K]; };
 interface ReturnsQueryOrExpression<T> {
   (): QueryOrExpression<T>;
 }
@@ -11000,7 +10950,7 @@ interface QueryDataAliases extends PickQueryDataAliases {
 type SetQueryTableAlias<T extends PickQuerySelectableShapeAs, As extends string> = { [K in keyof T]: K extends '__selectable' ? Omit<T['__selectable'], `${T['__as']}.${keyof T['shape'] & string}`> & { [K in keyof T['shape'] & string as `${As}.${K}`]: {
   as: K;
   column: T['shape'][K];
-} } : K extends '__as' ? As : T[K] };
+}; } : K extends '__as' ? As : T[K]; };
 type AsQueryArg = PickQuerySelectableShapeAs;
 /** getters **/
 declare const getQueryAs: (q: {
@@ -11026,6 +10976,8 @@ declare abstract class QueryAsMethods {
 }
 declare const _appendQuery: (main: Query, append: Query, asFn: (as: string) => void) => Query;
 declare const _appendQueryOnUpsertCreate: (main: Query, append: Query, asFn: (as: string) => void) => Query;
+declare const _onUpsertUpdate: (q: Query, asFn: (as: string) => void) => Query;
+declare const _prependWithOnUpsertCreate: (q: Query, name: string | ((as: string) => void), query: Query) => void;
 interface RefreshMaterializedViewOptions {
   /**
    * Refresh the materialized view without blocking concurrent selects.
@@ -11062,7 +11014,7 @@ declare const escapeString: (value: string) => string;
  * Sets query kind to 'columnInfo', returns a single value (may return undefined),
  * the value is a {@link GetColumnInfo} object or a Record with keys for column names and ColumnInfo objects as values.
  **/
-type SetQueryReturnsColumnInfo<T extends PickQueryShape, Column extends keyof T['shape'] | undefined, Result = (Column extends keyof T['shape'] ? GetColumnInfo : { [K in keyof T['shape']]: GetColumnInfo })> = Omit<T, 'result' | 'returnType' | 'then'> & {
+type SetQueryReturnsColumnInfo<T extends PickQueryShape, Column extends keyof T['shape'] | undefined, Result = Column extends keyof T['shape'] ? GetColumnInfo : { [K in keyof T['shape']]: GetColumnInfo; }> = Omit<T, 'result' | 'returnType' | 'then'> & {
   result: {
     value: Column.Pick.QueryColumnOfType<Result>;
   };
@@ -11195,4 +11147,4 @@ declare const testTransaction: {
    */
   close(arg: Arg$1): Promise<void>;
 };
-export { type Adapter, AdapterClass, type AdapterConfigBase, type AdapterParams, type AdapterSchemaConfigOptions, type AfterCommitStandaloneHook, type AfterHook, ArrayColumn, type ArrayColumnValue, type ArrayData, type AsyncState, type BaseNumberData, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CidrColumn, CircleColumn, CitextColumn, type Code, type Codes, Column, type ColumnFromDbParams, type ColumnSchemaConfig, type ColumnSchemaGetterColumns, type ColumnSchemaGetterTableClass, type ColumnToCodeCtx, type ColumnTypeSchemaArg, type ColumnsByType, type ColumnsShape, type ComputedColumnsFromOptions, type ComputedOptionsConfig, type ComputedOptionsFactory, type CreateCtx, type CreateData, type CreateManyMethodsNames, type CreateMethodsNames, type CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, type DateColumnData, DateTimeBaseClass, DateTimeTzBaseClass, Db, type DbDomainArg, type DbExtension, type DbOptions, type DbResult, type DbSharedOptions, type DbSqlMethod, type DbStructureDomainsMap, type DbTableOptionScopes, type DbTableOptions, DecimalColumn, type DecimalColumnData, type DefaultColumnTypes, type DefaultPrivileges, type DefaultSchemaConfig, type DeleteMethodsNames, DomainColumn, DoublePrecisionColumn, type DriverAdapter, DynamicRawSQL, type EmptyObject, type EmptyTuple, EnumColumn, Expression, type ExpressionData, type FromArg, type FromResult, type GeneratorIgnore, type Grant, type HookSelectValue, InetColumn, IntegerBaseColumn, IntegerColumn, IntervalColumn, type IsQuery, type IsolationLevel, JSONColumn, JSONTextColumn, type JoinedShapes, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, MoneyColumn, type NoPrimaryKeyOption, type NonUniqDataItem, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, type NumberColumnData, Operators, type OperatorsArray, type OperatorsJson, type OperatorsOrdinalText, type OperatorsText, OrchidOrmInternalError, type Ord, PathColumn, type PickQueryInputType, type PickQueryInternal, type PickQueryQ, type PickQueryRelations, type PickQuerySelectableRelations, type PickQueryShape, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type Query, type QueryAfterHook, type QueryBeforeActionHook, type QueryBeforeHook, type QueryData, QueryError, type QueryHasWhere, type QueryHelperResult, QueryHookUtils, QueryHooks, type QueryInternal, type QueryLogObject, type QueryLogOptions, type QueryLogger, type QueryManyTake, type QueryManyTakeOptional, type QueryOrExpression, type QueryResult, type QueryResultRow, type QueryReturnType, type QuerySchema, type QueryScopes, RawSql, type RawSqlBase, RealColumn, type RecordKeyTrue, type RecordOptionalString, type RecordString, type RecordStringOrNumber, type RecordUnknown, type RefreshMaterializedViewOptions, type RelationConfigBase, type RelationJoinQuery, type RelationsBase, type Rls, type RlsPolicy, type SchemaConfigFnWithOptions, type SearchWeight, type SelectableFromShape, SerialColumn, type SerialColumnData, type ShallowSimplify, type ShapeUniqueColumns, type SingleSql, type SingleSqlItem, SmallIntColumn, SmallSerialColumn, type Sql, type SqlFn, type SqlSessionState, type StorageOptions, StringColumn, type StringData, type TableData, type TableDataFn, type TableDataInput, type TableDataItem, type TableDataItemsUniqueColumnTuples, type TableDataItemsUniqueColumns, type TableDataItemsUniqueConstraints, type TableDataMethods, type TemplateLiteralArgs, TextBaseColumn, TextColumn, TimeColumn, TimestampColumn, TimestampTZColumn, type Timestamps, type ToSQLCtx, type ToSqlValues, type TransactionAdapter, TransactionAdapterClass, type TransactionOptions, TsQueryColumn, TsVectorColumn, UUIDColumn, type UniqueConstraints, type UniqueTableDataItem, UnknownColumn, type UpdateData, type UpsertData, type UpsertThis, VarCharColumn, VirtualColumn, type WhereArg, XMLColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _orCreate, _prependWith, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, addCode, addTopCte, addTopCteSql, applyMixins, assignDbDataToColumn, backtickQuote, cloneQueryBaseUnscoped, codeToString, colors, columnsShapeToCode, constraintInnerToCode, consumeColumnName, copyTableData, createDbWithAdapter, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnInfo, getColumnTypes, getDateAsDateFn, getDateAsNumberFn, getDriverErrorCode, getFreeAlias, getFreeSetAlias, getImportPath, getPrimaryKeys, getQueryAs, getQuerySchema, getShapeFromSelect, getSqlText, getStackTrace, getSupportedDefaultPrivileges, indexInnerToCode, internalSchemaConfig, isExpression, isQueryReturnsAll, isRawSQL, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeConnectRetryConfig, noop, objectHasValues, omit, parseTableData, parseTableDataInput, pathToLog, pick, pluralize, prepareSubQueryForSql, primaryKeyInnerToCode, pushQueryOnForOuter, pushQueryValueImmutable, pushTableDataCode, queryToSql, quoteIdentifier, quoteObjectKey, quoteTableWithSchema, raw, rawSqlToCode, rawSqlToSql, referencesArgsToCode, refreshMaterializedView, returnArg, setColumnData, setColumnEncode, setColumnParse, setColumnParseNull, setCurrentColumnName, setDataValue, setDefaultLanguage, setFreeAlias, setQueryObjectValueImmutable, singleQuote, sqlToRawSql, tableDataMethods, testTransaction, toArray, toCamelCase, toPascalCase, toSnakeCase, wrapAdapterFnWithConnectRetry };
+export { type Adapter, AdapterClass, type AdapterConfigBase, type AdapterParams, type AdapterSchemaConfigOptions, type AfterCommitStandaloneHook, type AfterHook, ArrayColumn, type ArrayColumnValue, type ArrayData, type AsyncState, type BaseNumberData, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CidrColumn, CircleColumn, CitextColumn, type Code, type Codes, Column, type ColumnFromDbParams, type ColumnRefExpression, type ColumnSchemaConfig, type ColumnSchemaGetterColumns, type ColumnSchemaGetterTableClass, type ColumnToCodeCtx, type ColumnTypeSchemaArg, type ColumnsByType, type ColumnsShape, type ComputedColumnsFromOptions, type ComputedOptionsConfig, type ComputedOptionsFactory, type CreateCtx, type CreateData, type CreateManyMethodsNames, type CreateMethodsNames, type CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, type DateColumnData, type DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, type DbDomainArg, type DbExtension, type DbOptions, type DbResult, type DbSharedOptions, type DbSqlMethod, type DbStructureDomainsMap, type DbTableOptionScopes, type DbTableOptions, DecimalColumn, type DecimalColumnData, type DefaultColumnTypes, type DefaultPrivileges, type DefaultSchemaConfig, type DeleteMethodsNames, DomainColumn, DoublePrecisionColumn, type DriverAdapter, DynamicRawSQL, type EmptyObject, type EmptyTuple, EnumColumn, Expression, type ExpressionData, type FromArg, type FromResult, type GeneratorIgnore, type Grant, type HookSelectValue, InetColumn, IntegerBaseColumn, IntegerColumn, IntervalColumn, type IsQuery, type IsolationLevel, JSONColumn, JSONTextColumn, type JoinedShapes, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, MoneyColumn, type NoPrimaryKeyOption, type NonUniqDataItem, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, type NumberColumnData, Operators, type OperatorsArray, type OperatorsDate, type OperatorsJson, type OperatorsNumber, type OperatorsOrdinalText, type OperatorsText, OrchidOrmInternalError, type Ord, PathColumn, type PickQueryInputType, type PickQueryInternal, type PickQueryQ, type PickQueryRelations, type PickQuerySelectableRelations, type PickQueryShape, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type Query, type QueryAfterHook, type QueryBeforeActionHook, type QueryBeforeHook, type QueryData, QueryError, type QueryHasWhere, type QueryHelperResult, QueryHookUtils, QueryHooks, type QueryInternal, type QueryLogObject, type QueryLogOptions, type QueryLogger, type QueryManyTake, type QueryManyTakeOptional, type QueryOrExpression, type QueryResult, type QueryResultRow, type QueryReturnType, type QuerySchema, type QueryScopes, RawSql, type RawSqlBase, RealColumn, type RecordKeyTrue, type RecordOptionalString, type RecordString, type RecordStringOrNumber, type RecordUnknown, type RefreshMaterializedViewOptions, type RelationConfigBase, type RelationJoinQuery, type RelationsBase, type Rls, type RlsPolicy, type SchemaConfigFnWithOptions, type SearchWeight, type SelectSqlColumn, type SelectableFromShape, SerialColumn, type SerialColumnData, type ShallowSimplify, type ShapeUniqueColumns, type SingleSql, type SingleSqlItem, SmallIntColumn, SmallSerialColumn, type Sql, type SqlFn, type SqlSessionState, type StaticSQLArgs, type StorageOptions, StringColumn, type StringData, type TableData, type TableDataFn, type TableDataInput, type TableDataItem, type TableDataItemsUniqueColumnTuples, type TableDataItemsUniqueColumns, type TableDataItemsUniqueConstraints, type TableDataMethods, type TemplateLiteralArgs, TextBaseColumn, TextColumn, TimeColumn, TimestampColumn, TimestampTZColumn, type Timestamps, type ToSQLCtx, type ToSqlValues, type TransactionAdapter, TransactionAdapterClass, type TransactionOptions, TsQueryColumn, TsVectorColumn, UUIDColumn, type UniqueConstraints, type UniqueTableDataItem, UnknownColumn, type UpdateData, type UpsertData, type UpsertThis, VarCharColumn, VirtualColumn, type WhereArg, XMLColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _onUpsertUpdate, _orCreate, _prependWith, _prependWithOnUpsertCreate, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, addCode, addTopCte, addTopCteSql, applyMixins, assignDbDataToColumn, backtickQuote, cloneQueryBaseUnscoped, codeToString, colors, columnsShapeToCode, constraintInnerToCode, constraintToCode, consumeColumnName, copyTableData, createDbWithAdapter, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, excludeToCode, exhaustive, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnInfo, getColumnTypes, getDateAsDateFn, getDateAsNumberFn, getDriverErrorCode, getFreeAlias, getFreeSetAlias, getImportPath, getPrimaryKeys, getQueryAs, getQuerySchema, getShapeFromSelect, getSqlText, getStackTrace, getSupportedDefaultPrivileges, indexInnerToCode, indexToCode, internalSchemaConfig, isExpression, isQueryReturnsAll, isRawSQL, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeConnectRetryConfig, noop, objectHasValues, omit, parseTableData, parseTableDataInput, pathToLog, pick, pluralize, prepareSubQueryForSql, primaryKeyInnerToCode, pushQueryOnForOuter, pushQueryValueImmutable, pushTableDataCode, queryToSql, quoteIdentifier, quoteObjectKey, quoteTableWithSchema, raw, rawSqlToCode, rawSqlToSql, referencesArgsToCode, refreshMaterializedView, returnArg, setColumnData, setColumnEncode, setColumnParse, setColumnParseNull, setCurrentColumnName, setDataValue, setDefaultLanguage, setFreeAlias, setQueryObjectValueImmutable, singleQuote, sqlToRawSql, tableDataMethods, testTransaction, toArray, toCamelCase, toPascalCase, toSnakeCase, wrapAdapterFnWithConnectRetry };