pqb 0.32.0 → 0.33.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { QueryResultRow, AdapterConfigBase, AdapterBase, QueryInput, SingleSqlItem, Sql, RecordUnknown, RecordKeyTrue, EmptyObject, QueryBaseCommon, QueryColumns, QueryMetaBase, QueryReturnType, QueryThen, Expression, QueryColumn, MaybeArray, SelectableBase, TemplateLiteralArgs, PickOutputTypeAndOperators, PickQueryResult, OperatorToSQL, ColumnsShapeBase, ColumnsParsers, RecordString, PickQueryTable, FnUnknownToUnknown, ExpressionChain, getValueKey, PickQueryShape, PickQueryTableMetaResult, EmptyTuple, PickQueryMeta, PickQueryMetaResultReturnType, QueryColumnToNullable, PickQueryMetaShape, PickQueryTableMetaResultShape, PickQueryMetaResultWindows, QueryColumnBooleanOrNull, ExpressionData, ValExpression, PickOutputType, SQLQueryArgs, ColumnSchemaConfig, DateColumnData, Code, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, RawSQLBase, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, StaticSQLArgs, ForeignKeyTable, ColumnNameOfTable, BaseNumberData, PickColumnBaseData, ColumnWithDefault, StringTypeData, PrimaryKeyColumn, ParseColumn, EncodeColumn, PickQueryMetaResult, QueryColumnsInit, DefaultSelectColumns, CoreQueryScopes, DbBase, QueryCatch, TransactionState, ColumnTypeBase, CoreBaseOperators, PickQueryUniqueProperties, IsQuery, PickQueryTableMetaResultInputType, PickQueryMetaShapeResultReturnType, SingleSql, MergeObjects, PickQueryResultUniqueColumns, QueryInternalBase, PickQueryReturnType, PickType, ColumnShapeOutput, OperatorsNullable, PickQueryMetaReturnType, UniqueColumn, TimestampHelpers, Codes, ColumnDataCheckBase, PickQueryTableMetaShape } from 'orchid-core';
+import { QueryResultRow, AdapterConfigBase, AdapterBase, QueryInput, SingleSqlItem, Sql, RecordUnknown, RecordKeyTrue, EmptyObject, QueryBaseCommon, QueryColumns, QueryMetaBase, QueryReturnType, QueryThen, Expression, MaybeArray, SelectableBase, TemplateLiteralArgs, ColumnsShapeBase, ColumnsParsers, RecordString, PickQueryTable, QueryDataTransform, ExpressionChain, getValueKey, QueryColumn, PickQueryShape, PickQueryTableMetaResult, EmptyTuple, PickQueryMeta, PickQueryMetaResultReturnType, QueryColumnToNullable, PickQueryMetaShape, PickQueryTableMetaResultShape, PickQueryMetaResultWindows, PickOutputTypeAndOperators, PickQueryResult, ExpressionData, ValExpression, PickOutputType, SQLQueryArgs, ColumnSchemaConfig, DateColumnData, Code, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, RawSQLBase, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, StaticSQLArgs, ForeignKeyTable, ColumnNameOfTable, BaseNumberData, PickColumnBaseData, ColumnWithDefault, StringTypeData, PrimaryKeyColumn, ParseColumn, EncodeColumn, QueryColumnsInit, DefaultSelectColumns, CoreQueryScopes, DbBase, QueryCatch, TransactionState, ColumnTypeBase, PickQueryUniqueProperties, PickQueryMetaResult, IsQuery, PickQueryTableMetaResultInputType, SingleSql, MergeObjects, PickQueryResultUniqueColumns, QueryInternalBase, PickQueryReturnType, PickType, ColumnShapeOutput, OperatorsNullable, PickQueryMetaReturnType, UniqueColumn, TimestampHelpers, Codes, ColumnDataCheckBase, PickQueryTableMetaShape } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'node:util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -119,50 +119,11 @@ interface WithOptions {
     materialized?: true;
     notMaterialized?: true;
 }
-interface JsonItem<As extends string = string, Type extends QueryColumn = QueryColumn> {
-    __json: [
-        kind: 'set',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
-        path: Array<string | number>,
-        value: unknown,
-        options?: {
-            createIfMissing?: boolean;
-        }
-    ] | [
-        kind: 'insert',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
-        path: Array<string | number>,
-        value: unknown,
-        options?: {
-            insertAfter?: boolean;
-        }
-    ] | [
-        kind: 'remove',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
-        path: Array<string | number>
-    ] | [
-        kind: 'pathQuery',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
-        path: string,
-        options?: {
-            vars?: string;
-            silent?: boolean;
-        }
-    ];
-}
-type SelectItem = string | SelectAs | JsonItem | Expression;
+type SelectItem = string | SelectAs | Expression;
 interface SelectAs {
-    selectAs: SelectAsValue$1;
+    selectAs: SelectAsValue;
 }
-interface SelectAsValue$1 {
+interface SelectAsValue {
     [K: string]: string | Query | Expression;
 }
 type OrderTsQueryConfig = true | OrderTsQueryConfigObject;
@@ -307,76 +268,6 @@ type OnConflictMerge = string | string[] | {
     except: string | string[];
 };
 
-interface Operator<Value, Column extends PickOutputTypeAndOperators = PickOutputTypeAndOperators> {
-    <T extends PickQueryResult>(this: T, arg: Value): Omit<SetQueryReturnsColumnOrThrow<T, Column>, keyof T['result']['value']['operators']> & Column['operators'];
-    _opType: Value;
-    _op: OperatorToSQL<any, ToSQLCtx>;
-}
-interface BaseOperators {
-    [K: string]: Operator<any>;
-}
-declare function setQueryOperators(query: PickQueryBaseQuery, operators: BaseOperators): PickQueryBaseQuery;
-type Base<Value> = {
-    equals: Operator<Value | Query | Expression, BooleanQueryColumn>;
-    not: Operator<Value | Query | Expression, BooleanQueryColumn>;
-    in: Operator<Value[] | Query | Expression, BooleanQueryColumn>;
-    notIn: Operator<Value[] | Query | Expression, BooleanQueryColumn>;
-};
-type OperatorsBoolean = Base<boolean> & {
-    and: Operator<{
-        result: {
-            value: BooleanQueryColumn;
-        };
-    } & OperatorsBoolean, BooleanQueryColumn>;
-    or: Operator<{
-        result: {
-            value: BooleanQueryColumn;
-        };
-    } & OperatorsBoolean, BooleanQueryColumn>;
-};
-type Ord<Value> = Base<Value> & {
-    lt: Operator<Value | Query | Expression, BooleanQueryColumn>;
-    lte: Operator<Value | Query | Expression, BooleanQueryColumn>;
-    gt: Operator<Value | Query | Expression, BooleanQueryColumn>;
-    gte: Operator<Value | Query | Expression, BooleanQueryColumn>;
-    between: Operator<[
-        Value | Query | Expression,
-        Value | Query | Expression
-    ], BooleanQueryColumn>;
-};
-type OperatorsNumber = Ord<number>;
-type OperatorsText = Base<string> & {
-    contains: Operator<string | Query | Expression, BooleanQueryColumn>;
-    containsSensitive: Operator<string | Query | Expression, BooleanQueryColumn>;
-    startsWith: Operator<string | Query | Expression, BooleanQueryColumn>;
-    startsWithSensitive: Operator<string | Query | Expression, BooleanQueryColumn>;
-    endsWith: Operator<string | Query | Expression, BooleanQueryColumn>;
-    endsWithSensitive: Operator<string | Query | Expression, BooleanQueryColumn>;
-};
-type OperatorsJson = Base<unknown> & {
-    jsonPath: Operator<[
-        path: string,
-        op: string,
-        value: unknown | Query | Expression
-    ], BooleanQueryColumn>;
-    jsonSupersetOf: Operator<unknown | Query | Expression, BooleanQueryColumn>;
-    jsonSubsetOf: Operator<unknown | Query | Expression, BooleanQueryColumn>;
-};
-type OperatorsAny = Base<any>;
-type OperatorsDate = Ord<Date | string>;
-type OperatorsArray = Base<any>;
-type OperatorsTime = Ord<string>;
-declare const Operators: {
-    any: OperatorsAny;
-    boolean: OperatorsBoolean;
-    number: OperatorsNumber;
-    date: OperatorsDate;
-    time: OperatorsTime;
-    text: OperatorsText;
-    json: OperatorsJson;
-    array: OperatorsArray;
-};
-
 interface RecordOfColumnsShapeBase {
     [K: string]: ColumnsShapeBase;
 }
@@ -446,15 +337,15 @@ interface CommonQueryData {
     logger: QueryLogger;
     autoPreparedStatements?: boolean;
     [toSQLCacheKey]?: Sql;
-    transform?: FnUnknownToUnknown[];
+    transform?: QueryDataTransform[];
     language?: string;
-    isSubQuery?: true;
+    subQuery?: number;
     relChain?: (Query | RelationQuery)[];
     /**
      * Stores current operator functions available for the query.
      * Is needed to remove these operators from query object when changing the query type, see {@link setQueryOperators}.
      */
-    operators?: BaseOperators;
+    operators?: RecordUnknown;
     scopes?: {
         [K: string]: QueryScopeData;
     };
@@ -732,10 +623,11 @@ type JoinOptionalMain<T extends PickQueryMetaResultReturnType, Selectable extend
                 column: QueryColumnToNullable<T['meta']['selectable'][K]['column']>;
             };
         } & Selectable : T['meta'][K];
-    } : K extends 'result' ? NullableResult<T> : K extends 'then' ? QueryThen<GetQueryResult<T, NullableResult<T>>> : T[K];
-};
-type NullableResult<T extends PickQueryResult> = {
-    [K in keyof T['result']]: QueryColumnToNullable<T['result'][K]>;
+    } : K extends 'result' ? {
+        [K in keyof T['result']]: QueryColumnToNullable<T['result'][K]>;
+    } : K extends 'then' ? QueryThen<GetQueryResult<T, {
+        [K in keyof T['result']]: QueryColumnToNullable<T['result'][K]>;
+    }>> : T[K];
 };
 /**
  * Map the `with` table first argument of `join` or `joinLateral` to a query type.
@@ -1437,9 +1329,9 @@ declare class OnMethods {
 
 interface AggregateOptions<T extends PickQueryMetaResultRelationsWindows> {
     distinct?: boolean;
-    order?: OrderArg<T> | OrderArg<T>[];
+    order?: OrderArg<T> | OrderArgs<T>;
     filter?: WhereArg<T>;
-    filterOr?: WhereArg<T>[];
+    filterOr?: WhereArgs<T>;
     withinGroup?: boolean;
     over?: Over<T>;
 }
@@ -1472,11 +1364,217 @@ declare class FnExpression<Q extends Query = Query, T extends QueryColumn = Quer
     constructor(query: Q, fn: string, args: FnExpressionArgs<Q>, options: AggregateOptions<Q>, value: T);
     makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
 }
-type ColumnExpression<C extends QueryColumn, Ops extends BaseOperators = C['operators']> = Expression<C> & {
-    [K in keyof Ops]: (arg: Ops[K]['_opType']) => ColumnExpression<QueryColumnBooleanOrNull>;
-};
 declare function makeFnExpression<T extends PickQueryMetaResultRelationsWindows, C extends QueryColumn>(self: T, type: C, fn: string, args: FnExpressionArgs<Query>, options?: AggregateOptions<T>): SetQueryReturnsColumnOrThrow<T, C> & C['operators'];
 
+interface Operator<Value, Column extends PickOutputTypeAndOperators = PickOutputTypeAndOperators> {
+    <T extends PickQueryResult>(this: T, arg: Value): Omit<SetQueryReturnsColumnOrThrow<T, Column>, keyof T['result']['value']['operators']> & Column['operators'];
+    _opType: Value;
+}
+declare function setQueryOperators(query: PickQueryBaseQuery, operators: RecordUnknown): PickQueryBaseQuery;
+interface Base<Value> {
+    equals: Operator<Value | Query | Expression, BooleanQueryColumn>;
+    not: Operator<Value | Query | Expression, BooleanQueryColumn>;
+    in: Operator<Value[] | Query | Expression, BooleanQueryColumn>;
+    notIn: Operator<Value[] | Query | Expression, BooleanQueryColumn>;
+}
+interface OperatorsBooleanSelf extends OperatorsBoolean {
+    result: {
+        value: BooleanQueryColumn;
+    };
+}
+interface OperatorsBoolean extends Base<boolean> {
+    and: Operator<OperatorsBooleanSelf, BooleanQueryColumn>;
+    or: Operator<OperatorsBooleanSelf, BooleanQueryColumn>;
+}
+interface Ord<Value> extends Base<Value> {
+    lt: Operator<Value | Query | Expression, BooleanQueryColumn>;
+    lte: Operator<Value | Query | Expression, BooleanQueryColumn>;
+    gt: Operator<Value | Query | Expression, BooleanQueryColumn>;
+    gte: Operator<Value | Query | Expression, BooleanQueryColumn>;
+    between: Operator<[
+        Value | Query | Expression,
+        Value | Query | Expression
+    ], BooleanQueryColumn>;
+}
+type OperatorsNumber = Ord<number>;
+interface OperatorsText extends Base<string> {
+    contains: Operator<string | Query | Expression, BooleanQueryColumn>;
+    containsSensitive: Operator<string | Query | Expression, BooleanQueryColumn>;
+    startsWith: Operator<string | Query | Expression, BooleanQueryColumn>;
+    startsWithSensitive: Operator<string | Query | Expression, BooleanQueryColumn>;
+    endsWith: Operator<string | Query | Expression, BooleanQueryColumn>;
+    endsWithSensitive: Operator<string | Query | Expression, BooleanQueryColumn>;
+}
+interface JsonPathQueryOptions {
+    vars?: RecordUnknown;
+    silent?: boolean;
+}
+interface JsonPathQueryTypeOptions<T extends PickQueryColumnTypes, C extends QueryColumn> extends JsonPathQueryOptions {
+    type?: (types: T['columnTypes']) => C;
+}
+interface JsonPathQuery {
+    /**
+     * Selects a value from JSON data using a JSON path.
+     *
+     * Calls the [jsonb_path_query_first](https://www.postgresql.org/docs/current/functions-json.html) Postgres function.
+     *
+     * Type can be provided via `{ type: (t) => t.columnType() }` options, by default the type is `unknown`.
+     *
+     * Optionally takes `vars` and `silent` parameters, see [Postgres docs](https://www.postgresql.org/docs/current/functions-json.html) for details.
+     *
+     * ```ts
+     * // query a single value from a JSON data,
+     * // because of the provided type, string JSON value will be parsed to a Date object.
+     * const value = await db.table
+     *   .get('data')
+     *   .jsonPathQueryFirst('$.path.to.date', { type: (t) => t.date().asDate() });
+     *
+     * // using it in a select
+     * const records = await db.table.select({
+     *   date: (q) =>
+     *     q.get('data').jsonPathQueryFirst('$[*] ? (@ = key)', {
+     *       type: (t) => t.integer(),
+     *       // defining `vars` and `silent`
+     *       vars: { key: 'key' },
+     *       silent: true,
+     *     }),
+     * });
+     *
+     * // using it in `where`
+     * const filtered = await db.table.where((q) =>
+     *   // filtering records by the `name` property from the `data` JSON column
+     *   q.get('data').jsonPathQueryFirst('$.name').equals('name'),
+     * );
+     *
+     * // using it in update
+     * await db.table.find(id).update({
+     *   // using data property to set the `name` column
+     *   name: (q) =>
+     *     q.get('data').jsonPathQueryFirst('$.name', { type: (t) => t.string() }),
+     * });
+     * ```
+     *
+     * @param path - JSON path
+     * @param options - can have type, vars, silent
+     */
+    <T extends PickQueryResultColumnTypes, C extends QueryColumn = QueryColumn<unknown, OperatorsAny>>(this: T, path: string, options?: JsonPathQueryTypeOptions<T, C>): Omit<SetQueryReturnsColumnOrThrow<T, C>, keyof T['result']['value']['operators']> & C['operators'];
+    _opType: never;
+}
+interface OperatorsJson extends Base<unknown> {
+    jsonPathQueryFirst: JsonPathQuery;
+    jsonSupersetOf: Operator<unknown | Query | Expression, BooleanQueryColumn>;
+    jsonSubsetOf: Operator<unknown | Query | Expression, BooleanQueryColumn>;
+    jsonSet: {
+        /**
+         * Returns a JSON value/object/array where a given value is set at the given path.
+         * The path is a key or an array of keys to access the value.
+         *
+         * Calls the [jsonb_set](https://www.postgresql.org/docs/current/functions-json.html) Postgres function.
+         *
+         * It can be used in all contexts on a single JSON value.
+         *
+         * ```ts
+         * await db.table.find(id).update({
+         *   data: (q) => q.get('data').jsonSet(['path', 'to', 'value'], 'new value'),
+         * });
+         * ```
+         *
+         * @param path - key or array of keys
+         * @param value - value to set
+         */
+        <T extends PickQueryResult>(this: T, path: MaybeArray<string | number>, value: unknown): T;
+        _opType: never;
+    };
+    jsonReplace: {
+        /**
+         * The same as {@link jsonSet}, but sets the last argument of `jsonb_set` to false,
+         * so this function only has effect when the value already existed in the JSON.
+         *
+         * ```ts
+         * await db.table.find(id).update({
+         *   // data.path.to.value will be updated only if it already was defined
+         *   data: (q) => q.get('data').jsonReplace(['path', 'to', 'value'], 'new value'),
+         * });
+         * ```
+         *
+         * @param path - key or array of keys
+         * @param value - value to set
+         */
+        <T extends PickQueryResult>(this: T, path: MaybeArray<string | number>, value: unknown): T;
+        _opType: never;
+    };
+    jsonInsert: {
+        /**
+         * Inserts a value into a given position of JSON array and returns the whole array.
+         * The path is a key or an array of keys to access the value.
+         *
+         * If a value exists at the given path, the value is not replaced.
+         *
+         * Provide `{ after: true }` option to insert a value after a given position.
+         *
+         * Calls the [jsonb_insert](https://www.postgresql.org/docs/current/functions-json.html) Postgres function.
+         *
+         * It can be used in all contexts on a single JSON value.
+         *
+         * ```ts
+         * // update the record with data { tags: ['two'] } to have data { tags: ['one', 'two'] }
+         * await db.table.find(id).update({
+         *   data: (q) => q.get('data').jsonInsert(['tags', 0], 'one'),
+         * });
+         *
+         * // add 'three' after 'two'
+         * await db.table.find(id).update({
+         *   data: (q) => q.get('data').jsonInsert(['tags', 1], 'three', { after: true }),
+         * });
+         * ```
+         *
+         * @param path - key or array of keys
+         * @param value - value to insert
+         * @param options - can have `after: true`
+         */
+        <T extends PickQueryResult>(this: T, path: MaybeArray<string | number>, value: unknown, options?: {
+            after?: boolean;
+        }): T;
+        _opType: never;
+    };
+    jsonRemove: {
+        /**
+         * Remove a value from a JSON object or array at a given path.
+         * The path is a key or an array of keys to access the value.
+         *
+         * Uses the [#-](https://www.postgresql.org/docs/current/functions-json.html) Postgres operator.
+         *
+         * It can be used in all contexts on a single JSON value.
+         *
+         * ```ts
+         * // the record has data { tags: ['one', 'two'] }
+         * // removing the first tag, the data will be { tags: ['two'] }
+         * const result = await db.table.find(id).update({
+         *   data: (q) => q.get('data').jsonRemove(['tags', 0]),
+         * });
+         * ```
+         *
+         * @param path - key or array of keys
+         */
+        <T extends PickQueryResult>(this: T, path: MaybeArray<string | number>): T;
+        _opType: never;
+    };
+}
+type OperatorsAny = Base<any>;
+type OperatorsDate = Ord<Date | string>;
+type OperatorsArray = Base<any>;
+type OperatorsTime = Ord<string>;
+declare const Operators: {
+    any: OperatorsAny;
+    boolean: OperatorsBoolean;
+    number: OperatorsNumber;
+    date: OperatorsDate;
+    time: OperatorsTime;
+    text: OperatorsText;
+    json: OperatorsJson;
+    array: OperatorsArray;
+};
+
 declare class ColumnRefExpression<T extends QueryColumn> extends Expression<T> {
     name: string;
     result: {
@@ -1603,12 +1701,12 @@ declare class ExpressionMethods {
      * @param args
      * @param options
      */
-    fn<T extends PickQueryMetaResultRelationsWindowsColumnTypes, Type = unknown, C extends QueryColumn = QueryColumn<Type>>(this: T, fn: string, args: SelectableOrExpression<T>[], options?: AggregateOptions<T>): SetQueryReturnsFn<T, C>;
+    fn<T extends PickQueryMetaResultRelationsWindowsColumnTypes, Type = unknown, C extends QueryColumn = QueryColumn<Type>>(this: T, fn: string, args: SelectableOrExpressions<T>, options?: AggregateOptions<T>): SetQueryReturnsFn<T, C>;
     or(...args: [OrExpressionArg, ...OrExpressionArg[]]): OrExpression;
 }
 
 type WhereArg<T extends PickQueryMetaRelations> = {
-    [K in keyof T['meta']['selectable'] | 'NOT' | 'OR' | 'IN']?: K extends 'NOT' ? MaybeArray<WhereArg<T>> : K extends 'OR' ? MaybeArray<WhereArg<T>>[] : K extends 'IN' ? MaybeArray<{
+    [K in keyof T['meta']['selectable'] | 'NOT' | 'OR' | 'IN']?: K extends 'NOT' ? WhereArg<T> | WhereArgs<T> : K extends 'OR' ? (WhereArg<T> | WhereArgs<T>)[] : K extends 'IN' ? MaybeArray<{
         columns: (keyof T['meta']['selectable'])[];
         values: unknown[][] | QueryBase | Expression;
     }> : T['meta']['selectable'][K]['column']['queryType'] | null | ColumnOperators<T['meta']['selectable'], K> | QueryOrExpression<T['meta']['selectable'][K]['column']['queryType'] | null> | ((q: T) => QueryOrExpression<T['meta']['selectable'][K]['column']['queryType'] | null>);
@@ -1622,9 +1720,9 @@ type WhereArg<T extends PickQueryMetaRelations> = {
  * ```
  */
 type WhereQueryBuilder<T extends PickQueryRelations> = RelationsBase extends T['relations'] ? {
-    [K in keyof T]: K extends keyof QueryBase | keyof Where | keyof ExpressionMethods | 'sql' ? T[K] : never;
+    [K in keyof T]: K extends keyof QueryBase | keyof Where | keyof ExpressionMethods | 'sql' | 'get' | 'ref' ? T[K] : never;
 } : {
-    [K in keyof T]: K extends keyof T['relations'] ? T['relations'][K] : K extends keyof QueryBase | keyof Where | keyof ExpressionMethods | 'sql' ? T[K] : never;
+    [K in keyof T]: K extends keyof T['relations'] ? T['relations'][K] : K extends keyof QueryBase | keyof Where | keyof ExpressionMethods | 'sql' | 'get' | 'ref' ? T[K] : never;
 };
 type WhereArgs<T extends PickQueryMetaRelations> = WhereArg<T>[];
 type WhereNotArgs<T extends PickQueryMetaRelations> = [WhereArg<T>];
@@ -1664,11 +1762,11 @@ declare const _queryWhereNotSql: <T>(q: T, args: SQLQueryArgs) => T;
 /**
  * Mutative {@link Where.orWhere}
  */
-declare const _queryOr: <T extends PickQueryMetaRelations>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const _queryOr: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => WhereResult<T>;
 /**
  * Mutative {@link Where.orWhereNot}
  */
-declare const _queryOrNot: <T extends PickQueryMetaRelations>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const _queryOrNot: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => WhereResult<T>;
 /**
  * Mutative {@link Where.whereIn}
  */
@@ -2122,13 +2220,13 @@ declare class Where {
      *
      * @param args - {@link WhereArgs} will be joined with `OR`
      */
-    orWhere<T extends PickQueryMetaRelations>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    orWhere<T extends PickQueryMetaRelations>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     /**
      * `orWhereNot` takes the same arguments as {@link orWhere}, and prepends each condition with `NOT` just as {@link whereNot} does.
      *
      * @param args - {@link WhereArgs} will be prefixed with `NOT` and joined with `OR`
      */
-    orWhereNot<T extends PickQueryMetaRelations>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    orWhereNot<T extends PickQueryMetaRelations>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     /**
      * `whereIn` and related methods are for the `IN` operator to check for inclusion in a list of values.
      *
@@ -2448,7 +2546,7 @@ declare class DynamicRawSQL<T extends QueryColumn, ColumnTypes = DefaultColumnTy
 }
 declare function raw<T = never>(...args: StaticSQLArgs): RawSQL<QueryColumn<T>>;
 declare function raw<T = never>(...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>>;
-declare const countSelect: RawSQL<QueryColumn<unknown, orchid_core.CoreBaseOperators>, DefaultColumnTypes<ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>>[];
+declare const countSelect: RawSQL<QueryColumn<unknown, any>, DefaultColumnTypes<ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>>[];
 declare function sqlQueryArgsToExpression(args: SQLQueryArgs): RawSQL<QueryColumn>;
 type SqlFn = <T, Args extends [sql: TemplateStringsArray, ...values: unknown[]] | [sql: string] | [values: RecordUnknown, sql?: string]>(this: T, ...args: Args) => Args extends [RecordUnknown] ? (...sql: TemplateLiteralArgs) => RawSQLBase<QueryColumn, T> : RawSQLBase<QueryColumn, T>;
 declare const sqlFn: SqlFn;
@@ -2940,7 +3038,7 @@ interface DefaultSchemaConfig extends ColumnSchemaConfig<ColumnType> {
     dateAsDate(): ParseColumn<DateBaseColumn<DefaultSchemaConfig>, unknown, Date>;
     enum<U extends string, T extends readonly [U, ...U[]]>(dataType: string, type: T): EnumColumn<DefaultSchemaConfig, unknown, U, T>;
     array<Item extends ArrayColumnValue>(item: Item): ArrayColumn<DefaultSchemaConfig, Item, unknown, unknown, unknown>;
-    json<T>(): JSONColumn<T, DefaultSchemaConfig>;
+    json<T extends MaybeArray<string | number | boolean | RecordUnknown>>(): JSONColumn<T, DefaultSchemaConfig>;
     inputSchema(): undefined;
     outputSchema(): undefined;
     querySchema(): undefined;
@@ -2968,12 +3066,10 @@ interface DefaultSchemaConfig extends ColumnSchemaConfig<ColumnType> {
 declare const defaultSchemaConfig: DefaultSchemaConfig;
 
 type SoftDeleteOption<Shape extends QueryColumns> = true | keyof Shape;
-interface QueryWithSoftDelete extends PickQueryMetaResult {
-    meta: QueryMetaBase & {
-        scopes: {
-            nonDeleted: unknown;
-        };
-    };
+interface QueryWithSoftDelete extends PickQueryResult {
+    meta: QueryMetaBase<{
+        nonDeleted: true;
+    }>;
 }
 /**
  * `softDelete` configures the table to set `deletedAt` to current time instead of deleting records.
@@ -3258,7 +3354,7 @@ interface DbResult<ColumnTypes> extends Db<string, never, never, never, never, n
  * })
  * ```
  */
-declare const createDb: <SchemaConfig extends ColumnSchemaConfig<ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ log, logger, snakeCase, nowSQL, schemaConfig, columnTypes: ctOrFn, ...options }: DbOptions<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
+declare const createDb: <SchemaConfig extends ColumnSchemaConfig<ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ log, logger, snakeCase, nowSQL, schemaConfig, columnTypes: ctOrFn, ...options }: DbOptions<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
 declare const _initQueryBuilder: (adapter: Adapter, columnTypes: unknown, transactionStorage: AsyncLocalStorage<TransactionState>, commonOptions: DbTableOptions<undefined, QueryColumns>, options: DbSharedOptions) => Db;
 
 type ToSQLCtx = {
@@ -3299,6 +3395,7 @@ declare const getSqlText: (sql: Sql) => string;
 
 type AliasOrTable<T extends PickQueryMetaTable> = T['meta']['as'] extends string ? T['meta']['as'] : T['table'] extends string ? T['table'] : never;
 type SelectableOrExpression<T extends PickQueryMeta = PickQueryMeta, C extends QueryColumn = QueryColumn> = '*' | keyof T['meta']['selectable'] | Expression<C>;
+type SelectableOrExpressions<T extends PickQueryMeta = PickQueryMeta, C extends QueryColumn = QueryColumn> = ('*' | keyof T['meta']['selectable'] | Expression<C>)[];
 type ExpressionOutput<T extends PickQueryMeta, Expr extends SelectableOrExpression<T>> = Expr extends keyof T['meta']['selectable'] ? T['meta']['selectable'][Expr]['column'] : Expr extends Expression ? Expr['result']['value'] : never;
 declare const getClonedQueryData: (query: QueryData) => QueryData;
 declare const getQueryAs: (q: {
@@ -3336,7 +3433,7 @@ declare function _queryGet<T extends QueryGetSelf, Arg extends GetArg<T>>(self:
 declare function _queryGetOptional<T extends QueryGetSelf, Arg extends GetArg<T>>(self: T, arg: Arg): GetResultOptional<T, Arg>;
 
 declare const isSelectingCount: (q: PickQueryQ) => boolean;
-type QueryReturnsAgg<T, C, Op extends CoreBaseOperators> = SetQueryReturnsColumnOrThrow<T, QueryColumn<C, Op>> & Op;
+type QueryReturnsAgg<T, C, Op> = SetQueryReturnsColumnOrThrow<T, QueryColumn<C, Op>> & Op;
 type CountReturn<T> = QueryReturnsAgg<T, number, OperatorsNumber> & {
     isCount: true;
 };
@@ -3803,7 +3900,7 @@ declare class Clear {
     clear<T extends Query>(this: T, ...clears: ClearStatement[]): T;
 }
 
-interface CreateSelf extends QueryBase {
+interface CreateSelf extends PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryUniqueProperties {
     inputType: RecordUnknown;
 }
 type CreateData<T extends CreateSelf, BelongsToData = CreateBelongsToData<T>> = RelationsBase extends T['relations'] ? CreateDataWithDefaults<T, keyof T['meta']['defaults']> : CreateRelationsData<T, BelongsToData>;
@@ -3975,7 +4072,7 @@ declare class Create {
      * const createdCount = await db.table.insertMany([data, data, data]);
      * ```
      *
-     * Because of a limitation of Postgres protocol, queries having more than **65536** are going to fail in runtime.
+     * Because of a limitation of Postgres protocol, queries having more than **65535** of values are going to fail in runtime.
      * To solve this seamlessly, OrchidORM will automatically batch such queries, and wrap them into a transaction, unless they are already in a transaction.
      *
      * ```ts
@@ -4778,153 +4875,6 @@ declare abstract class QueryHooks {
     afterDeleteCommit<T extends PickQueryShape, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
 }
 
-type JsonColumnName<T extends PickQueryMeta> = {
-    [K in keyof T['meta']['selectable']]: T['meta']['selectable'][K]['column']['dataType'] extends 'jsonb' ? K : never;
-}[keyof T['meta']['selectable']] & string;
-type ColumnOrJsonMethod<T extends PickQueryMeta> = JsonColumnName<T> | JsonItem;
-type JsonSetResult<T extends PickQueryMetaShapeResultReturnType, Column extends ColumnOrJsonMethod<T>, As extends string> = JsonItem<As, Column extends keyof T['shape'] ? T['shape'][Column] : Column extends JsonItem ? Column['__json'][2] : QueryColumn> & AddQuerySelect<T, Record<As, Column extends keyof T['shape'] ? T['shape'][Column] : Column extends JsonItem ? Column['__json'][2] : QueryColumn>>;
-type JsonPathQueryResult<T extends PickQueryMetaResultReturnType, As extends string, Type extends QueryColumn> = JsonItem & AddQuerySelect<T, {
-    [K in As]: Type;
-}>;
-declare abstract class JsonModifiers {
-    /**
-     * Return a JSON value/object/array where a given value is set at the given path.
-     * The path is an array of keys to access the value.
-     *
-     * Can be used in `update` callback.
-     *
-     * ```ts
-     * const result = await db.table.jsonSet('data', ['name'], 'new value').take();
-     *
-     * expect(result.data).toEqual({ name: 'new value' });
-     * ```
-     *
-     * Optionally takes parameters of type `{ as?: string, createIfMissing?: boolean }`
-     *
-     * ```ts
-     * await db.table.jsonSet('data', ['name'], 'new value', {
-     *   as: 'alias', // select data as `alias`
-     *   createIfMissing: true, // ignored if missing by default
-     * });
-     * ```
-     *
-     * @param column - name of JSON column, or a result of a nested json method
-     * @param path - path to value inside the json
-     * @param value - value to set into the json
-     * @param options - `as` to alias the json value when selecting, `createIfMissing: true` will create a new JSON property if it didn't exist before
-     */
-    jsonSet<T extends PickQueryMetaShapeResultReturnType, 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;
-    }): JsonSetResult<T, Column, As>;
-    /**
-     * Return a JSON value/object/array where a given value is inserted at the given JSON path. Value can be a single value or JSON object. If a value exists at the given path, the value is not replaced.
-     *
-     * Can be used in `update` callback.
-     *
-     * ```ts
-     * // imagine user has data = { tags: ['two'] }
-     * const result = await db.table.jsonInsert('data', ['tags', 0], 'one').take();
-     *
-     * // 'one' is inserted to 0 position
-     * expect(result.data).toEqual({ tags: ['one', 'two'] });
-     * ```
-     *
-     * Optionally takes parameters of type `{ as?: string, insertAfter?: boolean }`
-     *
-     * ```ts
-     * // imagine user has data = { tags: ['one'] }
-     * const result = await db.table
-     *   .jsonInsert('data', ['tags', 0], 'two', {
-     *     as: 'alias', // select as an alias
-     *     insertAfter: true, // insert after the specified position
-     *   })
-     *   .take();
-     *
-     * // 'one' is inserted to 0 position
-     * expect(result.alias).toEqual({ tags: ['one', 'two'] });
-     * ```
-     * @param column - name of JSON column, or a result of a nested json method
-     * @param path - path to the array inside the json, last path element is index to insert into
-     * @param value - value to insert into the json array
-     * @param options - `as` to alias the json value when selecting, `insertAfter: true` to insert after the specified position
-     */
-    jsonInsert<T extends PickQueryMetaShapeResultReturnType, 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;
-        insertAfter?: boolean;
-    }): JsonSetResult<T, Column, As>;
-    /**
-     * Return a JSON value/object/array where a given value is removed at the given JSON path.
-     *
-     * Can be used in `update` callback.
-     *
-     * ```ts
-     * // imagine a user has data = { tags: ['one', 'two'] }
-     * const result = await db.table
-     *   .jsonRemove(
-     *     'data',
-     *     ['tags', 0],
-     *     // optional parameters:
-     *     {
-     *       as: 'alias', // select as an alias
-     *     },
-     *   )
-     *   .take();
-     *
-     * expect(result.alias).toEqual({ tags: ['two'] });
-     * ```
-     *
-     * @param column - name of JSON column, or a result of a nested json method
-     * @param path - path to the array inside the json, last path element is index to remove this element
-     * @param options - `as` to alias the json value when selecting
-     */
-    jsonRemove<T extends PickQueryMetaShapeResultReturnType, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, options?: {
-        as?: As;
-    }): JsonSetResult<T, Column, As>;
-    /**
-     * Selects a value from JSON data using a JSON path.
-     *
-     * ```ts
-     * import { columnTypes } from 'orchid-orm';
-     *
-     * db.table.jsonPathQuery(
-     *   columnTypes.text(3, 100), // type of the value
-     *   'data', // name of the JSON column
-     *   '$.name', // JSON path
-     *   'name', // select value as name
-     *
-     *   // Optionally supports `vars` and `silent` options
-     *   // check Postgres docs for jsonb_path_query for details
-     *   {
-     *     vars: 'vars',
-     *     silent: true,
-     *   },
-     * );
-     * ```
-     *
-     * Nested JSON operations can be used in place of JSON column name:
-     *
-     * ```ts
-     * db.table.jsonPathQuery(
-     *   columnTypes.text(3, 100),
-     *   // Available: .jsonSet, .jsonInsert, .jsonRemove
-     *   db.table.jsonSet('data', ['key'], 'value'),
-     *   '$.name',
-     *   'name',
-     * );
-     * ```
-     *
-     * @param type - provide a column type to have a correct result type
-     * @param column - name of JSON column, or a result of a nested json method
-     * @param path - special JSON path string to reference a JSON value
-     * @param as - optional alias for the selected value
-     * @param options - supports `vars` and `silent`, check Postgres docs of `json_path_query` for these
-     */
-    jsonPathQuery<T extends PickQueryMetaShapeResultReturnType, As extends string, Type extends QueryColumn>(this: T, type: Type, column: ColumnOrJsonMethod<T>, path: string, as: As, options?: {
-        vars?: string;
-        silent?: boolean;
-    }): JsonPathQueryResult<T, As, Type>;
-}
 declare abstract class JsonMethods {
     /**
      * Wraps the query in a way to select a single JSON string.
@@ -4989,13 +4939,12 @@ interface SelectSelf {
     withData: WithDataBase;
 }
 type SelectArg<T extends SelectSelf> = '*' | keyof T['meta']['selectable'];
+type SelectArgs<T extends SelectSelf> = ('*' | keyof T['meta']['selectable'])[];
 interface SelectAsArg<T extends SelectSelf> {
-    [K: string]: SelectAsValue<T>;
+    [K: string]: keyof T['meta']['selectable'] | Expression | ((q: {
+        [K in keyof T]: K extends keyof T['relations'] ? T['relations'][K]['relationConfig']['methodQuery'] : T[K];
+    }) => QueryBase | Expression);
 }
-type SelectAsValue<T extends SelectSelf> = keyof T['meta']['selectable'] | Expression | ((q: SelectSubQueryArg<T>) => QueryBase | Expression);
-type SelectSubQueryArg<T extends SelectSelf> = {
-    [K in keyof T]: K extends keyof T['relations'] ? T['relations'][K]['relationConfig']['methodQuery'] : T[K];
-};
 type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = {
     [K in keyof T]: K extends 'result' ? ('*' extends Columns[number] ? {
         [K in Columns[number] | keyof T['shape'] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
@@ -5009,15 +4958,17 @@ type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = {
 } & QueryMetaHasSelect;
 type SelectResultObj<T extends SelectSelf, Obj> = {
     [K in keyof T]: K extends 'meta' ? T['meta'] & {
+        hasSelect: true;
         selectable: SelectAsSelectable<Obj>;
     } : K extends 'result' ? {
-        [K in keyof Obj | (T['meta']['hasSelect'] extends true ? keyof T['result'] : never)]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
+        [K in T['meta']['hasSelect'] extends true ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
     } : K extends 'then' ? QueryThen<GetQueryResult<T, {
-        [K in keyof Obj | (T['meta']['hasSelect'] extends true ? keyof T['result'] : never)]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
+        [K in T['meta']['hasSelect'] extends true ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
     }>> : T[K];
-} & QueryMetaHasSelect;
+};
 type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = {
     [K in keyof T]: K extends 'meta' ? T['meta'] & {
+        hasSelect: true;
         selectable: SelectAsSelectable<Obj>;
     } : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
     {
@@ -5025,7 +4976,7 @@ type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey
     } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown) : K extends 'then' ? QueryThen<GetQueryResult<T, {
         [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | keyof Obj as K extends keyof T['meta']['selectable'] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof T['meta']['selectable'] ? T['meta']['selectable'][K]['column'] : K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : never;
     } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : T[K];
-} & QueryMetaHasSelect;
+};
 type SelectAsSelectable<Arg> = {
     [K in keyof Arg]: Arg[K] extends (q: never) => {
         returnType: 'value' | 'valueOrThrow';
@@ -5051,9 +5002,9 @@ declare const addParserForSelectItem: <T extends PickQueryMeta>(q: T, as: string
 declare const processSelectArg: <T extends SelectSelf>(q: T, as: string | undefined, arg: SelectArg<T>, columnAs?: string | getValueKey) => SelectItem | undefined;
 declare const setParserForSelectedString: (q: PickQueryQ, arg: string, as: string | getValueKey | undefined, columnAs?: string | getValueKey) => string;
 declare const getShapeFromSelect: (q: QueryBase, isSubQuery?: boolean) => QueryColumns;
-declare function _querySelect<T extends SelectSelf, Columns extends SelectArg<T>[]>(q: T, columns: Columns): SelectResult<T, Columns>;
+declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>>(q: T, columns: Columns): SelectResult<T, Columns>;
 declare function _querySelect<T extends SelectSelf, Obj extends SelectAsArg<T>>(q: T, obj: Obj): SelectResultObj<T, Obj>;
-declare function _querySelect<T extends SelectSelf, Columns extends SelectArg<T>[], Obj extends SelectAsArg<T>>(q: T, args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
+declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>, Obj extends SelectAsArg<T>>(q: T, args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
 declare class Select {
     /**
      * Takes a list of columns to be selected, and by default, the query builder will select all columns of the table.
@@ -5116,9 +5067,9 @@ declare class Select {
      *   .where({ 'author.isPopular': true });
      * ```
      */
-    select<T extends SelectSelf, Columns extends SelectArg<T>[]>(this: T, ...args: Columns): SelectResult<T, Columns>;
+    select<T extends SelectSelf, Columns extends SelectArgs<T>>(this: T, ...args: Columns): SelectResult<T, Columns>;
     select<T extends SelectSelf, Obj extends SelectAsArg<T>>(this: T, obj: Obj): SelectResultObj<T, Obj>;
-    select<T extends SelectSelf, Columns extends SelectArg<T>[], Obj extends SelectAsArg<T>>(this: T, ...args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
+    select<T extends SelectSelf, Columns extends SelectArgs<T>, Obj extends SelectAsArg<T>>(this: T, ...args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
     /**
      * When querying the table or creating records, all columns are selected by default,
      * but updating and deleting queries are returning affected row counts by default.
@@ -5290,9 +5241,11 @@ interface WithArgsOptions {
 interface WithRecursiveOptions extends WithArgsOptions {
     union?: 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT' | 'EXCEPT ALL';
 }
-type WithQueryBuilder<T extends PickQueryWithDataColumnTypes> = {
-    [K in keyof Query]: K extends 'sql' ? SqlMethod<T['columnTypes']>['sql'] : K extends 'relations' ? EmptyObject : K extends 'withData' ? T['withData'] : Query[K];
-};
+interface WithQueryBuilder<T extends PickQueryWithDataColumnTypes> extends Query {
+    sql: SqlMethod<T['columnTypes']>['sql'];
+    relations: EmptyObject;
+    withData: T['withData'];
+}
 type WithResult<T extends PickQueryMetaWithDataColumnTypes, Name extends string, Q extends PickQueryResult> = {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta']]: K extends 'kind' ? 'select' : T['meta'][K];
@@ -5303,7 +5256,7 @@ type WithResult<T extends PickQueryMetaWithDataColumnTypes, Name extends string,
         } : K extends keyof T['withData'] ? T['withData'][K] : never;
     } : T[K];
 };
-type WithSqlResult<T extends PickQueryWithDataColumnTypes, Name extends string, Shape extends ColumnsShapeBase> = {
+type WithSqlResult<T extends PickQueryWithDataColumnTypes, Name extends string, Shape extends QueryColumns> = {
     [K in keyof T]: K extends 'withData' ? {
         [K in Name | keyof T['withData']]: K extends Name ? {
             table: Name;
@@ -5377,7 +5330,7 @@ declare class WithMethods {
      * ```
      */
     with<T extends PickQueryMetaWithDataColumnTypes, Name extends string, Q>(this: T, name: Name, query: Q | ((q: WithQueryBuilder<T>) => Q)): WithResult<T, Name, Q extends Query ? Q : never>;
-    with<T extends PickQueryMetaWithDataColumnTypes, Name extends string, Q extends Query>(this: T, name: Name, options: WithArgsOptions, query: Q | ((qb: WithQueryBuilder<T>) => Q)): WithResult<T, Name, Q>;
+    with<T extends PickQueryMetaWithDataColumnTypes, Name extends string, Q extends Query>(this: T, name: Name, options: WithArgsOptions, query: Q | ((q: WithQueryBuilder<T>) => Q)): WithResult<T, Name, Q>;
     withRecursive<T extends PickQueryMetaWithDataColumnTypes, Name extends string, Q extends Query, Result = WithResult<T, Name, Q>>(this: T, name: Name, base: Q | ((qb: WithQueryBuilder<T>) => Q), recursive: (qb: {
         [K in keyof Result]: K extends 'result' ? Q['result'] : Result[K];
     }) => Query): Result;
@@ -5388,14 +5341,14 @@ declare class WithMethods {
     withSql<T extends PickQueryWithDataColumnTypes, Name extends string, Shape extends ColumnsShapeBase>(this: T, name: Name, shape: (t: T['columnTypes']) => Shape, expr: (q: T) => Expression): WithSqlResult<T, Name, Shape>;
 }
 
-type UnionArg<T extends PickQueryResult> = {
+type UnionArgs<T extends PickQueryResult> = ({
     result: {
         [K in keyof T['result']]: {
             queryType: T['result'][K]['queryType'];
         };
     };
-} | ((q: T) => Expression);
-declare const _queryUnion: <T extends Query>(base: T, args: UnionArg<T>[], k: UnionKind) => T;
+} | ((q: T) => Expression))[];
+declare const _queryUnion: <T extends Query>(base: T, args: UnionArgs<T>, k: UnionKind) => T;
 declare class Union {
     /**
      * Creates a union query, takes one or more queries or SQL expressions.
@@ -5451,58 +5404,46 @@ declare class Union {
      *
      * @param args - array of queries or SQL expressions
      */
-    union<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
+    union<T extends PickQueryResult>(this: T, ...args: UnionArgs<T>): T;
     /**
      * Same as {@link union}, but allows duplicated rows.
      *
      * @param args - array of queries or SQL expressions
      */
-    unionAll<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
+    unionAll<T extends PickQueryResult>(this: T, ...args: UnionArgs<T>): T;
     /**
      * Same as {@link union}, but uses a `INTERSECT` SQL keyword instead
      *
      * @param args - array of queries or SQL expressions
      */
-    intersect<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
+    intersect<T extends PickQueryResult>(this: T, ...args: UnionArgs<T>): T;
     /**
      * Same as {@link intersect}, but allows duplicated rows.
      *
      * @param args - array of queries or SQL expressions
      */
-    intersectAll<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
+    intersectAll<T extends PickQueryResult>(this: T, ...args: UnionArgs<T>): T;
     /**
      * Same as {@link union}, but uses an `EXCEPT` SQL keyword instead
      *
      * @param args - array of queries or SQL expressions
      */
-    except<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
+    except<T extends PickQueryResult>(this: T, ...args: UnionArgs<T>): T;
     /**
      * Same as {@link except}, but allows duplicated rows.
      *
      * @param args - array of queries or SQL expressions
      */
-    exceptAll<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
+    exceptAll<T extends PickQueryResult>(this: T, ...args: UnionArgs<T>): T;
 }
 
-type UpdateSelf = {
-    [K in 'inputType' | 'relations' | UpdateColumnArgKeys]: Query[K];
-};
+interface UpdateSelf extends PickQueryMetaResultRelationsWithDataReturnTypeShape {
+    inputType: RecordUnknown;
+}
 type UpdateData<T extends UpdateSelf> = {
-    [K in keyof T['inputType']]?: UpdateColumn<T, K>;
-} & {
-    [K in keyof T['relations']]?: UpdateRelationData<T, T['relations'][K]['relationConfig']>;
+    [K in keyof T['inputType'] | keyof T['relations']]?: K extends keyof T['inputType'] ? UpdateColumn<T, K> : UpdateRelationData<T, T['relations'][K]['relationConfig']>;
 };
-type UpdateColumnArgKeys = keyof JsonModifiers | keyof ExpressionMethods | 'sql' | 'meta' | 'shape' | 'result' | 'returnType' | 'columnTypes';
-interface UpdateQueryOrExpression<T> extends QueryOrExpression<T> {
-    meta: {
-        kind: 'select';
-    };
-}
-type UpdateColumn<T extends UpdateSelf, Key extends keyof T['inputType']> = T['inputType'][Key] | QueryOrExpression<T['inputType'][Key]> | {
-    [K in keyof Query]: K extends 'then' ? QueryThen<T['inputType'][Key]> : Query[K];
-} | ((q: {
-    [K in keyof T['relations'] | UpdateColumnArgKeys]: K extends keyof T['relations'] ? T['relations'][K] : K extends UpdateColumnArgKeys ? T[K] : never;
-}) => JsonItem | UpdateQueryOrExpression<T['inputType'][Key]>);
+type UpdateColumn<T extends UpdateSelf, Key extends keyof T['inputType']> = T['inputType'][Key] | QueryOrExpression<T['inputType'][Key]> | ((q: T) => QueryOrExpression<T['inputType'][Key]>);
 type UpdateRelationData<T extends UpdateSelf, Rel extends RelationConfigBase> = QueryReturnsAll<T['returnType']> extends true ? Rel['dataForUpdate'] : Rel['one'] extends true ? Rel['dataForUpdate'] | Rel['dataForUpdateOne'] : Rel['dataForUpdate'] & Rel['dataForUpdateOne'];
 type UpdateArg<T extends UpdateSelf> = T['meta']['hasWhere'] extends true ? UpdateData<T> : never;
 type UpdateRawArgs<T extends UpdateSelf> = T['meta']['hasWhere'] extends true ? SQLQueryArgs : never;
@@ -5918,7 +5859,7 @@ declare module './aggregate' {
          * @param search - name of the search to use the query from
          * @param options - `text` for a text source, `options` for `ts_headline` options
          */
-        headline<T extends PickQueryMeta>(this: T, search: HeadlineSearchArg<T>, options?: HeadlineParams<T>): ColumnExpression<QueryColumn<string>>;
+        headline<T extends PickQueryMeta>(this: T, search: HeadlineSearchArg<T>, options?: HeadlineParams<T>): SetQueryReturnsColumnOrThrow<T, QueryColumn<string>>;
     }
 }
 type SearchArg<T extends PickQueryMeta, As extends string> = {
@@ -6144,22 +6085,14 @@ declare class SearchMethods {
     search<T extends PickQueryMeta, As extends string>(this: T, arg: SearchArg<T, As>): WhereSearchResult<T, As>;
 }
 
-type OrCreateArg<T extends Query, BT> = CreateData<T, BT> | (() => CreateData<T, BT>);
-type UpsertArg<T extends Query, Data, BT> = {
-    update: Data;
-    create: CreateData<T, BT> | ((update: Data) => CreateData<T, BT>);
-} | UpsertArgWithData<T, Data, BT>;
-type UpsertArgWithData<T extends Query, Data, BT> = {
-    data: Data;
-    create: UpsertCreate<keyof Data, CreateData<T, BT>> | ((update: Data) => UpsertCreate<keyof Data, CreateData<T, BT>>);
-};
+type OrCreateArg<Data> = Data | (() => Data);
 type UpsertCreate<DataKey extends PropertyKey, CD> = {
     [K in keyof CD as K extends DataKey ? never : K]: CD[K];
 } & {
     [K in DataKey]?: K extends keyof CD ? CD[K] : never;
 };
-type UpsertResult<T extends PickQueryMetaResult> = T['meta']['hasSelect'] extends true ? SetQueryReturnsOneKind<T, 'upsert'> : SetQueryReturnsVoid<SetQueryKind<T, 'upsert'>>;
-type UpsertThis = WhereResult<Query> & {
+type UpsertResult<T extends PickQueryMetaResult> = T['meta']['hasSelect'] extends true ? SetQueryReturnsOneKind<T, 'upsert'> : SetQueryReturnsVoidKind<T, 'upsert'>;
+type UpsertThis = UpdateSelf & CreateSelf & QueryMetaHasWhere & {
     returnType: 'one' | 'oneOrThrow';
 };
 declare class QueryUpsertOrCreate {
@@ -6256,7 +6189,13 @@ declare class QueryUpsertOrCreate {
      *
      * @param data - `update` property for the data to update, `create` property for the data to create
      */
-    upsert<T extends UpsertThis, Update extends UpdateData<T>, BT extends CreateBelongsToData<T>>(this: T, data: UpsertArg<T, Update, BT>): UpsertResult<T>;
+    upsert<T extends UpsertThis, Update extends UpdateData<T>, BT extends CreateBelongsToData<T>>(this: T, data: {
+        update: Update;
+        create: CreateData<T, BT> | ((update: Update) => CreateData<T, BT>);
+    } | {
+        data: Update;
+        create: UpsertCreate<keyof Update, CreateData<T, BT>> | ((update: Update) => UpsertCreate<keyof Update, CreateData<T, BT>>);
+    }): UpsertResult<T>;
     /**
      * `orCreate` creates a record only if it was not found by conditions.
      *
@@ -6288,21 +6227,17 @@ declare class QueryUpsertOrCreate {
      *
      * @param data - the same data as for `create`, it may be returned from a callback
      */
-    orCreate<T extends UpsertThis, BT extends CreateBelongsToData<T>>(this: T, data: OrCreateArg<T, BT>): UpsertResult<T>;
+    orCreate<T extends UpsertThis, BT extends CreateBelongsToData<T>>(this: T, data: OrCreateArg<CreateData<T, BT>>): UpsertResult<T>;
 }
 
-type QueryTransformFn<T extends Query> = (input: T['then'] extends QueryThen<infer Data> ? Data : never) => unknown;
-type QueryTransform<T extends QueryBase, Data> = {
-    [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
-        value: QueryColumn<Data>;
-    } : K extends 'then' ? QueryThen<Data> : T[K];
-};
 declare class TransformMethods {
     /**
      * Transform the result of the query right after loading it.
      *
      * `transform` method should be called in the last order, other methods can't be chained after calling it.
      *
+     * It is meant to transform the whole result of a query, for transforming individual records consider using {@link QueryMap.map}.
+     *
      * The [hooks](/guide/hooks.html) that are going to run after the query will receive the query result **before** transferring.
      *
      * Consider the following example of a cursor-based pagination by `id`:
@@ -6349,14 +6284,66 @@ declare class TransformMethods {
      *
      * @param fn - function to transform query result with
      */
-    transform<T extends Query, Fn extends QueryTransformFn<T>>(this: T, fn: Fn): QueryTransform<T, ReturnType<Fn>>;
+    transform<T extends Query, Result>(this: T, fn: (input: T['then'] extends QueryThen<infer Data> ? Data : never) => Result): {
+        [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
+            value: QueryColumn<Result>;
+        } : K extends 'then' ? QueryThen<Result> : T[K];
+    };
+}
+
+declare class QueryMap {
+    /**
+     * Use `map` to transform individual records of a query result.
+     *
+     * It accepts a single record and should return a single transformed record.
+     *
+     * For transforming the whole result of a query, consider using [transform](#transform) instead.
+     *
+     * The [hooks](/guide/hooks) that are going to run after the query will receive the query result **before** transformation.
+     *
+     * ```ts
+     * // add a `titleLength` to every post
+     * const posts = await db.post.limit(10).map((post) => ({
+     *   ...post,
+     *   titleLength: post.title.length,
+     * }));
+     *
+     * posts[0].titleLength; // number
+     *
+     * // using the exact same `map` function to transform a single post
+     * const singlePost = await db.post.find(id).map((post) => ({
+     *   ...post,
+     *   titleLength: post.title.length,
+     * }));
+     *
+     * singlePost.titleLength; // number
+     *
+     * // can be used in sub-queries
+     * const postsWithComments = await db.post.select('title', {
+     *   comments: (q) =>
+     *     q.comments.map((comment) => ({
+     *       ...comment,
+     *       truncatedContent: comment.content.slice(0, 100),
+     *     })),
+     * });
+     *
+     * postsWithComments[0].comments[0].truncatedContent; // string
+     * ```
+     *
+     * @param fn - function to transform an individual record
+     */
+    map<T extends Query, Result extends RecordUnknown>(this: T, fn: (input: QueryReturnsAll<T['returnType']> extends true ? T['then'] extends QueryThen<(infer Data)[]> ? Data : never : T['then'] extends QueryThen<infer Data> ? Data : never) => Result): {
+        [K in keyof T]: K extends 'result' ? {
+            [K in keyof Result]: QueryColumn<Result[K]>;
+        } : K extends 'then' ? QueryThen<QueryReturnsAll<T['returnType']> extends true ? Result[] : Result> : T[K];
+    };
 }
 
 interface WindowArg<T extends OrderArgSelf> {
     [K: string]: WindowArgDeclaration<T> | Expression;
 }
 interface WindowArgDeclaration<T extends OrderArgSelf = OrderArgSelf> {
-    partitionBy?: SelectableOrExpression<T> | SelectableOrExpression<T>[];
+    partitionBy?: SelectableOrExpression<T> | SelectableOrExpressions<T>;
     order?: OrderArg<T>;
 }
 type WindowResult<T, W extends RecordUnknown> = T & {
@@ -6368,16 +6355,15 @@ type OrderArgSelf = PickQueryMetaResult;
 type OrderArg<T extends OrderArgSelf> = OrderArgKey<T> | OrderArgTsQuery<T> | {
     [K in OrderArgKey<T> | OrderArgTsQuery<T>]?: K extends OrderArgTsQuery<T> ? OrderTsQueryConfig : SortDir;
 } | Expression;
+type OrderArgs<T extends OrderArgSelf> = OrderArg<T>[];
 type OrderArgTsQuery<T extends OrderArgSelf> = string | undefined extends T['meta']['tsQuery'] ? never : Exclude<T['meta']['tsQuery'], undefined>;
 type OrderArgKey<T extends OrderArgSelf> = keyof T['meta']['selectable'] | {
     [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' ? never : K;
 }[keyof T['result']];
-type OrderArgs<T extends OrderArgSelf> = OrderArg<T>[];
-type GroupArg<T extends PickQueryResult> = {
+type GroupArgs<T extends PickQueryResult> = ({
     [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' ? never : K;
-}[keyof T['result']] | Expression;
-type FindArg<T extends PickQueryShapeSinglePrimaryKey> = T['internal']['singlePrimaryKey'] | Expression;
-type QueryHelper<T extends PickQueryMetaShape, Args extends unknown[], Result> = {
+}[keyof T['result']] | Expression)[];
+interface QueryHelper<T extends PickQueryMetaShape, Args extends unknown[], Result> {
     <Q extends {
         returnType: QueryReturnType;
         meta: QueryMetaBase & {
@@ -6388,7 +6374,7 @@ type QueryHelper<T extends PickQueryMetaShape, Args extends unknown[], Result> =
         withData: WithDataBase;
     }>(q: Q, ...args: Args): Result extends Query ? MergeQuery<Q, Result> : Result;
     result: Result;
-};
+}
 type QueryHelperResult<T extends QueryHelper<Query, unknown[], unknown>> = T['result'];
 type NarrowTypeResult<T extends PickQueryMetaResultReturnType, Narrow> = {
     [K in keyof T['result']]: K extends keyof Narrow ? {
@@ -6400,10 +6386,10 @@ declare const _queryAll: <T extends Query>(q: T) => SetQueryReturnsAll<T>;
 declare const _queryTake: <T extends PickQueryResult>(q: T) => SetQueryReturnsOne<T>;
 declare const _queryTakeOptional: <T extends PickQueryResult>(q: T) => SetQueryReturnsOneOptional<T>;
 declare const _queryExec: <T extends Query>(q: T) => never;
-declare const _queryFindBy: <T extends QueryBase<EmptyObject>>(q: T, args: WhereArg<T>[]) => SetQueryReturnsOne<WhereResult<T>>;
-declare const _queryFindByOptional: <T extends QueryBase<EmptyObject>>(q: T, args: WhereArg<T>[]) => SetQueryReturnsOneOptional<WhereResult<T>>;
+declare const _queryFindBy: <T extends QueryBase<EmptyObject>>(q: T, args: WhereArgs<T>) => SetQueryReturnsOne<WhereResult<T>>;
+declare const _queryFindByOptional: <T extends QueryBase<EmptyObject>>(q: T, args: WhereArgs<T>) => SetQueryReturnsOneOptional<WhereResult<T>>;
 declare const _queryRows: <T extends Query>(q: T) => SetQueryReturnsRows<T>;
-interface QueryMethods<ColumnTypes> extends AsMethods, AggregateMethods, Select, FromMethods, Join, WithMethods, Union, JsonModifiers, JsonMethods, Create, Update, Delete, Transaction, For, Where, SearchMethods, Clear, Having, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, SqlMethod<ColumnTypes>, TransformMethods, ScopeMethods, SoftDeleteMethods, ExpressionMethods {
+interface QueryMethods<ColumnTypes> extends AsMethods, AggregateMethods, Select, FromMethods, Join, WithMethods, Union, JsonMethods, Create, Update, Delete, Transaction, For, Where, SearchMethods, Clear, Having, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, SqlMethod<ColumnTypes>, TransformMethods, QueryMap, ScopeMethods, SoftDeleteMethods, ExpressionMethods {
 }
 declare class QueryMethods<ColumnTypes> {
     /**
@@ -6515,7 +6501,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param columns - column names or a raw SQL
      */
-    distinct<T extends PickQueryMeta>(this: T, ...columns: SelectableOrExpression<T>[]): T;
+    distinct<T extends PickQueryMeta>(this: T, ...columns: SelectableOrExpressions<T>): T;
     /**
      * Finds a single record by the primary key (id), throws [NotFoundError](/guide/error-handling.html) if not found.
      * Not available if the table has no or multiple primary keys.
@@ -6526,7 +6512,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param value - primary key value to find by
      */
-    find<T extends PickQueryShapeResultSinglePrimaryKey>(this: T, value: FindArg<T>): SetQueryReturnsOne<WhereResult<T>>;
+    find<T extends PickQueryShapeResultSinglePrimaryKey>(this: T, value: T['internal']['singlePrimaryKey'] | Expression): SetQueryReturnsOne<T> & QueryMetaHasWhere;
     /**
      * Finds a single record with a given SQL, throws {@link NotFoundError} if not found:
      *
@@ -6539,7 +6525,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param args - SQL expression
      */
-    findBySql<T extends PickQueryResult>(this: T, ...args: SQLQueryArgs): SetQueryReturnsOne<WhereResult<T>>;
+    findBySql<T extends PickQueryResult>(this: T, ...args: SQLQueryArgs): SetQueryReturnsOne<T> & QueryMetaHasWhere;
     /**
      * Finds a single record by the primary key (id), returns `undefined` when not found.
      * Not available if the table has no or multiple primary keys.
@@ -6550,7 +6536,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param value - primary key value to find by, or a raw SQL
      */
-    findOptional<T extends PickQueryShapeResultSinglePrimaryKey>(this: T, value: FindArg<T>): SetQueryReturnsOneOptional<WhereResult<T>>;
+    findOptional<T extends PickQueryShapeResultSinglePrimaryKey>(this: T, value: T['internal']['singlePrimaryKey'] | Expression): SetQueryReturnsOneOptional<T> & QueryMetaHasWhere;
     /**
      * Finds a single record with a given SQL.
      * Returns `undefined` when not found.
@@ -6564,7 +6550,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param args - SQL expression
      */
-    findBySqlOptional<T extends PickQueryResult>(this: T, ...args: SQLQueryArgs): SetQueryReturnsOneOptional<WhereResult<T>>;
+    findBySqlOptional<T extends PickQueryResult>(this: T, ...args: SQLQueryArgs): SetQueryReturnsOneOptional<T> & QueryMetaHasWhere;
     /**
      * Finds a single unique record, throws [NotFoundError](/guide/error-handling.html) if not found.
      * It accepts values of primary keys or unique indexes defined on the table.
@@ -6578,7 +6564,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param uniqueColumnValues - is derived from primary keys and unique indexes in the table
      */
-    findBy<T extends PickQueryResultUniqueColumns>(this: T, uniqueColumnValues: T['internal']['uniqueColumns']): SetQueryReturnsOne<WhereResult<T>>;
+    findBy<T extends PickQueryResultUniqueColumns>(this: T, uniqueColumnValues: T['internal']['uniqueColumns']): SetQueryReturnsOne<T> & QueryMetaHasWhere;
     /**
      * Finds a single unique record, returns `undefined` if not found.
      * It accepts values of primary keys or unique indexes defined on the table.
@@ -6592,7 +6578,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param uniqueColumnValues - is derived from primary keys and unique indexes in the table
      */
-    findByOptional<T extends PickQueryResultUniqueColumns>(this: T, uniqueColumnValues: T['internal']['uniqueColumns']): SetQueryReturnsOneOptional<WhereResult<T>>;
+    findByOptional<T extends PickQueryResultUniqueColumns>(this: T, uniqueColumnValues: T['internal']['uniqueColumns']): SetQueryReturnsOneOptional<T> & QueryMetaHasWhere;
     /**
      * Specifies the schema to be used as a prefix of a table name.
      *
@@ -6644,7 +6630,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param columns - column names or a raw SQL
      */
-    group<T extends PickQueryResult>(this: T, ...columns: GroupArg<T>[]): T;
+    group<T extends PickQueryResult>(this: T, ...columns: GroupArgs<T>): T;
     /**
      * Add a window with `window` and use it later by its name for aggregate or window functions:
      *
@@ -7056,6 +7042,8 @@ interface PickQueryMetaResultRelationsWindowsColumnTypes extends PickQueryMetaRe
 }
 interface PickQueryWithDataColumnTypes extends PickQueryWithData, PickQueryColumnTypes {
 }
+interface PickQueryResultColumnTypes extends PickQueryResult, PickQueryColumnTypes {
+}
 interface PickQueryMetaWithDataColumnTypes extends PickQueryMeta, PickQueryWithData, PickQueryColumnTypes {
 }
 interface PickQueryMetaTable extends PickQueryMeta, PickQueryTable {
@@ -7175,7 +7163,7 @@ type SetQueryReturnsPluckColumnKindResult<T extends PickQueryMetaResult, Kind ex
         pluck: T['result']['value'];
     } : K extends 'returnType' ? 'pluck' : K extends 'result' ? Result : K extends 'then' ? QueryThen<T['result']['value']['outputType'][]> : T[K];
 } & QueryMetaHasSelect;
-type SetQueryReturnsValueOrThrow<T extends PickQueryMeta, Arg extends GetStringArg<T>> = SetQueryReturnsColumnOrThrow<T, T['meta']['selectable'][Arg]['column']> & T['meta']['selectable'][Arg]['column']['operators'];
+type SetQueryReturnsValueOrThrow<T extends PickQueryMeta, Arg extends keyof T['meta']['selectable']> = SetQueryReturnsColumnOrThrow<T, T['meta']['selectable'][Arg]['column']> & T['meta']['selectable'][Arg]['column']['operators'];
 type SetQueryReturnsValueOptional<T extends PickQueryMeta, Arg extends GetStringArg<T>> = SetQueryReturnsColumnOptional<T, {
     [K in keyof T['meta']['selectable'][Arg]['column']]: K extends 'outputType' ? T['meta']['selectable'][Arg]['column'][K] | undefined : T['meta']['selectable'][Arg]['column'][K];
 }> & Omit<T['meta']['selectable'][Arg]['column']['operators'], 'equals' | 'not'> & OperatorsNullable<T['meta']['selectable'][Arg]['column']>;
@@ -7270,7 +7258,7 @@ interface ColumnFromDbParams {
 interface PickColumnData {
     data: ColumnData;
 }
-declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTypeSchemaArg, Type = unknown, InputSchema = any, Ops extends BaseOperators = BaseOperators, InputType = Type, OutputType = Type, OutputSchema = InputSchema, QueryType = InputType, QuerySchema = InputSchema> extends ColumnTypeBase<Schema, Type, InputSchema, Ops, InputType, OutputType, OutputSchema, QueryType, QuerySchema, ColumnData> {
+declare abstract class ColumnType<Schema extends ColumnTypeSchemaArg = ColumnTypeSchemaArg, Type = unknown, InputSchema = any, Ops = any, InputType = Type, OutputType = Type, OutputSchema = InputSchema, QueryType = InputType, QuerySchema = InputSchema> extends ColumnTypeBase<Schema, Type, InputSchema, Ops, InputType, OutputType, OutputSchema, QueryType, QuerySchema, ColumnData> {
     /**
      * Mark the column as a primary key.
      * This column type becomes an argument of the `.find` method.
@@ -7631,9 +7619,9 @@ interface DefaultColumnTypes<SchemaConfig extends ColumnSchemaConfig> extends Ti
     type(dataType: string): CustomTypeColumn<SchemaConfig>;
     domain(dataType: string): DomainColumn<SchemaConfig>;
 }
-declare const makeColumnTypes: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>(schema: SchemaConfig) => DefaultColumnTypes<SchemaConfig>;
+declare const makeColumnTypes: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>(schema: SchemaConfig) => DefaultColumnTypes<SchemaConfig>;
 
-declare const simplifyColumnDefault: (value?: string) => RawSQL<orchid_core.QueryColumn<unknown, orchid_core.CoreBaseOperators>, DefaultColumnTypes<orchid_core.ColumnSchemaConfig<ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>> | undefined;
+declare const simplifyColumnDefault: (value?: string) => RawSQL<orchid_core.QueryColumn<unknown, any>, DefaultColumnTypes<orchid_core.ColumnSchemaConfig<ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>>> | undefined;
 declare const instantiateColumn: (typeFn: () => ColumnTypeBase, params: ColumnFromDbParams) => ColumnTypeBase;
 
 interface ColumnsShape {
@@ -7904,4 +7892,4 @@ type CopyResult<T extends PickQueryMeta> = SetQueryKind<T, 'copy'>;
  */
 declare function copyTableData<T extends PickQueryMetaShape>(query: T, arg: CopyArg<T>): CopyResult<T>;
 
-export { Adapter, AdapterConfig, AdapterOptions, AddQueryDefaults, AddQuerySelect, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayColumnValue, ArrayData, AsMethods, AsQueryArg, BaseOperators, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanQueryColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, CloneSelfKeys, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfoQueryData, ColumnOperators, ColumnRefExpression, ColumnType, ColumnsByType, ColumnsShape, ColumnsShapeToNullableObject, ColumnsShapeToObject, ColumnsShapeToObjectArray, ColumnsShapeToPluck, CommonQueryData, ComputedColumnsBase, CopyOptions, CopyQueryData, Create, CreateBelongsToData, CreateColumn, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CreateRelationsData, CreateRelationsDataOmittingFKeys, CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbDomainArg, DbDomainArgRecord, DbExtension, DbOptions, DbResult, DbSharedOptions, DbTableConstructor, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultSchemaConfig, Delete, DeleteArgs, DeleteMethodsNames, DeleteQueryData, DeleteResult, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, EnumColumn, ExpressionMethods, ExpressionOutput, FnExpression, FnExpressionArgs, FnExpressionArgsPairs, FnExpressionArgsValue, For, FromArg, FromMethods, FromQuerySelf, FromResult, GetArg, GetColumnInfo, GetQueryResult, GetResult, GetResultOptional, GetStringArg, GroupArg, Having, HavingItem, HookAction, HookSelect, IdentityColumn, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinItemArgs, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinQueryBuilder, JoinQueryMethod, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MapTableScopesOption, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumnData, OnConflictMerge, OnConflictQueryBuilder, OnConflictSet, OnConflictTarget, OnMethods, Operator, Operators, OperatorsAny, OperatorsArray, OperatorsBoolean, OperatorsDate, OperatorsJson, OperatorsNumber, OperatorsText, OperatorsTime, OrCreateArg, OrExpression, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgSelf, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PickColumnData, PickQueryBaseQuery, PickQueryColumnTypes, PickQueryDataShapeAndJoinedShapes, PickQueryInternal, PickQueryMetaRelations, PickQueryMetaResultRelations, PickQueryMetaResultRelationsWindows, PickQueryMetaResultRelationsWindowsColumnTypes, PickQueryMetaResultRelationsWithDataReturnType, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryMetaResultReturnTypeWithDataWindows, PickQueryMetaResultReturnTypeWithDataWindowsTable, PickQueryMetaShapeRelationsWithData, PickQueryMetaTable, PickQueryMetaTableShape, PickQueryMetaTableShapeReturnTypeWithData, PickQueryMetaWithData, PickQueryMetaWithDataColumnTypes, PickQueryQ, PickQueryQAndBaseQuery, PickQueryQAndInternal, PickQueryRelations, PickQueryRelationsWithData, PickQueryShapeResultSinglePrimaryKey, PickQueryShapeSinglePrimaryKey, PickQuerySinglePrimaryKey, PickQueryWindows, PickQueryWithData, PickQueryWithDataColumnTypes, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBaseThen, QueryBeforeHook, QueryData, QueryDataFromItem, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryInternal, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryOrExpression, QueryOrExpressionBooleanOrNullResult, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RealColumn, RecordOfColumnsShapeBase, RefExpression, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, SearchArg, SearchMethods, SearchWeight, SearchWeightRecord, Select, SelectArg, SelectAs, SelectItem, SelectQueryData, SelectSubQueryResult, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryKindResult, SetQueryReturnsAll, SetQueryReturnsAllKind, SetQueryReturnsAllKindResult, SetQueryReturnsColumnInfo, SetQueryReturnsColumnKind, SetQueryReturnsColumnKindResult, SetQueryReturnsColumnOptional, SetQueryReturnsColumnOrThrow, SetQueryReturnsOne, SetQueryReturnsOneKind, SetQueryReturnsOneKindResult, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsPluckColumn, SetQueryReturnsPluckColumnKind, SetQueryReturnsPluckColumnKindResult, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValueOptional, SetQueryReturnsValueOrThrow, SetQueryReturnsVoid, SetQueryReturnsVoidKind, SetQueryTableAlias, ShapeColumnPrimaryKeys, ShapeUniqueColumns, SimpleJoinItem, SimpleJoinItemNonSubQueryArgs, SmallIntColumn, SmallSerialColumn, SortDir, SqlFn, SqlMethod, StringColumn$1 as StringColumn, TableData, TableDataFn, TableDataInput, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TableDataMethods, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, ToSQLQuery, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnionSet, UniqueConstraints, UniqueQueryTypeOrExpression, UniqueTableDataItem, UnknownColumn, Update, UpdateArg, UpdateCtx, UpdateCtxCollect, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdateSelf, UpdatedAtDataInjector, UpsertArg, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereNotArgs, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, WithArgsOptions, WithDataBase, WithDataItem, WithDataItems, WithItem, WithMethods, WithOptions, WithQueryBuilder, WithRecursiveOptions, WithResult, WithSqlResult, WrapQueryArg, XMLColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryAs, _queryChangeCounter, _queryCreate, _queryCreateFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateManyRaw, _queryCreateRaw, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertManyRaw, _queryInsertRaw, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUnion, _queryUpdate, _queryUpdateOrThrow, _queryUpdateRaw, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotSql, _queryWhereSql, addComputedColumns, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, checkIfASimpleQuery, cloneQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, commitSql, constraintInnerToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, foreignKeyArgumentToCode, getClonedQueryData, getColumnInfo, getColumnTypes, getPrimaryKeys, getQueryAs, getShapeFromSelect, getSqlText, handleResult, identityToCode, indexInnerToCode, indexToCode, instantiateColumn, isDefaultTimeStamp, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeFnExpression, makeRegexToFindInSql, makeSQL, parseRecord, parseResult, parseTableData, parseTableDataInput, primaryKeyInnerToCode, processSelectArg, pushLimitSQL, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, pushTableDataCode, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quote, quoteString, raw, referencesArgsToCode, resolveSubQueryCallback, rollbackSql, saveSearchAlias, setParserForSelectedString, setQueryObjectValue, setQueryOperators, simplifyColumnDefault, sqlFn, sqlQueryArgsToExpression, tableDataMethods, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };
+export { Adapter, AdapterConfig, AdapterOptions, AddQueryDefaults, AddQuerySelect, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayColumnValue, ArrayData, AsMethods, AsQueryArg, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanQueryColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, CloneSelfKeys, ColumnData, ColumnFromDbParams, ColumnInfoQueryData, ColumnOperators, ColumnRefExpression, ColumnType, ColumnsByType, ColumnsShape, ColumnsShapeToNullableObject, ColumnsShapeToObject, ColumnsShapeToObjectArray, ColumnsShapeToPluck, CommonQueryData, ComputedColumnsBase, CopyOptions, CopyQueryData, Create, CreateBelongsToData, CreateColumn, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CreateRelationsData, CreateRelationsDataOmittingFKeys, CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbDomainArg, DbDomainArgRecord, DbExtension, DbOptions, DbResult, DbSharedOptions, DbTableConstructor, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultSchemaConfig, Delete, DeleteArgs, DeleteMethodsNames, DeleteQueryData, DeleteResult, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, EnumColumn, ExpressionMethods, ExpressionOutput, FnExpression, FnExpressionArgs, FnExpressionArgsPairs, FnExpressionArgsValue, For, FromArg, FromMethods, FromQuerySelf, FromResult, GetArg, GetColumnInfo, GetQueryResult, GetResult, GetResultOptional, GetStringArg, GroupArgs, Having, HavingItem, HookAction, HookSelect, IdentityColumn, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinItemArgs, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinQueryBuilder, JoinQueryMethod, JoinResult, JoinedParsers, JoinedShapes, JsonMethods, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MapTableScopesOption, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumnData, OnConflictMerge, OnConflictQueryBuilder, OnConflictSet, OnConflictTarget, OnMethods, Operator, Operators, OperatorsAny, OperatorsArray, OperatorsBoolean, OperatorsDate, OperatorsJson, OperatorsNumber, OperatorsText, OperatorsTime, OrCreateArg, OrExpression, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgSelf, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PickColumnData, PickQueryBaseQuery, PickQueryColumnTypes, PickQueryDataShapeAndJoinedShapes, PickQueryInternal, PickQueryMetaRelations, PickQueryMetaResultRelations, PickQueryMetaResultRelationsWindows, PickQueryMetaResultRelationsWindowsColumnTypes, PickQueryMetaResultRelationsWithDataReturnType, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryMetaResultReturnTypeWithDataWindows, PickQueryMetaResultReturnTypeWithDataWindowsTable, PickQueryMetaShapeRelationsWithData, PickQueryMetaTable, PickQueryMetaTableShape, PickQueryMetaTableShapeReturnTypeWithData, PickQueryMetaWithData, PickQueryMetaWithDataColumnTypes, PickQueryQ, PickQueryQAndBaseQuery, PickQueryQAndInternal, PickQueryRelations, PickQueryRelationsWithData, PickQueryResultColumnTypes, PickQueryShapeResultSinglePrimaryKey, PickQueryShapeSinglePrimaryKey, PickQuerySinglePrimaryKey, PickQueryWindows, PickQueryWithData, PickQueryWithDataColumnTypes, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBaseThen, QueryBeforeHook, QueryData, QueryDataFromItem, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryInternal, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryOrExpression, QueryOrExpressionBooleanOrNullResult, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RealColumn, RecordOfColumnsShapeBase, RefExpression, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, SearchArg, SearchMethods, SearchWeight, SearchWeightRecord, Select, SelectArg, SelectArgs, SelectAs, SelectItem, SelectQueryData, SelectSubQueryResult, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SelectableOrExpressions, SerialColumn, SerialColumnData, SetQueryKind, SetQueryKindResult, SetQueryReturnsAll, SetQueryReturnsAllKind, SetQueryReturnsAllKindResult, SetQueryReturnsColumnInfo, SetQueryReturnsColumnKind, SetQueryReturnsColumnKindResult, SetQueryReturnsColumnOptional, SetQueryReturnsColumnOrThrow, SetQueryReturnsOne, SetQueryReturnsOneKind, SetQueryReturnsOneKindResult, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsPluckColumn, SetQueryReturnsPluckColumnKind, SetQueryReturnsPluckColumnKindResult, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValueOptional, SetQueryReturnsValueOrThrow, SetQueryReturnsVoid, SetQueryReturnsVoidKind, SetQueryTableAlias, ShapeColumnPrimaryKeys, ShapeUniqueColumns, SimpleJoinItem, SimpleJoinItemNonSubQueryArgs, SmallIntColumn, SmallSerialColumn, SortDir, SqlFn, SqlMethod, StringColumn$1 as StringColumn, TableData, TableDataFn, TableDataInput, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TableDataMethods, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, ToSQLQuery, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArgs, UnionItem, UnionKind, UnionSet, UniqueConstraints, UniqueQueryTypeOrExpression, UniqueTableDataItem, UnknownColumn, Update, UpdateArg, UpdateCtx, UpdateCtxCollect, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdateSelf, UpdatedAtDataInjector, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereNotArgs, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, WithArgsOptions, WithDataBase, WithDataItem, WithDataItems, WithItem, WithMethods, WithOptions, WithQueryBuilder, WithRecursiveOptions, WithResult, WithSqlResult, WrapQueryArg, XMLColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryAs, _queryChangeCounter, _queryCreate, _queryCreateFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateManyRaw, _queryCreateRaw, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertManyRaw, _queryInsertRaw, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUnion, _queryUpdate, _queryUpdateOrThrow, _queryUpdateRaw, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotSql, _queryWhereSql, addComputedColumns, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, checkIfASimpleQuery, cloneQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, commitSql, constraintInnerToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, foreignKeyArgumentToCode, getClonedQueryData, getColumnInfo, getColumnTypes, getPrimaryKeys, getQueryAs, getShapeFromSelect, getSqlText, handleResult, identityToCode, indexInnerToCode, indexToCode, instantiateColumn, isDefaultTimeStamp, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeFnExpression, makeRegexToFindInSql, makeSQL, parseRecord, parseResult, parseTableData, parseTableDataInput, primaryKeyInnerToCode, processSelectArg, pushLimitSQL, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, pushTableDataCode, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quote, quoteString, raw, referencesArgsToCode, resolveSubQueryCallback, rollbackSql, saveSearchAlias, setParserForSelectedString, setQueryObjectValue, setQueryOperators, simplifyColumnDefault, sqlFn, sqlQueryArgsToExpression, tableDataMethods, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };