pqb 0.33.2 → 0.35.0

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, 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 { QueryResultRow, AdapterConfigBase, AdapterBase, QueryInput, SingleSqlItem, Sql, RecordUnknown, RecordKeyTrue, EmptyObject, QueryBaseCommon, QueryColumns, QueryMetaBase, QueryReturnType, QueryThen, Expression, MaybeArray, SelectableBase, TemplateLiteralArgs, QueryColumn, MaybePromise, FnUnknownToUnknown, RecordString, ColumnsShapeBase, ColumnsParsers, PickQueryTable, BatchParsers, HookSelect, QueryDataTransform, ExpressionChain, getValueKey, 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 } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'node:util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -119,12 +119,12 @@ interface WithOptions {
     materialized?: true;
     notMaterialized?: true;
 }
-type SelectItem = string | SelectAs | Expression;
+type SelectItem = string | SelectAs | Expression | undefined;
 interface SelectAs {
     selectAs: SelectAsValue;
 }
 interface SelectAsValue {
-    [K: string]: string | Query | Expression;
+    [K: string]: string | Query | Expression | undefined;
 }
 type OrderTsQueryConfig = true | OrderTsQueryConfigObject;
 interface OrderTsQueryConfigObject {
@@ -268,9 +268,75 @@ type OnConflictMerge = string | string[] | {
     except: string | string[];
 };
 
+declare module 'orchid-core' {
+    interface ColumnDataBase {
+        computed?: Expression;
+    }
+}
+type ComputedColumnsFromOptions<T extends ComputedOptionsFactory<never, never> | undefined> = T extends (...args: any[]) => any ? {
+    [K in keyof ReturnType<T>]: ReturnType<T>[K]['result']['value'];
+} : EmptyObject;
+type ComputedOptionsFactory<ColumnTypes, Shape extends QueryColumns> = (t: ComputedMethods<ColumnTypes, Shape>) => {
+    [K: string]: QueryOrExpression<unknown>;
+};
+interface RuntimeComputedQueryColumn<OutputType> extends QueryColumn {
+    dataType: 'runtimeComputed';
+    type: never;
+    outputType: OutputType;
+    queryType: undefined;
+    operators: {
+        cannotQueryRuntimeComputed: never;
+    };
+}
+interface ComputedMethods<ColumnTypes, Shape extends QueryColumns> extends QueryComputedArg<ColumnTypes, Shape> {
+    computeAtRuntime<Deps extends keyof Shape, OutputType>(dependsOn: Deps[], fn: (record: Pick<Shape, Deps>) => OutputType): {
+        result: {
+            value: RuntimeComputedQueryColumn<OutputType>;
+        };
+    };
+    computeBatchAtRuntime<Deps extends keyof Shape, OutputType>(dependsOn: Deps[], fn: (record: Pick<Shape, Deps>[]) => MaybePromise<OutputType[]>): {
+        result: {
+            value: RuntimeComputedQueryColumn<OutputType>;
+        };
+    };
+}
+declare class ComputedColumn {
+    kind: 'one' | 'many';
+    deps: string[];
+    fn: FnUnknownToUnknown;
+    constructor(kind: 'one' | 'many', deps: string[], fn: FnUnknownToUnknown);
+}
+interface ComputedColumns {
+    [K: string]: ComputedColumn;
+}
+interface QueryComputedArg<ColumnTypes, Shape extends QueryColumns> extends ExpressionMethods, SqlMethod<ColumnTypes> {
+    shape: Shape;
+    columnTypes: ColumnTypes;
+    windows: EmptyObject;
+    relations: RelationsBase;
+    result: EmptyObject;
+    meta: Omit<QueryMetaBase, 'selectable'> & {
+        selectable: {
+            [K in keyof Shape]: {
+                as: string;
+                column: QueryColumn;
+            };
+        };
+    };
+}
+declare const applyComputedColumns: (q: Query, fn: ComputedOptionsFactory<never, never>) => void;
+declare const processComputedResult: (query: QueryData, result: unknown) => Promise<void[]> | undefined;
+declare const processComputedBatches: (query: QueryData, batches: QueryBatchResult[], originalReturnType: QueryReturnType, returnType: QueryReturnType, tempColumns: Set<string> | undefined, renames: RecordString | undefined, key: string) => Promise<void> | undefined;
+
 interface RecordOfColumnsShapeBase {
     [K: string]: ColumnsShapeBase;
 }
+interface WithConfigs {
+    [K: string]: {
+        shape: ColumnsShapeBase;
+        computeds?: ComputedColumns;
+    };
+}
 type JoinedShapes = RecordOfColumnsShapeBase;
 interface JoinedParsers {
     [K: string]: ColumnsParsers;
@@ -289,19 +355,26 @@ interface QueryScopeData {
 type QueryDataFromItem = string | Query | Expression;
 interface QueryDataJoinTo extends PickQueryTable, PickQueryQ {
 }
+type HandleResult = (q: Query, returnType: QueryReturnType, result: QueryResult, isSubQuery?: true) => MaybePromise<unknown>;
 interface CommonQueryData {
     adapter: Adapter;
     shape: ColumnsShapeBase;
     patchResult?(q: Query, queryResult: QueryResult): Promise<void>;
-    handleResult(q: Query, returnType: QueryReturnType, result: QueryResult, isSubQuery?: true): unknown;
+    handleResult: HandleResult;
     returnType: QueryReturnType;
     wrapInTransaction?: boolean;
     throwOnNotFound?: boolean;
     with?: WithItem[];
-    withShapes?: RecordOfColumnsShapeBase;
+    withShapes?: WithConfigs;
     joinTo?: QueryDataJoinTo;
     joinedShapes?: JoinedShapes;
     joinedParsers?: JoinedParsers;
+    joinedBatchParsers?: {
+        [K: string]: BatchParsers;
+    };
+    joinedComputeds?: {
+        [K: string]: ComputedColumns;
+    };
     joinedForSelect?: string;
     innerJoinLateral?: true;
     joinOverrides?: JoinOverrides;
@@ -317,22 +390,26 @@ interface CommonQueryData {
     or?: WhereItem[][];
     coalesceValue?: unknown | Expression;
     parsers?: ColumnsParsers;
+    batchParsers?: BatchParsers;
     notFoundDefault?: unknown;
     defaults?: RecordUnknown;
+    hookSelect?: HookSelect;
+    computeds?: ComputedColumns;
+    selectedComputeds?: ComputedColumns;
     before?: QueryBeforeHook[];
     after?: QueryAfterHook[];
     beforeCreate?: QueryBeforeHook[];
     afterCreate?: QueryAfterHook[];
     afterCreateCommit?: QueryAfterHook[];
-    afterCreateSelect?: QueryHookSelect;
+    afterCreateSelect?: Set<string>;
     beforeUpdate?: QueryBeforeHook[];
     afterUpdate?: QueryAfterHook[];
     afterUpdateCommit?: QueryAfterHook[];
-    afterUpdateSelect?: QueryHookSelect;
+    afterUpdateSelect?: Set<string>;
     beforeDelete?: QueryBeforeHook[];
     afterDelete?: QueryAfterHook[];
     afterDeleteCommit?: QueryAfterHook[];
-    afterDeleteSelect?: QueryHookSelect;
+    afterDeleteSelect?: Set<string>;
     log?: QueryLogObject;
     logger: QueryLogger;
     autoPreparedStatements?: boolean;
@@ -664,21 +741,6 @@ type JoinArgToQueryCallback = (...args: any[]) => PickQueryTableMetaResult;
  * Callback must return a query builder.
  */
 type JoinCallback<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>> = (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => PickQueryTableMetaResult;
-/**
- * Type of the `joinLateral`.
- *
- * Receives a query builder that can access columns of both the main and the joined table.
- *
- * Query builder inside callback is the query derived from the `joinLateral` first argument,
- * all query methods are allowed, `on` methods are available.
- *
- * The callback must return a query object. Its resulting type will become a type of the joined table.
- */
-type JoinLateralCallback<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>, Table extends string, Meta extends QueryMetaBase, Result extends QueryColumns> = (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => {
-    table: Table;
-    meta: Meta;
-    result: Result;
-};
 /**
  * Type of {@link Join.join} query method.
  */
@@ -1235,7 +1297,11 @@ declare class Join {
      * @param arg - {@link JoinFirstArg}
      * @param cb - {@link JoinLateralCallback}
      */
-    joinLateral<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Table extends string, Meta extends QueryMetaBase, Result extends QueryColumns>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, Table, Meta, Result>): JoinLateralResult<T, Table, Meta, Result, true>;
+    joinLateral<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Table extends string, Meta extends QueryMetaBase, Result extends QueryColumns>(this: T, arg: Arg, cb: (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => {
+        table: Table;
+        meta: Meta;
+        result: Result;
+    }): JoinLateralResult<T, Table, Meta, Result, true>;
     /**
      * The same as {@link joinLateral}, but when no records found for the join it will result in `null`:
      *
@@ -1251,7 +1317,11 @@ declare class Join {
      * @param arg - {@link JoinFirstArg}
      * @param cb - {@link JoinLateralCallback}
      */
-    leftJoinLateral<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Table extends string, Meta extends QueryMetaBase, Result extends QueryColumns>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, Table, Meta, Result>): JoinLateralResult<T, Table, Meta, Result, false>;
+    leftJoinLateral<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Table extends string, Meta extends QueryMetaBase, Result extends QueryColumns>(this: T, arg: Arg, cb: (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => {
+        table: Table;
+        meta: Meta;
+        result: Result;
+    }): JoinLateralResult<T, Table, Meta, Result, false>;
 }
 type OnArgs<S extends SelectableBase> = [leftColumn: keyof S, rightColumn: keyof S] | [leftColumn: keyof S, op: string, rightColumn: keyof S];
 declare const pushQueryOn: <T extends PickQueryMeta>(q: T, joinFrom: PickQueryMeta, joinTo: PickQueryMeta, ...on: OnArgs<SelectableBase>) => T;
@@ -1264,21 +1334,21 @@ type OnJsonPathEqualsArgs<S extends SelectableBase> = [
     rightPath: string
 ];
 /**
- * Mutative {@link OnMethods.on}
+ * Mutative {@link OnMethods.prototype.on}
  */
 declare const _queryJoinOn: <T extends PickQueryMeta>(q: T, args: OnArgs<T['meta']['selectable']>) => T;
 /**
- * Mutative {@link OnMethods.orOn}
+ * Mutative {@link OnMethods.prototype.orOn}
  */
 declare const _queryJoinOrOn: <T extends PickQueryMeta>(q: T, args: OnArgs<T['meta']['selectable']>) => T;
 /**
- * Mutative {@link OnMethods.onJsonPathEquals}
+ * Mutative {@link OnMethods.prototype.onJsonPathEquals}
  */
 declare const _queryJoinOnJsonPathEquals: <T extends PickQueryMeta>(q: T, args: OnJsonPathEqualsArgs<T["meta"]["selectable"]>) => T;
 /**
  * Argument of join callback.
  * It is a query object of table that you're joining, with ability to select main table's columns.
- * Adds {@link OnMethods.on} method and similar to the query.
+ * Adds {@link OnMethods.prototype.on} method and similar to the query.
  */
 type JoinQueryBuilder<T extends PickQueryMetaShape = PickQueryMetaShape, J extends PickQueryTableMetaResult = PickQueryTableMetaResult> = {
     [K in keyof J]: K extends 'meta' ? {
@@ -1709,7 +1779,21 @@ type WhereArg<T extends PickQueryMetaRelations> = {
     [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>);
+    }> : T['meta']['selectable'][K]['column']['queryType'] | null | {
+        [O in keyof T['meta']['selectable'][K]['column']['operators']]?: T['meta']['selectable'][K]['column']['operators'][O]['_opType'];
+    } | {
+        result: {
+            value: {
+                queryType: T['meta']['selectable'][K]['column']['queryType'] | null;
+            };
+        };
+    } | ((q: T) => {
+        result: {
+            value: {
+                queryType: T['meta']['selectable'][K]['column']['queryType'] | null;
+            };
+        };
+    });
 } | QueryOrExpressionBooleanOrNullResult | ((q: WhereQueryBuilder<T>) => QueryOrExpressionBooleanOrNullResult | WhereQueryBuilder<T>);
 /**
  * Callback argument of `where`.
@@ -1744,35 +1828,35 @@ interface QueryMetaHasWhere {
     };
 }
 /**
- * Mutative {@link Where.where}
+ * Mutative {@link Where.prototype.where}
  */
 declare const _queryWhere: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => WhereResult<T>;
 /**
- * Mutative {@link Where.whereSql}
+ * Mutative {@link Where.prototype.whereSql}
  */
 declare const _queryWhereSql: <T>(q: T, args: SQLQueryArgs) => T;
 /**
- * Mutative {@link Where.whereNot}
+ * Mutative {@link Where.prototype.whereNot}
  */
 declare const _queryWhereNot: <T extends PickQueryMetaRelations>(q: T, args: WhereNotArgs<T>) => WhereResult<T>;
 /**
- * Mutative {@link Where.whereNotSql}
+ * Mutative {@link Where.prototype.whereNotSql}
  */
 declare const _queryWhereNotSql: <T>(q: T, args: SQLQueryArgs) => T;
 /**
- * Mutative {@link Where.orWhere}
+ * Mutative {@link Where.prototype.orWhere}
  */
 declare const _queryOr: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => WhereResult<T>;
 /**
- * Mutative {@link Where.orWhereNot}
+ * Mutative {@link Where.prototype.orWhereNot}
  */
 declare const _queryOrNot: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => WhereResult<T>;
 /**
- * Mutative {@link Where.whereIn}
+ * Mutative {@link Where.prototype.whereIn}
  */
 declare const _queryWhereIn: <T>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | Expression | undefined, not?: boolean) => WhereResult<T>;
 /**
- * Mutative {@link Where.whereExists}
+ * Mutative {@link Where.prototype.whereExists}
  */
 declare const _queryWhereExists: <T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>>(q: T, arg: Arg, args: JoinArgs<T, Arg>) => WhereResult<T>;
 declare class Where {
@@ -2085,7 +2169,7 @@ declare class Where {
      *
      * ### Text column operators
      *
-     * For `text`, `char`, `varchar`, and `json` columns.
+     * For `text`, `varchar`, `string`, and `json` columns.
      *
      * `json` is stored as text, so it has text operators. Use the `jsonb` type for JSON operators.
      *
@@ -2533,19 +2617,17 @@ declare class RawSQL<T extends QueryColumn, ColumnTypes = DefaultColumnTypes<Col
 interface DynamicRawSQL<T extends QueryColumn> extends Expression<T>, ExpressionTypeMethod {
 }
 declare class DynamicRawSQL<T extends QueryColumn, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>> extends Expression<T> {
-    fn: DynamicSQLArg;
+    fn: DynamicSQLArg<T>;
     columnTypes: ColumnTypes;
     result: {
         value: T;
     };
-    q: {
-        chain?: ExpressionChain;
-    };
-    constructor(fn: DynamicSQLArg);
+    q: ExpressionData;
+    constructor(fn: DynamicSQLArg<T>);
     makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
 }
 declare function raw<T = never>(...args: StaticSQLArgs): RawSQL<QueryColumn<T>>;
-declare function raw<T = never>(...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>>;
+declare function raw<T = never>(...args: [DynamicSQLArg<QueryColumn<T>>]): DynamicRawSQL<QueryColumn<T>>;
 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>;
@@ -2679,8 +2761,7 @@ type TableDataInput = {
     constraint?: TableData.Constraint;
 };
 interface TableDataItem {
-    columns: unknown;
-    name: unknown;
+    tableDataItem: true;
 }
 interface UniqueTableDataItem<Shape extends QueryColumns = QueryColumns> {
     columns: (keyof Shape)[];
@@ -2688,6 +2769,7 @@ interface UniqueTableDataItem<Shape extends QueryColumns = QueryColumns> {
 }
 interface TableDataMethods<Key extends PropertyKey> {
     primaryKey<Columns extends [Key, ...Key[]], Name extends string>(columns: Columns, name?: Name): {
+        tableDataItem: true;
         columns: Columns;
         name: string extends Name ? never : Name;
     };
@@ -2695,6 +2777,7 @@ interface TableDataMethods<Key extends PropertyKey> {
         Key | TableData.Index.ColumnOrExpressionOptions<Key>,
         ...(Key | TableData.Index.ColumnOrExpressionOptions<Key>)[]
     ], Name extends string>(columns: Columns, ...args: [options?: TableData.Index.UniqueOptionsArg] | [name?: Name, options?: TableData.Index.UniqueOptionsArg]): {
+        tableDataItem: true;
         columns: Columns extends (Key | TableData.Index.ColumnOptionsForColumn<Key>)[] ? {
             [I in keyof Columns]: 'column' extends keyof Columns[I] ? Columns[I]['column'] : Columns[I];
         } : never;
@@ -2820,7 +2903,7 @@ declare abstract class LimitedTextBaseColumn<Schema extends ColumnSchemaConfig>
     data: TextColumnData & {
         maxChars?: number;
     };
-    constructor(schema: Schema, limit?: number);
+    constructor(schema: Schema, limit: number);
     toSQL(): string;
 }
 declare class VarCharColumn<Schema extends ColumnSchemaConfig> extends LimitedTextBaseColumn<Schema> {
@@ -2831,17 +2914,13 @@ declare class StringColumn$1<Schema extends ColumnSchemaConfig> extends VarCharC
     constructor(schema: Schema, limit?: number);
     toCode(t: string, m?: boolean): Code;
 }
-declare class CharColumn<Schema extends ColumnSchemaConfig> extends LimitedTextBaseColumn<Schema> {
-    dataType: "char";
-    toCode(t: string, m?: boolean): Code;
-}
 declare class TextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColumn<Schema> {
     dataType: "text";
     data: TextColumnData & {
         minArg?: number;
         maxArg?: number;
     };
-    constructor(schema: Schema, min?: number, max?: number);
+    constructor(schema: Schema);
     toCode(t: string, m?: boolean): Code;
 }
 declare class ByteaColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, Buffer, ReturnType<Schema['buffer']>, OperatorsText> {
@@ -3010,7 +3089,7 @@ declare class CitextColumn<Schema extends ColumnSchemaConfig> extends TextBaseCo
         minArg?: number;
         maxArg?: number;
     };
-    constructor(schema: Schema, min?: number, max?: number);
+    constructor(schema: Schema);
     toCode(t: string, m?: boolean): Code;
 }
 
@@ -3054,11 +3133,10 @@ interface DefaultSchemaConfig extends ColumnSchemaConfig<ColumnType> {
     doublePrecision(): DoublePrecisionColumn<DefaultSchemaConfig>;
     bigSerial(): BigSerialColumn<DefaultSchemaConfig>;
     money(): MoneyColumn<DefaultSchemaConfig>;
-    varchar(limit?: number): VarCharColumn<DefaultSchemaConfig>;
-    char(limit?: number): CharColumn<DefaultSchemaConfig>;
-    text(min: number, max: number): TextColumn<DefaultSchemaConfig>;
+    varchar(limit: number): VarCharColumn<DefaultSchemaConfig>;
+    text(): TextColumn<DefaultSchemaConfig>;
     string(limit?: number): StringColumn$1<DefaultSchemaConfig>;
-    citext(min: number, max: number): CitextColumn<DefaultSchemaConfig>;
+    citext(): CitextColumn<DefaultSchemaConfig>;
     date(): DateColumn<DefaultSchemaConfig>;
     timestampNoTZ(precision?: number): TimestampColumn<DefaultSchemaConfig>;
     timestamp(precision?: number): TimestampTZColumn<DefaultSchemaConfig>;
@@ -3151,7 +3229,7 @@ type DbOptions<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> = ({
     snakeCase?: boolean;
     nowSQL?: string;
 };
-interface DbTableOptions<Table extends string | undefined, Shape extends QueryColumns> extends QueryLogOptions {
+interface DbTableOptions<ColumnTypes, Table extends string | undefined, Shape extends QueryColumns> extends QueryLogOptions {
     schema?: string;
     autoPreparedStatements?: boolean;
     noPrimaryKey?: NoPrimaryKeyOption;
@@ -3166,6 +3244,7 @@ interface DbTableOptions<Table extends string | undefined, Shape extends QueryCo
      */
     softDelete?: SoftDeleteOption<Shape>;
     comment?: string;
+    computed?: ComputedOptionsFactory<ColumnTypes, Shape>;
 }
 /**
  * See {@link ScopeMethods}
@@ -3180,7 +3259,7 @@ declare const anyShape: QueryColumnsInit;
 interface Db<Table extends string | undefined = undefined, Shape extends QueryColumnsInit = QueryColumnsInit, PrimaryKeys = never, UniqueColumns = never, UniqueColumnTuples = never, UniqueConstraints = never, Relations extends RelationsBase = EmptyObject, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends QueryColumnsInit = Shape, Scopes extends CoreQueryScopes | undefined = EmptyObject> extends DbBase<Adapter, Table, Shape, ColumnTypes, ShapeWithComputed>, QueryMethods<ColumnTypes>, QueryBase {
     result: Pick<Shape, DefaultSelectColumns<Shape>[number]>;
     queryBuilder: Db;
-    returnType: Query['returnType'];
+    returnType: undefined;
     then: QueryThen<QueryDefaultReturnData<Shape>>;
     windows: Query['windows'];
     defaultSelectColumns: DefaultSelectColumns<Shape>;
@@ -3210,7 +3289,7 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Que
     table: Table;
     shape: ShapeWithComputed;
     columnTypes: ColumnTypes;
-    constructor(adapter: Adapter, queryBuilder: Db, table: Table, shape: ShapeWithComputed, columnTypes: ColumnTypes, transactionStorage: AsyncLocalStorage<TransactionState>, options: DbTableOptions<Table, ShapeWithComputed>, tableData?: TableData);
+    constructor(adapter: Adapter, queryBuilder: Db, table: Table, shape: ShapeWithComputed, columnTypes: ColumnTypes, transactionStorage: AsyncLocalStorage<TransactionState>, options: DbTableOptions<ColumnTypes, Table, ShapeWithComputed>, tableData?: TableData);
     [inspect.custom](): string;
     /**
      * Use `query` to perform raw SQL queries.
@@ -3270,7 +3349,7 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Que
      */
     queryArrays<R extends any[] = any[]>(...args: SQLQueryArgs): Promise<QueryArraysResult<R>>;
 }
-type DbTableConstructor<ColumnTypes> = <Table extends string, Shape extends QueryColumnsInit, Data extends MaybeArray<TableDataItem>, Options extends DbTableOptions<Table, Shape>>(table: Table, shape?: ((t: ColumnTypes) => Shape) | Shape, tableData?: TableDataFn<Shape, Data>, options?: Options) => Db<Table, Shape, keyof ShapeColumnPrimaryKeys<Shape> extends never ? never : ShapeColumnPrimaryKeys<Shape>, ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>, EmptyObject, ColumnTypes, Shape, MapTableScopesOption<Options['scopes'], Options['softDelete']>>;
+type DbTableConstructor<ColumnTypes> = <Table extends string, Shape extends QueryColumnsInit, Data extends MaybeArray<TableDataItem>, Options extends DbTableOptions<ColumnTypes, Table, Shape>>(table: Table, shape?: ((t: ColumnTypes) => Shape) | Shape, tableData?: TableDataFn<Shape, Data>, options?: Options) => Db<Table, Shape, keyof ShapeColumnPrimaryKeys<Shape> extends never ? never : ShapeColumnPrimaryKeys<Shape>, ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>, EmptyObject, ColumnTypes, Shape & ComputedColumnsFromOptions<Options['computed']>, MapTableScopesOption<Options['scopes'], Options['softDelete']>>;
 type MapTableScopesOption<Scopes extends CoreQueryScopes | undefined, SoftDelete extends true | PropertyKey | undefined> = {
     [K in keyof Scopes | (SoftDelete extends true | PropertyKey ? 'nonDeleted' : never)]: unknown;
 };
@@ -3322,8 +3401,8 @@ interface DbResult<ColumnTypes> extends Db<string, never, never, never, never, n
  * ```ts
  * export const User = db('user', (t) => ({
  *   id: t.identity().primaryKey(),
- *   name: t.text(3, 100),
- *   password: t.text(8, 200),
+ *   name: t.string(),
+ *   password: t.varchar(100),
  *   age: t.integer().nullable(),
  *   ...t.timestamps(),
  * }));
@@ -3355,7 +3434,7 @@ interface DbResult<ColumnTypes> extends Db<string, never, never, never, never, n
  * ```
  */
 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;
+declare const _initQueryBuilder: (adapter: Adapter, columnTypes: unknown, transactionStorage: AsyncLocalStorage<TransactionState>, commonOptions: DbTableOptions<unknown, undefined, QueryColumns>, options: DbSharedOptions) => Db;
 
 type ToSQLCtx = {
     queryBuilder: Db;
@@ -3395,7 +3474,15 @@ 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 SelectableOrExpressions<T extends {
+    meta: {
+        selectable: unknown;
+    };
+} = {
+    meta: {
+        selectable: unknown;
+    };
+}, 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: {
@@ -3915,19 +4002,21 @@ type CreateDataWithDefaultsForRelations<T extends CreateSelf, Defaults extends k
     [K in Defaults as K extends OmitFKeys ? never : K]?: CreateColumn<T, K>;
 };
 type CreateColumn<T extends CreateSelf, K extends keyof T['inputType']> = T['inputType'][K] | QueryOrExpression<T['inputType'][K]> | ((q: T) => QueryOrExpression<T['inputType'][K]>);
-type CreateRelationsData<T extends CreateSelf, BelongsToData> = CreateDataWithDefaultsForRelations<T, keyof T['meta']['defaults'], T['relations'][keyof T['relations']]['relationConfig']['omitForeignKeyInCreate']> & BelongsToData & T['relations'][keyof T['relations']]['relationConfig']['optionalDataForCreate'];
-type CreateBelongsToData<T extends CreateSelf> = CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['relationConfig']['dataForCreate']>;
+type CreateRelationsData<T extends CreateSelf, BelongsToData> = CreateDataWithDefaultsForRelations<T, keyof T['meta']['defaults'], T['relations'][keyof T['relations']]['relationConfig']['omitForeignKeyInCreate']> & ([BelongsToData] extends [never] ? EmptyObject : BelongsToData) & T['relations'][keyof T['relations']]['relationConfig']['optionalDataForCreate'];
+type CreateBelongsToData<T extends CreateSelf> = [
+    T['relations'][keyof T['relations']]['relationConfig']['dataForCreate']
+] extends [never] ? never : CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['relationConfig']['dataForCreate']>;
 type CreateRelationsDataOmittingFKeys<T extends CreateSelf, Union> = (Union extends RelationConfigDataForCreate ? (u: keyof Union['columns'] extends keyof T['meta']['defaults'] ? Omit<Union['columns'], keyof T['meta']['defaults']> & {
     [P in keyof T['meta']['defaults'] & keyof Union['columns']]?: Union['columns'][P];
-} & Partial<Union['nested']> : Union['columns'] | Union['nested']) => void : never) extends (u: infer Obj extends RecordUnknown) => void ? Obj : never;
+} & Partial<Union['nested']> : Union['columns'] | Union['nested']) => void : never) extends (u: infer Obj) => void ? Obj : never;
 type CreateResult<T extends CreateSelf, BT> = T extends {
     isCount: true;
-} ? SetQueryKind<T, 'create'> : QueryReturnsAll<T['returnType']> extends true ? SetQueryReturnsOneKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>>;
+} ? SetQueryKind<T, 'create'> : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>>;
 type CreateRawOrFromResult<T extends CreateSelf> = T extends {
     isCount: true;
-} ? SetQueryKind<T, 'create'> : QueryReturnsAll<T['returnType']> extends true ? SetQueryReturnsOneKind<T, 'create'> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKind<T, 'create'> : SetQueryKind<T, 'create'>;
-type InsertResult<T extends CreateSelf, BT> = T['meta']['hasSelect'] extends true ? QueryReturnsAll<T['returnType']> extends true ? SetQueryReturnsOneKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryReturnsRowCount<T, 'create'>;
-type InsertRawOrFromResult<T extends CreateSelf> = T['meta']['hasSelect'] extends true ? QueryReturnsAll<T['returnType']> extends true ? SetQueryReturnsOneKind<T, 'create'> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKind<T, 'create'> : SetQueryKind<T, 'create'> : SetQueryReturnsRowCount<T, 'create'>;
+} ? SetQueryKind<T, 'create'> : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKind<T, 'create'> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKind<T, 'create'> : SetQueryKind<T, 'create'>;
+type InsertResult<T extends CreateSelf, BT> = T['meta']['hasSelect'] extends true ? T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryReturnsRowCount<T, 'create'>;
+type InsertRawOrFromResult<T extends CreateSelf> = T['meta']['hasSelect'] extends true ? T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKind<T, 'create'> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKind<T, 'create'> : SetQueryKind<T, 'create'> : SetQueryReturnsRowCount<T, 'create'>;
 type CreateManyResult<T extends CreateSelf, BT> = T extends {
     isCount: true;
 } ? SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKindResult<T, 'create', NarrowCreateResult<T, BT>> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKindResult<T, 'create', NarrowCreateResult<T, BT>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T, BT>>;
@@ -3942,10 +4031,12 @@ type InsertManyRawOrFromResult<T extends CreateSelf> = T['meta']['hasSelect'] ex
  *
  * The same should work as well with any non-null columns passed to `create`, but it's to be implemented later.
  */
-type NarrowCreateResult<T extends CreateSelf, BT> = [
-    T['relations'][keyof T['relations'] & keyof BT]['relationConfig']['omitForeignKeyInCreate']
+type NarrowCreateResult<T extends CreateSelf, Bt> = [
+    {
+        [K in keyof T['relations']]: T['relations'][K]['relationConfig']['omitForeignKeyInCreate'];
+    }[keyof T['relations'] & keyof Bt]
 ] extends [never] ? T['result'] : {
-    [K in keyof T['result']]: K extends T['relations'][keyof T['relations'] & keyof BT]['relationConfig']['omitForeignKeyInCreate'] ? QueryColumn<Exclude<T['result'][K]['type'], null>, T['result'][K]['operators']> : T['result'][K];
+    [K in keyof T['result']]: K extends T['relations'][keyof T['relations']]['relationConfig']['omitForeignKeyInCreate'] ? QueryColumn<Exclude<T['result'][K]['type'], null>, T['result'][K]['operators']> : T['result'][K];
 };
 type IgnoreResult<T extends CreateSelf> = T['returnType'] extends 'oneOrThrow' ? SetQueryReturnsOneOptional<T> : T['returnType'] extends 'valueOrThrow' ? SetQueryReturnsColumnOptional<T, T['result']['value']> : T;
 interface CreateRawData<T extends CreateSelf> {
@@ -3981,10 +4072,10 @@ interface CreateCtx {
     returnTypeAll?: true;
     resultAll: RecordUnknown[];
 }
-declare const _queryCreate: <T extends CreateSelf, BT extends CreateRelationsDataOmittingFKeys<T, T["relations"][keyof T["relations"]]["relationConfig"]["dataForCreate"]>>(q: T, data: CreateData<T, BT>) => CreateResult<T, BT>;
-declare const _queryInsert: <T extends CreateSelf, BT extends CreateRelationsDataOmittingFKeys<T, T["relations"][keyof T["relations"]]["relationConfig"]["dataForCreate"]>>(q: T, data: CreateData<T, BT>) => InsertResult<T, BT>;
-declare const _queryCreateMany: <T extends CreateSelf, BT extends CreateRelationsDataOmittingFKeys<T, T["relations"][keyof T["relations"]]["relationConfig"]["dataForCreate"]>>(q: T, data: CreateData<T, BT>[]) => CreateManyResult<T, BT>;
-declare const _queryInsertMany: <T extends CreateSelf, BT extends CreateRelationsDataOmittingFKeys<T, T["relations"][keyof T["relations"]]["relationConfig"]["dataForCreate"]>>(q: T, data: CreateData<T, BT>[]) => InsertManyResult<T, BT>;
+declare const _queryCreate: <T extends CreateSelf, BT extends CreateBelongsToData<T>>(q: T, data: CreateData<T, BT>) => CreateResult<T, BT>;
+declare const _queryInsert: <T extends CreateSelf, BT extends CreateBelongsToData<T>>(q: T, data: CreateData<T, BT>) => InsertResult<T, BT>;
+declare const _queryCreateMany: <T extends CreateSelf, BT extends CreateBelongsToData<T>>(q: T, data: CreateData<T, BT>[]) => CreateManyResult<T, BT>;
+declare const _queryInsertMany: <T extends CreateSelf, BT extends CreateBelongsToData<T>>(q: T, data: CreateData<T, BT>[]) => InsertManyResult<T, BT>;
 declare const _queryCreateRaw: <T extends CreateSelf>(q: T, args: CreateRawArgs<T, CreateRawData<T>>) => CreateRawOrFromResult<T>;
 declare const _queryInsertRaw: <T extends CreateSelf>(q: T, args: CreateRawArgs<T, CreateRawData<T>>) => InsertRawOrFromResult<T>;
 declare const _queryCreateManyRaw: <T extends CreateSelf>(q: T, args: CreateRawArgs<T, CreateManyRawData<T>>) => CreateManyRawOrFromResult<T>;
@@ -3997,7 +4088,7 @@ declare const _queryInsertFrom: <T extends CreateSelf, Q extends Query & {
 }>(q: T, query: Q, data?: Omit<CreateData<T, CreateBelongsToData<T>>, keyof Q['result']>) => InsertRawOrFromResult<T>;
 declare const _queryCreateManyFrom: <T extends CreateSelf>(q: T, query: Query) => CreateManyRawOrFromResult<T>;
 declare const _queryInsertManyFrom: <T extends CreateSelf>(q: T, query: Query) => InsertManyRawOrFromResult<T>;
-declare const _queryDefaults: <T extends CreateSelf, Data extends Partial<CreateData<T, CreateRelationsDataOmittingFKeys<T, T["relations"][keyof T["relations"]]["relationConfig"]["dataForCreate"]>>>>(q: T, data: Data) => AddQueryDefaults<T, { [K in keyof Data]: true; }>;
+declare const _queryDefaults: <T extends CreateSelf, Data extends Partial<CreateData<T, CreateBelongsToData<T>>>>(q: T, data: Data) => AddQueryDefaults<T, { [K in keyof Data]: true; }>;
 /**
  * Names of all create methods,
  * is used in {@link RelationQuery} to remove these methods if chained relation shouldn't have them,
@@ -4740,22 +4831,22 @@ declare class Having {
 type AfterHook<Select extends PropertyKey[], Shape extends QueryColumns> = QueryAfterHook<{
     [K in keyof Select[number]]: K extends keyof Shape ? Shape[K]['outputType'] : never;
 }[]>;
-type HookSelect<T extends PickQueryShape> = (keyof T['shape'] & string)[];
+type HookSelectArg<T extends PickQueryShape> = (keyof T['shape'] & string)[];
 type HookAction = 'Create' | 'Update' | 'Delete';
 declare const _queryHookBeforeQuery: <T extends PickQueryShape>(q: T, cb: QueryBeforeHook) => T;
 declare const _queryHookAfterQuery: <T extends PickQueryShape>(q: T, cb: QueryAfterHook) => T;
 declare const _queryHookBeforeCreate: <T extends PickQueryShape>(q: T, cb: QueryBeforeHook) => T;
-declare const _queryHookAfterCreate: <T extends PickQueryShape, S extends HookSelect<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
-declare const _queryHookAfterCreateCommit: <T extends PickQueryShape, S extends HookSelect<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
+declare const _queryHookAfterCreate: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
+declare const _queryHookAfterCreateCommit: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
 declare const _queryHookBeforeUpdate: <T extends PickQueryShape>(q: T, cb: QueryBeforeHook) => T;
-declare const _queryHookAfterUpdate: <T extends PickQueryShape, S extends HookSelect<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
-declare const _queryHookAfterUpdateCommit: <T extends PickQueryShape, S extends HookSelect<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
+declare const _queryHookAfterUpdate: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
+declare const _queryHookAfterUpdateCommit: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
 declare const _queryHookBeforeSave: <T extends PickQueryShape>(q: T, cb: QueryBeforeHook) => T;
-declare const _queryHookAfterSave: <T extends PickQueryShape, S extends HookSelect<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
-declare const _queryAfterSaveCommit: <T extends PickQueryShape, S extends HookSelect<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
+declare const _queryHookAfterSave: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
+declare const _queryAfterSaveCommit: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
 declare const _queryHookBeforeDelete: <T extends PickQueryShape>(q: T, cb: QueryBeforeHook) => T;
-declare const _queryHookAfterDelete: <T extends PickQueryShape, S extends HookSelect<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
-declare const _queryHookAfterDeleteCommit: <T extends PickQueryShape, S extends HookSelect<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
+declare const _queryHookAfterDelete: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
+declare const _queryHookAfterDeleteCommit: <T extends PickQueryShape, S extends HookSelectArg<T>>(q: T, select: S, cb: AfterHook<S, T['shape']>) => T;
 declare abstract class QueryHooks {
     /**
      * Run the function before any kind of query.
@@ -4786,7 +4877,7 @@ declare abstract class QueryHooks {
      * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    afterCreate<T extends PickQueryShape, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    afterCreate<T extends PickQueryShape, S extends HookSelectArg<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
      * Run the function after transaction for a `create` kind of query will be committed.
      * If the query wasn't wrapped in a transaction, will run after the query.
@@ -4794,7 +4885,7 @@ declare abstract class QueryHooks {
      * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    afterCreateCommit<T extends PickQueryShape, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    afterCreateCommit<T extends PickQueryShape, S extends HookSelectArg<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
      * Run the function before an `update` kind of query.
      *
@@ -4811,7 +4902,7 @@ declare abstract class QueryHooks {
      * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    afterUpdate<T extends PickQueryShape, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    afterUpdate<T extends PickQueryShape, S extends HookSelectArg<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
      * Run the function after transaction for an `update` kind of query will be committed.
      * If the query wasn't wrapped in a transaction, will run after the query.
@@ -4820,7 +4911,7 @@ declare abstract class QueryHooks {
      * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    afterUpdateCommit<T extends PickQueryShape, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    afterUpdateCommit<T extends PickQueryShape, S extends HookSelectArg<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
      * Run the function before a `create` or an `update` kind of query.
      *
@@ -4837,7 +4928,7 @@ declare abstract class QueryHooks {
      * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    afterSave<T extends PickQueryShape, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    afterSave<T extends PickQueryShape, S extends HookSelectArg<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
      * Run the function after transaction for a `create` or an `update` kind of query will be committed.
      * If the query wasn't wrapped in a transaction, will run after the query.
@@ -4846,7 +4937,7 @@ declare abstract class QueryHooks {
      * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    afterSaveCommit<T extends PickQueryShape, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    afterSaveCommit<T extends PickQueryShape, S extends HookSelectArg<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
      * Run the function before a `delete` kind of query.
      *
@@ -4863,7 +4954,7 @@ declare abstract class QueryHooks {
      * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    afterDelete<T extends PickQueryShape, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    afterDelete<T extends PickQueryShape, S extends HookSelectArg<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
      * Run the function after transaction for a `delete` kind of query will be committed.
      * If the query wasn't wrapped in a transaction, will run after the query.
@@ -4872,7 +4963,7 @@ declare abstract class QueryHooks {
      * @param select - list of columns to select for the hook
      * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    afterDeleteCommit<T extends PickQueryShape, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    afterDeleteCommit<T extends PickQueryShape, S extends HookSelectArg<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
 }
 
 declare abstract class JsonMethods {
@@ -4921,7 +5012,7 @@ declare class QueryLog {
 type MergeQuery<T extends PickQueryMetaResultReturnTypeWithDataWindows, Q extends PickQueryMetaResultReturnTypeWithDataWindows> = {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta'] | keyof Q['meta']]: K extends 'selectable' ? MergeObjects<T['meta']['selectable'], Q['meta']['selectable']> : K extends keyof Q['meta'] ? Q['meta'][K] : T['meta'][K];
-    } : K extends 'result' ? MergeQueryResult<T, Q> : K extends 'returnType' ? QueryReturnType extends Q['returnType'] ? T['returnType'] : Q['returnType'] : K extends 'then' ? QueryThen<GetQueryResult<QueryReturnType extends Q['returnType'] ? T : Q, MergeQueryResult<T, Q>>> : K extends 'windows' ? MergeObjects<T['windows'], Q['windows']> : K extends 'withData' ? MergeObjects<T['withData'], Q['withData']> : T[K];
+    } : K extends 'result' ? MergeQueryResult<T, Q> : K extends 'returnType' ? Q['returnType'] extends undefined ? T['returnType'] : Q['returnType'] : K extends 'then' ? QueryThen<GetQueryResult<QueryReturnType extends Q['returnType'] ? T : Q, MergeQueryResult<T, Q>>> : K extends 'windows' ? MergeObjects<T['windows'], Q['windows']> : K extends 'withData' ? MergeObjects<T['withData'], Q['withData']> : T[K];
 };
 type MergeQueryResult<T extends PickQueryMetaResult, Q extends PickQueryMetaResult> = T['meta']['hasSelect'] extends true ? Q['meta']['hasSelect'] extends true ? {
     [K in keyof T['result'] | keyof Q['result']]: K extends keyof Q['result'] ? Q['result'][K] : T['result'][K];
@@ -4943,7 +5034,9 @@ type SelectArgs<T extends SelectSelf> = ('*' | keyof T['meta']['selectable'])[];
 interface SelectAsArg<T extends SelectSelf> {
     [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);
+    }) => (QueryBase & {
+        returnType: Exclude<QueryReturnType, 'rows'>;
+    }) | Expression);
 }
 type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = {
     [K in keyof T]: K extends 'result' ? ('*' extends Columns[number] ? {
@@ -4972,9 +5065,9 @@ type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey
         selectable: SelectAsSelectable<Obj>;
     } : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
     {
-        [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;
+        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends Columns[number] ? T['meta']['selectable'][K]['column'] : never;
     } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown) : K extends 'then' ? QueryThen<GetQueryResult<T, {
-        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | keyof Obj as K extends keyof T['meta']['selectable'] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof T['meta']['selectable'] ? T['meta']['selectable'][K]['column'] : K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : never;
+        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends Columns[number] ? T['meta']['selectable'][K]['column'] : never;
     } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : T[K];
 };
 type SelectAsSelectable<Arg> = {
@@ -4996,11 +5089,16 @@ type SelectAsSelectable<Arg> = {
     } : never;
 }[keyof Arg];
 type SelectAsValueResult<T extends SelectSelf, Arg> = Arg extends keyof T['meta']['selectable'] ? T['meta']['selectable'][Arg]['column'] : Arg extends Expression ? Arg['result']['value'] : Arg extends (q: never) => QueryBase ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends (q: never) => Expression ? ReturnType<Arg>['result']['value'] : Arg extends (q: never) => QueryBase | Expression ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression>> | Exclude<ReturnType<Arg>, QueryBase>['result']['value'] : never;
-type SelectSubQueryResult<Arg extends SelectSelf> = QueryReturnsAll<Arg['returnType']> extends true ? ColumnsShapeToObjectArray<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShapeToPluck<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShapeToNullableObject<Arg['result']> : ColumnsShapeToObject<Arg['result']>;
+type SelectSubQueryResult<Arg extends SelectSelf> = Arg['returnType'] extends undefined | 'all' ? ColumnsShapeToObjectArray<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShapeToPluck<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShapeToNullableObject<Arg['result']> : ColumnsShapeToObject<Arg['result']>;
 declare const addParserForRawExpression: (q: PickQueryQ, key: string | getValueKey, raw: Expression) => void;
-declare const addParserForSelectItem: <T extends PickQueryMeta>(q: T, as: string | getValueKey | undefined, key: string, arg: SelectableOrExpression<T> | Query) => string | Expression | Query;
-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;
+interface QueryBatchResult {
+    data: any;
+    parent: any;
+    key: PropertyKey;
+}
+declare const addParserForSelectItem: <T extends PickQueryMeta>(q: T, as: string | getValueKey | undefined, key: string, arg: SelectableOrExpression<T> | Query) => string | Expression | Query | undefined;
+declare const processSelectArg: <T extends SelectSelf>(q: T, as: string | undefined, arg: SelectArg<T>, columnAs?: string | getValueKey) => SelectItem | undefined | false;
+declare const setParserForSelectedString: (q: PickQueryQAndInternal, arg: string, as: string | getValueKey | undefined, columnAs?: string | getValueKey) => string | undefined;
 declare const getShapeFromSelect: (q: QueryBase, isSubQuery?: boolean) => QueryColumns;
 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>;
@@ -5230,7 +5328,7 @@ declare class SqlMethod<ColumnTypes> {
      * @return object that has `type` and `values` methods
      */
     sql<T = unknown>(this: PickQueryColumnTypes, ...args: StaticSQLArgs): RawSQL<QueryColumn<T>, ColumnTypes>;
-    sql<T = unknown>(this: PickQueryColumnTypes, ...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>, ColumnTypes>;
+    sql<T = unknown>(this: PickQueryColumnTypes, ...args: [DynamicSQLArg<QueryColumn<T>>]): DynamicRawSQL<QueryColumn<T>, ColumnTypes>;
 }
 
 interface WithArgsOptions {
@@ -5444,7 +5542,7 @@ type UpdateData<T extends UpdateSelf> = {
     [K in keyof T['inputType'] | keyof T['relations']]?: K extends keyof T['inputType'] ? UpdateColumn<T, K> : UpdateRelationData<T, T['relations'][K]['relationConfig']>;
 };
 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 UpdateRelationData<T extends UpdateSelf, Rel extends RelationConfigBase> = T['returnType'] extends undefined | 'all' ? 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;
 type UpdateResult<T extends UpdateSelf> = T['meta']['hasSelect'] extends true ? SetQueryKind<T, 'update'> : SetQueryReturnsRowCount<T, 'update'>;
@@ -6332,10 +6430,10 @@ declare class QueryMap {
      *
      * @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): {
+    map<T extends Query, Result extends RecordUnknown>(this: T, fn: (input: T['returnType'] extends undefined | 'all' ? 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];
+        } : K extends 'then' ? QueryThen<T['returnType'] extends undefined | 'all' ? Result[] : Result> : T[K];
     };
 }
 
@@ -6357,11 +6455,13 @@ type OrderArg<T extends OrderArgSelf> = OrderArgKey<T> | OrderArgTsQuery<T> | {
 } | 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;
+type OrderArgKey<T extends OrderArgSelf> = {
+    [K in keyof T['meta']['selectable']]: T['meta']['selectable'][K]['column']['queryType'] extends undefined ? never : K;
+}[keyof T['meta']['selectable']] | {
+    [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K;
 }[keyof T['result']];
 type GroupArgs<T extends PickQueryResult> = ({
-    [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' ? never : K;
+    [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K;
 }[keyof T['result']] | Expression)[];
 interface QueryHelper<T extends PickQueryMetaShape, Args extends unknown[], Result> {
     <Q extends {
@@ -6940,14 +7040,14 @@ declare class QueryMethods<ColumnTypes> {
 }
 
 declare const queryMethodByReturnType: {
-    [K in QueryReturnType]: 'query' | 'arrays';
+    [K in string]: 'query' | 'arrays';
 };
 declare class Then {
     catch(this: Query, fn: (reason: any) => unknown): Promise<unknown>;
 }
-declare const handleResult: CommonQueryData['handleResult'];
-declare const parseResult: (q: Query, parsers: ColumnsParsers | undefined, returnType: QueryReturnType | undefined, result: QueryResult, isSubQuery?: boolean) => unknown;
-declare const parseRecord: (parsers: ColumnsParsers, row: any) => any;
+declare const handleResult: HandleResult;
+declare const parseRecord: (parsers: ColumnsParsers, row: any) => unknown;
+declare const filterResult: (q: Query, returnType: QueryReturnType, queryResult: QueryResult, result: unknown, tempColumns: Set<string> | undefined, hasAfterHook?: unknown) => unknown;
 
 declare function queryJson<T>(self: T, coalesce?: boolean): SetQueryReturnsColumnOptional<T, QueryColumn<string>>;
 
@@ -7087,20 +7187,9 @@ type SelectableOrExpressionOfType<T extends PickQueryMeta, C extends PickType> =
 interface QueryWithTable extends Query {
     table: string;
 }
-declare const queryTypeWithLimitOne: {
-    all: true | undefined;
-    one: true | undefined;
-    oneOrThrow: true | undefined;
-    rows: true | undefined;
-    pluck: true | undefined;
-    value: true | undefined;
-    valueOrThrow: true | undefined;
-    rowCount: true | undefined;
-    void: true | undefined;
-};
+declare const queryTypeWithLimitOne: RecordKeyTrue;
 declare const isQueryReturnsAll: (q: Query) => boolean;
-type QueryReturnsAll<T extends QueryReturnType> = QueryReturnType extends T ? true : T extends 'all' ? true : false;
-type GetQueryResult<T extends PickQueryReturnType, Result extends QueryColumns> = QueryReturnsAll<T['returnType']> extends true ? ColumnShapeOutput<Result>[] : T['returnType'] extends 'one' ? ColumnShapeOutput<Result> | undefined : T['returnType'] extends 'oneOrThrow' ? ColumnShapeOutput<Result> : T['returnType'] extends 'value' ? Result['value']['outputType'] | undefined : T['returnType'] extends 'valueOrThrow' ? Result['value']['outputType'] : T['returnType'] extends 'rows' ? ColumnShapeOutput<Result>[keyof Result][][] : T['returnType'] extends 'pluck' ? Result['pluck']['outputType'][] : T['returnType'] extends 'rowCount' ? number : void;
+type GetQueryResult<T extends PickQueryReturnType, Result extends QueryColumns> = T['returnType'] extends undefined | 'all' ? ColumnShapeOutput<Result>[] : T['returnType'] extends 'one' ? ColumnShapeOutput<Result> | undefined : T['returnType'] extends 'oneOrThrow' ? ColumnShapeOutput<Result> : T['returnType'] extends 'value' ? Result['value']['outputType'] | undefined : T['returnType'] extends 'valueOrThrow' ? Result['value']['outputType'] : T['returnType'] extends 'rows' ? ColumnShapeOutput<Result>[keyof Result][][] : T['returnType'] extends 'pluck' ? Result['pluck']['outputType'][] : T['returnType'] extends 'rowCount' ? number : void;
 type AddQuerySelect<T extends PickQueryMetaResultReturnType, Result extends QueryColumns> = {
     [K in keyof T]: K extends 'result' ? {
         [K in (T['meta']['hasSelect'] extends true ? keyof T['result'] : never) | keyof Result]: K extends keyof Result ? Result[K] : K extends keyof T['result'] ? T['result'][K] : never;
@@ -7586,7 +7675,6 @@ interface DefaultColumnTypes<SchemaConfig extends ColumnSchemaConfig> extends Ti
     bigSerial: SchemaConfig['bigSerial'];
     money: SchemaConfig['money'];
     varchar: SchemaConfig['varchar'];
-    char: SchemaConfig['char'];
     text: SchemaConfig['text'];
     string: SchemaConfig['string'];
     citext: SchemaConfig['citext'];
@@ -7675,6 +7763,7 @@ declare abstract class VirtualColumn<Schema extends ColumnSchemaConfig, InputSch
 }
 
 declare class UnknownColumn<Schema extends ColumnSchemaConfig> extends VirtualColumn<Schema> {
+    static instance: UnknownColumn<DefaultSchemaConfig>;
     constructor(schema: Schema);
 }
 
@@ -7779,23 +7868,6 @@ declare const testTransaction: {
     close(arg: Arg): Promise<void>;
 };
 
-interface ComputedColumnsBase<T extends PickQueryTableMetaShape> {
-    [K: string]: (q: T) => Expression;
-}
-type QueryWithComputed<T extends PickQueryTableMetaShape, Computed extends ComputedColumnsBase<T>, Shape extends QueryColumns = {
-    [K in keyof Computed]: ReturnType<Computed[K]>['result']['value'];
-}> = {
-    [K in keyof T]: K extends 'shape' ? T['shape'] & Shape : K extends 'meta' ? T['meta'] & {
-        selectable: SelectableFromShape<Shape, T['table']>;
-    } : T[K];
-};
-declare module 'orchid-core' {
-    interface ColumnDataBase {
-        computed?: Expression;
-    }
-}
-declare function addComputedColumns<T extends PickQueryTableMetaShape, Computed extends ComputedColumnsBase<T>>(q: T, computed: Computed): QueryWithComputed<T, Computed>;
-
 /**
  * Result type for `columnInfo` method.
  * Sets query kind to 'columnInfo', returns a single value (may return undefined),
@@ -7892,4 +7964,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, 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 };
+export { Adapter, AdapterConfig, AdapterOptions, AddQueryDefaults, AddQuerySelect, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayColumnValue, ArrayData, AsMethods, AsQueryArg, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanQueryColumn, BoxColumn, ByteaColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, CloneSelfKeys, ColumnData, ColumnFromDbParams, ColumnInfoQueryData, ColumnOperators, ColumnRefExpression, ColumnType, ColumnsByType, ColumnsShape, ColumnsShapeToNullableObject, ColumnsShapeToObject, ColumnsShapeToObjectArray, ColumnsShapeToPluck, CommonQueryData, ComputedColumn, ComputedColumns, ComputedColumnsFromOptions, ComputedMethods, ComputedOptionsFactory, 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, HandleResult, Having, HavingItem, HookAction, HookSelectArg, IdentityColumn, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgToQuery, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinItemArgs, 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, QueryBatchResult, QueryBeforeHook, QueryComputedArg, QueryData, QueryDataFromItem, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryInternal, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryOrExpression, QueryOrExpressionBooleanOrNullResult, QueryResult, QueryScopeData, QueryScopes, QuerySourceItem, QueryUpsertOrCreate, QueryWithTable, RawSQL, RealColumn, RecordOfColumnsShapeBase, RefExpression, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, RuntimeComputedQueryColumn, SearchArg, SearchMethods, SearchWeight, SearchWeightRecord, Select, SelectArg, SelectArgs, SelectAs, SelectAsValue, 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, WithConfigs, 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, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, applyComputedColumns, checkIfASimpleQuery, cloneQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, commitSql, constraintInnerToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, filterResult, 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, parseTableData, parseTableDataInput, primaryKeyInnerToCode, processComputedBatches, processComputedResult, 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 };