pqb 0.27.6 → 0.28.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { QueryResultRow, AdapterConfigBase, AdapterBase, QueryInput, Sql, RecordUnknown, RecordKeyTrue, EmptyObject, QueryBaseCommon, QueryColumns, QueryInternal, QueryMetaBase, QueryReturnType, QueryThen, Expression, QueryColumn, MaybeArray, SelectableBase, TemplateLiteralArgs, PickOutputTypeAndOperators, PickQueryResult, OperatorToSQL, ColumnsShapeBase, ColumnsParsers, RecordString, PickQueryTable, getValueKey, PickQueryShape, PickQueryTableMetaResult, EmptyTuple, PickQueryMeta, PickQueryMetaResultReturnType, QueryColumnToNullable, QueryCatch, PickQueryMetaShape, PickQueryTableMetaResultShape, QueryColumnBooleanOrNull, SQLQueryArgs, ColumnSchemaConfig, DateColumnData, Code, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, StringTypeData, StaticSQLArgs, PickColumnBaseData, PrimaryKeyColumn, RawSQLBase, ColumnTypeBase, ForeignKeyTable, QueryColumnsInit, TimestampHelpers, ColumnNameOfTable, BaseNumberData, ColumnWithDefault, ParseColumn, EncodeColumn, PickQueryMetaResult, ColumnShapeOutput, DefaultSelectColumns, CoreQueryScopes, DbBase, TransactionState, PickQueryMetaResultWindows, CoreBaseOperators, IsQuery, PickQueryMetaShapeResultReturnType, MergeObjects, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, PickQueryReturnType, PickType, PickOutputType, Spread, PickQueryTableMetaShape } from 'orchid-core';
+import { QueryResultRow, AdapterConfigBase, AdapterBase, QueryInput, Sql, RecordUnknown, RecordKeyTrue, EmptyObject, QueryBaseCommon, QueryColumns, QueryMetaBase, QueryReturnType, QueryThen, Expression, QueryColumn, MaybeArray, SelectableBase, TemplateLiteralArgs, PickOutputTypeAndOperators, PickQueryResult, OperatorToSQL, ColumnsShapeBase, ColumnsParsers, RecordString, PickQueryTable, getValueKey, PickQueryShape, PickQueryTableMetaResult, EmptyTuple, PickQueryMeta, PickQueryMetaResultReturnType, QueryColumnToNullable, PickQueryMetaShape, PickQueryTableMetaResultShape, QueryColumnBooleanOrNull, SQLQueryArgs, ColumnSchemaConfig, DateColumnData, Code, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, RawSQLBase, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, StaticSQLArgs, ForeignKeyTable, ColumnNameOfTable, BaseNumberData, PickColumnBaseData, ColumnWithDefault, StringTypeData, PrimaryKeyColumn, ParseColumn, EncodeColumn, PickQueryMetaResult, QueryColumnsInit, DefaultSelectColumns, CoreQueryScopes, DbBase, QueryCatch, TransactionState, ColumnTypeBase, PickQueryMetaResultWindows, CoreBaseOperators, PickQueryUniqueProperties, IsQuery, PickQueryMetaShapeResultReturnType, MergeObjects, PickQueryResultUniqueColumns, QueryInternalBase, PickQueryReturnType, PickType, ColumnShapeOutput, PickOutputType, Spread, UniqueColumn, TimestampHelpers, Codes, ColumnDataCheckBase, PickQueryTableMetaShape } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'node:util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -37,7 +37,7 @@ declare class Adapter implements AdapterBase {
     connect(): Promise<PoolClient>;
     query<T extends QueryResultRow = QueryResultRow>(query: QueryInput, types?: TypeParsers): Promise<QueryResult<T>>;
     arrays<R extends any[] = any[]>(query: QueryInput, types?: TypeParsers): Promise<QueryArraysResult<R>>;
-    transaction<Result>(begin: Sql, cb: (adapter: TransactionAdapter) => Promise<Result>): Promise<Result>;
+    transaction<Result>(begin: Sql, cb: (adapter: TransactionAdapter) => Promise<Result>, end?: Sql): Promise<Result>;
     close(): Promise<void>;
 }
 declare class TransactionAdapter implements Adapter {
@@ -54,7 +54,6 @@ declare class TransactionAdapter implements Adapter {
     close(): Promise<void>;
 }
 
-type RelationsChain = (Query | RelationQuery)[];
 type RelationJoinQuery = (joiningQuery: Query, baseQuery: Query) => Query;
 interface RelationConfigBase {
     query: Query;
@@ -185,7 +184,7 @@ type QuerySourceItem = {
 }) & ({
     text: string | Expression;
 } | {
-    in: MaybeArray<string> | Record<string, SearchWeight>;
+    in: MaybeArray<string> | SearchWeightRecord;
 } | {
     vector: string;
 }) & ({
@@ -198,7 +197,9 @@ type QuerySourceItem = {
     tsQuery: string | Expression;
 });
 type JoinItem = SimpleJoinItem | JoinLateralItem;
-type SimpleJoinItemNonSubQueryArgs = [Record<string, string | Expression> | Expression | true] | [leftColumn: string | Expression, rightColumn: string | Expression] | [
+type SimpleJoinItemNonSubQueryArgs = [{
+    [K: string]: string | Expression;
+} | Expression | true] | [leftColumn: string | Expression, rightColumn: string | Expression] | [
     leftColumn: string | Expression,
     op: string,
     rightColumn: string | Expression
@@ -232,7 +233,9 @@ interface SimpleJoinItem {
 }
 type JoinLateralItem = [type: string, joined: Query, as: string];
 type WhereItem = {
-    [K: string]: unknown | Record<string, unknown | Query | Expression> | Expression;
+    [K: string]: unknown | {
+        [K: string]: unknown | Query | Expression;
+    } | Expression;
     NOT?: MaybeArray<WhereItem>;
     AND?: MaybeArray<WhereItem>;
     OR?: MaybeArray<WhereItem>[];
@@ -263,24 +266,33 @@ type WhereOnJoinItem = {
     };
 } | string;
 type SearchWeight = 'A' | 'B' | 'C' | 'D';
+type SearchWeightRecord = {
+    [K: string]: SearchWeight;
+};
 interface WhereSearchItem {
     as: string;
     vectorSQL: string;
 }
 type SortDir = 'ASC' | 'DESC' | 'ASC NULLS FIRST' | 'DESC NULLS LAST';
-type OrderItem = string | Record<string, SortDir> | Expression;
+type OrderItem = string | {
+    [K: string]: SortDir;
+} | Expression;
 type ColumnOperators<S extends SelectableBase, Column extends keyof S> = {
     [O in keyof S[Column]['column']['operators']]?: S[Column]['column']['operators'][O]['_opType'];
 };
 type HavingItem = TemplateLiteralArgs | Expression[];
-type WindowItem = Record<string, WindowDeclaration | Expression>;
+type WindowItem = {
+    [K: string]: WindowDeclaration | Expression;
+};
 interface WindowDeclaration {
     partitionBy?: SelectableOrExpression | SelectableOrExpression[];
     order?: OrderItem;
 }
 type UnionItem = Query | Expression;
 type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT' | 'EXCEPT ALL';
-type OnConflictItem = string | string[] | Expression;
+type OnConflictItem = string | string[] | Expression | {
+    constraint: string;
+};
 type OnConflictMergeUpdate = string | string[] | RecordUnknown | Expression;
 
 interface Operator<Value, Column extends PickOutputTypeAndOperators = PickOutputTypeAndOperators> {
@@ -353,13 +365,20 @@ declare const Operators: {
     array: OperatorsArray;
 };
 
-type JoinedShapes = Record<string, ColumnsShapeBase>;
-type JoinedParsers = Record<string, ColumnsParsers>;
+interface RecordOfColumnsShapeBase {
+    [K: string]: ColumnsShapeBase;
+}
+type JoinedShapes = RecordOfColumnsShapeBase;
+interface JoinedParsers {
+    [K: string]: ColumnsParsers;
+}
 type JoinOverrides = RecordString;
 type QueryBeforeHook = (query: Query) => void | Promise<void>;
 type QueryAfterHook<Data = unknown> = (data: Data, query: Query) => void | Promise<void>;
 type QueryHookSelect = string[];
-type QueryScopes = Record<string, QueryScopeData>;
+interface QueryScopes {
+    [K: string]: QueryScopeData;
+}
 type QueryScopeData = {
     and?: WhereItem[];
     or?: WhereItem[][];
@@ -375,7 +394,7 @@ type CommonQueryData = {
     wrapInTransaction?: boolean;
     throwOnNotFound?: boolean;
     with?: WithItem[];
-    withShapes?: Record<string, ColumnsShapeBase>;
+    withShapes?: RecordOfColumnsShapeBase;
     joinTo?: QueryDataJoinTo;
     joinedShapes?: JoinedShapes;
     joinedParsers?: JoinedParsers;
@@ -387,7 +406,9 @@ type CommonQueryData = {
     expr?: Expression;
     as?: string;
     from?: string | Query | Expression;
-    sources?: Record<string, QuerySourceItem>;
+    sources?: {
+        [K: string]: QuerySourceItem;
+    };
     and?: WhereItem[];
     or?: WhereItem[][];
     coalesceValue?: unknown | Expression;
@@ -415,7 +436,7 @@ type CommonQueryData = {
     transform?: ((input: unknown) => unknown)[];
     language?: string;
     isSubQuery?: true;
-    relChain?: RelationsChain;
+    relChain?: (Query | RelationQuery)[];
     /**
      * Stores current operator functions available for the query.
      * Is needed to remove these operators from query object when changing the query type, see {@link setQueryOperators}.
@@ -425,7 +446,9 @@ type CommonQueryData = {
      * Used by {@link setQueryOperators} to store the original `baseQuery` before extending it with operators.
      */
     originalQuery?: Query;
-    scopes: Record<string, QueryScopeData>;
+    scopes: {
+        [K: string]: QueryScopeData;
+    };
     all?: true;
 };
 type SelectQueryData = CommonQueryData & {
@@ -472,10 +495,12 @@ type InsertQueryData = CommonQueryData & {
         update?: OnConflictMergeUpdate;
     };
 };
-type UpdateQueryDataObject = Record<string, Expression | {
-    op: string;
-    arg: unknown;
-} | unknown>;
+interface UpdateQueryDataObject {
+    [K: string]: Expression | {
+        op: string;
+        arg: unknown;
+    } | unknown;
+}
 type UpdatedAtDataInjector = (data: UpdateQueryDataItem[]) => UpdateQueryDataItem | void;
 type UpdateQueryDataItem = UpdateQueryDataObject | Expression | UpdatedAtDataInjector;
 type UpdateQueryData = CommonQueryData & {
@@ -701,7 +726,7 @@ type JoinOptionalMain<T extends PickQueryMetaResultReturnType, Selectable extend
                 column: QueryColumnToNullable<T['meta']['selectable'][K]['column']>;
             };
         } & Selectable : T['meta'][K];
-    } : K extends 'result' ? NullableResult<T> : K extends 'then' ? QueryThen<GetQueryResult<T, NullableResult<T>>> : K extends 'catch' ? QueryCatch<GetQueryResult<T, NullableResult<T>>> : T[K];
+    } : K extends 'result' ? NullableResult<T> : K extends 'then' ? QueryThen<GetQueryResult<T, NullableResult<T>>> : T[K];
 };
 type NullableResult<T extends PickQueryResult> = {
     [K in keyof T['result']]: QueryColumnToNullable<T['result'][K]>;
@@ -2130,7 +2155,7 @@ declare abstract class DateBaseColumn<Schema extends ColumnSchemaConfig> extends
 }
 declare class DateColumn<Schema extends ColumnSchemaConfig> extends DateBaseColumn<Schema> {
     dataType: "date";
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare abstract class DateTimeBaseClass<Schema extends ColumnSchemaConfig> extends DateBaseColumn<Schema> {
     data: DateColumnData & {
@@ -2145,12 +2170,12 @@ declare abstract class DateTimeTzBaseClass<Schema extends ColumnSchemaConfig> ex
 }
 declare class TimestampColumn<Schema extends ColumnSchemaConfig> extends DateTimeBaseClass<Schema> {
     dataType: "timestamp";
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class TimestampTZColumn<Schema extends ColumnSchemaConfig> extends DateTimeTzBaseClass<Schema> {
     dataType: "timestamptz";
     baseDataType: "timestamp";
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class TimeColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsTime> {
     data: DateColumnData & {
@@ -2159,7 +2184,7 @@ declare class TimeColumn<Schema extends ColumnSchemaConfig> extends ColumnType<S
     dataType: "time";
     operators: OperatorsTime;
     constructor(schema: Schema, dateTimePrecision?: number);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class IntervalColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, TimeInterval, ReturnType<Schema['timeInterval']>, OperatorsDate> {
     data: ColumnData & {
@@ -2169,7 +2194,7 @@ declare class IntervalColumn<Schema extends ColumnSchemaConfig> extends ColumnTy
     dataType: "interval";
     operators: OperatorsDate;
     constructor(schema: Schema, fields?: string, precision?: number);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
     toSQL(): string;
 }
 
@@ -2179,7 +2204,7 @@ declare class EnumColumn<Schema extends ColumnTypeSchemaArg, SchemaType extends
     operators: OperatorsAny;
     dataType: string;
     constructor(schema: Schema, enumName: string, options: T, schemaType: SchemaType);
-    toCode(t: string, migration?: boolean): Code;
+    toCode(t: string, m?: boolean): Code;
     toSQL(): string;
 }
 
@@ -2192,7 +2217,7 @@ interface ArrayColumnValue {
     queryType: unknown;
     querySchema: any;
     toSQL(): string;
-    toCode(t: string, migration?: boolean): Code;
+    toCode(t: string, m?: boolean): Code;
     parseItem?(input: string): unknown;
     data: ColumnDataBase;
 }
@@ -2205,7 +2230,7 @@ declare class ArrayColumn<Schema extends ColumnTypeSchemaArg, Item extends Array
     data: ArrayData<Item>;
     constructor(schema: Schema, item: Item, inputType: InputType, outputType?: OutputType, queryType?: QueryType);
     toSQL(): string;
-    toCode(this: ArrayColumn<ColumnSchemaConfig, ArrayColumnValue, unknown, unknown, unknown>, t: string): Code;
+    toCode(this: ArrayColumn<ColumnSchemaConfig, ArrayColumnValue, unknown, unknown, unknown>, t: string, m?: boolean): Code;
     parseFn: ((input: unknown) => unknown[]) & {
         hideFromCode: boolean;
     };
@@ -2214,13 +2239,294 @@ declare class ArrayColumn<Schema extends ColumnTypeSchemaArg, Item extends Array
 declare class JSONColumn<T, Schema extends ColumnTypeSchemaArg> extends ColumnType<Schema, T, Schema['type'], OperatorsJson> {
     dataType: "jsonb";
     operators: OperatorsJson;
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class JSONTextColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "json";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
+}
+
+declare const templateLiteralToSQL: (template: TemplateLiteralArgs, ctx: ToSQLCtx, quotedAs?: string) => string;
+declare class RawSQL<T extends QueryColumn, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>> extends RawSQLBase<T, ColumnTypes> {
+    columnTypes: ColumnTypes;
+    constructor(sql: string | TemplateLiteralArgs, values?: RawSQLValues, type?: T);
+    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
+}
+interface DynamicRawSQL<T extends QueryColumn> extends Expression<T>, ExpressionTypeMethod {
+}
+declare class DynamicRawSQL<T extends QueryColumn, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>> extends Expression<T> {
+    fn: DynamicSQLArg;
+    _type: T;
+    columnTypes: ColumnTypes;
+    constructor(fn: DynamicSQLArg);
+    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
+}
+declare function raw<T = unknown>(...args: StaticSQLArgs): RawSQL<QueryColumn<T>>;
+declare function raw<T = unknown>(...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>>;
+declare const countSelect: RawSQL<QueryColumn<unknown, orchid_core.CoreBaseOperators>, DefaultColumnTypes<ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>>[];
+declare function sqlQueryArgsToExpression(args: SQLQueryArgs): RawSQL<QueryColumn>;
+type SqlFn = <T, Args extends [sql: TemplateStringsArray, ...values: unknown[]] | [sql: string] | [values: RecordUnknown, sql?: string]>(this: T, ...args: Args) => Args extends [RecordUnknown] ? (...sql: TemplateLiteralArgs) => RawSQLBase<QueryColumn, T> : RawSQLBase<QueryColumn, T>;
+declare const sqlFn: SqlFn;
+
+interface TableData {
+    primaryKey?: TableData.PrimaryKey;
+    indexes?: TableData.Index[];
+    constraints?: TableData.Constraint[];
+}
+declare namespace TableData {
+    export type DropMode = 'CASCADE' | 'RESTRICT';
+    export interface PrimaryKey {
+        columns: string[];
+        name?: string;
+    }
+    export interface ColumnIndex {
+        options: Index.ColumnArg & Index.Options;
+        name?: string;
+    }
+    export interface Index {
+        columns: Index.ColumnOrExpressionOptions[];
+        options: Index.Options;
+        name?: string;
+    }
+    export interface Constraint {
+        name?: string;
+        check?: Check;
+        identity?: Identity;
+        references?: References;
+        dropMode?: TableData.DropMode;
+    }
+    export type Check = RawSQLBase;
+    export interface ColumnReferences {
+        fnOrTable: TableData.References.FnOrTable;
+        foreignColumns: string[];
+        options?: References.Options;
+    }
+    export interface References extends ColumnReferences {
+        columns: string[];
+    }
+    export interface Identity extends SequenceBaseOptions {
+        always?: boolean;
+    }
+    interface SequenceBaseOptions {
+        increment?: number;
+        start?: number;
+        min?: number;
+        max?: number;
+        cache?: number;
+        cycle?: boolean;
+    }
+    export interface SequenceOptions extends SequenceBaseOptions {
+        dataType?: 'smallint' | 'integer' | 'bigint';
+        ownedBy?: string;
+    }
+    export namespace Index {
+        export interface ColumnOptions {
+            collate?: string;
+            opclass?: string;
+            order?: string;
+            weight?: SearchWeight;
+        }
+        export interface UniqueOptionsArg {
+            nullsNotDistinct?: boolean;
+            using?: string;
+            include?: MaybeArray<string>;
+            with?: string;
+            tablespace?: string;
+            where?: string;
+            dropMode?: 'CASCADE' | 'RESTRICT';
+        }
+        export interface OptionsArg extends UniqueOptionsArg {
+            unique?: boolean;
+        }
+        export interface TsVectorArg extends OptionsArg, TsVectorOptions {
+        }
+        export type Options = TsVectorArg;
+        export interface UniqueColumnArg extends ColumnOptions, UniqueOptionsArg {
+            expression?: string;
+        }
+        export interface ColumnArg extends UniqueColumnArg {
+            unique?: boolean;
+        }
+        interface TsVectorOptions {
+            language?: string;
+            languageColumn?: string;
+            tsVector?: boolean;
+        }
+        export interface TsVectorColumnArg extends ColumnArg, TsVectorOptions {
+        }
+        export interface ExpressionOptions extends ColumnOptions {
+            expression: string;
+        }
+        export interface ColumnOptionsForColumn<Column extends PropertyKey> extends ColumnOptions {
+            column: Column;
+        }
+        export type ColumnOrExpressionOptions<Column extends PropertyKey = string> = ColumnOptionsForColumn<Column> | ExpressionOptions;
+        export {};
+    }
+    export namespace References {
+        type FnOrTable = (() => ForeignKeyTable) | string;
+        /**
+         * - MATCH FULL will not allow one column of a multicolumn foreign key to be null unless all foreign key columns are null;
+         * if they are all null, the row is not required to have a match in the referenced table.
+         * - MATCH SIMPLE (default) allows any of the foreign key columns to be null; if any of them are null, the row is not required to have a match in the referenced table.
+         * - MATCH PARTIAL - PG docs say it's not implemented.
+         */
+        type Match = 'FULL' | 'PARTIAL' | 'SIMPLE';
+        /**
+         * - NO ACTION Produce an error indicating that the deletion or update would create a foreign key constraint violation. If the constraint is deferred, this error will be produced at constraint check time if there still exist any referencing rows. This is the default action.
+         * - RESTRICT Produce an error indicating that the deletion or update would create a foreign key constraint violation. This is the same as NO ACTION except that the check is not deferrable.
+         * - CASCADE Delete any rows referencing the deleted row, or update the values of the referencing column(s) to the new values of the referenced columns, respectively.
+         * - SET NULL Set all the referencing columns, or a specified subset of the referencing columns, to null. A subset of columns can only be specified for ON DELETE actions.
+         * - SET DEFAULT Set all the referencing columns, or a specified subset of the referencing columns, to their default values. A subset of columns can only be specified for ON DELETE actions. (There must be a row in the referenced table matching the default values, if they are not null, or the operation will fail.)
+         */
+        type Action = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
+        interface Options {
+            name?: string;
+            match?: Match;
+            onUpdate?: Action;
+            onDelete?: Action;
+            dropMode?: TableData.DropMode;
+        }
+    }
+    export {};
+}
+type TableDataInput = {
+    primaryKey?: TableData.PrimaryKey;
+    index?: TableData.Index;
+    constraint?: TableData.Constraint;
+};
+interface TableDataItem {
+    columns: unknown;
+    name: unknown;
+}
+interface UniqueTableDataItem<Shape extends QueryColumns = QueryColumns> {
+    columns: (keyof Shape)[];
+    name: string;
+}
+interface TableDataMethods<Key extends PropertyKey> {
+    primaryKey<Columns extends [Key, ...Key[]], Name extends string>(columns: Columns, name?: Name): {
+        columns: Columns;
+        name: string extends Name ? never : Name;
+    };
+    unique<Columns extends [
+        Key | TableData.Index.ColumnOrExpressionOptions<Key>,
+        ...(Key | TableData.Index.ColumnOrExpressionOptions<Key>)[]
+    ], Name extends string>(columns: Columns, ...args: [options?: TableData.Index.UniqueOptionsArg] | [name?: Name, options?: TableData.Index.UniqueOptionsArg]): {
+        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>)[], ...args: [options?: TableData.Index.OptionsArg] | [name?: string, options?: TableData.Index.OptionsArg]): TableDataItem;
+    searchIndex(columns: (Key | TableData.Index.ColumnOrExpressionOptions<Key>)[], ...args: [options?: TableData.Index.TsVectorArg] | [name?: string, options?: TableData.Index.TsVectorArg]): TableDataItem;
+    foreignKey<ForeignTable extends (() => ForeignKeyTable) | string, ForeignColumns extends ForeignTable extends () => ForeignKeyTable ? [
+        ColumnNameOfTable<ReturnType<ForeignTable>>,
+        ...ColumnNameOfTable<ReturnType<ForeignTable>>[]
+    ] : [string, ...string[]]>(columns: [string, ...string[]], fnOrTable: ForeignTable, foreignColumns: ForeignColumns, options?: TableData.References.Options): TableDataItem;
+    check(check: RawSQLBase, name?: string): TableDataItem;
+    sql: SqlFn;
+}
+type TableDataItemsUniqueColumns<Shape extends QueryColumns, T extends MaybeArray<TableDataItem>> = MaybeArray<TableDataItem> extends T ? never : T extends UniqueTableDataItem<Shape> ? ItemUniqueColumns<Shape, T> : T extends UniqueTableDataItem<Shape>[] ? {
+    [Item in T[number] as PropertyKey]: ItemUniqueColumns<Shape, Item>;
+}[PropertyKey] : never;
+type ItemUniqueColumns<Shape extends QueryColumns, T extends UniqueTableDataItem<Shape>> = {
+    [Column in T['columns'][number]]: UniqueQueryTypeOrExpression<Shape[Column]['queryType']>;
+};
+type TableDataItemsUniqueColumnTuples<Shape extends QueryColumns, T extends MaybeArray<TableDataItem>> = MaybeArray<TableDataItem> extends T ? never : T extends UniqueTableDataItem<Shape> ? T['columns'] : T extends UniqueTableDataItem<Shape>[] ? T[number]['columns'] : never;
+type UniqueQueryTypeOrExpression<T> = T | Expression<QueryColumn<T, EmptyObject>>;
+type TableDataItemsUniqueConstraints<T extends MaybeArray<TableDataItem>> = MaybeArray<TableDataItem> extends T ? never : T extends UniqueTableDataItem ? T['name'] : T extends UniqueTableDataItem[] ? T[number]['name'] : never;
+type TableDataFn<Shape, Data extends MaybeArray<TableDataItem>> = (t: TableDataMethods<keyof Shape>) => Data;
+declare const tableDataMethods: TableDataMethods<string>;
+declare const parseTableData: (dataFn?: TableDataFn<unknown, any>) => TableData;
+declare const parseTableDataInput: (tableData: TableData, item: TableDataInput) => void;
+
+interface NumberColumnData extends BaseNumberData {
+    identity: TableData.Identity;
+}
+interface SerialColumnData extends NumberColumnData {
+    default: Expression;
+}
+declare abstract class NumberBaseColumn<Schema extends ColumnSchemaConfig, SchemaType extends Schema['type']> extends ColumnType<Schema, number, SchemaType, OperatorsNumber> {
+    data: NumberColumnData;
+    operators: OperatorsNumber;
+}
+declare abstract class IntegerBaseColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['int']>> {
+    data: NumberColumnData;
+    constructor(schema: Schema);
+}
+declare abstract class NumberAsStringBaseColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsNumber> {
+    operators: OperatorsNumber;
+    data: ColumnData;
+    constructor(schema: Schema);
+}
+interface DecimalColumnData extends ColumnData {
+    numericPrecision?: number;
+    numericScale?: number;
+}
+declare class DecimalColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsNumber> {
+    data: DecimalColumnData;
+    operators: OperatorsNumber;
+    dataType: "numeric";
+    constructor(schema: Schema, numericPrecision?: number, numericScale?: number);
+    toCode(t: string, m?: boolean): Code;
+    toSQL(): string;
+}
+type IdentityColumn<T extends PickColumnBaseData> = ColumnWithDefault<T, Expression>;
+declare class SmallIntColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
+    dataType: "int2";
+    constructor(schema: Schema);
+    parseItem: typeof parseInt;
+    toCode(t: string, m?: boolean): Code;
+    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+}
+declare class IntegerColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
+    dataType: "int4";
+    constructor(schema: Schema);
+    parseItem: typeof parseInt;
+    toCode(t: string, m?: boolean): Code;
+    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+}
+declare class BigIntColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
+    dataType: "int8";
+    constructor(schema: Schema);
+    toCode(t: string, m?: boolean): Code;
+    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+}
+declare class RealColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['number']>> {
+    dataType: "float4";
+    parseItem: typeof parseFloat;
+    constructor(schema: Schema);
+    toCode(t: string, m?: boolean): Code;
+}
+declare class DoublePrecisionColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
+    dataType: "float8";
+    constructor(schema: Schema);
+    toCode(t: string, m?: boolean): Code;
+}
+declare class SmallSerialColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
+    dataType: "int2";
+    parseItem: typeof parseInt;
+    data: SerialColumnData;
+    constructor(schema: Schema);
+    toSQL(): string;
+    toCode(t: string, m?: boolean): Code;
+}
+declare class SerialColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
+    dataType: "int4";
+    parseItem: typeof parseInt;
+    data: SerialColumnData;
+    constructor(schema: Schema);
+    toSQL(): string;
+    toCode(t: string, m?: boolean): Code;
+}
+declare class BigSerialColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
+    dataType: "int8";
+    data: SerialColumnData;
+    constructor(schema: Schema);
+    toSQL(): string;
+    toCode(t: string, m?: boolean): Code;
 }
 
 type TextColumnData = StringTypeData;
@@ -2238,15 +2544,15 @@ declare abstract class LimitedTextBaseColumn<Schema extends ColumnSchemaConfig>
 }
 declare class VarCharColumn<Schema extends ColumnSchemaConfig> extends LimitedTextBaseColumn<Schema> {
     dataType: "varchar";
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class StringColumn$1<Schema extends ColumnSchemaConfig> extends VarCharColumn<Schema> {
     constructor(schema: Schema, limit?: number);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class CharColumn<Schema extends ColumnSchemaConfig> extends LimitedTextBaseColumn<Schema> {
     dataType: "char";
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class TextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColumn<Schema> {
     dataType: "text";
@@ -2255,60 +2561,60 @@ declare class TextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColu
         maxArg?: number;
     };
     constructor(schema: Schema, min?: number, max?: number);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class ByteaColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, Buffer, ReturnType<Schema['buffer']>, OperatorsText> {
     dataType: "bytea";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class PointColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "point";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class LineColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "line";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class LsegColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "lseg";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class BoxColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "box";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class PathColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "path";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class PolygonColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "polygon";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class CircleColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "circle";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class MoneyColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['stringSchema']>> {
     dataType: "money";
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
     parseFn: ((input: unknown) => number) & {
         hideFromCode: boolean;
     };
@@ -2317,25 +2623,25 @@ declare class CidrColumn<Schema extends ColumnSchemaConfig> extends ColumnType<S
     dataType: "cidr";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class InetColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "inet";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class MacAddrColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "macaddr";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class MacAddr8Column<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "macaddr8";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class BitColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['bit']>, OperatorsText> {
     dataType: "bit";
@@ -2344,26 +2650,26 @@ declare class BitColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Sc
         length: number;
     };
     constructor(schema: Schema, length: number);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
     toSQL(): string;
 }
 declare class BitVaryingColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['bit']>, OperatorsText> {
-    dataType: "bit varying";
+    dataType: "varbit";
     operators: OperatorsText;
     data: ColumnData & {
         length?: number;
     };
     constructor(schema: Schema, length?: number);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
     toSQL(): string;
 }
-type TsVectorGeneratedColumns = string[] | Record<string, SearchWeight>;
+type TsVectorGeneratedColumns = string[] | SearchWeightRecord;
 declare class TsVectorColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     defaultLanguage: string;
     dataType: "tsvector";
     operators: OperatorsText;
     constructor(schema: Schema, defaultLanguage?: string);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
     /**
      * For `tsvector` column type, it can also accept language (optional) and columns:
      *
@@ -2394,271 +2700,37 @@ declare class TsQueryColumn<Schema extends ColumnSchemaConfig> extends ColumnTyp
     dataType: "tsquery";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['uuid']>, OperatorsText> {
     dataType: "uuid";
     operators: OperatorsText;
     constructor(schema: Schema);
-    primaryKey<T extends PickColumnBaseData>(this: T): // using & bc otherwise the return type doesn't match `primaryKey` in ColumnType and TS complains
-    PrimaryKeyColumn<T> & {
+    /**
+     * see {@link ColumnType.primaryKey}
+     */
+    primaryKey<T extends PickColumnBaseData, Name extends string>(this: T, name?: Name): // using & bc otherwise the return type doesn't match `primaryKey` in ColumnType and TS complains
+    PrimaryKeyColumn<T, Name> & {
         data: {
             default: RawSQLBase;
         };
     };
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
 declare class XMLColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "xml";
     operators: OperatorsText;
     constructor(schema: Schema);
-    toCode(t: string): Code;
+    toCode(t: string, m?: boolean): Code;
 }
-declare class CitextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColumn<Schema> {
-    dataType: "citext";
-    data: TextColumnData & {
-        minArg?: number;
-        maxArg?: number;
-    };
-    constructor(schema: Schema, min?: number, max?: number);
-    toCode(t: string): Code;
-}
-
-declare class BooleanColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, boolean, ReturnType<Schema['boolean']>, OperatorsBoolean> {
-    dataType: "boolean";
-    operators: OperatorsBoolean;
-    constructor(schema: Schema);
-    toCode(t: string): Code;
-    parseItem: (input: string) => boolean;
-}
-
-declare class CustomTypeColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, unknown, ReturnType<Schema['unknown']>, typeof Operators.any> {
-    dataType: string;
-    operators: OperatorsAny;
-    constructor(schema: Schema, dataType: string);
-    toCode(t: string): Code;
-    as<T extends Pick<ColumnTypeBase, 'inputType' | 'outputType' | 'data'>, C extends Omit<ColumnTypeBase, 'inputType' | 'outputType'> & Pick<T, 'inputType' | 'outputType'>>(this: T, column: C): C;
-}
-declare class DomainColumn<Schema extends ColumnSchemaConfig> extends CustomTypeColumn<Schema> {
-    toCode(t: string): Code;
-}
-
-interface TableData {
-    primaryKey?: TableData.PrimaryKey;
-    indexes?: TableData.Index[];
-    constraints?: TableData.Constraint[];
-}
-declare namespace TableData {
-    export interface PrimaryKey {
-        columns: string[];
-        options?: {
-            name?: string;
-        };
-    }
-    export interface Index {
-        columns: IndexColumnOptions[];
-        options: IndexOptions;
-    }
-    export interface Constraint {
-        name?: string;
-        check?: Check;
-        identity?: Identity;
-        references?: References;
-        dropMode?: DropMode;
-    }
-    export type Check = RawSQLBase;
-    export interface References {
-        columns: string[];
-        fnOrTable: (() => ForeignKeyTable) | string;
-        foreignColumns: string[];
-        options?: ForeignKeyOptions;
-    }
-    export interface Identity extends SequenceBaseOptions {
-        always?: boolean;
-    }
-    interface SequenceBaseOptions {
-        incrementBy?: number;
-        startWith?: number;
-        min?: number;
-        max?: number;
-        cache?: number;
-        cycle?: boolean;
-    }
-    export interface SequenceOptions extends SequenceBaseOptions {
-        dataType?: 'smallint' | 'integer' | 'bigint';
-        ownedBy?: string;
-    }
-    export {};
-}
-declare const newTableData: () => TableData;
-declare const getTableData: () => TableData;
-declare const resetTableData: (data?: TableData) => void;
-declare const getColumnTypes: <ColumnTypes, Shape extends QueryColumnsInit>(types: ColumnTypes, fn: (t: ColumnTypes) => Shape, nowSQL: string | undefined, language: string | undefined, data?: TableData) => Shape;
-interface DefaultColumnTypes<SchemaConfig extends ColumnSchemaConfig> extends TimestampHelpers {
-    schema: SchemaConfig;
-    enum: SchemaConfig['enum'];
-    array: SchemaConfig['array'];
-    name<T>(this: T, name: string): T;
-    sql<T, Args extends [sql: TemplateStringsArray, ...values: unknown[]] | [sql: string] | [values: RecordUnknown, sql?: string]>(this: T, ...args: Args): Args extends [RecordUnknown] ? (...sql: TemplateLiteralArgs) => RawSQLBase<QueryColumn, T> : RawSQLBase<QueryColumn, T>;
-    smallint: SchemaConfig['smallint'];
-    integer: SchemaConfig['integer'];
-    bigint: SchemaConfig['bigint'];
-    numeric: SchemaConfig['decimal'];
-    decimal: SchemaConfig['decimal'];
-    real: SchemaConfig['real'];
-    doublePrecision: SchemaConfig['doublePrecision'];
-    identity(options?: TableData.Identity): IdentityColumn<ReturnType<SchemaConfig['integer']>>;
-    smallSerial: SchemaConfig['smallSerial'];
-    serial: SchemaConfig['serial'];
-    bigSerial: SchemaConfig['bigSerial'];
-    money: SchemaConfig['money'];
-    varchar: SchemaConfig['varchar'];
-    char: SchemaConfig['char'];
-    text: SchemaConfig['text'];
-    string: SchemaConfig['string'];
-    citext: SchemaConfig['citext'];
-    bytea(): ByteaColumn<SchemaConfig>;
-    date: SchemaConfig['date'];
-    timestampNoTZ: SchemaConfig['timestampNoTZ'];
-    timestamp: SchemaConfig['timestamp'];
-    time(precision?: number): TimeColumn<SchemaConfig>;
-    interval(fields?: string, precision?: number): IntervalColumn<SchemaConfig>;
-    boolean(): BooleanColumn<SchemaConfig>;
-    point(): PointColumn<SchemaConfig>;
-    line(): LineColumn<SchemaConfig>;
-    lseg(): LsegColumn<SchemaConfig>;
-    box(): BoxColumn<SchemaConfig>;
-    path(): PathColumn<SchemaConfig>;
-    polygon(): PolygonColumn<SchemaConfig>;
-    circle(): CircleColumn<SchemaConfig>;
-    cidr(): CidrColumn<SchemaConfig>;
-    inet(): InetColumn<SchemaConfig>;
-    macaddr(): MacAddrColumn<SchemaConfig>;
-    macaddr8(): MacAddr8Column<SchemaConfig>;
-    bit(length: number): BitColumn<SchemaConfig>;
-    bitVarying(length?: number): BitVaryingColumn<SchemaConfig>;
-    tsvector(): TsVectorColumn<SchemaConfig>;
-    tsquery(): TsQueryColumn<SchemaConfig>;
-    uuid(): UUIDColumn<SchemaConfig>;
-    xml(): XMLColumn<SchemaConfig>;
-    json: SchemaConfig['json'];
-    jsonText(): JSONTextColumn<SchemaConfig>;
-    type(dataType: string): CustomTypeColumn<SchemaConfig>;
-    domain(dataType: string): DomainColumn<SchemaConfig>;
-    primaryKey(columns: string[], options?: {
-        name?: string;
-    }): EmptyObject;
-    index(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): EmptyObject;
-    unique(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): EmptyObject;
-    /**
-     * See {@link ColumnType.searchIndex}
-     */
-    searchIndex(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): EmptyObject;
-    constraint<Table extends (() => ForeignKeyTable) | string, Columns extends Table extends () => ForeignKeyTable ? [
-        ColumnNameOfTable<ReturnType<Table>>,
-        ...ColumnNameOfTable<ReturnType<Table>>[]
-    ] : [string, ...string[]]>({ name, references, check, dropMode, }: {
-        name?: string;
-        references?: [
-            columns: string[],
-            fnOrTable: Table,
-            foreignColumns: Columns,
-            options?: ForeignKeyOptions
-        ];
-        check?: RawSQLBase;
-        dropMode?: DropMode;
-    }): EmptyObject;
-    foreignKey<Table extends (() => ForeignKeyTable) | string, Columns extends Table extends () => ForeignKeyTable ? [
-        ColumnNameOfTable<ReturnType<Table>>,
-        ...ColumnNameOfTable<ReturnType<Table>>[]
-    ] : [string, ...string[]]>(columns: string[], fnOrTable: Table, foreignColumns: Columns, options?: ForeignKeyOptions & {
-        name?: string;
-        dropMode?: DropMode;
-    }): EmptyObject;
-    check(check: RawSQLBase): EmptyObject;
-}
-declare const makeColumnTypes: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>(schema: SchemaConfig) => DefaultColumnTypes<SchemaConfig>;
-
-interface NumberColumnData extends BaseNumberData {
-    identity: TableData.Identity;
-}
-interface SerialColumnData extends NumberColumnData {
-    default: Expression;
-}
-declare abstract class NumberBaseColumn<Schema extends ColumnSchemaConfig, SchemaType extends Schema['type']> extends ColumnType<Schema, number, SchemaType, OperatorsNumber> {
-    data: NumberColumnData;
-    operators: OperatorsNumber;
-}
-declare abstract class IntegerBaseColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['int']>> {
-    data: NumberColumnData;
-    constructor(schema: Schema);
-}
-declare abstract class NumberAsStringBaseColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsNumber> {
-    operators: OperatorsNumber;
-    data: ColumnData;
-    constructor(schema: Schema);
-}
-interface DecimalColumnData extends ColumnData {
-    numericPrecision?: number;
-    numericScale?: number;
-}
-declare class DecimalColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsNumber> {
-    data: DecimalColumnData;
-    operators: OperatorsNumber;
-    dataType: "decimal";
-    constructor(schema: Schema, numericPrecision?: number, numericScale?: number);
-    toCode(t: string): Code;
-    toSQL(): string;
-}
-type IdentityColumn<T extends PickColumnBaseData> = ColumnWithDefault<T, Expression>;
-declare class SmallIntColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
-    dataType: "smallint";
-    parseItem: typeof parseInt;
-    toCode(t: string): Code;
-    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
-}
-declare class IntegerColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
-    dataType: "integer";
-    parseItem: typeof parseInt;
-    toCode(t: string): Code;
-    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
-}
-declare class BigIntColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
-    dataType: "bigint";
-    toCode(t: string): Code;
-    identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
-}
-declare class RealColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['number']>> {
-    dataType: "real";
-    parseItem: typeof parseFloat;
-    constructor(schema: Schema);
-    toCode(t: string): Code;
-}
-declare class DoublePrecisionColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
-    dataType: "double precision";
-    toCode(t: string): Code;
-}
-declare class SmallSerialColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
-    dataType: "smallint";
-    parseItem: typeof parseInt;
-    data: SerialColumnData;
-    constructor(schema: Schema);
-    toSQL(): string;
-    toCode(t: string): Code;
-}
-declare class SerialColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
-    dataType: "integer";
-    parseItem: typeof parseInt;
-    data: SerialColumnData;
-    constructor(schema: Schema);
-    toSQL(): string;
-    toCode(t: string): Code;
-}
-declare class BigSerialColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema> {
-    dataType: "bigint";
-    data: SerialColumnData;
-    toSQL(): string;
-    toCode(t: string): Code;
+declare class CitextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColumn<Schema> {
+    dataType: "citext";
+    data: TextColumnData & {
+        minArg?: number;
+        maxArg?: number;
+    };
+    constructor(schema: Schema, min?: number, max?: number);
+    toCode(t: string, m?: boolean): Code;
 }
 
 interface DefaultSchemaConfig extends ColumnSchemaConfig<ColumnType> {
@@ -2770,14 +2842,33 @@ declare class SoftDeleteMethods {
     hardDelete<T extends QueryWithSoftDelete>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
 }
 
+type ShapeColumnPrimaryKeys<Shape extends QueryColumnsInit> = {
+    [K in {
+        [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? K : never;
+    }[keyof Shape]]: UniqueQueryTypeOrExpression<Shape[K]['queryType']>;
+};
+type ShapeUniqueColumns<Shape extends 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 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;
+    noPrimaryKey?: NoPrimaryKeyOption;
+    extensions?: (string | RecordString)[];
+    domains?: {
+        [K: string]: DbDomainArg<DefaultColumnTypes<DefaultSchemaConfig>>;
+    };
+}
 type DbOptions<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> = ({
     adapter: Adapter;
-} | Omit<AdapterOptions, 'log'>) & QueryLogOptions & {
+} | Omit<AdapterOptions, 'log'>) & DbSharedOptions & {
     schemaConfig?: SchemaConfig;
     columnTypes?: ColumnTypes | ((t: DefaultColumnTypes<SchemaConfig>) => ColumnTypes);
-    autoPreparedStatements?: boolean;
-    noPrimaryKey?: NoPrimaryKeyOption;
     snakeCase?: boolean;
     nowSQL?: string;
 };
@@ -2795,21 +2886,23 @@ interface DbTableOptions<Table extends string | undefined, Shape extends QueryCo
      * See {@link SoftDeleteMethods}
      */
     softDelete?: SoftDeleteOption<Shape>;
+    comment?: string;
 }
 /**
  * See {@link ScopeMethods}
  */
-type DbTableOptionScopes<Table extends string | undefined, Shape extends QueryColumns, Keys extends string = string> = Record<Keys, (q: ScopeArgumentQuery<Table, Shape>) => QueryBase>;
-type QueryDefaultReturnData<Shape extends QueryColumnsInit> = Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[];
+type DbTableOptionScopes<Table extends string | undefined, Shape extends QueryColumns, Keys extends string = string> = {
+    [K in Keys]: (q: ScopeArgumentQuery<Table, Shape>) => QueryBase;
+};
+type QueryDefaultReturnData<Shape extends QueryColumnsInit> = {
+    [K in DefaultSelectColumns<Shape>[number]]: Shape[K]['outputType'];
+}[];
 declare const anyShape: QueryColumnsInit;
-interface Db<Table extends string | undefined = undefined, Shape extends QueryColumnsInit = QueryColumnsInit, Relations extends RelationsBase = EmptyObject, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends QueryColumnsInit = Shape, Scopes extends CoreQueryScopes | undefined = EmptyObject> extends DbBase<Adapter, Table, Shape, ColumnTypes, ShapeWithComputed>, QueryMethods<ColumnTypes>, QueryBase {
-    new (adapter: Adapter, queryBuilder: Db<Table, Shape, Relations, ColumnTypes>, table?: Table, shape?: Shape, options?: DbTableOptions<Table, ShapeWithComputed>): this;
+interface Db<Table extends string | undefined = undefined, Shape extends QueryColumnsInit = QueryColumnsInit, PrimaryKeys = never, UniqueColumns = never, UniqueColumnTuples = never, UniqueConstraints = never, Relations extends RelationsBase = EmptyObject, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends QueryColumnsInit = Shape, Scopes extends CoreQueryScopes | undefined = EmptyObject> extends DbBase<Adapter, Table, Shape, ColumnTypes, ShapeWithComputed>, QueryMethods<ColumnTypes>, QueryBase {
     result: Pick<Shape, DefaultSelectColumns<Shape>[number]>;
     queryBuilder: Db;
-    primaryKeys: Query['primaryKeys'];
     returnType: Query['returnType'];
     then: QueryThen<QueryDefaultReturnData<Shape>>;
-    catch: QueryCatch<QueryDefaultReturnData<Shape>>;
     windows: Query['windows'];
     defaultSelectColumns: DefaultSelectColumns<Shape>;
     relations: Relations;
@@ -2820,17 +2913,25 @@ interface Db<Table extends string | undefined = undefined, Shape extends QueryCo
         defaults: {
             [K in keyof Shape as unknown extends Shape[K]['data']['default'] ? never : K]: true;
         };
-        scopes: Record<keyof Scopes, true>;
+        scopes: {
+            [K in keyof Scopes]: true;
+        };
         selectable: SelectableFromShape<ShapeWithComputed, Table>;
     };
-}
-declare class Db<Table extends string | undefined = undefined, Shape extends QueryColumnsInit = QueryColumnsInit, Relations extends RelationsBase = EmptyObject, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends QueryColumnsInit = Shape> implements Query {
+    internal: QueryInternal<{
+        [K in keyof PrimaryKeys]: (keyof PrimaryKeys extends K ? never : keyof PrimaryKeys) extends never ? PrimaryKeys[K] : never;
+    }[keyof PrimaryKeys], PrimaryKeys | UniqueColumns, {
+        [K in keyof Shape]: Shape[K]['data']['unique'] extends string ? K : never;
+    }[keyof Shape] | keyof PrimaryKeys, UniqueColumnTuples, UniqueConstraints>;
+    catch: QueryCatch;
+}
+declare class Db<Table extends string | undefined = undefined, Shape extends QueryColumnsInit = QueryColumnsInit, PrimaryKeys = never, UniqueColumns = never, UniqueColumnTuples = never, UniqueConstraints = never, Relations extends RelationsBase = EmptyObject, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends QueryColumnsInit = Shape> implements Query {
     adapter: Adapter;
     queryBuilder: Db;
     table: Table;
     shape: ShapeWithComputed;
     columnTypes: ColumnTypes;
-    constructor(adapter: Adapter, queryBuilder: Db, table: Table, shape: ShapeWithComputed, columnTypes: ColumnTypes, transactionStorage: AsyncLocalStorage<TransactionState>, options: DbTableOptions<Table, ShapeWithComputed>);
+    constructor(adapter: Adapter, queryBuilder: Db, table: Table, shape: ShapeWithComputed, columnTypes: ColumnTypes, transactionStorage: AsyncLocalStorage<TransactionState>, options: DbTableOptions<Table, ShapeWithComputed>, tableData?: TableData);
     [inspect.custom](): string;
     /**
      * Use `query` to perform raw SQL queries.
@@ -2890,16 +2991,16 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Que
      */
     queryArrays<R extends any[] = any[]>(...args: SQLQueryArgs): Promise<QueryArraysResult<R>>;
 }
-type DbTableConstructor<ColumnTypes> = <Table extends string, Shape extends QueryColumnsInit, Options extends DbTableOptions<Table, Shape>>(table: Table, shape?: ((t: ColumnTypes) => Shape) | Shape, options?: Options) => Db<Table, Shape, EmptyObject, ColumnTypes, Shape, MapTableScopesOption<Options['scopes'], Options['softDelete']>>;
+type DbTableConstructor<ColumnTypes> = <Table extends string, Shape extends QueryColumnsInit, Data extends MaybeArray<TableDataItem>, Options extends DbTableOptions<Table, Shape>>(table: Table, shape?: ((t: ColumnTypes) => Shape) | Shape, tableData?: TableDataFn<Shape, Data>, options?: Options) => Db<Table, Shape, keyof ShapeColumnPrimaryKeys<Shape> extends never ? never : ShapeColumnPrimaryKeys<Shape>, ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>, EmptyObject, ColumnTypes, Shape, MapTableScopesOption<Options['scopes'], Options['softDelete']>>;
 type MapTableScopesOption<Scopes extends CoreQueryScopes | undefined, SoftDelete extends true | PropertyKey | undefined> = {
     [K in keyof Scopes | (SoftDelete extends true | PropertyKey ? 'nonDeleted' : never)]: unknown;
 };
-interface DbResult<ColumnTypes> extends Db<string, Record<string, never>, EmptyObject, ColumnTypes>, DbTableConstructor<ColumnTypes> {
+interface DbResult<ColumnTypes> extends Db<string, never, never, never, never, never, EmptyObject, ColumnTypes>, DbTableConstructor<ColumnTypes> {
     adapter: Adapter;
     close: Adapter['close'];
 }
 /**
- * For the case of using the query builder as a standalone tool, use `createDb`.
+ * If you'd like to use the query builder of OrchidORM as a standalone tool, install `pqb` package and use `createDb` to initialize it.
  *
  * As `Orchid ORM` focuses on ORM usage, docs examples mostly demonstrates how to work with ORM-defined tables,
  * but everything that's not related to table relations should also work with `pqb` query builder on its own.
@@ -2975,6 +3076,7 @@ interface DbResult<ColumnTypes> extends Db<string, Record<string, never>, EmptyO
  * ```
  */
 declare const createDb: <SchemaConfig extends ColumnSchemaConfig<ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ log, logger, snakeCase, nowSQL, schemaConfig, columnTypes: ctOrFn, ...options }: DbOptions<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
+declare const _initQueryBuilder: (adapter: Adapter, columnTypes: unknown, transactionStorage: AsyncLocalStorage<TransactionState>, commonOptions: DbTableOptions<undefined, QueryColumns>, options: DbSharedOptions) => Db;
 
 type ToSQLCtx = {
     queryBuilder: Db;
@@ -2991,7 +3093,21 @@ type ToSQLOptions = {
 type ToSqlOptionsInternal = ToSQLOptions & {
     aliasValue?: true;
 };
-type ToSQLQuery = Pick<Query, '__isQuery' | 'q' | 'queryBuilder' | 'table' | 'internal' | 'relations' | 'withData' | 'clone' | 'baseQuery' | 'meta' | 'returnType' | 'result' | 'shape'>;
+type ToSQLQuery = {
+    __isQuery: Query['__isQuery'];
+    q: Query['q'];
+    queryBuilder: Query['queryBuilder'];
+    table?: Query['table'];
+    internal: Query['internal'];
+    relations: Query['relations'];
+    withData: Query['withData'];
+    clone: Query['clone'];
+    baseQuery: Query['baseQuery'];
+    meta: Query['meta'];
+    returnType: Query['returnType'];
+    result: Query['result'];
+    shape: Query['shape'];
+};
 declare const toSQL: (table: ToSQLQuery, options?: ToSQLOptions) => Sql;
 declare const makeSQL: (table: ToSQLQuery, options?: ToSqlOptionsInternal) => Sql;
 declare function pushLimitSQL(sql: string[], values: unknown[], q: SelectQueryData): void;
@@ -3001,7 +3117,7 @@ type SelectableOrExpression<T extends PickQueryMeta = PickQueryMeta, C extends Q
 type ExpressionOutput<T extends PickQueryMeta, Expr extends SelectableOrExpression<T>> = Expr extends keyof T['meta']['selectable'] ? T['meta']['selectable'][Expr]['column'] : Expr extends Expression ? Expr['_type'] : never;
 declare const getClonedQueryData: (query: QueryData) => QueryData;
 declare const getQueryAs: (q: {
-    table?: string | undefined;
+    table?: string;
     q: {
         as?: string;
     };
@@ -3037,7 +3153,9 @@ interface AggregateOptions<T extends PickQueryMetaResultRelationsWindows> {
 type Over<T extends PickQueryMetaResultWindows> = keyof T['windows'] | WindowArgDeclaration<T>;
 type FnExpressionArgs<Q extends PickQueryMeta> = (SelectableOrExpression<Q> | FnExpressionArgsPairs<Q> | FnExpressionArgsValue)[];
 interface FnExpressionArgsPairs<Q extends PickQueryMeta> {
-    pairs: Record<string, SelectableOrExpression<Q>>;
+    pairs: {
+        [K: string]: SelectableOrExpression<Q>;
+    };
 }
 interface FnExpressionArgsValue {
     value: unknown;
@@ -3622,7 +3740,9 @@ type CreateRawArgs<T extends CreateSelf, Arg extends {
 }> = keyof RawRequiredColumns<T> extends Arg['columns'][number] ? [data: Arg] : [
     `Missing required columns: ${Exclude<keyof RawRequiredColumns<T> & string, Arg['columns'][number]>}`
 ];
-type OnConflictArg<T extends CreateSelf> = keyof T['shape'] | (keyof T['shape'])[] | Expression;
+type OnConflictArg<T extends PickQueryUniqueProperties> = T['internal']['uniqueColumnNames'] | T['internal']['uniqueColumnTuples'] | Expression | {
+    constraint: T['internal']['uniqueConstraints'];
+};
 type AddQueryDefaults<T extends CreateSelf, Defaults> = {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta']]: K extends 'defaults' ? T['meta']['defaults'] & Defaults : T['meta'][K];
@@ -3653,7 +3773,7 @@ declare const _queryInsertFrom: <T extends CreateSelf, Q extends Query & {
 }>(q: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>) => InsertResult<T>;
 declare const _queryCreateManyFrom: <T extends CreateSelf>(q: T, query: Query) => CreateManyResult<T>;
 declare const _queryInsertManyFrom: <T extends CreateSelf>(q: T, query: Query) => InsertManyResult<T>;
-declare const _queryDefaults: <T extends CreateSelf, Data extends Partial<CreateData<T>>>(q: T, data: Data) => AddQueryDefaults<T, Record<keyof Data, true>>;
+declare const _queryDefaults: <T extends CreateSelf, Data extends Partial<CreateData<T>>>(q: T, data: Data) => AddQueryDefaults<T, { [K in keyof Data]: true; }>;
 /**
  * Names of all create methods,
  * is used in {@link RelationQuery} to remove these methods if chained relation shouldn't have them,
@@ -3672,9 +3792,9 @@ declare class Create {
      *   password: '1234',
      * });
      *
-     * // When using `.onConflict().ignore()`,
+     * // When using `.onConflictIgnore()`,
      * // the record may be not created and the `createdCount` will be 0.
-     * const createdCount = await db.table.insert(data).onConflict().ignore();
+     * const createdCount = await db.table.insert(data).onConflictIgnore();
      *
      * await db.table.create({
      *   // raw SQL
@@ -3864,34 +3984,48 @@ declare class Create {
      *
      * @param data - default values for `create` and `createMany` which will follow `defaults`
      */
-    defaults<T extends CreateSelf, Data extends Partial<CreateData<T>>>(this: T, data: Data): AddQueryDefaults<T, Record<keyof Data, true>>;
+    defaults<T extends CreateSelf, Data extends Partial<CreateData<T>>>(this: T, data: Data): AddQueryDefaults<T, {
+        [K in keyof Data]: true;
+    }>;
     /**
-     * A modifier for creating queries that specify alternative behavior in the case of a conflict.
-     * A conflict occurs when a table has a `PRIMARY KEY` or a `UNIQUE` index on a column
-     * (or a composite index on a set of columns) and a row being created has the same value as a row
-     * that already exists in the table in this column(s).
-     * The default behavior in case of conflict is to raise an error and abort the query.
+     * By default, violating unique constraint will cause the creative query to throw,
+     * you can define what to do on a conflict: to ignore it, or to merge the existing record with a new data.
+     *
+     * A conflict occurs when a table has a primary key or a unique index on a column,
+     * or a composite primary key unique index on a set of columns,
+     * and a row being created has the same value as a row that already exists in the table in this column(s).
+     *
+     * Use `onConflictIgnore()` to suppress the error and continue without updating the record,
+     * or `onConflict(['uniqueColumn']).merge()` to update the record with a new data.
      *
-     * Use `onConflict` to either ignore the error by using `.onConflict().ignore()`,
-     * or to update the existing row with new data (perform an "UPSERT") by using `.onConflict().merge()`.
+     * `onConflict` only accepts column names that are defined in `primaryKey` or `unique` in the table definition.
+     * To specify a constraint, its name also must be explicitly set in `primaryKey` or `unique` in the table code.
+     *
+     * Postgres has a limitation that a single `INSERT` query can have only a single `ON CONFLICT` clause that can target only a single unique constraint
+     * for updating the record.
+     *
+     * If your table has multiple potential reasons for unique constraint violation, such as username and email columns in a user table,
+     * consider using [upsert](#upsert) instead.
      *
      * ```ts
      * // leave `onConflict` without argument to ignore or merge on any conflict
-     * db.table.create(data).onConflict().ignore();
+     * db.table.create(data).onConflictIgnore();
      *
      * // single column:
-     * db.table.create(data).onConfict('email');
+     * db.table.create(data).onConfict('email').merge();
      *
      * // array of columns:
-     * db.table.create(data).onConfict(['email', 'name']);
+     * db.table.create(data).onConfict(['email', 'name']).merge();
      *
-     * // raw expression:
-     * db.table.create(data).onConfict(db.table.sql`(email) where condition`);
-     * ```
+     * // constraint name
+     * db.table.create(data).onConfict({ constraint: 'unique_index_name' }).merge();
      *
-     * ::: info
-     * The column(s) given to the `onConflict` must either be the table's PRIMARY KEY or have a UNIQUE index on them, or the query will fail to execute.
-     * When specifying multiple columns, they must be a composite PRIMARY KEY or have a composite UNIQUE index.
+     * // raw SQL expression:
+     * db.table
+     *   .create(data)
+     *   .onConfict(db.table.sql`(email) where condition`)
+     *   .merge();
+     * ```
      *
      * You can use the db.table.sql function in onConflict.
      * It can be useful to specify a condition when you have a partial index:
@@ -3908,26 +4042,15 @@ declare class Create {
      *   .ignore();
      * ```
      *
-     * :::
-     *
-     * See the documentation on the .ignore() and .merge() methods for more details.
-     *
      * @param arg - optionally provide an array of columns
      */
-    onConflict<T extends CreateSelf, Arg extends OnConflictArg<T>>(this: T, arg?: Arg): OnConflictQueryBuilder<T, Arg>;
-}
-declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflictArg<T> | undefined> {
-    private query;
-    private onConflict;
-    constructor(query: T, onConflict: Arg);
+    onConflict<T extends CreateSelf, Arg extends OnConflictArg<T>>(this: T, arg: Arg): OnConflictQueryBuilder<T, Arg>;
     /**
-     * Available only after `onConflict`.
+     * Use `onConflictIgnore` to suppress unique constraint violation error when creating a record.
      *
-     * `ignore` modifies a create query, and causes it to be silently dropped without an error if a conflict occurs.
+     * Adds `ON CONFLICT (columns) DO NOTHING` clause to the insert statement, columns are optional.
      *
-     * Adds the `ON CONFLICT (columns) DO NOTHING` clause to the insert statement.
-     *
-     * It produces `ON CONFLICT DO NOTHING` when no `onConflict` argument provided.
+     * Can also accept a constraint name.
      *
      * ```ts
      * db.table
@@ -3935,53 +4058,55 @@ declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflic
      *     email: 'ignore@example.com',
      *     name: 'John Doe',
      *   })
-     *   .onConflict('email')
-     *   .ignore();
+     *   // on any conflict:
+     *   .onConflictIgnore()
+     *   // or, for a specific column:
+     *   .onConflictIgnore('email')
+     *   // or, for a specific constraint:
+     *   .onConflictIgnore({ constraint: 'unique_index_name' });
      * ```
      *
-     *
-     * When there is a conflict, nothing can be returned from the database, that's why `ignore` has to add `| undefined` part to the response type.
-     *
-     * `create` returns a full record by default, it becomes `RecordType | undefined` after applying `ignore`.
+     * When there is a conflict, nothing can be returned from the database, so `onConflictIgnore` adds `| undefined` part to the response type.
      *
      * ```ts
      * const maybeRecord: RecordType | undefined = await db.table
      *   .create(data)
-     *   .onConflict()
-     *   .ignore();
+     *   .onConflictIgnore();
      *
      * const maybeId: number | undefined = await db.table
      *   .get('id')
      *   .create(data)
-     *   .onConflict()
-     *   .ignore();
+     *   .onConflictIgnore();
      * ```
      *
-     * When creating many records, only the created records will be returned. If no records were created, array will be empty:
+     * When creating multiple records, only created records will be returned. If no records were created, array will be empty:
      *
      * ```ts
      * // array can be empty
-     * const arr = await db.table.createMany([data, data, data]).onConflict().ignore();
+     * const arr = await db.table.createMany([data, data, data]).onConflictIgnore();
      * ```
      */
-    ignore(): IgnoreResult<T>;
+    onConflictIgnore<T extends CreateSelf, Arg extends OnConflictArg<T>>(this: T, arg?: Arg): IgnoreResult<T>;
+}
+declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflictArg<T> | undefined> {
+    private query;
+    private onConflict;
+    constructor(query: T, onConflict: Arg);
     /**
-     * Available only after `onConflict`.
-     *
-     * Modifies a create query, to turn it into an 'upsert' operation.
+     * Available only after [onConflict](#onconflict).
      *
      * Adds an `ON CONFLICT (columns) DO UPDATE` clause to the insert statement.
      *
-     * When no `onConflict` argument provided,
-     * it will automatically collect all table columns that have unique index and use them as a conflict target.
-     *
      * ```ts
      * db.table
      *   .create({
      *     email: 'ignore@example.com',
      *     name: 'John Doe',
      *   })
+     *   // for a specific column:
      *   .onConflict('email')
+     *   // or, for a specific constraint:
+     *   .onConflict({ constraint: 'unique_constraint_name' })
      *   .merge();
      * ```
      *
@@ -4012,15 +4137,15 @@ declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflic
      *     updatedAt: timestamp,
      *   })
      *   .onConflict('email')
-     *   // string argument for a single column:
+     *   // update only a single column
      *   .merge('email')
-     *   // array of strings for multiple columns:
+     *   // or, update multiple columns
      *   .merge(['email', 'name', 'updatedAt']);
      * ```
      *
-     * It is also possible to specify data to update separately from the data to create.
+     * It's possible to specify data to update separately from the data to create.
      * This is useful if you want to make an update with different data than in creating.
-     * For example, you may want to change a value if the row already exists:
+     * For example, changing a value if the row already exists:
      *
      * ```ts
      * const timestamp = Date.now();
@@ -4038,7 +4163,7 @@ declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflic
      *   });
      * ```
      *
-     * It is also possible to add a WHERE clause to conditionally update only the matching rows:
+     * You can use `where` to update only the matching rows:
      *
      * ```ts
      * const timestamp = Date.now();
@@ -4058,7 +4183,7 @@ declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflic
      *   .where({ updatedAt: { lt: timestamp } });
      * ```
      *
-     * `merge` also accepts raw expression:
+     * `merge` can take a raw SQL expression:
      *
      * ```ts
      * db.table
@@ -4156,7 +4281,7 @@ type FromResult<T extends FromQuerySelf, Arg extends FromArg<T>> = Arg extends s
                 column: Arg['result'][K];
             } : never;
         } : T['meta'][K];
-    } : K extends 'result' ? Arg['result'] : K extends 'shape' ? Arg['result'] : K extends 'then' ? QueryThen<GetQueryResult<T, Arg['result']>> : K extends 'catch' ? QueryCatch<GetQueryResult<T, Arg['result']>> : T[K];
+    } : K extends 'result' ? Arg['result'] : K extends 'shape' ? Arg['result'] : K extends 'then' ? QueryThen<GetQueryResult<T, Arg['result']>> : T[K];
 } : T;
 declare function queryFrom<T extends FromQuerySelf, Arg extends FromArg<T>>(self: T, arg: Arg, options?: FromArgOptions): FromResult<T, Arg>;
 declare function queryFromSql<T extends FromQuerySelf>(self: T, args: SQLQueryArgs): T;
@@ -4630,7 +4755,7 @@ declare class QueryLog {
 type MergeQuery<T extends PickQueryMetaResultReturnTypeWithDataWindows, Q extends PickQueryMetaResultReturnTypeWithDataWindows> = {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta'] | keyof Q['meta']]: K extends 'selectable' ? MergeObjects<T['meta']['selectable'], Q['meta']['selectable']> : K extends keyof Q['meta'] ? Q['meta'][K] : T['meta'][K];
-    } : K extends 'result' ? MergeQueryResult<T, Q> : K extends 'returnType' ? QueryReturnType extends Q['returnType'] ? T['returnType'] : Q['returnType'] : K extends 'then' ? QueryThen<GetQueryResult<QueryReturnType extends Q['returnType'] ? T : Q, MergeQueryResult<T, Q>>> : K extends 'catch' ? QueryCatch<GetQueryResult<QueryReturnType extends Q['returnType'] ? T : Q, MergeQueryResult<T, Q>>> : K extends 'windows' ? MergeObjects<T['windows'], Q['windows']> : K extends 'withData' ? MergeObjects<T['withData'], Q['withData']> : T[K];
+    } : K extends 'result' ? MergeQueryResult<T, Q> : K extends 'returnType' ? QueryReturnType extends Q['returnType'] ? T['returnType'] : Q['returnType'] : K extends 'then' ? QueryThen<GetQueryResult<QueryReturnType extends Q['returnType'] ? T : Q, MergeQueryResult<T, Q>>> : K extends 'windows' ? MergeObjects<T['windows'], Q['windows']> : K extends 'withData' ? MergeObjects<T['withData'], Q['withData']> : T[K];
 };
 type MergeQueryResult<T extends PickQueryMetaResult, Q extends PickQueryMetaResult> = T['meta']['hasSelect'] extends true ? Q['meta']['hasSelect'] extends true ? {
     [K in keyof T['result'] | keyof Q['result']]: K extends keyof Q['result'] ? Q['result'][K] : T['result'][K];
@@ -4639,7 +4764,9 @@ declare class MergeQueryMethods {
     merge<T extends Query, Q extends Query>(this: T, q: Q): MergeQuery<T, Q>;
 }
 
-declare const queryMethodByReturnType: Record<QueryReturnType, 'query' | 'arrays'>;
+declare const queryMethodByReturnType: {
+    [K in QueryReturnType]: 'query' | 'arrays';
+};
 type Resolve = (result: any) => any;
 type Reject = (error: any) => any;
 declare class Then {
@@ -4675,10 +4802,6 @@ type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = {
         [K in Columns[number] | keyof T['shape'] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
     } : {
         [K in Columns[number] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
-    }) & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : K extends 'catch' ? QueryCatch<GetQueryResult<T, ('*' extends Columns[number] ? {
-        [K in Columns[number] | keyof T['shape'] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
-    } : {
-        [K in Columns[number] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
     }) & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : T[K];
 } & QueryMetaHasSelect;
 type SelectResultObj<T extends SelectSelf, Obj> = {
@@ -4688,8 +4811,6 @@ type SelectResultObj<T extends SelectSelf, Obj> = {
         [K in keyof Obj | (T['meta']['hasSelect'] extends true ? keyof T['result'] : never)]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
     } : K extends 'then' ? QueryThen<GetQueryResult<T, {
         [K in keyof Obj | (T['meta']['hasSelect'] extends true ? keyof T['result'] : never)]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
-    }>> : K extends 'catch' ? QueryCatch<GetQueryResult<T, {
-        [K in keyof Obj | (T['meta']['hasSelect'] extends true ? keyof T['result'] : never)]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
     }>> : T[K];
 } & QueryMetaHasSelect;
 type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = {
@@ -4700,8 +4821,6 @@ type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey
         [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | keyof Obj as K extends keyof T['meta']['selectable'] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof T['meta']['selectable'] ? T['meta']['selectable'][K]['column'] : K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : never;
     } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown) : K extends 'then' ? QueryThen<GetQueryResult<T, {
         [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | keyof Obj as K extends keyof T['meta']['selectable'] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof T['meta']['selectable'] ? T['meta']['selectable'][K]['column'] : K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : never;
-    } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : K extends 'catch' ? QueryCatch<GetQueryResult<T, {
-        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | keyof Obj as K extends keyof T['meta']['selectable'] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof T['meta']['selectable'] ? T['meta']['selectable'][K]['column'] : K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : never;
     } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : T[K];
 } & QueryMetaHasSelect;
 type SelectAsSelectable<Arg> = {
@@ -4884,7 +5003,9 @@ declare class With {
 
 type UnionArg<T extends PickQueryResult> = {
     result: {
-        [K in keyof T['result']]: Pick<T['result'][K], 'dataType'>;
+        [K in keyof T['result']]: {
+            dataType: T['result'][K]['dataType'];
+        };
     };
 } | Expression;
 declare class Union {
@@ -4943,7 +5064,9 @@ declare class Union {
     exceptAll<T extends PickQueryResult>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
 }
 
-type UpdateSelf = Pick<Query, 'meta' | 'inputType' | 'relations' | 'shape' | 'result' | 'returnType' | keyof JsonModifiers>;
+type UpdateSelf = {
+    [K in 'meta' | 'inputType' | 'relations' | 'shape' | 'result' | 'returnType' | keyof JsonModifiers]: Query[K];
+};
 type UpdateData<T extends UpdateSelf> = {
     [K in keyof T['inputType']]?: UpdateColumn<T, K>;
 } & {
@@ -4969,10 +5092,14 @@ type UpdateResult<T extends UpdateSelf> = T['meta']['hasSelect'] extends true ?
 type ChangeCountArg<T extends PickQueryShape> = keyof T['shape'] | {
     [K in keyof T['shape']]?: number;
 };
-type UpdateCtx = {
+interface UpdateCtx {
     queries?: ((queryResult: QueryResult) => Promise<void>)[];
-    updateData?: RecordUnknown;
-};
+    collect?: UpdateCtxCollect;
+}
+interface UpdateCtxCollect {
+    keys: string[];
+    data: RecordUnknown;
+}
 declare const _queryChangeCounter: <T extends UpdateSelf>(self: T, op: string, data: ChangeCountArg<T>) => never;
 declare const _queryUpdate: <T extends UpdateSelf>(query: T, arg: UpdateArg<T>) => UpdateResult<T>;
 declare const _queryUpdateRaw: <T extends UpdateSelf>(q: T, sql: Expression) => UpdateResult<T>;
@@ -5727,26 +5854,6 @@ declare class QueryUpsertOrCreate {
     orCreate<T extends UpsertThis>(this: T, data: OrCreateArg<T>): UpsertResult<T>;
 }
 
-declare const templateLiteralToSQL: (template: TemplateLiteralArgs, ctx: ToSQLCtx, quotedAs?: string) => string;
-declare class RawSQL<T extends QueryColumn, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>> extends RawSQLBase<T, ColumnTypes> {
-    columnTypes: ColumnTypes;
-    constructor(sql: string | TemplateLiteralArgs, values?: RawSQLValues, type?: T);
-    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
-}
-interface DynamicRawSQL<T extends QueryColumn> extends Expression<T>, ExpressionTypeMethod {
-}
-declare class DynamicRawSQL<T extends QueryColumn, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>> extends Expression<T> {
-    fn: DynamicSQLArg;
-    _type: T;
-    columnTypes: ColumnTypes;
-    constructor(fn: DynamicSQLArg);
-    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
-}
-declare function raw<T = unknown>(...args: StaticSQLArgs): RawSQL<QueryColumn<T>>;
-declare function raw<T = unknown>(...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>>;
-declare const countSelect: RawSQL<QueryColumn<unknown, orchid_core.CoreBaseOperators>, DefaultColumnTypes<ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>>[];
-declare function sqlQueryArgsToExpression(args: SQLQueryArgs): RawSQL<QueryColumn>;
-
 declare abstract class RawSqlMethods<ColumnTypes> {
     /**
      * When there is a need to use a piece of raw SQL, use the `sql` method from tables, or a `raw` function imported from `orchid-orm`.
@@ -5905,11 +6012,11 @@ declare abstract class RawSqlMethods<ColumnTypes> {
     }, ...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>, ColumnTypes>;
 }
 
-type QueryTransformFn<T extends Query> = (input: T['catch'] extends QueryCatch<infer Data> ? Data : never) => unknown;
+type QueryTransformFn<T extends Query> = (input: T['then'] extends QueryThen<infer Data> ? Data : never) => unknown;
 type QueryTransform<T extends QueryBase, Data> = {
     [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
         value: QueryColumn<Data>;
-    } : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : T[K];
+    } : K extends 'then' ? QueryThen<Data> : T[K];
 };
 declare class TransformMethods {
     /**
@@ -5974,7 +6081,9 @@ interface WindowArgDeclaration<T extends OrderArgSelf = OrderArgSelf> {
     order?: OrderArg<T>;
 }
 type WindowResult<T, W extends RecordUnknown> = T & {
-    windows: Record<keyof W, true>;
+    windows: {
+        [K in keyof W]: true;
+    };
 };
 type OrderArgSelf = PickQueryMetaResult;
 type OrderArg<T extends OrderArgSelf> = OrderArgKey<T> | OrderArgTsQuery<T> | {
@@ -5988,7 +6097,7 @@ type OrderArgs<T extends OrderArgSelf> = OrderArg<T>[];
 type GroupArg<T extends PickQueryResult> = {
     [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' ? never : K;
 }[keyof T['result']] | Expression;
-type FindArg<T extends PickQueryShapeSinglePrimaryKey> = T['shape'][T['singlePrimaryKey']]['queryType'] | Expression;
+type FindArg<T extends PickQueryShapeSinglePrimaryKey> = T['internal']['singlePrimaryKey'] | Expression;
 type QueryHelper<T extends PickQueryMetaShape, Args extends unknown[], Result> = {
     <Q extends {
         returnType: QueryReturnType;
@@ -6128,20 +6237,11 @@ declare class QueryMethods<ColumnTypes> {
      */
     distinct<T extends PickQueryMeta>(this: T, ...columns: SelectableOrExpression<T>[]): T;
     /**
-     * The `find` method is available only for tables which has exactly one primary key.
-     * And also it can accept raw SQL template literal, then the primary key is not required.
-     *
-     * Finds a record by id, throws {@link NotFoundError} if not found:
-     *
-     * ```ts
-     * await db.table.find(1);
-     * ```
+     * Finds a single record by the primary key (id), throws [NotFoundError](/guide/error-handling.html) if not found.
+     * Not available if the table has no or multiple primary keys.
      *
      * ```ts
-     * await db.user.find`
-     *   age = ${age} AND
-     *   name = ${name}
-     * `;
+     * const result: TableType = await db.table.find(1);
      * ```
      *
      * @param value - primary key value to find by
@@ -6159,10 +6259,10 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param args - SQL expression
      */
-    findBySql<T extends PickQueryShapeResultSinglePrimaryKey>(this: T, ...args: SQLQueryArgs): SetQueryReturnsOne<WhereResult<T>>;
+    findBySql<T extends PickQueryResult>(this: T, ...args: SQLQueryArgs): SetQueryReturnsOne<WhereResult<T>>;
     /**
-     * Find a single record by the primary key (id), adds `LIMIT 1`.
-     * Returns `undefined` when not found.
+     * Finds a single record by the primary key (id), returns `undefined` when not found.
+     * Not available if the table has no or multiple primary keys.
      *
      * ```ts
      * const result: TableType | undefined = await db.table.find(123);
@@ -6184,33 +6284,35 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param args - SQL expression
      */
-    findBySqlOptional<T extends PickQueryShapeResultSinglePrimaryKey>(this: T, ...args: SQLQueryArgs): SetQueryReturnsOneOptional<WhereResult<T>>;
+    findBySqlOptional<T extends PickQueryResult>(this: T, ...args: SQLQueryArgs): SetQueryReturnsOneOptional<WhereResult<T>>;
     /**
-     * The same as `where(conditions).take()`, takes the same arguments as {@link Where.where}, it will filter records and add a `LIMIT 1`.
-     * Throws `NotFoundError` if not found.
+     * Finds a single unique record, throws [NotFoundError](/guide/error-handling.html) if not found.
+     * It accepts values of primary keys or unique indexes defined on the table.
+     * `findBy`'s argument type is a union of all possible sets of unique conditions.
+     *
+     * You can use `where(...).take()` for non-unique conditions.
      *
      * ```ts
-     * const result: TableType = await db.table.findBy({ key: 'value' });
-     * // is equivalent to:
-     * db.table.where({ key: 'value' }).take()
+     * await db.table.findBy({ key: 'value' });
      * ```
      *
-     * @param args - `where` conditions
+     * @param uniqueColumnValues - is derived from primary keys and unique indexes in the table
      */
-    findBy<T extends PickQueryMetaResultRelations>(this: T, ...args: WhereArg<T>[]): SetQueryReturnsOne<WhereResult<T>>;
+    findBy<T extends PickQueryResultUniqueColumns>(this: T, uniqueColumnValues: T['internal']['uniqueColumns']): SetQueryReturnsOne<WhereResult<T>>;
     /**
-     * The same as `where(conditions).takeOptional()`, it will filter records and add a `LIMIT 1`.
-     * Returns `undefined` when not found.
+     * Finds a single unique record, returns `undefined` if not found.
+     * It accepts values of primary keys or unique indexes defined on the table.
+     * `findBy`'s argument type is a union of all possible sets of unique conditions.
+     *
+     * You can use `where(...).takeOptional()` for non-unique conditions.
      *
      * ```ts
-     * const result: TableType | undefined = await db.table.findByOptional({
-     *   key: 'value',
-     * });
+     * await db.table.findByOptional({ key: 'value' });
      * ```
      *
-     * @param args - `where` conditions
+     * @param uniqueColumnValues - is derived from primary keys and unique indexes in the table
      */
-    findByOptional<T extends PickQueryMetaResultRelations>(this: T, ...args: WhereArg<T>[]): SetQueryReturnsOneOptional<WhereResult<T>>;
+    findByOptional<T extends PickQueryResultUniqueColumns>(this: T, uniqueColumnValues: T['internal']['uniqueColumns']): SetQueryReturnsOneOptional<WhereResult<T>>;
     /**
      * Specifies the schema to be used as a prefix of a table name.
      *
@@ -6331,9 +6433,9 @@ declare class QueryMethods<ColumnTypes> {
      * Order by raw SQL expression.
      *
      * ```ts
-     * db.table.order`raw sql`;
+     * db.table.orderSql`raw sql`;
      * // or
-     * db.table.order(db.table.sql`raw sql`);
+     * db.table.orderSql(db.table.sql`raw sql`);
      * ```
      *
      * @param args - SQL expression
@@ -6519,6 +6621,25 @@ declare function queryWrap<T extends PickQueryTableMetaResult, Q extends WrapQue
  */
 declare function cloneQueryBaseUnscoped(query: Query): Query;
 
+interface DbExtension {
+    name: string;
+    version?: string;
+}
+type DbDomainArg<ColumnTypes> = (columnTypes: ColumnTypes) => ColumnType;
+type DbDomainArgRecord = {
+    [K: string]: DbDomainArg<any>;
+};
+interface QueryInternal<SinglePrimaryKey = any, UniqueColumns = any, UniqueColumnNames = any, UniqueColumnTuples = any, UniqueConstraints = any> extends QueryInternalBase {
+    singlePrimaryKey: SinglePrimaryKey;
+    uniqueColumns: UniqueColumns;
+    uniqueColumnNames: UniqueColumnNames;
+    uniqueColumnTuples: UniqueColumnTuples;
+    uniqueConstraints: UniqueConstraints;
+    extensions?: DbExtension[];
+    domains?: DbDomainArgRecord;
+    tableData: TableData;
+    primaryKeys?: string[];
+}
 type SelectableFromShape<Shape extends QueryColumns, Table extends string | undefined> = {
     [K in keyof Shape]: {
         as: K;
@@ -6542,12 +6663,10 @@ interface Query extends QueryBase, QueryMethods<unknown> {
     queryBuilder: Db;
     columnTypes: unknown;
     shape: QueryColumns;
-    singlePrimaryKey: string;
-    primaryKeys: string[];
     inputType: RecordUnknown;
     q: QueryData;
     then: QueryThen<unknown>;
-    catch: QueryCatch<unknown>;
+    catch: QueryCatch;
     windows: EmptyObject;
     defaultSelectColumns: string[];
     relations: RelationsBase;
@@ -6606,7 +6725,9 @@ interface PickQueryQAndInternal extends PickQueryQ, PickQueryInternal {
 interface PickQueryQAndBaseQuery extends PickQueryQ, PickQueryBaseQuery {
 }
 interface PickQuerySinglePrimaryKey {
-    singlePrimaryKey: string;
+    internal: {
+        singlePrimaryKey: unknown;
+    };
 }
 interface PickQueryShapeSinglePrimaryKey extends PickQueryShape, PickQuerySinglePrimaryKey {
 }
@@ -6619,14 +6740,24 @@ type SelectableOrExpressionOfType<T extends PickQueryMeta, C extends PickType> =
 interface QueryWithTable extends Query {
     table: string;
 }
-declare const queryTypeWithLimitOne: Record<QueryReturnType, true | undefined>;
+declare const queryTypeWithLimitOne: {
+    all: true | undefined;
+    one: true | undefined;
+    oneOrThrow: true | undefined;
+    rows: true | undefined;
+    pluck: true | undefined;
+    value: true | undefined;
+    valueOrThrow: true | undefined;
+    rowCount: true | undefined;
+    void: true | undefined;
+};
 declare const isQueryReturnsAll: (q: Query) => boolean;
 type QueryReturnsAll<T extends QueryReturnType> = (QueryReturnType extends T ? 'all' : T) extends 'all' ? true : false;
 type GetQueryResult<T extends PickQueryReturnType, Result extends QueryColumns> = QueryReturnsAll<T['returnType']> extends true ? ColumnShapeOutput<Result>[] : T['returnType'] extends 'one' ? ColumnShapeOutput<Result> | undefined : T['returnType'] extends 'oneOrThrow' ? ColumnShapeOutput<Result> : T['returnType'] extends 'value' ? Result['value']['outputType'] | undefined : T['returnType'] extends 'valueOrThrow' ? Result['value']['outputType'] : T['returnType'] extends 'rows' ? ColumnShapeOutput<Result>[keyof Result][][] : T['returnType'] extends 'pluck' ? Result['pluck']['outputType'][] : T['returnType'] extends 'rowCount' ? number : T['returnType'] extends 'void' ? void : never;
 type AddQuerySelect<T extends PickQueryMetaResultReturnType, Result extends QueryColumns> = {
     [K in keyof T]: K extends 'result' ? {
         [K in (T['meta']['hasSelect'] extends true ? keyof T['result'] : never) | keyof Result]: K extends keyof Result ? Result[K] : K extends keyof T['result'] ? T['result'][K] : never;
-    } : K extends 'then' ? QueryThen<GetQueryResult<T, Result>> : K extends 'catch' ? QueryCatch<GetQueryResult<T, Result>> : T[K];
+    } : K extends 'then' ? QueryThen<GetQueryResult<T, Result>> : T[K];
 } & QueryMetaHasSelect;
 interface QueryMetaHasSelect {
     meta: {
@@ -6634,71 +6765,71 @@ interface QueryMetaHasSelect {
     };
 }
 type SetQueryReturnsAll<T extends PickQueryResult> = {
-    [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']>[]> : K extends 'catch' ? QueryCatch<ColumnShapeOutput<T['result']>[]> : T[K];
+    [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']>[]> : T[K];
 } & QueryMetaHasWhere;
 type SetQueryReturnsAllKind<T extends PickQueryMetaResult, Kind extends string> = {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'all' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']>[]> : K extends 'catch' ? QueryCatch<ColumnShapeOutput<T['result']>[]> : T[K];
+    } : K extends 'returnType' ? 'all' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']>[]> : T[K];
 } & QueryMetaHasWhere;
 type SetQueryReturnsOneOptional<T extends PickQueryResult> = {
-    [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']> | undefined> : K extends 'catch' ? QueryCatch<ColumnShapeOutput<T['result']> | undefined> : T[K];
+    [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']> | undefined> : T[K];
 };
 type SetQueryReturnsOne<T extends PickQueryResult> = {
-    [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']>> : K extends 'catch' ? QueryCatch<ColumnShapeOutput<T['result']>> : T[K];
+    [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']>> : T[K];
 };
 type SetQueryReturnsOneKind<T extends PickQueryMetaResult, Kind extends string> = {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']>> : K extends 'catch' ? QueryCatch<ColumnShapeOutput<T['result']>> : T[K];
+    } : K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']>> : T[K];
 };
 type SetQueryReturnsRows<T extends PickQueryResult> = {
-    [K in keyof T]: K extends 'returnType' ? 'rows' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']>[keyof T['result']][][]> : K extends 'catch' ? QueryCatch<ColumnShapeOutput<T['result']>[keyof T['result']][][]> : T[K];
+    [K in keyof T]: K extends 'returnType' ? 'rows' : K extends 'then' ? QueryThen<ColumnShapeOutput<T['result']>[keyof T['result']][][]> : T[K];
 };
 type SetQueryReturnsPluck<T extends PickQueryMeta, S extends keyof T['meta']['selectable'] | Expression> = SetQueryReturnsPluckColumn<T, S extends keyof T['meta']['selectable'] ? T['meta']['selectable'][S]['column'] : S extends Expression ? S['_type'] : never>;
 type SetQueryReturnsPluckColumn<T, C extends QueryColumn> = {
     [K in keyof T]: K extends 'result' ? {
         pluck: C;
-    } : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<C['outputType'][]> : K extends 'catch' ? QueryCatch<C['outputType'][]> : T[K];
+    } : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<C['outputType'][]> : T[K];
 } & QueryMetaHasSelect;
 type SetQueryReturnsPluckColumnKind<T extends PickQueryMetaResult, Kind extends string> = {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
     } : K extends 'result' ? {
         pluck: T['result']['value'];
-    } : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['result']['value']['outputType'][]> : K extends 'catch' ? QueryCatch<T['result']['value']['outputType'][]> : T[K];
+    } : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['result']['value']['outputType'][]> : T[K];
 } & QueryMetaHasSelect;
 type SetQueryReturnsValueOrThrow<T extends PickQueryMeta, Arg extends GetStringArg<T>> = SetQueryReturnsColumnOrThrow<T, T['meta']['selectable'][Arg]['column']> & T['meta']['selectable'][Arg]['column']['operators'];
 type SetQueryReturnsValueOptional<T extends PickQueryMeta, Arg extends GetStringArg<T>> = SetQueryReturnsColumnOptional<T, T['meta']['selectable'][Arg]['column']> & T['meta']['selectable'][Arg]['column']['operators'];
 type SetQueryReturnsColumnOrThrow<T, Column extends PickOutputType> = {
     [K in keyof T]: K extends 'result' ? {
         value: Column;
-    } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['outputType']> : K extends 'catch' ? QueryCatch<Column['outputType']> : T[K];
+    } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['outputType']> : T[K];
 } & QueryMetaHasSelect;
 type SetQueryReturnsColumnOptional<T, Column extends PickOutputType> = {
     [K in keyof T]: K extends 'result' ? {
         value: Column;
-    } : K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<Column['outputType'] | undefined> : K extends 'catch' ? QueryCatch<Column['outputType'] | undefined> : T[K];
+    } : K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<Column['outputType'] | undefined> : T[K];
 } & QueryMetaHasSelect;
 type SetQueryReturnsColumnKind<T extends PickQueryMetaResult, Kind extends string> = {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
     } : K extends 'result' ? {
         value: T['result']['pluck'];
-    } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['pluck']['outputType']> : K extends 'catch' ? QueryCatch<T['result']['pluck']['outputType']> : T[K];
+    } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['pluck']['outputType']> : T[K];
 } & QueryMetaHasSelect;
 type SetQueryReturnsRowCount<T extends PickQueryMetaResult, Kind extends string> = {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'rowCount' : K extends 'then' ? QueryThen<number> : K extends 'catch' ? QueryCatch<number> : T[K];
+    } : K extends 'returnType' ? 'rowCount' : K extends 'then' ? QueryThen<number> : T[K];
 };
 type SetQueryReturnsVoid<T> = {
-    [K in keyof T]: K extends 'returnType' ? 'void' : K extends 'then' ? QueryThen<void> : K extends 'catch' ? QueryCatch<void> : T[K];
+    [K in keyof T]: K extends 'returnType' ? 'void' : K extends 'then' ? QueryThen<void> : T[K];
 };
 type SetQueryReturnsVoidKind<T extends PickQueryMeta, Kind extends string> = {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'void' : K extends 'then' ? QueryThen<void> : K extends 'catch' ? QueryCatch<void> : T[K];
+    } : K extends 'returnType' ? 'void' : K extends 'then' ? QueryThen<void> : T[K];
 };
 type SetQueryKind<T extends PickQueryMeta, Kind extends string> = {
     [K in keyof T]: K extends 'meta' ? {
@@ -6728,75 +6859,14 @@ interface ColumnData extends ColumnDataBase {
     numericScale?: number;
     dateTimePrecision?: number;
     validationDefault?: unknown;
-    indexes?: Omit<SingleColumnIndexOptions, 'column'>[];
+    indexes?: TableData.ColumnIndex[];
     comment?: string;
     collate?: string;
     compression?: string;
-    foreignKeys?: ForeignKey<string, string[]>[];
+    foreignKeys?: TableData.ColumnReferences[];
     identity?: TableData.Identity;
     generated?: RawSQLBase;
 }
-/**
- * - MATCH FULL will not allow one column of a multicolumn foreign key to be null unless all foreign key columns are null;
- * if they are all null, the row is not required to have a match in the referenced table.
- * - MATCH SIMPLE (default) allows any of the foreign key columns to be null; if any of them are null, the row is not required to have a match in the referenced table.
- * - MATCH PARTIAL - PG docs say it's not implemented.
- */
-type ForeignKeyMatch = 'FULL' | 'PARTIAL' | 'SIMPLE';
-/**
- * - NO ACTION Produce an error indicating that the deletion or update would create a foreign key constraint violation. If the constraint is deferred, this error will be produced at constraint check time if there still exist any referencing rows. This is the default action.
- * - RESTRICT Produce an error indicating that the deletion or update would create a foreign key constraint violation. This is the same as NO ACTION except that the check is not deferrable.
- * - CASCADE Delete any rows referencing the deleted row, or update the values of the referencing column(s) to the new values of the referenced columns, respectively.
- * - SET NULL Set all the referencing columns, or a specified subset of the referencing columns, to null. A subset of columns can only be specified for ON DELETE actions.
- * - SET DEFAULT Set all the referencing columns, or a specified subset of the referencing columns, to their default values. A subset of columns can only be specified for ON DELETE actions. (There must be a row in the referenced table matching the default values, if they are not null, or the operation will fail.)
- */
-type ForeignKeyAction = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
-type ForeignKey<Table extends string, Columns extends string[]> = ({
-    fn(): new () => {
-        table: Table;
-        columns: ColumnsShapeBase;
-    };
-} | {
-    table: Table;
-}) & {
-    columns: Columns;
-} & ForeignKeyOptions;
-type DropMode = 'CASCADE' | 'RESTRICT';
-interface ForeignKeyOptions {
-    name?: string;
-    match?: ForeignKeyMatch;
-    onUpdate?: ForeignKeyAction;
-    onDelete?: ForeignKeyAction;
-    dropMode?: DropMode;
-}
-interface IndexColumnOptionsForColumn {
-    collate?: string;
-    opclass?: string;
-    order?: string;
-    weight?: SearchWeight;
-}
-type IndexColumnOptions = ({
-    column: string;
-} | {
-    expression: string;
-}) & IndexColumnOptionsForColumn;
-interface IndexOptions {
-    name?: string;
-    unique?: boolean;
-    nullsNotDistinct?: boolean;
-    using?: string;
-    include?: MaybeArray<string>;
-    with?: string;
-    tablespace?: string;
-    where?: string;
-    dropMode?: 'CASCADE' | 'RESTRICT';
-    language?: string | RawSQLBase;
-    languageColumn?: string;
-    tsVector?: boolean;
-}
-interface SingleColumnIndexOptionsForColumn extends IndexColumnOptionsForColumn, IndexOptions {
-}
-type SingleColumnIndexOptions = IndexColumnOptions & IndexOptions;
 interface ColumnFromDbParams {
     isNullable?: boolean;
     default?: string;
@@ -6804,6 +6874,8 @@ interface ColumnFromDbParams {
     numericPrecision?: number;
     numericScale?: number;
     dateTimePrecision?: number;
+    compression?: string;
+    collate?: string;
 }
 interface PickColumnData {
     data: ColumnData;
@@ -6822,18 +6894,22 @@ declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTyp
      *   readonly table = 'table';
      *   columns = this.setColumns((t) => ({
      *     id: t.uuid().primaryKey(),
+     *     // database-level name can be passed:
+     *     id: t.uuid().primaryKey('primary_key_name'),
      *   }));
      * }
      *
      * // primary key can be used by `find` later:
      * db.table.find('97ba9e78-7510-415a-9c03-23d440aec443');
      * ```
+     *
+     * @param name - to specify a constraint name
      */
-    primaryKey<T extends PickColumnBaseData>(this: T): PrimaryKeyColumn<T>;
+    primaryKey<T extends PickColumnBaseData, Name extends string>(this: T, name?: Name): PrimaryKeyColumn<T, Name>;
     /**
-     * Set the foreignKey for the column.
+     * Defines a reference between different tables to enforce data integrity.
      *
-     * In `snakeCase` mode, columns of both tables are translated to a snake_case.
+     * In [snakeCase](/guide/orm-and-query-builder.html#snakecase-option) mode, columns of both tables are translated to a snake_case.
      *
      * ```ts
      * import { change } from '../dbScript';
@@ -6845,7 +6921,7 @@ declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTyp
      * });
      * ```
      *
-     * In the ORM specify a function returning a table class instead of a name:
+     * In the migration it's different from OrchidORM table code where a callback with a table is expected:
      *
      * ```ts
      * export class SomeTable extends BaseTable {
@@ -6854,13 +6930,6 @@ declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTyp
      *     otherTableId: t.integer().foreignKey(() => OtherTable, 'id'),
      *   }));
      * }
-     *
-     * export class OtherTable extends BaseTable {
-     *   readonly table = 'otherTable';
-     *   columns = this.setColumns((t) => ({
-     *     id: t.identity().primaryKey(),
-     *   }));
-     * }
      * ```
      *
      * Optionally you can pass the third argument to `foreignKey` with options:
@@ -6891,7 +6960,7 @@ declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTyp
      * change(async (db) => {
      *   await db.createTable('table', (t) => ({
      *     id: t.integer(),
-     *     name: t.string(),
+     *     name: t.string(), // string is varchar(255)
      *     ...t.foreignKey(
      *       ['id', 'name'],
      *       'otherTable',
@@ -6911,18 +6980,63 @@ declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTyp
      * @param column - column in the foreign table to connect with
      * @param options - {@link ForeignKeyOptions}
      */
-    foreignKey<T, Table extends ForeignKeyTable, Column extends ColumnNameOfTable<Table>>(this: T, fn: () => Table, column: Column, options?: ForeignKeyOptions): {
-        [K in keyof T]: T extends 'foreignKeyData' ? ForeignKey<InstanceType<Table>['table'], [Column]> : T[K];
-    };
-    foreignKey<T, Table extends string, Column extends string>(this: T, table: Table, column: Column, options?: ForeignKeyOptions): {
-        [K in keyof T]: K extends 'foreignKeyData' ? ForeignKey<Table, [Column]> : T[K];
-    };
+    foreignKey<T, Table extends ForeignKeyTable, Column extends ColumnNameOfTable<Table>>(this: T, fn: () => Table, column: Column, 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;
-    index<T extends PickColumnData>(this: T, options?: SingleColumnIndexOptionsForColumn): T;
     /**
-     * `searchIndex` is designed for full text search.
+     * Add an index to the column.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createTable('table', (t) => ({
+     *     // add an index to the name column with default settings:
+     *     name: t.text().index(),
+     *     // options are described below:
+     *     name: t.text().index({ ...options }),
+     *     // with a database-level name:
+     *     name: t.text().index('custom_index_name'),
+     *     // with name and options:
+     *     name: t.text().index('custom_index_name', { ...options }),
+     *   }));
+     * });
+     * ```
+     *
+     * Possible options are:
+     *
+     * ```ts
+     * type IndexOptions = {
+     *   // NULLS NOT DISTINCT: availabe in Postgres 15+, makes sense only for unique index
+     *   nullsNotDistinct?: true;
+     *   // index algorithm to use such as GIST, GIN
+     *   using?: string;
+     *   // specify collation:
+     *   collate?: string;
+     *   // see `opclass` in the Postgres document for creating the index
+     *   opclass?: string;
+     *   // specify index order such as ASC NULLS FIRST, DESC NULLS LAST
+     *   order?: string;
+     *   // include columns to an index to optimize specific queries
+     *   include?: MaybeArray<string>;
+     *   // see "storage parameters" in the Postgres document for creating an index, for example, 'fillfactor = 70'
+     *   with?: string;
+     *   // The tablespace in which to create the index. If not specified, default_tablespace is consulted, or temp_tablespaces for indexes on temporary tables.
+     *   tablespace?: string;
+     *   // WHERE clause to filter records for the index
+     *   where?: string;
+     *   // mode is for dropping the index
+     *   mode?: 'CASCADE' | 'RESTRICT';
+     * };
+     * ```
+     *
+     * @param args
+     */
+    index<T extends PickColumnData>(this: T, ...args: [options?: TableData.Index.ColumnArg] | [name: string, options?: TableData.Index.ColumnArg]): T;
+    /**
+     * `searchIndex` is designed for [full text search](/guide/text-search).
      *
-     * It can accept the same options as a regular `index`, but it is `USING GIN` by default, and it is concatenating columns into a `tsvector`.
+     * It can accept the same options as a regular `index`, but it is `USING GIN` by default, and it is concatenating columns into a `tsvector` database type.
      *
      * ```ts
      * import { change } from '../dbScript';
@@ -6930,8 +7044,8 @@ declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTyp
      * change(async (db) => {
      *   await db.createTable('table', (t) => ({
      *     id: t.identity().primaryKey(),
-     *     title: t.string(),
-     *     body: t.string(),
+     *     title: t.text(),
+     *     body: t.text(),
      *     ...t.searchIndex(['title', 'body']),
      *   }));
      * });
@@ -6940,10 +7054,65 @@ declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTyp
      * Produces the following index ('english' is a default language, see [full text search](/guide/text-search.html#language) for changing it):
      *
      * ```sql
-     * CREATE INDEX "table_title_body_idx" ON "table" USING GIN (to_tsvector('english', concat_ws(' ', "title", "body")))
+     * CREATE INDEX "table_title_body_idx" ON "table" USING GIN (to_tsvector('english', "title" || ' ' || "body"))
+     * ```
+     *
+     * You can set different search weights (`A` to `D`) on different columns inside the index:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createTable('table', (t) => ({
+     *     id: t.identity().primaryKey(),
+     *     title: t.text(),
+     *     body: t.text(),
+     *     ...t.searchIndex([
+     *       { column: 'title', weight: 'A' },
+     *       { column: 'body', weight: 'B' },
+     *     ]),
+     *   }));
+     * });
+     * ```
+     *
+     * When the table has localized columns,
+     * you can define different indexes for different languages by setting the `language` parameter:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createTable('table', (t) => ({
+     *     id: t.identity().primaryKey(),
+     *     titleEn: t.text(),
+     *     bodyEn: t.text(),
+     *     titleFr: t.text(),
+     *     bodyFr: t.text(),
+     *     ...t.searchIndex(['titleEn', 'bodyEn'], { language: 'english' }),
+     *     ...t.searchIndex(['titleFr', 'bodyFr'], { language: 'french' }),
+     *   }));
+     * });
+     * ```
+     *
+     * Alternatively, different table records may correspond to a single language,
+     * then you can define a search index that relies on a language column by using `languageColumn` parameter:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createTable('table', (t) => ({
+     *     id: t.identity().primaryKey(),
+     *     lang: t.type('regconfig'),
+     *     title: t.text(),
+     *     body: t.text(),
+     *     ...t.searchIndex(['title', 'body'], { languageColumn: 'lang' }),
+     *   }));
+     * });
      * ```
      *
-     * Also, it works well with a generated `tsvector` column:
+     * It can be more efficient to use a [generated](/guide/migration-column-methods.html#generated-column) column instead of indexing text column in the way described above,
+     * and to set a `searchIndex` on it:
      *
      * ```ts
      * import { change } from '../dbScript';
@@ -6951,8 +7120,8 @@ declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTyp
      * change(async (db) => {
      *   await db.createTable('table', (t) => ({
      *     id: t.identity().primaryKey(),
-     *     title: t.string(),
-     *     body: t.string(),
+     *     title: t.text(),
+     *     body: t.text(),
      *     generatedTsVector: t.tsvector().generated(['title', 'body']).searchIndex(),
      *   }));
      * });
@@ -6966,8 +7135,11 @@ declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTyp
      *
      * @param options - index options
      */
-    searchIndex<T extends Pick<ColumnType, 'data' | 'dataType'>>(this: T, options?: Omit<SingleColumnIndexOptions, 'tsVector'>): T;
-    unique<T extends PickColumnData>(this: T, options?: Omit<SingleColumnIndexOptionsForColumn, 'unique'>): T;
+    searchIndex<T extends {
+        data: ColumnType['data'];
+        dataType: string;
+    }>(this: T, ...args: [options?: TableData.Index.TsVectorColumnArg] | [name: string, options?: TableData.Index.TsVectorColumnArg]): T;
+    unique<T extends PickColumnData, Name extends string>(this: T, ...args: [options?: TableData.Index.UniqueColumnArg] | [name: Name, options?: TableData.Index.UniqueColumnArg]): UniqueColumn<T, Name>;
     comment<T extends PickColumnData>(this: T, comment: string): T;
     compression<T extends PickColumnData>(this: T, compression: string): T;
     collate<T extends PickColumnData>(this: T, collate: string): T;
@@ -6990,9 +7162,89 @@ declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTyp
     generated<T extends PickColumnData>(this: T, ...args: StaticSQLArgs): T;
 }
 
+declare class BooleanColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, boolean, ReturnType<Schema['boolean']>, OperatorsBoolean> {
+    dataType: "bool";
+    operators: OperatorsBoolean;
+    constructor(schema: Schema);
+    toCode(t: string, m?: boolean): Code;
+    parseItem: (input: string) => boolean;
+}
+
+declare class CustomTypeColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, unknown, ReturnType<Schema['unknown']>, typeof Operators.any> {
+    dataType: string;
+    operators: OperatorsAny;
+    constructor(schema: Schema, dataType: string);
+    toCode(t: string, m?: boolean): Code;
+    as<T extends {
+        inputType: unknown;
+        outputType: unknown;
+        data: ColumnDataBase;
+    }, C extends Omit<ColumnTypeBase, 'inputType' | 'outputType'> & {
+        inputType: T['inputType'];
+        outputType: T['outputType'];
+    }>(this: T, column: C): C;
+}
+declare class DomainColumn<Schema extends ColumnSchemaConfig> extends CustomTypeColumn<Schema> {
+    toCode(t: string, m?: boolean): Code;
+}
+
+declare const getColumnTypes: <ColumnTypes, Shape extends QueryColumnsInit>(types: ColumnTypes, fn: (t: ColumnTypes) => Shape, nowSQL: string | undefined, language: string | undefined) => Shape;
+interface DefaultColumnTypes<SchemaConfig extends ColumnSchemaConfig> extends TimestampHelpers {
+    schema: SchemaConfig;
+    enum: SchemaConfig['enum'];
+    array: SchemaConfig['array'];
+    name<T>(this: T, name: string): T;
+    sql: SqlFn;
+    smallint: SchemaConfig['smallint'];
+    integer: SchemaConfig['integer'];
+    bigint: SchemaConfig['bigint'];
+    numeric: SchemaConfig['decimal'];
+    decimal: SchemaConfig['decimal'];
+    real: SchemaConfig['real'];
+    doublePrecision: SchemaConfig['doublePrecision'];
+    identity(options?: TableData.Identity): IdentityColumn<ReturnType<SchemaConfig['integer']>>;
+    smallSerial: SchemaConfig['smallSerial'];
+    serial: SchemaConfig['serial'];
+    bigSerial: SchemaConfig['bigSerial'];
+    money: SchemaConfig['money'];
+    varchar: SchemaConfig['varchar'];
+    char: SchemaConfig['char'];
+    text: SchemaConfig['text'];
+    string: SchemaConfig['string'];
+    citext: SchemaConfig['citext'];
+    bytea(): ByteaColumn<SchemaConfig>;
+    date: SchemaConfig['date'];
+    timestampNoTZ: SchemaConfig['timestampNoTZ'];
+    timestamp: SchemaConfig['timestamp'];
+    time(precision?: number): TimeColumn<SchemaConfig>;
+    interval(fields?: string, precision?: number): IntervalColumn<SchemaConfig>;
+    boolean(): BooleanColumn<SchemaConfig>;
+    point(): PointColumn<SchemaConfig>;
+    line(): LineColumn<SchemaConfig>;
+    lseg(): LsegColumn<SchemaConfig>;
+    box(): BoxColumn<SchemaConfig>;
+    path(): PathColumn<SchemaConfig>;
+    polygon(): PolygonColumn<SchemaConfig>;
+    circle(): CircleColumn<SchemaConfig>;
+    cidr(): CidrColumn<SchemaConfig>;
+    inet(): InetColumn<SchemaConfig>;
+    macaddr(): MacAddrColumn<SchemaConfig>;
+    macaddr8(): MacAddr8Column<SchemaConfig>;
+    bit(length: number): BitColumn<SchemaConfig>;
+    bitVarying(length?: number): BitVaryingColumn<SchemaConfig>;
+    tsvector(): TsVectorColumn<SchemaConfig>;
+    tsquery(): TsQueryColumn<SchemaConfig>;
+    uuid(): UUIDColumn<SchemaConfig>;
+    xml(): XMLColumn<SchemaConfig>;
+    json: SchemaConfig['json'];
+    jsonText(): JSONTextColumn<SchemaConfig>;
+    type(dataType: string): CustomTypeColumn<SchemaConfig>;
+    domain(dataType: string): DomainColumn<SchemaConfig>;
+}
+declare const makeColumnTypes: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>(schema: SchemaConfig) => DefaultColumnTypes<SchemaConfig>;
+
 declare const simplifyColumnDefault: (value?: string) => RawSQL<orchid_core.QueryColumn<unknown, orchid_core.CoreBaseOperators>, DefaultColumnTypes<orchid_core.ColumnSchemaConfig<ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>> | undefined;
 declare const instantiateColumn: (typeFn: () => ColumnTypeBase, params: ColumnFromDbParams) => ColumnTypeBase;
-declare const getConstraintKind: (it: TableData.Constraint) => 'constraint' | 'foreignKey' | 'check';
 
 interface ColumnsShape {
     [K: string]: ColumnType;
@@ -7049,18 +7301,20 @@ declare class UnknownColumn<Schema extends ColumnSchemaConfig> extends VirtualCo
 }
 
 declare const isDefaultTimeStamp: (item: ColumnTypeBase) => boolean;
-declare const columnsShapeToCode: (shape: ColumnsShapeBase, tableData: TableData, t: string) => Code[];
-declare const primaryKeyToCode: (primaryKey: TableData.PrimaryKey, t: string) => string;
-declare const indexToCode: (index: TableData.Index, t: string) => Code[];
-declare const constraintToCode: (item: TableData.Constraint, t: string) => Code;
-declare const constraintPropsToCode: (t: string, item: TableData.Constraint) => Code[];
-declare const referencesArgsToCode: ({ columns, fnOrTable, foreignColumns, options, }: Exclude<TableData.Constraint['references'], undefined>, name?: string | false) => Code[];
-declare const columnForeignKeysToCode: (foreignKeys: ForeignKey<string, string[]>[]) => Code[];
-declare const foreignKeyArgumentToCode: (foreignKey: ForeignKey<string, string[]>) => Code[];
-declare const columnIndexesToCode: (indexes: Exclude<ColumnData['indexes'], undefined>) => Code[];
-declare const columnCheckToCode: (t: string, check: RawSQLBase) => string;
-declare const identityToCode: (identity: TableData.Identity, dataType?: string) => Code[];
-declare const columnCode: (type: ColumnType, t: string, code: Code, data?: ColumnData, skip?: {
+declare const columnsShapeToCode: (shape: ColumnsShapeBase, t: string) => Codes;
+declare const pushTableDataCode: (code: Codes, ast: TableData) => Codes;
+declare const primaryKeyInnerToCode: (primaryKey: TableData.PrimaryKey, t: string) => string;
+declare const indexToCode: (index: TableData.Index, t: string, prefix?: string) => Codes;
+declare const indexInnerToCode: (index: TableData.Index, t: string) => Codes;
+declare const constraintToCode: (item: TableData.Constraint, t: string, m?: boolean, prefix?: 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 columnForeignKeysToCode: (foreignKeys: TableData.ColumnReferences[], migration: boolean | undefined) => Codes;
+declare const foreignKeyArgumentToCode: ({ fnOrTable, foreignColumns, options, }: TableData.ColumnReferences, migration: boolean | undefined) => Codes;
+declare const columnIndexesToCode: (indexes: Exclude<ColumnData['indexes'], undefined>) => Codes;
+declare const columnCheckToCode: (t: string, { sql, name }: ColumnDataCheckBase) => string;
+declare const identityToCode: (identity: TableData.Identity, dataType?: string) => Codes;
+declare const columnCode: (type: ColumnType, t: string, code: Code, migration: boolean | undefined, data?: ColumnData, skip?: {
     encodeFn: unknown;
 }) => Code;
 
@@ -7119,6 +7373,7 @@ declare const saveSearchAlias: (q: QueryBase, as: string, key: 'joinedShapes' |
  * @param methods - methods to add
  */
 declare const extendQuery: <T extends PickQueryQAndBaseQuery, Methods extends RecordUnknown>(q: T, methods: Methods) => T & Methods;
+declare const getPrimaryKeys: (q: Query) => string[];
 
 type Arg = {
     $queryBuilder: Query;
@@ -7168,13 +7423,14 @@ declare function addComputedColumns<T extends PickQueryTableMetaShape, Computed
  * 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 PickQueryMetaShape, Column extends keyof T['shape'] | undefined, Result = Column extends keyof T['shape'] ? GetColumnInfo : Record<keyof T['shape'], GetColumnInfo>> = Omit<SetQueryKind<T, 'columnInfo'>, 'result' | 'returnType' | 'then' | 'catch'> & {
+type SetQueryReturnsColumnInfo<T extends PickQueryMetaShape, Column extends keyof T['shape'] | undefined, Result = Column extends keyof T['shape'] ? GetColumnInfo : {
+    [K in keyof T['shape']]: GetColumnInfo;
+}> = Omit<SetQueryKind<T, 'columnInfo'>, 'result' | 'returnType' | 'then'> & {
     result: {
         value: QueryColumn<Result>;
     };
     returnType: 'value';
     then: QueryThen<Result>;
-    catch: QueryCatch<Result>;
 };
 type GetColumnInfo = {
     defaultValue: unknown;
@@ -7258,4 +7514,4 @@ type CopyResult<T extends PickQueryMeta> = SetQueryKind<T, 'copy'>;
  */
 declare function copyTableData<T extends PickQueryMetaShape>(query: T, arg: CopyArg<T>): CopyResult<T>;
 
-export { Adapter, AdapterConfig, AdapterOptions, AddQueryDefaults, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayColumnValue, ArrayData, AsMethods, AsQueryArg, BaseOperators, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanQueryColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, CloneSelfKeys, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfoQueryData, ColumnOperators, ColumnRefExpression, ColumnType, ColumnsByType, ColumnsShape, ColumnsShapeToNullableObject, ColumnsShapeToObject, ColumnsShapeToObjectArray, ColumnsShapeToPluck, CommonQueryData, ComputedColumnsBase, CopyOptions, CopyQueryData, Create, CreateColumn, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CreateRelationsData, CreateRelationsDataOmittingFKeys, CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableConstructor, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultSchemaConfig, Delete, DeleteArgs, DeleteMethodsNames, DeleteQueryData, DeleteResult, DomainColumn, DoublePrecisionColumn, DropMode, DynamicRawSQL, EnumColumn, ExpressionOutput, FnExpression, FnExpressionArgs, FnExpressionArgsPairs, FnExpressionArgsValue, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArg, FromArgOptions, FromQuerySelf, FromResult, GetArg, GetColumnInfo, GetQueryResult, GetResult, GetResultOptional, GetStringArg, GroupArg, Having, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinItemArgs, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinQueryBuilder, JoinQueryMethod, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MapTableScopesOption, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumnData, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnMethods, Operator, Operators, OperatorsAny, OperatorsArray, OperatorsBoolean, OperatorsDate, OperatorsJson, OperatorsNumber, OperatorsText, OperatorsTime, OrCreateArg, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgSelf, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PickColumnData, PickQueryBaseQuery, PickQueryDataShapeAndJoinedShapes, PickQueryInternal, PickQueryMetaRelations, PickQueryMetaResultRelations, PickQueryMetaResultRelationsWindows, PickQueryMetaResultRelationsWindowsColumnTypes, PickQueryMetaResultRelationsWithDataReturnType, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryMetaResultReturnTypeWithDataWindows, PickQueryMetaResultReturnTypeWithDataWindowsTable, PickQueryMetaShapeRelationsWithData, PickQueryMetaTable, PickQueryMetaTableShape, PickQueryMetaTableShapeReturnTypeWithData, PickQueryMetaWithData, PickQueryQ, PickQueryQAndBaseQuery, PickQueryQAndInternal, PickQueryRelations, PickQueryRelationsWithData, PickQueryShapeResultSinglePrimaryKey, PickQueryShapeSinglePrimaryKey, PickQuerySinglePrimaryKey, PickQueryWindows, PickQueryWithData, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBaseThen, QueryBeforeHook, QueryData, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, RelationsChain, SearchArg, SearchMethods, SearchWeight, Select, SelectArg, SelectAs, SelectItem, SelectQueryData, SelectSubQueryResult, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryReturnsAll, SetQueryReturnsAllKind, SetQueryReturnsColumnInfo, SetQueryReturnsColumnKind, SetQueryReturnsColumnOptional, SetQueryReturnsColumnOrThrow, SetQueryReturnsOne, SetQueryReturnsOneKind, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsPluckColumn, SetQueryReturnsPluckColumnKind, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValueOptional, SetQueryReturnsValueOrThrow, SetQueryReturnsVoid, SetQueryReturnsVoidKind, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SimpleJoinItemNonSubQueryArgs, SingleColumnIndexOptions, SingleColumnIndexOptionsForColumn, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn$1 as StringColumn, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, ToSQLQuery, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateArg, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdateSelf, UpdatedAtDataInjector, UpsertArg, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereNotArgs, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithDataItems, WithItem, WithOptions, WrapQueryArg, XMLColumn, _queryAfterSaveCommit, _queryAll, _queryAs, _queryChangeCounter, _queryCreate, _queryCreateFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateManyRaw, _queryCreateRaw, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertManyRaw, _queryInsertRaw, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpdateRaw, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotSql, _queryWhereSql, addComputedColumns, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, checkIfASimpleQuery, cloneQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, constraintPropsToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, foreignKeyArgumentToCode, getClonedQueryData, getColumnInfo, getColumnTypes, getConstraintKind, getQueryAs, getShapeFromSelect, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isDefaultTimeStamp, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeExpression, makeFnExpression, makeRegexToFindInSql, makeSQL, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushLimitSQL, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quote, quoteString, raw, referencesArgsToCode, resetTableData, resolveSubQueryCallback, saveSearchAlias, setParserForSelectedString, setQueryObjectValue, setQueryOperators, simplifyColumnDefault, sqlQueryArgsToExpression, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };
+export { Adapter, AdapterConfig, AdapterOptions, AddQueryDefaults, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayColumnValue, ArrayData, AsMethods, AsQueryArg, BaseOperators, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanQueryColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, CloneSelfKeys, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfoQueryData, ColumnOperators, ColumnRefExpression, ColumnType, ColumnsByType, ColumnsShape, ColumnsShapeToNullableObject, ColumnsShapeToObject, ColumnsShapeToObjectArray, ColumnsShapeToPluck, CommonQueryData, ComputedColumnsBase, CopyOptions, CopyQueryData, Create, CreateColumn, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CreateRelationsData, CreateRelationsDataOmittingFKeys, CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbDomainArg, DbDomainArgRecord, DbExtension, DbOptions, DbResult, DbSharedOptions, DbTableConstructor, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultSchemaConfig, Delete, DeleteArgs, DeleteMethodsNames, DeleteQueryData, DeleteResult, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, EnumColumn, ExpressionOutput, FnExpression, FnExpressionArgs, FnExpressionArgsPairs, FnExpressionArgsValue, For, From, FromArg, FromArgOptions, FromQuerySelf, FromResult, GetArg, GetColumnInfo, GetQueryResult, GetResult, GetResultOptional, GetStringArg, GroupArg, Having, HavingItem, HookAction, HookSelect, IdentityColumn, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinItemArgs, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinQueryBuilder, JoinQueryMethod, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MapTableScopesOption, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumnData, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnMethods, Operator, Operators, OperatorsAny, OperatorsArray, OperatorsBoolean, OperatorsDate, OperatorsJson, OperatorsNumber, OperatorsText, OperatorsTime, OrCreateArg, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgSelf, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PickColumnData, PickQueryBaseQuery, PickQueryDataShapeAndJoinedShapes, PickQueryInternal, PickQueryMetaRelations, PickQueryMetaResultRelations, PickQueryMetaResultRelationsWindows, PickQueryMetaResultRelationsWindowsColumnTypes, PickQueryMetaResultRelationsWithDataReturnType, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryMetaResultReturnTypeWithDataWindows, PickQueryMetaResultReturnTypeWithDataWindowsTable, PickQueryMetaShapeRelationsWithData, PickQueryMetaTable, PickQueryMetaTableShape, PickQueryMetaTableShapeReturnTypeWithData, PickQueryMetaWithData, PickQueryQ, PickQueryQAndBaseQuery, PickQueryQAndInternal, PickQueryRelations, PickQueryRelationsWithData, PickQueryShapeResultSinglePrimaryKey, PickQueryShapeSinglePrimaryKey, PickQuerySinglePrimaryKey, PickQueryWindows, PickQueryWithData, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBaseThen, QueryBeforeHook, QueryData, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryInternal, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, RecordOfColumnsShapeBase, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, SearchArg, SearchMethods, SearchWeight, SearchWeightRecord, Select, SelectArg, SelectAs, SelectItem, SelectQueryData, SelectSubQueryResult, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryReturnsAll, SetQueryReturnsAllKind, SetQueryReturnsColumnInfo, SetQueryReturnsColumnKind, SetQueryReturnsColumnOptional, SetQueryReturnsColumnOrThrow, SetQueryReturnsOne, SetQueryReturnsOneKind, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsPluckColumn, SetQueryReturnsPluckColumnKind, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValueOptional, SetQueryReturnsValueOrThrow, SetQueryReturnsVoid, SetQueryReturnsVoidKind, SetQueryTableAlias, SetQueryWith, ShapeColumnPrimaryKeys, ShapeUniqueColumns, SimpleJoinItem, SimpleJoinItemNonSubQueryArgs, SmallIntColumn, SmallSerialColumn, SortDir, SqlFn, StringColumn$1 as StringColumn, TableData, TableDataFn, TableDataInput, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TableDataMethods, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, ToSQLQuery, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UniqueConstraints, UniqueQueryTypeOrExpression, UniqueTableDataItem, UnknownColumn, Update, UpdateArg, UpdateCtx, UpdateCtxCollect, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdateSelf, UpdatedAtDataInjector, UpsertArg, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereNotArgs, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithDataItems, WithItem, WithOptions, WrapQueryArg, XMLColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryAs, _queryChangeCounter, _queryCreate, _queryCreateFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateManyRaw, _queryCreateRaw, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertManyRaw, _queryInsertRaw, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpdateRaw, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotSql, _queryWhereSql, addComputedColumns, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, checkIfASimpleQuery, cloneQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, constraintInnerToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, foreignKeyArgumentToCode, getClonedQueryData, getColumnInfo, getColumnTypes, getPrimaryKeys, getQueryAs, getShapeFromSelect, handleResult, identityToCode, indexInnerToCode, indexToCode, instantiateColumn, isDefaultTimeStamp, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeExpression, makeFnExpression, makeRegexToFindInSql, makeSQL, parseRecord, parseResult, parseTableData, parseTableDataInput, primaryKeyInnerToCode, processSelectArg, pushLimitSQL, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, pushTableDataCode, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quote, quoteString, raw, referencesArgsToCode, resolveSubQueryCallback, saveSearchAlias, setParserForSelectedString, setQueryObjectValue, setQueryOperators, simplifyColumnDefault, sqlFn, sqlQueryArgsToExpression, tableDataMethods, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };