pqb 0.71.3 → 0.72.0

package/dist/index.d.ts

@@ -984,10 +984,15 @@ 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;
@@ -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,8 +1085,11 @@ 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 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,
@@ -1140,21 +1150,21 @@ declare class SmallIntColumn<Schema extends ColumnSchemaConfig> extends IntegerB
   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";
   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";
   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";
@@ -1357,10 +1367,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
    */
@@ -1389,8 +1399,8 @@ interface DefaultSchemaConfig extends ColumnSchemaConfig<Column> {
     __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>;
+  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>;
@@ -1721,7 +1731,7 @@ 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;
@@ -1808,8 +1818,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 {
   /**
@@ -1892,7 +1902,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'];
@@ -2055,8 +2065,8 @@ type JoinResultRequireMain<T extends PickQuerySelectable, JoinedSelectable> = {
  */
 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.
@@ -2103,7 +2113,7 @@ type JoinResultSelectable<Result extends Column.QueryColumns, As extends string,
     column: ColumnsShape.MapToNullableObjectColumn<Result>;
   } : {
     as: K;
-    column: Column.Modifiers.QueryColumnToNullable<Result[K]>;
+    column: Column.QueryColumnToNullable<Result[K]>;
   } };
   relations: { [K in keyof JoinedRelations & string as `${As}.${K}`]: JoinedRelations[K] };
 };
@@ -2199,36 +2209,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 +2420,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")`,
    * );
    * ```
@@ -3110,12 +3105,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',
    * });
    * ```
@@ -3900,7 +3895,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 +3911,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`,
@@ -4526,21 +4521,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 +4650,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 +4723,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[];
   }
@@ -5379,7 +5371,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 +5498,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 +5517,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()),
@@ -6297,24 +6294,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 {
@@ -6716,45 +6708,42 @@ interface SelectSqlCallback {
 }
 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 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 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 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 +6834,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;
+    }
+    interface TableParamWithData {
+      data: {
+        columns: unknown;
+      };
+      instance(): TableParamInstanceInput;
     }
-    type ColumnNameOfTable<Table extends Column.ForeignKey.TableParam> = Table extends (new () => {
+    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,7 +6984,7 @@ 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 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;
@@ -7000,31 +7016,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 +7069,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 +7086,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 +7122,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 +7149,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 +7165,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 +7220,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 +7241,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 +7260,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 +7290,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');
@@ -7339,14 +7325,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 +7352,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 +7368,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 +7392,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 +7411,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 +7430,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 +7451,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 +7463,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 +7482,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 +7535,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 +7693,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 +7759,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;
@@ -7873,14 +7849,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 +7916,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,10 +7951,17 @@ 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 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 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 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 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 {
@@ -8196,31 +8179,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
@@ -8378,7 +8356,7 @@ 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 })[];
@@ -9135,6 +9113,8 @@ interface QueryData extends QueryDataAliases, PickQueryDataParsers, HasHookSelec
   /** upsert **/
   upsertUpdate?: boolean;
   upsertSecond?: boolean;
+  upsertUpdateAsFns?: AsFn[];
+  upsertCreateWith?: WithItems;
   upsertCreateAppendQueries?: SubQueryForSql[];
   upsertCreateAsFns?: AsFn[];
   upsertInsert?(): unknown;
@@ -9428,14 +9408,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.
@@ -10223,7 +10200,7 @@ interface NarrowValueTypeResult<T extends PickQueryResultReturnType, Narrow> ext
 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] };
 }
-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 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> {
@@ -10808,7 +10785,7 @@ type SetQueryReturnsPluckColumnResult<T extends PickQueryResult, Result extends
 } : 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 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;
@@ -11026,6 +11003,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.
@@ -11195,4 +11174,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 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, _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 };