pqb 0.11.33 → 0.11.35

package/dist/index.d.ts

@@ -1,12 +1,161 @@
 import * as orchid_core from 'orchid-core';
-import { Sql, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, RawExpression, ColumnTypeBase, MaybeArray, QueryResultRow, AdapterBase, QueryInput, ColumnsParsers, getValueKey, StringKey, ColumnOutput, QueryThen, QueryCatch, NullableColumn, EmptyTuple, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, SetOptional, MergeObjects, CoalesceString, QueryCommon, Spread, BaseNumberData, Code, ColumnWithDefault, numberTypeMethods, BaseStringData, PrimaryKeyColumn, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, JSONTypeAny, record, ArrayMethodsData, arrayMethods, ForeignKeyTable, name, ColumnNameOfTable, ColumnDataBase, BaseOperators, ValidationContext, MessageParam } from 'orchid-core';
+import { QueryResultRow, AdapterBase, QueryInput, Sql, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, QueryThen, QueryCatch, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, RawExpression, ColumnTypeBase, MaybeArray, ColumnsParsers, getValueKey, StringKey, ColumnOutput, NullableColumn, EmptyTuple, SetOptional, MergeObjects, CoalesceString, QueryCommon, Spread, BaseNumberData, Code, ColumnWithDefault, numberTypeMethods, BaseStringData, PrimaryKeyColumn, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, JSONTypeAny, record, ArrayMethodsData, arrayMethods, ForeignKeyTable, name, ColumnNameOfTable, ColumnDataBase, BaseOperators, ValidationContext, MessageParam } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'util';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
+type TypeParsers = Record<number, (input: string) => unknown>;
+type QueryResult<T extends QueryResultRow = any> = {
+    rowCount: number;
+    rows: T[];
+};
+type QueryArraysResult<R extends any[] = any[]> = {
+    rowCount: number;
+    rows: R[];
+    fields: {
+        name: string;
+    }[];
+};
+type AdapterConfig = Omit<PoolConfig, 'types' | 'connectionString'> & {
+    schema?: string;
+    databaseURL?: string;
+};
+type AdapterOptions = AdapterConfig & {
+    types?: TypeParsers;
+};
+declare class Adapter implements AdapterBase {
+    types: TypeParsers;
+    pool: Pool;
+    config: PoolConfig;
+    schema?: string;
+    constructor({ types, ...config }: AdapterOptions);
+    query<T extends QueryResultRow = any>(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>;
+    close(): Promise<void>;
+}
+declare class TransactionAdapter implements Adapter {
+    adapter: Adapter;
+    client: PoolClient;
+    types: TypeParsers;
+    pool: Pool;
+    config: PoolConfig;
+    constructor(adapter: Adapter, client: PoolClient, types: TypeParsers);
+    query<T extends QueryResultRow = any>(query: QueryInput, types?: TypeParsers): Promise<QueryResult<T>>;
+    arrays<R extends any[] = any[]>(query: QueryInput, types?: TypeParsers): Promise<QueryArraysResult<R>>;
+    transaction<Result>(_: Sql, cb: (adapter: TransactionAdapter) => Promise<Result>): Promise<Result>;
+    close(): Promise<void>;
+}
+
+declare abstract class OrchidOrmError extends Error {
+    abstract query: Query;
+}
+declare class NotFoundError extends OrchidOrmError {
+    query: Query;
+    constructor(query: Query, message?: string);
+}
+declare class OrchidOrmInternalError extends Error {
+    query: Query;
+    constructor(query: Query, message?: string);
+}
+type QueryErrorName = 'parseComplete' | 'bindComplete' | 'closeComplete' | 'noData' | 'portalSuspended' | 'replicationStart' | 'emptyQuery' | 'copyDone' | 'copyData' | 'rowDescription' | 'parameterDescription' | 'parameterStatus' | 'backendKeyData' | 'notification' | 'readyForQuery' | 'commandComplete' | 'dataRow' | 'copyInResponse' | 'copyOutResponse' | 'authenticationOk' | 'authenticationMD5Password' | 'authenticationCleartextPassword' | 'authenticationSASL' | 'authenticationSASLContinue' | 'authenticationSASLFinal' | 'error' | 'notice';
+declare abstract class QueryError<T extends {
+    shape: ColumnsShape;
+} = {
+    shape: ColumnsShape;
+}> extends OrchidOrmInternalError {
+    message: string;
+    name: QueryErrorName;
+    stack: string | undefined;
+    code: string | undefined;
+    detail: string | undefined;
+    severity: string | undefined;
+    hint: string | undefined;
+    position: string | undefined;
+    internalPosition: string | undefined;
+    internalQuery: string | undefined;
+    where: string | undefined;
+    schema: string | undefined;
+    table: string | undefined;
+    column: string | undefined;
+    dataType: string | undefined;
+    constraint: string | undefined;
+    file: string | undefined;
+    line: string | undefined;
+    routine: string | undefined;
+    get isUnique(): boolean;
+    columnsCache?: {
+        [K in keyof T['shape']]?: true;
+    };
+    get columns(): T["shape"] extends infer T_1 ? { [K in keyof T_1]?: true | undefined; } : never;
+}
+declare class MoreThanOneRowError extends OrchidOrmInternalError {
+    constructor(query: Query, message?: string);
+}
+declare class UnhandledTypeError extends OrchidOrmInternalError {
+    query: Query;
+    constructor(query: Query, value: never);
+}
+
+type NoPrimaryKeyOption = 'error' | 'warning' | 'ignore';
+type DbOptions<CT extends ColumnTypesBase> = ({
+    adapter: Adapter;
+} | Omit<AdapterOptions, 'log'>) & QueryLogOptions & {
+    columnTypes?: CT | ((t: DefaultColumnTypes) => CT);
+    autoPreparedStatements?: boolean;
+    noPrimaryKey?: NoPrimaryKeyOption;
+    snakeCase?: boolean;
+    nowSQL?: string;
+};
+type DbTableOptions = {
+    schema?: string;
+    autoPreparedStatements?: boolean;
+    noPrimaryKey?: NoPrimaryKeyOption;
+    snakeCase?: boolean;
+} & QueryLogOptions;
+declare const anyShape: Record<string, ColumnType<unknown, orchid_core.BaseOperators, unknown>>;
+interface Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends Query['relations'] = Query['relations'], CT extends ColumnTypesBase = DefaultColumnTypes, Data = Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]> extends DbBase<Adapter, Table, Shape, CT>, QueryMethods {
+    new (adapter: Adapter, queryBuilder: Db<Table, Shape, Relations, CT>, table?: Table, shape?: Shape, options?: DbTableOptions): this;
+    queryBuilder: Db;
+    whereQueryBuilder: Query['whereQueryBuilder'];
+    onQueryBuilder: Query['onQueryBuilder'];
+    primaryKeys: Query['primaryKeys'];
+    query: QueryData;
+    selectable: SelectableFromShape<Shape, Table>;
+    returnType: Query['returnType'];
+    then: QueryThen<Data>;
+    catch: QueryCatch<Data>;
+    windows: Query['windows'];
+    defaultSelectColumns: DefaultSelectColumns<Shape>;
+    relations: Relations;
+    relationsQueries: Record<string, Query>;
+    withData: Query['withData'];
+    error: new (message: string, length: number, name: QueryErrorName) => QueryError<this>;
+    isSubQuery: false;
+    meta: {
+        defaults: Record<{
+            [K in keyof Shape]: undefined extends Shape[K]['data']['default'] ? never : K;
+        }[keyof Shape], true>;
+    };
+}
+declare class Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends Query['relations'] = Query['relations'], CT extends ColumnTypesBase = DefaultColumnTypes> implements Query {
+    adapter: Adapter;
+    queryBuilder: Db;
+    table: Table;
+    shape: Shape;
+    columnTypes: CT;
+    constructor(adapter: Adapter, queryBuilder: Db, table: Table, shape: Shape, columnTypes: CT, transactionStorage: AsyncLocalStorage<AdapterBase>, options: DbTableOptions);
+    [inspect.custom](): string;
+}
+type DbResult<CT extends ColumnTypesBase> = Db<string, Record<string, never>, Query['relations'], ColumnTypesBase extends CT ? DefaultColumnTypes : CT> & {
+    <Table extends string, Shape extends ColumnsShape = ColumnsShape>(table: Table, shape?: ((t: ColumnTypesBase extends CT ? DefaultColumnTypes : CT) => Shape) | Shape, options?: DbTableOptions): Db<Table, Shape>;
+    adapter: Adapter;
+    close: Adapter['close'];
+};
+declare const createDb: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>({ log, logger, columnTypes: ctOrFn, snakeCase, nowSQL, ...options }: DbOptions<CT>) => DbResult<CT>;
+
 type ToSqlCtx = {
-    whereQueryBuilder: typeof WhereQueryBuilder;
-    onQueryBuilder: typeof OnQueryBuilder;
+    queryBuilder: Db;
     sql: string[];
     values: unknown[];
     aliasValue?: true;
@@ -265,49 +414,6 @@ type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT
 type OnConflictItem = string | string[] | RawExpression;
 type OnConflictMergeUpdate = string | string[] | Record<string, unknown> | RawExpression;
 
-type TypeParsers = Record<number, (input: string) => unknown>;
-type QueryResult<T extends QueryResultRow = any> = {
-    rowCount: number;
-    rows: T[];
-};
-type QueryArraysResult<R extends any[] = any[]> = {
-    rowCount: number;
-    rows: R[];
-    fields: {
-        name: string;
-    }[];
-};
-type AdapterConfig = Omit<PoolConfig, 'types' | 'connectionString'> & {
-    schema?: string;
-    databaseURL?: string;
-};
-type AdapterOptions = AdapterConfig & {
-    types?: TypeParsers;
-};
-declare class Adapter implements AdapterBase {
-    types: TypeParsers;
-    pool: Pool;
-    config: PoolConfig;
-    schema?: string;
-    constructor({ types, ...config }: AdapterOptions);
-    query<T extends QueryResultRow = any>(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>;
-    close(): Promise<void>;
-}
-declare class TransactionAdapter implements Adapter {
-    adapter: Adapter;
-    client: PoolClient;
-    types: TypeParsers;
-    pool: Pool;
-    config: PoolConfig;
-    constructor(adapter: Adapter, client: PoolClient, types: TypeParsers);
-    query<T extends QueryResultRow = any>(query: QueryInput, types?: TypeParsers): Promise<QueryResult<T>>;
-    arrays<R extends any[] = any[]>(query: QueryInput, types?: TypeParsers): Promise<QueryArraysResult<R>>;
-    transaction<Result>(_: Sql, cb: (adapter: TransactionAdapter) => Promise<Result>): Promise<Result>;
-    close(): Promise<void>;
-}
-
 type JoinedShapes = Record<string, ColumnsShapeBase>;
 type JoinedParsers = Record<string, ColumnsParsers>;
 type JoinOverrides = Record<string, string>;
@@ -446,14 +552,6 @@ type CopyOptions<Column = string> = {
 type QueryData = SelectQueryData | InsertQueryData | UpdateQueryData | DeleteQueryData | TruncateQueryData | ColumnInfoQueryData | CopyQueryData;
 declare const cloneQueryArrays: (q: QueryData) => void;
 
-declare const getClonedQueryData: (query: QueryData) => QueryData;
-declare const getQueryAs: (q: {
-    table?: string;
-    query: {
-        as?: string;
-    };
-}) => string;
-declare const makeRegexToFindInSql: (value: string) => RegExp;
 type AliasOrTable<T extends Pick<Query, 'table' | 'meta'>> = T['meta']['as'] extends string ? T['meta']['as'] : T['table'] extends string ? T['table'] : never;
 type Expression<T extends Query = Query, C extends ColumnTypeBase = ColumnTypeBase> = StringKey<keyof T['selectable']> | RawExpression<C>;
 type ExpressionOfType<T extends Query, C extends ColumnTypeBase, Type> = {
@@ -463,6 +561,32 @@ type NumberExpression<T extends Query, C extends ColumnTypeBase = ColumnTypeBase
 type StringExpression<T extends Query, C extends ColumnTypeBase = ColumnTypeBase> = ExpressionOfType<T, C, string>;
 type BooleanExpression<T extends Query, C extends ColumnTypeBase = ColumnTypeBase> = ExpressionOfType<T, C, boolean>;
 type ExpressionOutput<T extends Query, Expr extends Expression<T>> = Expr extends keyof T['selectable'] ? T['selectable'][Expr]['column'] : Expr extends RawExpression<infer ColumnTypeBase> ? ColumnTypeBase : never;
+declare const getClonedQueryData: (query: QueryData) => QueryData;
+declare const getQueryAs: (q: {
+    table?: string;
+    query: {
+        as?: string;
+    };
+}) => string;
+declare const makeRegexToFindInSql: (value: string) => RegExp;
+/**
+ * In `select`, `update`, `create` it's possible to pass a callback with a sub-query.
+ * This function resolves such sub-query.
+ *
+ * @param q - main query object to pass to a callback as argument
+ * @param cb - sub-query callback
+ */
+declare const resolveSubQueryCallback: (q: Query, cb: (q: Query) => Query) => Query;
+/**
+ * After getting a query from a sub-query callback,
+ * join it to the main query in case it's a relation query.
+ *
+ * If it's not a relation query, it will be returned as is.
+ *
+ * @param q - main query object
+ * @param sub - sub-query query object
+ */
+declare const joinSubQuery: (q: Query, sub: Query) => Query;
 
 declare const queryMethodByReturnType: Record<QueryReturnType, 'query' | 'arrays'>;
 type Resolve = (result: any) => any;
@@ -856,148 +980,39 @@ declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBas
     _onJsonPathEquals<T extends OnQueryBuilder>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
 }
 
-declare abstract class OrchidOrmError extends Error {
-    abstract query: Query;
-}
-declare class NotFoundError extends OrchidOrmError {
-    query: Query;
-    constructor(query: Query, message?: string);
+type WithArgsOptions = Omit<WithOptions, 'columns'> & {
+    columns?: boolean | string[];
+};
+type WithArgs = [string, ColumnsShapeBase, RawExpression] | [string, WithArgsOptions, ColumnsShapeBase, RawExpression] | [string, Query | ((qb: Db) => Query)] | [string, WithArgsOptions, Query | ((qb: Db) => Query)];
+type WithShape<Args extends WithArgs> = Args[1] extends Query ? Args[1]['result'] : Args[1] extends (qb: Db) => Query ? ReturnType<Args[1]>['result'] : Args[2] extends Query ? Args[2]['result'] : Args[2] extends (qb: Db) => Query ? ReturnType<Args[2]>['result'] : Args[1] extends ColumnsShapeBase ? Args[1] : Args[2] extends ColumnsShapeBase ? Args[2] : Args[2] extends (t: ColumnTypes) => ColumnsShapeBase ? ReturnType<Args[2]> extends ColumnsShapeBase ? ReturnType<Args[2]> : never : never;
+type WithResult<T extends Query, Args extends WithArgs, Shape extends ColumnsShapeBase> = AddQueryWith<T, {
+    table: Args[0];
+    shape: Shape;
+    type: ColumnShapeOutput<Shape>;
+}>;
+declare class With {
+    with<T extends Query, Args extends WithArgs, Shape extends ColumnsShapeBase = WithShape<Args>>(this: T, ...args: Args): WithResult<T, Args, Shape>;
+    _with<T extends Query, Args extends WithArgs, Shape extends ColumnsShapeBase = WithShape<Args>>(this: T, ...args: Args): WithResult<T, Args, Shape>;
 }
-declare class OrchidOrmInternalError extends Error {
-    query: Query;
-    constructor(query: Query, message?: string);
-}
-type QueryErrorName = 'parseComplete' | 'bindComplete' | 'closeComplete' | 'noData' | 'portalSuspended' | 'replicationStart' | 'emptyQuery' | 'copyDone' | 'copyData' | 'rowDescription' | 'parameterDescription' | 'parameterStatus' | 'backendKeyData' | 'notification' | 'readyForQuery' | 'commandComplete' | 'dataRow' | 'copyInResponse' | 'copyOutResponse' | 'authenticationOk' | 'authenticationMD5Password' | 'authenticationCleartextPassword' | 'authenticationSASL' | 'authenticationSASLContinue' | 'authenticationSASLFinal' | 'error' | 'notice';
-declare abstract class QueryError<T extends {
-    shape: ColumnsShape;
-} = {
-    shape: ColumnsShape;
-}> extends OrchidOrmInternalError {
-    message: string;
-    name: QueryErrorName;
-    stack: string | undefined;
-    code: string | undefined;
-    detail: string | undefined;
-    severity: string | undefined;
-    hint: string | undefined;
-    position: string | undefined;
-    internalPosition: string | undefined;
-    internalQuery: string | undefined;
-    where: string | undefined;
-    schema: string | undefined;
-    table: string | undefined;
-    column: string | undefined;
-    dataType: string | undefined;
-    constraint: string | undefined;
-    file: string | undefined;
-    line: string | undefined;
-    routine: string | undefined;
-    get isUnique(): boolean;
-    columnsCache?: {
-        [K in keyof T['shape']]?: true;
-    };
-    get columns(): T["shape"] extends infer T_1 ? { [K in keyof T_1]?: true | undefined; } : never;
-}
-declare class MoreThanOneRowError extends OrchidOrmInternalError {
-    constructor(query: Query, message?: string);
-}
-declare class UnhandledTypeError extends OrchidOrmInternalError {
-    query: Query;
-    constructor(query: Query, value: never);
-}
-
-type NoPrimaryKeyOption = 'error' | 'warning' | 'ignore';
-type DbOptions<CT extends ColumnTypesBase> = ({
-    adapter: Adapter;
-} | Omit<AdapterOptions, 'log'>) & QueryLogOptions & {
-    columnTypes?: CT | ((t: DefaultColumnTypes) => CT);
-    autoPreparedStatements?: boolean;
-    noPrimaryKey?: NoPrimaryKeyOption;
-    snakeCase?: boolean;
-    nowSQL?: string;
-};
-type DbTableOptions = {
-    schema?: string;
-    autoPreparedStatements?: boolean;
-    noPrimaryKey?: NoPrimaryKeyOption;
-    snakeCase?: boolean;
-} & QueryLogOptions;
-declare const anyShape: Record<string, ColumnType<unknown, orchid_core.BaseOperators, unknown>>;
-interface Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends Query['relations'] = Query['relations'], CT extends ColumnTypesBase = DefaultColumnTypes, Data = Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]> extends DbBase<Adapter, Table, Shape, CT>, QueryMethods {
-    new (adapter: Adapter, queryBuilder: Db<Table, Shape, Relations, CT>, table?: Table, shape?: Shape, options?: DbTableOptions): this;
-    queryBuilder: Db;
-    whereQueryBuilder: Query['whereQueryBuilder'];
-    onQueryBuilder: Query['onQueryBuilder'];
-    primaryKeys: Query['primaryKeys'];
-    query: QueryData;
-    selectable: SelectableFromShape<Shape, Table>;
-    returnType: Query['returnType'];
-    then: QueryThen<Data>;
-    catch: QueryCatch<Data>;
-    windows: Query['windows'];
-    defaultSelectColumns: DefaultSelectColumns<Shape>;
-    relations: Relations;
-    relationsQueries: Record<string, Query>;
-    withData: Query['withData'];
-    error: new (message: string, length: number, name: QueryErrorName) => QueryError<this>;
-    isSubQuery: false;
-    meta: {
-        defaults: Record<{
-            [K in keyof Shape]: undefined extends Shape[K]['data']['default'] ? never : K;
-        }[keyof Shape], true>;
-    };
-}
-declare class Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends Query['relations'] = Query['relations'], CT extends ColumnTypesBase = DefaultColumnTypes> implements Query {
-    adapter: Adapter;
-    queryBuilder: Db;
-    table: Table;
-    shape: Shape;
-    columnTypes: CT;
-    whereQueryBuilder: typeof WhereQueryBuilder;
-    onQueryBuilder: typeof OnQueryBuilder;
-    constructor(adapter: Adapter, queryBuilder: Db, table: Table, shape: Shape, columnTypes: CT, transactionStorage: AsyncLocalStorage<AdapterBase>, options: DbTableOptions);
-    [inspect.custom](): string;
-}
-type DbResult<CT extends ColumnTypesBase> = Db<string, Record<string, never>, Query['relations'], ColumnTypesBase extends CT ? DefaultColumnTypes : CT> & {
-    <Table extends string, Shape extends ColumnsShape = ColumnsShape>(table: Table, shape?: ((t: ColumnTypesBase extends CT ? DefaultColumnTypes : CT) => Shape) | Shape, options?: DbTableOptions): Db<Table, Shape>;
-    adapter: Adapter;
-    close: Adapter['close'];
-};
-declare const createDb: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>({ log, logger, columnTypes: ctOrFn, snakeCase, nowSQL, ...options }: DbOptions<CT>) => DbResult<CT>;
-
-type WithArgsOptions = Omit<WithOptions, 'columns'> & {
-    columns?: boolean | string[];
-};
-type WithArgs = [string, ColumnsShapeBase, RawExpression] | [string, WithArgsOptions, ColumnsShapeBase, RawExpression] | [string, Query | ((qb: Db) => Query)] | [string, WithArgsOptions, Query | ((qb: Db) => Query)];
-type WithShape<Args extends WithArgs> = Args[1] extends Query ? Args[1]['result'] : Args[1] extends (qb: Db) => Query ? ReturnType<Args[1]>['result'] : Args[2] extends Query ? Args[2]['result'] : Args[2] extends (qb: Db) => Query ? ReturnType<Args[2]>['result'] : Args[1] extends ColumnsShapeBase ? Args[1] : Args[2] extends ColumnsShapeBase ? Args[2] : Args[2] extends (t: ColumnTypes) => ColumnsShapeBase ? ReturnType<Args[2]> extends ColumnsShapeBase ? ReturnType<Args[2]> : never : never;
-type WithResult<T extends Query, Args extends WithArgs, Shape extends ColumnsShapeBase> = AddQueryWith<T, {
-    table: Args[0];
-    shape: Shape;
-    type: ColumnShapeOutput<Shape>;
-}>;
-declare class With {
-    with<T extends Query, Args extends WithArgs, Shape extends ColumnsShapeBase = WithShape<Args>>(this: T, ...args: Args): WithResult<T, Args, Shape>;
-    _with<T extends Query, Args extends WithArgs, Shape extends ColumnsShapeBase = WithShape<Args>>(this: T, ...args: Args): WithResult<T, Args, Shape>;
-}
-
-type UnionArg<T extends Query> = (Omit<Query, 'result'> & {
-    result: {
-        [K in keyof T['result']]: Pick<T['result'][K], 'dataType'>;
-    };
-}) | RawExpression;
-declare class Union {
-    union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    unionAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _unionAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    intersect<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _intersect<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    intersectAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _intersectAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    except<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _except<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    exceptAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _exceptAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+
+type UnionArg<T extends Query> = (Omit<Query, 'result'> & {
+    result: {
+        [K in keyof T['result']]: Pick<T['result'][K], 'dataType'>;
+    };
+}) | RawExpression;
+declare class Union {
+    union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    unionAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _unionAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    intersect<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _intersect<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    intersectAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _intersectAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    except<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _except<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    exceptAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _exceptAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
 }
 
 type JsonColumnName<T extends Pick<Query, 'selectable'>> = StringKey<{
@@ -1009,8 +1024,8 @@ type JsonPathQueryResult<T extends Query, As extends string, Type extends Column
     [K in As]: Type;
 }>;
 declare class Json {
-    json<T extends Query>(this: T, coalesce?: boolean): SetQueryReturnsValueOptional<T, StringColumn>;
-    _json<T extends Query>(this: T, coalesce?: boolean): SetQueryReturnsValueOptional<T, StringColumn>;
+    json<T extends Query>(this: T, coalesce?: boolean): SetQueryReturnsColumnOptional<T, StringColumn>;
+    _json<T extends Query>(this: T, coalesce?: boolean): SetQueryReturnsColumnOptional<T, StringColumn>;
     jsonSet<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, value: unknown, options?: {
         as?: As;
         createIfMissing?: boolean;
@@ -1058,7 +1073,12 @@ declare class Json {
     }): JsonPathQueryResult<T, As, Type>;
 }
 
-type CreateData<T extends Query, Data = SetOptional<T['inputType'], keyof T['meta']['defaults']>> = [keyof T['relations']] extends [never] ? Data : OmitBelongsToForeignKeys<T['relations'], Data> & CreateRelationData<T>;
+type CreateData<T extends Query, Data = SetOptional<{
+    [K in keyof T['inputType']]: CreateColumn<T, K>;
+}, keyof T['meta']['defaults']>> = [keyof T['relations']] extends [never] ? Data : OmitBelongsToForeignKeys<T['relations'], Data> & CreateRelationData<T>;
+type CreateColumn<T extends Query, Key extends keyof T['inputType']> = T['inputType'][Key] | {
+    [K in keyof Query]: K extends 'then' ? QueryThen<T['inputType'][Key]> : Query[K];
+};
 type OmitBelongsToForeignKeys<R extends RelationsBase, Data> = Omit<Data, {
     [K in keyof R]: R[K] extends BelongsToRelation ? R[K]['options']['foreignKey'] : never;
 }[keyof R]>;
@@ -1150,22 +1170,171 @@ type CreateCtx = {
 };
 type CreateMethodsNames = 'create' | '_create' | 'createMany' | '_createMany' | 'createRaw' | '_createRaw' | 'createFrom' | '_createFrom';
 declare class Create {
+    /**
+     * `create` will create one record.
+     *
+     * Each column may accept a specific value, a raw SQL, or a query that returns a single value.
+     *
+     * ```ts
+     * const oneRecord = await db.table.create({
+     *   name: 'John',
+     *   password: '1234',
+     * });
+     *
+     * await db.table.create({
+     *   // raw SQL
+     *   column1: db.table.sql`'John' | 'Doe'`,
+     *
+     *   // query that returns a single value
+     *   // returning multiple values will result in Postgres error
+     *   column2: db.otherTable.get('someColumn'),
+     * });
+     * ```
+     *
+     * @param data - data for the record, may have values, raw SQL, queries, relation operations
+     */
     create<T extends Query>(this: T, data: CreateData<T>): CreateResult<T>;
     _create<T extends Query>(this: T, data: CreateData<T>): CreateResult<T>;
+    /**
+     * `createMany` will create a batch of records.
+     *
+     * Each column may be set with a specific value, a raw SQL, or a query, the same as in [create](#create).
+     *
+     * In case one of the objects has fewer fields, the `DEFAULT` SQL keyword will be placed in its place in the `VALUES` statement.
+     *
+     * ```ts
+     * const manyRecords = await db.table.createMany([
+     *   { key: 'value', otherKey: 'other value' },
+     *   { key: 'value' }, // default will be used for `otherKey`
+     * ]);
+     * ```
+     *
+     * @param data - data for the record, may have values, raw SQL, queries, relation operations
+     */
     createMany<T extends Query>(this: T, data: CreateData<T>[]): CreateManyResult<T>;
     _createMany<T extends Query>(this: T, data: CreateData<T>[]): CreateManyResult<T>;
+    /**
+     * `createRaw` is for creating one record with a raw expression.
+     *
+     * Provided SQL will be wrapped into parens for a single `VALUES` record.
+     *
+     * If the table has a column with runtime defaults (defined with callbacks), the value will be appended to your SQL.
+     *
+     * `columns` are type-checked to contain all required columns.
+     *
+     * ```ts
+     * const oneRecord = await db.table.createRaw({
+     *   columns: ['name', 'amount'],
+     *   values: db.table.sql`'name', random()`,
+     * });
+     * ```
+     *
+     * @param args - object with columns list and raw SQL for values
+     */
     createRaw<T extends Query, Arg extends CreateRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateResult<T>;
     _createRaw<T extends Query, Arg extends CreateRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateResult<T>;
+    /**
+     * `createRaw` is for creating many record with raw expressions.
+     *
+     * Takes array of SQL expressions, each of them will be wrapped into parens for `VALUES` records.
+     *
+     * If the table has a column with runtime defaults (defined with callbacks), function will be called for each SQL and the value will be appended.
+     *
+     * `columns` are type-checked to contain all required columns.
+     *
+     * ```ts
+     * const manyRecords = await db.table.createManyRaw({
+     *   columns: ['name', 'amount'],
+     *   values: [db.table.sql`'one', 2`, db.table.sql`'three', 4`],
+     * });
+     * ```
+     *
+     * @param args - object with columns list and array of raw SQL for values
+     */
     createManyRaw<T extends Query, Arg extends CreateManyRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateManyResult<T>;
     _createManyRaw<T extends Query, Arg extends CreateManyRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateManyResult<T>;
+    /**
+     * This method is for creating a single record, for batch creating see `createManyFrom`.
+     *
+     * `createFrom` is to perform the `INSERT ... SELECT ...` SQL statement, it does select and insert in a single query.
+     *
+     * The first argument is a query for a **single** record, it should have `find`, `take`, or similar.
+     *
+     * The second optional argument is a data which will be merged with columns returned from the select query.
+     *
+     * The data for the second argument is the same as in [create](#create) and [createMany](#createMany).
+     *
+     * Columns with runtime defaults (defined with a callback) are supported here.
+     * The value for such a column will be injected unless selected from a related table or provided in a data object.
+     *
+     * ```ts
+     * const oneRecord = await db.table.createFrom(
+     *   // In the select, key is a related table column, value is a column to insert as
+     *   RelatedTable.select({ relatedId: 'id' }).findBy({ key: 'value' }),
+     *   // optional argument:
+     *   {
+     *     key: 'value',
+     *   },
+     * );
+     * ```
+     *
+     * The query above will produce such SQL:
+     *
+     * ```sql
+     * INSERT INTO "table"("relatedId", "key")
+     * SELECT "relatedTable"."id" AS "relatedId", 'value'
+     * FROM "relatedTable"
+     * WHERE "relatedTable"."key" = 'value'
+     * LIMIT 1
+     * RETURNING *
+     * ```
+     *
+     * @param query - query to create new records from
+     * @param data - additionally you can set some columns
+     */
     createFrom<T extends Query, Q extends Query & {
         returnType: 'one' | 'oneOrThrow';
     }>(this: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>): CreateResult<T>;
     _createFrom<T extends Query, Q extends Query & {
         returnType: 'one' | 'oneOrThrow';
     }>(this: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>): CreateResult<T>;
+    /**
+     * Similar to `createFrom`, but intended to create many records.
+     *
+     * Unlike `createFrom`, it doesn't accept second argument with data, and runtime defaults cannot work with it.
+     *
+     * ```ts
+     * const manyRecords = await db.table.createManyFrom(
+     *   RelatedTable.select({ relatedId: 'id' }).where({ key: 'value' }),
+     * );
+     * ```
+     *
+     * @param query - query to create new records from
+     */
     createManyFrom<T extends Query, Q extends Query>(this: T, query: Q): CreateManyResult<T>;
     _createManyFrom<T extends Query, Q extends Query>(this: T, query: Q): CreateManyResult<T>;
+    /**
+     * `.defaults` allows setting values that will be used later in `.create`.
+     *
+     * Columns provided in `.defaults` are marked as optional in the following `.create`.
+     *
+     * Default data is the same as in [create](#create) and [createMany](#createMany),
+     * so you can provide a raw SQL, or a query with a query.
+     *
+     * ```ts
+     * // Will use firstName from defaults and lastName from create argument:
+     * db.table
+     *   .defaults({
+     *     firstName: 'first name',
+     *     lastName: 'last name',
+     *   })
+     *   .create({
+     *     lastName: 'override the last name',
+     *   });
+     * ```
+     *
+     * @param data - default values for `create` and `createMany` which will follow `defaults`
+     */
     defaults<T extends Query, Data extends Partial<CreateData<T>>>(this: T, data: Data): T & {
         meta: {
             defaults: Record<keyof Data, true>;
@@ -1176,6 +1345,54 @@ declare class Create {
             defaults: Record<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.
+     * Using this method you can change this behavior to either silently ignore the error by using .onConflict().ignore()
+     * or to update the existing row with new data (perform an "UPSERT") by using .onConflict().merge().
+     *
+     * ```ts
+     * // leave without argument to ignore or merge on any conflict
+     * Target.create(data).onConflict().ignore();
+     *
+     * // single column:
+     * db.table.create(data).onConfict('email');
+     *
+     * // array of columns:
+     * db.table.create(data).onConfict(['email', 'name']);
+     *
+     * // raw expression:
+     * db.table.create(data).onConfict(db.table.sql`(email) where condition`);
+     * ```
+     *
+     * ::: info
+     * The column(s) specified by this method 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.
+     *
+     * You can use the db.table.sql function in onConflict.
+     * It can be useful to specify a condition when you have a partial index:
+     *
+     * ```ts
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *     active: true,
+     *   })
+     *   // ignore only on email conflict and active is true.
+     *   .onConflict(db.table.sql`(email) where active`)
+     *   .ignore();
+     * ```
+     *
+     * :::
+     *
+     * See the documentation on the .ignore() and .merge() methods for more details.
+     *
+     * @param arg - optionally provide an array of columns
+     */
     onConflict<T extends Query, Arg extends OnConflictArg<T>>(this: T, arg?: Arg): OnConflictQueryBuilder<T, Arg>;
     _onConflict<T extends Query, Arg extends OnConflictArg<T> | undefined = undefined>(this: T, arg?: Arg): OnConflictQueryBuilder<T, Arg>;
 }
@@ -1183,17 +1400,143 @@ declare class OnConflictQueryBuilder<T extends Query, Arg extends OnConflictArg<
     private query;
     private onConflict;
     constructor(query: T, onConflict: Arg);
+    /**
+     * Available only after `.onConflict`.
+     *
+     * Modifies a create query, and causes it to be silently dropped without an error if a conflict occurs.
+     *
+     * Adds the `ON CONFLICT (columns) DO NOTHING` clause to the insert statement.
+     *
+     * It produces `ON CONFLICT DO NOTHING` when no `onConflict` argument provided.
+     *
+     * ```ts
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *   })
+     *   .onConflict('email')
+     *   .ignore();
+     * ```
+     */
     ignore(): T;
+    /**
+     * Available only after `.onConflict`.
+     *
+     * Modifies a create query, to turn it into an 'upsert' operation.
+     *
+     * 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',
+     *   })
+     *   .onConflict('email')
+     *   .merge();
+     * ```
+     *
+     * This also works with batch creates:
+     *
+     * ```ts
+     * db.table
+     *   .createMany([
+     *     { email: 'john@example.com', name: 'John Doe' },
+     *     { email: 'jane@example.com', name: 'Jane Doe' },
+     *     { email: 'alex@example.com', name: 'Alex Doe' },
+     *   ])
+     *   .onConflict('email')
+     *   .merge();
+     * ```
+     *
+     * It is also possible to specify a subset of the columns to merge when a conflict occurs.
+     * For example, you may want to set a `createdAt` column when creating but would prefer not to update it if the row already exists:
+     *
+     * ```ts
+     * const timestamp = Date.now();
+     *
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *     createdAt: timestamp,
+     *     updatedAt: timestamp,
+     *   })
+     *   .onConflict('email')
+     *   // string argument for a single column:
+     *   .merge('email')
+     *   // array of strings for multiple columns:
+     *   .merge(['email', 'name', 'updatedAt']);
+     * ```
+     *
+     * It is also 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:
+     *
+     * ```ts
+     * const timestamp = Date.now();
+     *
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *     createdAt: timestamp,
+     *     updatedAt: timestamp,
+     *   })
+     *   .onConflict('email')
+     *   .merge({
+     *     name: 'John Doe The Second',
+     *   });
+     * ```
+     *
+     * It is also possible to add a WHERE clause to conditionally update only the matching rows:
+     *
+     * ```ts
+     * const timestamp = Date.now();
+     *
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *     createdAt: timestamp,
+     *     updatedAt: timestamp,
+     *   })
+     *   .onConflict('email')
+     *   .merge({
+     *     name: 'John Doe',
+     *     updatedAt: timestamp,
+     *   })
+     *   .where({ updatedAt: { lt: timestamp } });
+     * ```
+     *
+     * `.merge` also accepts raw expression:
+     *
+     * ```ts
+     * db.table
+     *   .create(data)
+     *   .onConflict()
+     *   .merge(db.table.sql`raw SQL expression`);
+     * ```
+     *
+     * @param update - column, or array of columns, or object for new column values, or raw SQL
+     */
     merge(update?: keyof T['shape'] | (keyof T['shape'])[] | Partial<T['inputType']> | RawExpression): T;
 }
 
 type UpdateData<T extends Query> = {
-    [K in keyof T['inputType']]?: T['inputType'][K] | RawExpression;
+    [K in keyof T['inputType']]?: UpdateColumn<T, K>;
 } & (T['relations'] extends Record<string, Relation> ? {
     [K in keyof T['relations']]?: T['relations'][K] extends BelongsToRelation ? UpdateBelongsToData<T, T['relations'][K]> : T['relations'][K] extends HasOneRelation ? UpdateHasOneData<T, T['relations'][K]> : T['relations'][K] extends HasManyRelation ? UpdateHasManyData<T, T['relations'][K]> : T['relations'][K] extends HasAndBelongsToManyRelation ? UpdateHasAndBelongsToManyData<T['relations'][K]> : never;
 } : EmptyObject) & {
     __raw?: never;
 };
+type UpdateColumn<T extends Query, Key extends keyof T['inputType'], SubQuery = {
+    [K in keyof Query]: K extends 'then' ? QueryThen<T['inputType'][Key]> : Query[K];
+}> = T['inputType'][Key] | RawExpression | SubQuery | ((q: T) => SubQuery);
 type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> = {
     disconnect: boolean;
 } | {
@@ -1248,7 +1591,7 @@ type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
     create?: CreateData<Rel['nestedCreateQuery']>[];
 };
 type UpdateArg<T extends Query> = T['meta']['hasWhere'] extends true ? UpdateData<T> : never;
-type UpdateRawArg<T extends Query> = T['meta']['hasWhere'] extends true ? RawExpression : never;
+type UpdateRawArgs<T extends Query> = T['meta']['hasWhere'] extends true ? [sql: RawExpression] | [TemplateStringsArray, ...unknown[]] : never;
 type UpdateResult<T extends Query> = T['meta']['hasSelect'] extends true ? T : SetQueryReturnsRowCount<T>;
 type ChangeCountArg<T extends Query> = keyof T['shape'] | Partial<Record<keyof T['shape'], number>>;
 type UpdateCtx = {
@@ -1259,14 +1602,173 @@ type UpdateCtx = {
     updateData?: Record<string, unknown>;
 };
 declare class Update {
+    /**
+     * `.update` takes an object with columns and values to update records.
+     *
+     * By default, `.update` will return a count of updated records.
+     *
+     * Place `.select`, `.selectAll`, or `.get` before `.update` to specify returning columns.
+     *
+     * You need to provide `.where`, `.findBy`, or `.find` conditions before calling `.update`.
+     * To ensure that the whole table won't be updated by accident, updating without where conditions will result in TypeScript and runtime errors.
+     *
+     * If you need to update ALL records, use `where` method without arguments:
+     *
+     * ```ts
+     * await db.table.where().update({ name: 'new name' });
+     * ```
+     *
+     * If `.select` and `.where` were specified before the update it will return an array of updated records.
+     *
+     * If `.select` and `.take`, `.find`, or similar were specified before the update it will return one updated record.
+     *
+     * For a column value you can provide a specific value, raw SQL, a query object that returns a single value, or a callback with a sub-query.
+     *
+     * ```ts
+     * // returns number of updated records by default
+     * const updatedCount = await db.table
+     *   .where({ name: 'old name' })
+     *   .update({ name: 'new name' });
+     *
+     * // returning only `id`
+     * const id = await db.table.find(1).get('id').update({ name: 'new name' });
+     *
+     * // `selectAll` + `find` will return a full record
+     * const oneFullRecord = await db.table
+     *   .selectAll()
+     *   .find(1)
+     *   .update({ name: 'new name' });
+     *
+     * // `selectAll` + `where` will return array of full records
+     * const recordsArray = await db.table
+     *   .select('id', 'name')
+     *   .where({ id: 1 })
+     *   .update({ name: 'new name' });
+     *
+     * await db.table.where({ ...conditions }).update({
+     *   // set the column to a specific value
+     *   column1: 123,
+     *
+     *   // use raw SQL to update the column
+     *   column2: db.table.sql`2 + 2`,
+     *
+     *   // use query that returns a single value
+     *   // returning multiple values will result in Postgres error
+     *   column3: db.otherTable.get('someColumn'),
+     *
+     *   // select a single value from a related record
+     *   column4: (q) => q.relatedTable.get('someColumn'),
+     * });
+     * ```
+     *
+     * `null` value will set a column to `NULL`, but the `undefined` value will be ignored:
+     *
+     * ```ts
+     * db.table.findBy({ id: 1 }).update({
+     *   name: null, // updates to null
+     *   age: undefined, // skipped, no effect
+     * });
+     * ```
+     *
+     * @param arg - data to update records with, may have specific values, raw SQL, queries, or callbacks with sub-queries.
+     */
     update<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
     _update<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
-    updateRaw<T extends Query>(this: T, arg: UpdateRawArg<T>): UpdateResult<T>;
-    _updateRaw<T extends Query>(this: T, arg: UpdateRawArg<T>): UpdateResult<T>;
+    /**
+     * `updateRaw` is for updating records with raw expression.
+     *
+     * The behavior is the same as a regular `update` method has:
+     * `find` or `where` must precede calling this method,
+     * it returns an updated count by default,
+     * you can customize returning data by using `select`.
+     *
+     * ```ts
+     * const value = 'new name';
+     *
+     * // update with SQL template string
+     * const updatedCount = await db.table.find(1).updateRaw`name = ${value}`;
+     *
+     * // or update with `sql` function:
+     * await db.table.find(1).updateRaw(db.table.sql`name = ${value}`);
+     * ```
+     * @param args - raw SQL via a template string or by using a `sql` method
+     */
+    updateRaw<T extends Query>(this: T, ...args: UpdateRawArgs<T>): UpdateResult<T>;
+    _updateRaw<T extends Query>(this: T, ...args: UpdateRawArgs<T>): UpdateResult<T>;
+    /**
+     * To make sure that at least one row was updated use `updateOrThrow`:
+     *
+     * ```ts
+     * import { NotFoundError } from 'pqb';
+     *
+     * try {
+     *   // updatedCount is guaranteed to be greater than 0
+     *   const updatedCount = await db.table
+     *     .where(conditions)
+     *     .updateOrThrow({ name: 'name' });
+     *
+     *   // updatedRecords is guaranteed to be a non-empty array
+     *   const updatedRecords = await db.table
+     *     .where(conditions)
+     *     .select('id')
+     *     .updateOrThrow({ name: 'name' });
+     * } catch (err) {
+     *   if (err instanceof NotFoundError) {
+     *     // handle error
+     *   }
+     * }
+     * ```
+     *
+     * @param arg - data to update records with, may have specific values, raw SQL, queries, or callbacks with sub-queries.
+     */
     updateOrThrow<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
     _updateOrThrow<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
+    /**
+     * Increments a column value by the specified amount. Optionally takes `returning` argument.
+     *
+     * ```ts
+     * // increment numericColumn column by 1, return updated records
+     * const result = await db.table
+     *   .selectAll()
+     *   .where(...conditions)
+     *   .increment('numericColumn');
+     *
+     * // increment someColumn by 5 and otherColumn by 10, return updated records
+     * const result2 = await db.table
+     *   .selectAll()
+     *   .where(...conditions)
+     *   .increment({
+     *     someColumn: 5,
+     *     otherColumn: 10,
+     *   });
+     * ```
+     *
+     * @param data - name of the column to increment, or an object with columns and values to add
+     */
     increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
     _increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+    /**
+     * Decrements a column value by the specified amount. Optionally takes `returning` argument.
+     *
+     * ```ts
+     * // decrement numericColumn column by 1, return updated records
+     * const result = await db.table
+     *   .selectAll()
+     *   .where(...conditions)
+     *   .decrement('numericColumn');
+     *
+     * // decrement someColumn by 5 and otherColumn by 10, return updated records
+     * const result2 = await db.table
+     *   .selectAll()
+     *   .where(...conditions)
+     *   .decrement({
+     *     someColumn: 5,
+     *     otherColumn: 10,
+     *   });
+     * ```
+     *
+     * @param data - name of the column to decrement, or an object with columns and values to subtract
+     */
     decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
     _decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
 }
@@ -1275,8 +1777,59 @@ type DeleteMethodsNames = 'del' | '_del' | 'delete' | '_delete';
 type DeleteArgs<T extends Query> = T['meta']['hasWhere'] extends true ? [] : [never];
 type DeleteResult<T extends Query> = T['meta']['hasSelect'] extends true ? T : SetQueryReturnsRowCount<T>;
 declare class Delete {
+    /**
+     * Alias for `delete` method
+     */
     del<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
     _del<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
+    /**
+     * It is aliased to `del` because `delete` is a reserved word in JavaScript.
+     *
+     * This method deletes one or more rows, based on other conditions specified in the query.
+     *
+     * By default, `.delete` will return a count of deleted records.
+     *
+     * Place `.select`, `.selectAll`, or `.get` before `.delete` to specify returning columns.
+     *
+     * Need to provide `.where`, `.findBy`, or `.find` conditions before calling `.delete`.
+     * To prevent accidental deletion of all records, deleting without where will result in TypeScript and a runtime error.
+     *
+     * To delete all records without conditions add an empty `where`:
+     *
+     * ```ts
+     * await db.table.where().delete();
+     * ```
+     *
+     * ```ts
+     * // deletedCount is the number of deleted records
+     * const deletedCount = await db.table.where(...conditions).delete();
+     *
+     * // returns a single value, throws if not found
+     * const id: number | undefined = await db.table
+     *   .findBy(...conditions)
+     *   .get('id')
+     *   .delete();
+     *
+     * // returns an array of records with specified columns
+     * const deletedRecord = await db.table
+     *   .select('id', 'name', 'age')
+     *   .where(...conditions)
+     *   .delete();
+     *
+     * // returns an array of fully deleted records
+     * const deletedUsersFull = await db.table
+     *   .selectAll()
+     *   .where(...conditions)
+     *   .delete();
+     * ```
+     *
+     * `.delete` supports joining, under the hood the join is transformed to `USING` and `WHERE` statements:
+     *
+     * ```ts
+     * // delete all users who have corresponding profile records:
+     * db.table.join(Profile, 'profile.userId', 'user.id').where().delete();
+     * ```
+     */
     delete<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
     _delete<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
 }
@@ -1421,21 +1974,122 @@ type UpsertThis = WhereResult<Query> & {
     returnType: 'one' | 'oneOrThrow';
 };
 declare class QueryUpsertOrCreate {
+    /**
+     * `.upsert` tries to update one record, and it will perform create in case a record was not found.
+     *
+     * It will implicitly wrap queries in a transaction if it was not wrapped yet.
+     *
+     * `.find` or `.findBy` must precede `.upsert` because it does not work with multiple updates.
+     *
+     * In case more than one row was updated, it will throw `MoreThanOneRowError` and the transaction will be rolled back.
+     *
+     * `update` and `create` properties are accepting the same type of objects as the `update` and `create` commands.
+     *
+     * Not returning a value by default, place `.select` or `.selectAll` before `.upsert` to specify returning columns.
+     *
+     * ```ts
+     * const user = await User.selectAll()
+     *   .find({ email: 'some@email.com' })
+     *   .upsert({
+     *     update: {
+     *       name: 'updated user',
+     *     },
+     *     create: {
+     *       email: 'some@email.com',
+     *       name: 'created user',
+     *     },
+     *   });
+     * ```
+     *
+     * The data for `create` may be returned from a function, it won't be called if a record was updated:
+     *
+     * ```ts
+     * const user = await User.selectAll()
+     *   .find({ email: 'some@email.com' })
+     *   .upsert({
+     *     update: {
+     *       name: 'updated user',
+     *     },
+     *     create: () => ({
+     *       email: 'some@email.com',
+     *       name: 'created user',
+     *     }),
+     *   });
+     * ```
+     *
+     * @param data - `update` property for the data to update, `create` property for the data to create
+     */
     upsert<T extends UpsertThis>(this: T, data: UpsertData<T>): UpsertResult<T>;
     _upsert<T extends UpsertThis>(this: T, data: UpsertData<T>): UpsertResult<T>;
+    /**
+     * `.orCreate` creates a record only if it was not found by conditions.
+     *
+     * It will implicitly wrap queries in a transaction if it was not wrapped yet.
+     *
+     * `.find` or `.findBy` must precede `.orCreate`.
+     *
+     * It is accepting the same argument as `create` commands.
+     *
+     * By default, it is not returning columns, place `.get`, `.select`, or `.selectAll` before `.orCreate` to specify returning columns.
+     *
+     * ```ts
+     * const user = await User.selectAll().find({ email: 'some@email.com' }).orCreate({
+     *   email: 'some@email.com',
+     *   name: 'created user',
+     * });
+     * ```
+     *
+     * The data may be returned from a function, it won't be called if the record was found:
+     *
+     * ```ts
+     * const user = await User.selectAll()
+     *   .find({ email: 'some@email.com' })
+     *   .orCreate(() => ({
+     *     email: 'some@email.com',
+     *     name: 'created user',
+     *   }));
+     * ```
+     *
+     * @param data - the same data as for `create`, it may be returned from a callback
+     */
     orCreate<T extends UpsertThis>(this: T, data: UpsertCreateArg<T>): UpsertResult<T>;
     _orCreate<T extends UpsertThis>(this: T, data: UpsertCreateArg<T>): UpsertResult<T>;
 }
 
-type GetArg<T extends QueryBase> = StringKey<keyof T['selectable']> | RawExpression;
-type UnwrapRaw<T extends Query, Arg extends GetArg<T>> = Arg extends RawExpression ? Arg['__column'] : Exclude<Arg, RawExpression>;
-type GetResult<T extends Query, Arg extends GetArg<T>> = SetQueryReturnsValue<T, UnwrapRaw<T, Arg>>;
-type GetOptionalResult<T extends Query, Arg extends GetArg<T>> = SetQueryReturnsValueOptional<T, UnwrapRaw<T, Arg>>;
+type GetArg<T extends QueryBase> = GetStringArg<T> | RawExpression;
+type GetStringArg<T extends QueryBase> = StringKey<keyof T['selectable']>;
+type GetResult<T extends Query, Arg extends GetArg<T>> = Arg extends GetStringArg<T> ? SetQueryReturnsValue<T, Arg> : Arg extends RawExpression ? SetQueryReturnsColumn<T, Arg['__column']> : never;
+type GetResultOptional<T extends Query, Arg extends GetArg<T>> = Arg extends GetStringArg<T> ? SetQueryReturnsValueOptional<T, Arg> : Arg extends RawExpression ? SetQueryReturnsColumnOptional<T, Arg['__column']> : never;
 declare class QueryGet {
+    /**
+     * `.get` returns a single value, it will add `LIMIT 1` to the query, and accepts a column name or a raw expression.
+     * It will throw `NotFoundError` when not found.
+     *
+     * ```ts
+     * import { NumberColumn } from 'pqb';
+     *
+     * const firstName: string = await db.table.get('name');
+     *
+     * const rawResult: number = await db.table.get(
+     *   db.table.sql((t) => t.integer())`1 + 1`,
+     * );
+     * ```
+     *
+     * @param arg - string for a column to get, or a raw SQL
+     */
     get<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResult<T, Arg>;
     _get<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResult<T, Arg>;
-    getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetOptionalResult<T, Arg>;
-    _getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetOptionalResult<T, Arg>;
+    /**
+     * `.getOptional` returns a single value or undefined when not found:
+     *
+     * ```ts
+     * const firstName: string | undefined = await db.table.getOptional('name');
+     * ```
+     *
+     * @param arg - string for a column to get, or a raw SQL
+     */
+    getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResultOptional<T, Arg>;
+    _getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResultOptional<T, Arg>;
 }
 
 type MergeQuery<T extends Query, Q extends Query, ReturnType extends QueryReturnType = QueryReturnType extends Q['returnType'] ? T['returnType'] : Q['returnType'], Result extends ColumnsShapeBase = T['meta']['hasSelect'] extends true ? Q['meta']['hasSelect'] extends true ? {
@@ -1515,27 +2169,130 @@ interface QueryMethods extends Omit<AsMethods, 'result'>, Aggregate, Select, Fro
 declare class QueryMethods {
     windows: EmptyObject;
     baseQuery: Query;
+    /**
+     * `.all` is a default behavior, that returns an array of objects:
+     *
+     * ```ts
+     * const records = db.table
+     *   .take() // .take() will be overridden by .all()
+     *   .all();
+     * ```
+     */
     all<T extends Query>(this: T): SetQueryReturnsAll<T>;
     _all<T extends Query>(this: T): SetQueryReturnsAll<T>;
+    /**
+     * Takes a single record, adds `LIMIT 1`.
+     * Throws when not found.
+     *
+     * ```ts
+     * const result: TableType = await db.table.where({ key: 'value' }).take();
+     * ```
+     */
     take<T extends Query>(this: T): SetQueryReturnsOne<T>;
     _take<T extends Query>(this: T): SetQueryReturnsOne<T>;
+    /**
+     * Takes a single record, adds `LIMIT 1`.
+     * Returns `undefined` when not found.
+     *
+     * ```ts
+     * const result: TableType | undefined = await db.table
+     *   .where({ key: 'value' })
+     *   .takeOptional();
+     * ```
+     */
     takeOptional<T extends Query>(this: T): SetQueryReturnsOneOptional<T>;
     _takeOptional<T extends Query>(this: T): SetQueryReturnsOneOptional<T>;
+    /**
+     * `.rows` returns an array of arrays without field names:
+     *
+     * ```ts
+     * const rows: Array<Array<number | string>> = await db.table
+     *   .select('id', 'name')
+     *   .rows();
+     *
+     * rows.forEach((row) => {
+     *   // row is array of column values
+     *   row.forEach((value) => {
+     *     // value is an id or a name
+     *   });
+     * });
+     * ```
+     */
     rows<T extends Query>(this: T): SetQueryReturnsRows<T>;
     _rows<T extends Query>(this: T): SetQueryReturnsRows<T>;
+    /**
+     * `.pluck` returns a single array of a single selected column values:
+     *
+     * ```ts
+     * const ids = await db.table.select('id').pluck();
+     * // ids are an array of all users' id like [1, 2, 3]
+     * ```
+     * @param select - column name or a raw SQL
+     */
     pluck<T extends Query, S extends Expression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
     _pluck<T extends Query, S extends Expression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
+    /**
+     * `.exec` won't parse the response at all, and returns undefined:
+     *
+     * ```ts
+     * const nothing = await db.table.take().exec();
+     * ```
+     */
     exec<T extends Query>(this: T): SetQueryReturnsVoid<T>;
     _exec<T extends Query>(this: T): SetQueryReturnsVoid<T>;
     toSql(this: Query, options?: ToSqlOptions): Sql;
     distinct<T extends Query>(this: T, ...columns: Expression<T>[]): T;
     _distinct<T extends Query>(this: T, ...columns: Expression<T>[]): T;
+    /**
+     * Find a single record by the primary key (id), adds `LIMIT 1`.
+     * Throws when not found.
+     *
+     * ```ts
+     * const result: TableType = await db.table.find(123);
+     * ```
+     *
+     * @param args - primary key value to find by
+     */
     find<T extends Query>(this: T, ...args: FindArgs<T>): SetQueryReturnsOne<WhereResult<T>>;
     _find<T extends Query>(this: T, ...args: FindArgs<T>): SetQueryReturnsOne<WhereResult<T>>;
+    /**
+     * Find a single record by the primary key (id), adds `LIMIT 1`.
+     * Returns `undefined` when not found.
+     *
+     * ```ts
+     * const result: TableType | undefined = await db.table.find(123);
+     * ```
+     *
+     * @param args - primary key value to find by
+     */
     findOptional<T extends Query>(this: T, ...args: FindArgs<T>): SetQueryReturnsOneOptional<WhereResult<T>>;
     _findOptional<T extends Query>(this: T, ...args: FindArgs<T>): SetQueryReturnsOneOptional<WhereResult<T>>;
+    /**
+     * The same as `where(conditions).take()`, it will filter records and add a `LIMIT 1`.
+     * Throws when not found.
+     *
+     * ```ts
+     * const result: TableType = await db.table.findBy({
+     *   key: 'value',
+     * });
+     * ```
+     *
+     * @param args - `where` conditions
+     */
     findBy<T extends Query>(this: T, ...args: WhereArg<T>[]): SetQueryReturnsOne<WhereResult<T>>;
     _findBy<T extends Query>(this: T, ...args: WhereArg<T>[]): SetQueryReturnsOne<WhereResult<T>>;
+    /**
+     * The same as `where(conditions).takeOptional()`, it will filter records and add a `LIMIT 1`.
+     * Returns `undefined` when not found.
+     *
+     * ```ts
+     * const result: TableType | undefined = await db.table.findByOptional({
+     *   key: 'value',
+     * });
+     * ```
+     *
+     * @param args - `where` conditions
+     */
     findByOptional<T extends Query>(this: T, ...args: WhereArg<T>[]): SetQueryReturnsOneOptional<WhereResult<T>>;
     _findByOptional<T extends Query>(this: T, ...args: WhereArg<T>[]): SetQueryReturnsOneOptional<WhereResult<T>>;
     withSchema<T extends Query>(this: T, schema: string): T;
@@ -1552,8 +2309,8 @@ declare class QueryMethods {
     _limit<T extends Query>(this: T, arg: number | undefined): T;
     offset<T extends Query>(this: T, arg: number | undefined): T;
     _offset<T extends Query>(this: T, arg: number | undefined): T;
-    exists<T extends Query>(this: T): SetQueryReturnsValue<T, BooleanColumn>;
-    _exists<T extends Query>(this: T): SetQueryReturnsValue<T, BooleanColumn>;
+    exists<T extends Query>(this: T): SetQueryReturnsColumn<T, BooleanColumn>;
+    _exists<T extends Query>(this: T): SetQueryReturnsColumn<T, BooleanColumn>;
     truncate<T extends Query>(this: T, options?: {
         restartIdentity?: boolean;
         cascade?: boolean;
@@ -1650,66 +2407,66 @@ type WindowFunctionOptions<T extends Query = Query, As extends string | undefine
 declare class Aggregate {
     selectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnType>(this: T, functionName: Func, arg: AggregateArg<T>, options?: AggregateOptions<T, As>): SelectAgg<T, Func, As, Value>;
     _selectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnTypeBase>(this: T, functionName: Func, arg: AggregateArg<T>, options?: AggregateOptions<T, As>, columnType?: ColumnTypeBase): SelectAgg<T, Func, As, Value>;
-    count<T extends Query>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T>): SetQueryReturnsValue<T, NumberColumn> & {
+    count<T extends Query>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NumberColumn> & {
         isCount: true;
     };
-    _count<T extends Query>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T>): SetQueryReturnsValue<T, NumberColumn> & {
+    _count<T extends Query>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NumberColumn> & {
         isCount: true;
     };
     selectCount<T extends Query, As extends string | undefined = undefined>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T, As>): SelectAgg<T, 'count', As, NumberColumn>;
     _selectCount<T extends Query, As extends string | undefined = undefined>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T, As>): SelectAgg<T, 'count', As, NumberColumn>;
-    avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
+    _avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
     _selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
-    min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
+    _min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
     _selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
-    max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
+    _max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
     _selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
-    sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
+    _sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
     _selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
-    bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
+    _bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
     _selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
-    bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
+    _bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<NumberColumn>>;
     selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
     _selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
-    boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
-    _boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
+    _boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
     selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
     _selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
-    boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
-    _boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
+    _boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
     selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
     _selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
-    every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
-    _every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
+    _every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<BooleanColumn>>;
     selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
     _selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
-    jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    _jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    _jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
     selectJsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
     _selectJsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    jsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    _jsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    jsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    _jsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
     selectJsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
     _selectJsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
-    _xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
+    xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<StringColumn>>;
+    _xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<StringColumn>>;
     selectXmlAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Aggregate1ArgumentTypes<T>['xmlAgg'], options?: AggregateOptions<T, As>): SelectAgg<T, 'xmlagg', As, NullableColumn<StringColumn>>;
     _selectXmlAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Aggregate1ArgumentTypes<T>['xmlAgg'], options?: AggregateOptions<T, As>): SelectAgg<T, 'xmlagg', As, NullableColumn<StringColumn>>;
-    jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+    jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    _jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+    _jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
     selectJsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
@@ -1718,10 +2475,10 @@ declare class Aggregate {
     _selectJsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+    jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    _jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+    _jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
     selectJsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
@@ -1730,8 +2487,8 @@ declare class Aggregate {
     _selectJsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
     }>>>;
-    stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
-    _stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
+    stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<StringColumn>>;
+    _stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsColumn<T, NullableColumn<StringColumn>>;
     selectStringAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T, As>): SelectAgg<T, 'string_agg', As, NullableColumn<StringColumn>>;
     _selectStringAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T, As>): SelectAgg<T, 'string_agg', As, NullableColumn<StringColumn>>;
 }
@@ -1825,27 +2582,15 @@ type SetQueryReturnsPluck<T extends Query, S extends keyof T['selectable'] | Raw
     then: QueryThen<C['type'][]>;
     catch: QueryCatch<C['type'][]>;
 };
-type SetQueryReturnsValueOptional<T extends Query, Arg extends Exclude<GetArg<T>, RawExpression> | ColumnTypeBase, Column extends ColumnTypeBase = Arg extends ColumnTypeBase ? Arg : Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends RelationQueryBase ? Arg['result']['value'] : never> = Omit<T, 'result' | 'returnType' | 'then' | 'catch'> & {
-    meta: {
-        hasSelect: true;
-    };
-    result: {
-        value: Column;
-    };
-    returnType: 'value';
-    then: QueryThen<Column['type'] | undefined>;
-    catch: QueryThen<Column['type'] | undefined>;
-};
-type SetQueryReturnsValue<T extends Query, Arg extends Exclude<GetArg<T>, RawExpression> | ColumnTypeBase, Column extends ColumnTypeBase = Arg extends ColumnTypeBase ? Arg : Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends RelationQueryBase ? Arg['result']['value'] : never> = Omit<T, 'result' | 'returnType' | 'then' | 'catch'> & {
-    meta: {
+type SetQueryReturnsValueOptional<T extends Query, Arg extends GetStringArg<T>> = SetQueryReturnsValue<T, Arg, 'value'>;
+type SetQueryReturnsValue<T extends Query, Arg extends GetStringArg<T>, ReturnType extends 'value' | 'valueOrThrow' = 'valueOrThrow'> = SetQueryReturnsColumn<T, Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends RelationQueryBase ? Arg['result']['value'] : never, ReturnType>;
+type SetQueryReturnsColumnOptional<T extends QueryBase, Column extends ColumnTypeBase> = SetQueryReturnsColumn<T, Column, 'value'>;
+type SetQueryReturnsColumn<T extends QueryBase, Column extends ColumnTypeBase, ReturnType extends 'value' | 'valueOrThrow' = 'valueOrThrow', Data = ReturnType extends 'value' ? Column['type'] | undefined : Column['type']> = {
+    [K in keyof T]: K extends 'meta' ? T['meta'] & {
         hasSelect: true;
-    };
-    result: {
+    } : K extends 'result' ? {
         value: Column;
-    };
-    returnType: 'valueOrThrow';
-    then: QueryThen<Column['type']>;
-    catch: QueryCatch<Column['type']>;
+    } : K extends 'returnType' ? ReturnType : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : T[K];
 };
 type SetQueryReturnsRowCount<T extends Query> = SetQueryReturns<T, 'rowCount'>;
 type SetQueryReturnsVoid<T extends Query> = SetQueryReturns<T, 'void'>;
@@ -3869,4 +4614,4 @@ declare const testTransaction: {
     close(arg: Arg): Promise<void>;
 };
 
-export { Adapter, AdapterConfig, AdapterOptions, AddQuerySelect, AddQueryWith, AfterHook, AfterHookKey, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, BaseRelation, BeforeHook, BeforeHookKey, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, ColumnData, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnOperators, ColumnType, ColumnTypes, ColumnsObject, ColumnsShape, CommonQueryData, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateMethodsNames, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DomainColumn, DoublePrecisionColumn, DropMode, EnumColumn, Expression, ExpressionOfType, ExpressionOutput, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArgs, FromResult, GetArg, GetQueryResult, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingArg, HavingArgs, HavingItem, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, JSONTypes, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinResult, JoinedParsers, JoinedShapes, Json, JsonItem, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operators, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgs, OrderItem, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, Query, QueryArraysResult, QueryBase, QueryData, QueryError, QueryErrorName, QueryGet, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QueryUpsertOrCreate, QueryWithTable, RawSqlMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SerialColumn, SerialColumnData, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumnInfo, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn, StringExpression, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimeInterval, TimestampColumn, TimestampTZColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TransactionOptions, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertCreateArg, UpsertData, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addQueryHook, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, anyShape, checkIfASimpleQuery, cloneQueryArrays, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, utils as columnUtils, columnsByType, columnsShapeToCode, constraintPropsToCode, constraintToCode, createDb, foreignKeyArgumentToCode, getClonedQueryData, getColumnTypes, getConstraintKind, getQueryAs, getRaw, getShapeFromSelect, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, jsonTypes, logColors, logParamToLogObject, makeRegexToFindInSql, makeSql, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, referencesArgsToCode, relationQueryKey, resetTableData, setQueryObjectValue, simplifyColumnDefault, testTransaction, toSql, toSqlCacheKey };
+export { Adapter, AdapterConfig, AdapterOptions, AddQuerySelect, AddQueryWith, AfterHook, AfterHookKey, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, BaseRelation, BeforeHook, BeforeHookKey, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, ColumnData, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnOperators, ColumnType, ColumnTypes, ColumnsObject, ColumnsShape, CommonQueryData, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateMethodsNames, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DomainColumn, DoublePrecisionColumn, DropMode, EnumColumn, Expression, ExpressionOfType, ExpressionOutput, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArgs, FromResult, GetArg, GetQueryResult, GetStringArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingArg, HavingArgs, HavingItem, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, JSONTypes, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinResult, JoinedParsers, JoinedShapes, Json, JsonItem, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operators, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgs, OrderItem, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, Query, QueryArraysResult, QueryBase, QueryData, QueryError, QueryErrorName, QueryGet, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QueryUpsertOrCreate, QueryWithTable, RawSqlMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SerialColumn, SerialColumnData, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumn, SetQueryReturnsColumnInfo, SetQueryReturnsColumnOptional, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn, StringExpression, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimeInterval, TimestampColumn, TimestampTZColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TransactionOptions, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertCreateArg, UpsertData, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addQueryHook, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, anyShape, checkIfASimpleQuery, cloneQueryArrays, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, utils as columnUtils, columnsByType, columnsShapeToCode, constraintPropsToCode, constraintToCode, createDb, foreignKeyArgumentToCode, getClonedQueryData, getColumnTypes, getConstraintKind, getQueryAs, getRaw, getShapeFromSelect, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, joinSubQuery, jsonTypes, logColors, logParamToLogObject, makeRegexToFindInSql, makeSql, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, referencesArgsToCode, relationQueryKey, resetTableData, resolveSubQueryCallback, setQueryObjectValue, simplifyColumnDefault, testTransaction, toSql, toSqlCacheKey };