pqb 0.30.1 → 0.30.3

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { QueryResultRow, AdapterConfigBase, AdapterBase, QueryInput, Sql, RecordUnknown, RecordKeyTrue, EmptyObject, QueryBaseCommon, QueryColumns, 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, QueryColumnBooleanOrNull, SQLQueryArgs, ColumnSchemaConfig, DateColumnData, Code, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, RawSQLBase, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, StaticSQLArgs, ForeignKeyTable, ColumnNameOfTable, BaseNumberData, PickColumnBaseData, ColumnWithDefault, StringTypeData, PrimaryKeyColumn, ParseColumn, EncodeColumn, PickQueryMetaResult, QueryColumnsInit, DefaultSelectColumns, CoreQueryScopes, DbBase, QueryCatch, TransactionState, ColumnTypeBase, PickQueryMetaResultWindows, CoreBaseOperators, PickQueryUniqueProperties, IsQuery, PickQueryMetaShapeResultReturnType, MergeObjects, ExpressionData, PickQueryResultUniqueColumns, QueryInternalBase, PickQueryReturnType, PickType, ColumnShapeOutput, PickOutputType, PickQueryMetaReturnType, UniqueColumn, TimestampHelpers, Codes, ColumnDataCheckBase, PickQueryTableMetaShape } from 'orchid-core';
+import { QueryResultRow, AdapterConfigBase, AdapterBase, QueryInput, Sql, RecordUnknown, RecordKeyTrue, EmptyObject, QueryBaseCommon, QueryColumns, QueryMetaBase, QueryReturnType, QueryThen, Expression, QueryColumn, MaybeArray, SelectableBase, TemplateLiteralArgs, PickOutputTypeAndOperators, PickQueryResult, OperatorToSQL, ColumnsShapeBase, ColumnsParsers, RecordString, PickQueryTable, FnUnknownToUnknown, ExpressionChain, getValueKey, PickQueryShape, PickQueryTableMetaResult, EmptyTuple, PickQueryMeta, PickQueryMetaResultReturnType, QueryColumnToNullable, PickQueryMetaShape, PickQueryTableMetaResultShape, QueryColumnBooleanOrNull, SQLQueryArgs, ColumnSchemaConfig, DateColumnData, Code, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, RawSQLBase, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, StaticSQLArgs, ForeignKeyTable, ColumnNameOfTable, BaseNumberData, PickColumnBaseData, ColumnWithDefault, StringTypeData, PrimaryKeyColumn, ParseColumn, EncodeColumn, PickQueryMetaResult, QueryColumnsInit, DefaultSelectColumns, CoreQueryScopes, DbBase, QueryCatch, TransactionState, ColumnTypeBase, PickQueryMetaResultWindows, CoreBaseOperators, PickQueryUniqueProperties, IsQuery, PickQueryMetaShapeResultReturnType, MergeObjects, ExpressionData, ValExpression, PickOutputType, PickQueryResultUniqueColumns, QueryInternalBase, PickQueryReturnType, PickType, ColumnShapeOutput, 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';
@@ -796,15 +796,14 @@ declare class Join {
      *   profile: (q) => q.profile,
      * });
      *
-     * // select posts with counts of comments, order by comments count
+     * // select posts with counts of comments, filter and order by comments count
      * // result type is Array<Post & { commentsCount: number }>
      * await db.post
      *   .select('*', {
      *     commentsCount: (q) => q.comments.count(),
      *   })
-     *   .order({
-     *     commentsCount: 'DESC',
-     *   });
+     *   .where({ commentsCount: { gt: 10 } })
+     *   .order({ commentsCount: 'DESC' });
      *
      * // select authors with array of their book titles
      * // result type is Array<Author & { books: string[] }>
@@ -1055,7 +1054,8 @@ declare class Join {
      * ```ts
      * db.user.join(
      *   db.message,
-     *   db.user.sql`lower("message"."text") = lower("user"."name")`,
+     *   // `sql` can be imported from your `BaseTable` file
+     *   sql`lower("message"."text") = lower("user"."name")`,
      * );
      * ```
      *
@@ -1064,16 +1064,16 @@ declare class Join {
      * ```ts
      * db.user.join(
      *   db.message,
-     *   db.user.sql`lower("message"."text")`,
-     *   db.user.sql`lower("user"."name")`,
+     *   sql`lower("message"."text")`,
+     *   sql`lower("user"."name")`,
      * );
      *
      * // with operator:
      * db.user.join(
      *   db.message,
-     *   db.user.sql`lower("message"."text")`,
+     *   sql`lower("message"."text")`,
      *   '!=',
-     *   db.user.sql`lower("user"."name")`,
+     *   sql`lower("user"."name")`,
      * );
      * ```
      *
@@ -1087,7 +1087,7 @@ declare class Join {
      *   'message.userId': 'user.id',
      *
      *   // value can be a raw SQL expression:
-     *   text: db.user.sql`lower("user"."name")`,
+     *   text: sql`lower("user"."name")`,
      * });
      * ```
      *
@@ -1516,7 +1516,8 @@ declare class Where {
      *   },
      *
      *   // where column equals to raw SQL
-     *   column: db.table.sql`sql expression`,
+     *   // import `sql` from your `BaseTable`
+     *   column: sql`sql expression`,
      * });
      * ```
      *
@@ -1565,12 +1566,7 @@ declare class Where {
      * `where` supports raw SQL:
      *
      * ```ts
-     * db.table.where(db.table.sql`a = b`);
-     *
-     * // or
-     * import { raw } from 'orchid-orm';
-     *
-     * db.table.where(raw`a = b`);
+     * db.table.where(sql`a = b`);
      * ```
      *
      * `where` can accept a callback with a specific query builder containing all "where" methods such as `where`, `orWhere`, `whereNot`, `whereIn`, `whereExists`:
@@ -1591,7 +1587,7 @@ declare class Where {
      * db.table.where(
      *   { id: 1 },
      *   db.table.where({ name: 'John' }),
-     *   db.table.sql`a = b`,
+     *   sql`a = b`,
      * );
      * ```
      *
@@ -1704,8 +1700,6 @@ declare class Where {
      * All column operators can take a value of the same type as the column, a sub-query, or a raw SQL expression:
      *
      * ```ts
-     * import { sql } from 'orchid-orm';
-     *
      * db.table.where({
      *   numericColumn: {
      *     // lower than 5
@@ -1754,7 +1748,7 @@ declare class Where {
      *     // WHERE "column" IN (SELECT "column" FROM "otherTable")
      *     in: OtherTable.select('column'),
      *
-     *     in: db.table.sql`('a', 'b')`,
+     *     in: sql`('a', 'b')`,
      *   },
      * });
      * ```
@@ -1801,7 +1795,7 @@ declare class Where {
      *     between: [1, 10],
      *
      *     // sub-query and raw SQL expression
-     *     between: [OtherTable.select('column').take(), db.table.sql`2 + 2`],
+     *     between: [OtherTable.select('column').take(), sql`2 + 2`],
      *   },
      * });
      * ```
@@ -1888,15 +1882,7 @@ declare class Where {
      * Use a custom SQL expression in `WHERE` statement:
      *
      * ```ts
-     * db.table.where`a = b`;
-     *
-     * // or
-     * db.table.where(db.table.sql`a = b`);
-     *
-     * // or
-     * import { raw } from 'orchid-orm';
-     *
-     * db.table.where(raw`a = b`);
+     * db.table.whereSql`a = b`;
      * ```
      *
      * @param args - SQL expression
@@ -1919,10 +1905,10 @@ declare class Where {
      */
     whereNot<T extends PickQueryMetaRelations>(this: T, ...args: WhereNotArgs<T>): WhereResult<T>;
     /**
-     * `whereNot` version accepting SQL expression:
+     * `whereNotSql` is a version of `whereNot` accepting SQL expression:
      *
      * ```ts
-     * db.table.whereNot`sql expression`
+     * db.table.whereNotSql`sql expression`
      * ```
      *
      * @param args - SQL expression
@@ -1990,7 +1976,7 @@ declare class Where {
      * It supports raw SQL expression:
      *
      * ```ts
-     * db.table.whereIn(['id', 'name'], db.table.sql`((1, 'one'), (2, 'two'))`);
+     * db.table.whereIn(['id', 'name'], sql`((1, 'one'), (2, 'two'))`);
      * ```
      */
     whereIn<T extends PickQueryMetaRelations, Column extends WhereInColumn<T>>(this: T, ...args: [column: Column, values: WhereInValues<T, Column>] | [arg: WhereInArg<T>]): WhereResult<T>;
@@ -3233,41 +3219,6 @@ type StringColumn = QueryColumn<string, OperatorsText>;
 type StringNullable = QueryColumn<string | null, OperatorsText>;
 type NullableStringReturn<T> = SetQueryReturnsColumnOrThrow<T, StringNullable> & OperatorsText;
 declare class AggregateMethods {
-    /**
-     * `fn` allows to call an arbitrary SQL function.
-     *
-     * For example, calling `sqrt` function to get a square root from some numeric column:
-     *
-     * ```ts
-     * const q = await User.select({
-     *   // todo: use type callback instead of generic type
-     *   sqrt: (q) => q.fn<number>('sqrt', ['numericColumn']),
-     * }).take();
-     *
-     * q.sqrt; // has type `number` just as provided
-     * ```
-     *
-     * If this is an aggregate function, you can specify aggregation options via third parameter.
-     *
-     * Forth parameter is for runtime column type. When specified, allows to chain the function with the column operators:
-     *
-     * ```ts
-     * const q = await User.select({
-     *   // chain `sqrt("numericColumn")` with the "greater than 5"
-     *   sqrtIsGreaterThan5: (q) => q.fn('sqrt', ['numericColumn'], {}, (t) => t.float()).gt(5),
-     * }).take();
-     *
-     * // Return type is boolean | null
-     * // todo: it should be just boolean if the column is not nullable, but for now it's always nullable
-     * q.sqrtIsGreaterThan5
-     * ```
-     *
-     * @param fn
-     * @param args
-     * @param options
-     * @param type
-     */
-    fn<T extends PickQueryMetaResultRelationsWindowsColumnTypes, Type = unknown, C extends QueryColumn = QueryColumn<Type>>(this: T, fn: string, args: SelectableOrExpression<T>[], options?: AggregateOptions<T>, type?: (t: T['columnTypes']) => C): SetQueryReturnsColumnOrThrow<T, C> & C['operators'];
     /**
      * Use `exists()` to check if there is at least one record-matching condition.
      *
@@ -3514,7 +3465,7 @@ declare class AggregateMethods {
      *     // select a column with alias
      *     nameAlias: 'name',
      *     // select raw SQL with alias
-     *     foo: db.table.sql<string>`"bar" || "baz"`,
+     *     foo: sql<string>`"bar" || "baz"`,
      *   },
      *   aggregateOptions,
      * );
@@ -3524,7 +3475,7 @@ declare class AggregateMethods {
      *   object: (q) =>
      *     q.jsonObjectAgg({
      *       nameAlias: 'name',
-     *       foo: db.table.sql<string>`"bar" || "baz"`,
+     *       foo: sql<string>`"bar" || "baz"`,
      *     }),
      * });
      * ```
@@ -3823,7 +3774,7 @@ declare class Create {
      *
      * await db.table.create({
      *   // raw SQL
-     *   column1: db.table.sql`'John' | 'Doe'`,
+     *   column1: sql`'John' || ' ' || 'Doe'`,
      *
      *   // query that returns a single value
      *   // returning multiple values will result in Postgres error
@@ -3878,7 +3829,7 @@ declare class Create {
      * ```ts
      * const oneRecord = await db.table.createRaw({
      *   columns: ['name', 'amount'],
-     *   values: db.table.sql`'name', random()`,
+     *   values: sql`'name', random()`,
      * });
      * ```
      *
@@ -3903,7 +3854,7 @@ declare class Create {
      * ```ts
      * const manyRecords = await db.table.createManyRaw({
      *   columns: ['name', 'amount'],
-     *   values: [db.table.sql`'one', 2`, db.table.sql`'three', 4`],
+     *   values: [sql`'one', 2`, sql`'three', 4`],
      * });
      * ```
      *
@@ -4049,11 +4000,11 @@ declare class Create {
      * // raw SQL expression:
      * db.table
      *   .create(data)
-     *   .onConfict(db.table.sql`(email) where condition`)
+     *   .onConfict(sql`(email) where condition`)
      *   .merge();
      * ```
      *
-     * You can use the db.table.sql function in onConflict.
+     * You can use the `sql` function exported from your `BaseTable` file in onConflict.
      * It can be useful to specify a condition when you have a partial index:
      *
      * ```ts
@@ -4064,7 +4015,7 @@ declare class Create {
      *     active: true,
      *   })
      *   // ignore only when having conflicting email and when active is true.
-     *   .onConflict(db.table.sql`(email) where active`)
+     *   .onConflict(sql`(email) where active`)
      *   .ignore();
      * ```
      *
@@ -4150,7 +4101,7 @@ declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflic
      * db.table
      *   .create(data)
      *   .onConflict()
-     *   .set(db.table.sql`raw SQL expression`);
+     *   .set(sql`raw SQL expression`);
      *
      * // update records only on certain conditions
      * db.table
@@ -4345,7 +4296,6 @@ declare class From {
      * ```ts
      * const value = 123;
      * db.table.fromSql`value = ${value}`;
-     * db.table.fromSql(db.table.sql`value = ${value}`);
      * ```
      *
      * @param args - SQL expression
@@ -4370,16 +4320,20 @@ declare class From {
 
 declare class QueryGet {
     /**
-     * `.get` returns a single value, it will add `LIMIT 1` to the query, and accepts a column name or a raw expression.
-     * It will throw `NotFoundError` when not found.
+     * `.get` returns a single value, adds `LIMIT 1` to the query, and accepts a column name or a raw SQL expression.
+     *
+     * `get` throws a `NotFoundError` when not found, and `getOptional` returns `undefined`.
      *
      * ```ts
      * import { NumberColumn } from 'orchid-orm';
+     * import { sql } from './baseTable';
      *
      * const firstName: string = await db.table.get('name');
      *
-     * const rawResult: number = await db.table.get(
-     *   db.table.sql((t) => t.integer())`1 + 1`,
+     * const rawResult: number = await db.table.get(sql((t) => t.integer())`1 + 1`);
+     *
+     * const firstNameOptional: string | undefined = await db.table.getOptional(
+     *   'name',
      * );
      * ```
      *
@@ -4461,7 +4415,7 @@ declare class Having {
      * Provide SQL expression for the `HAVING` SQL statement:
      *
      * ```ts
-     * db.table.having`count(*) >= ${10}`;
+     * db.table.havingSql`count(*) >= ${10}`;
      * ```
      *
      * @param args - SQL expression
@@ -4809,19 +4763,6 @@ declare class MergeQueryMethods {
     merge<T extends Query, Q extends Query>(this: T, q: Q): MergeQuery<T, Q>;
 }
 
-declare const queryMethodByReturnType: {
-    [K in QueryReturnType]: 'query' | 'arrays';
-};
-type Resolve = (result: any) => any;
-type Reject = (error: any) => any;
-declare class Then {
-    then: (this: Query, resolve?: Resolve, reject?: Reject) => Promise<unknown>;
-    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;
-
 interface SelectSelf {
     shape: QueryColumns;
     relations: RelationsBase;
@@ -4869,12 +4810,20 @@ type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey
     } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : T[K];
 } & QueryMetaHasSelect;
 type SelectAsSelectable<Arg> = {
-    [K in keyof Arg]: Arg[keyof Arg] extends (q: never) => {
+    [K in keyof Arg]: Arg[K] extends (q: never) => {
+        returnType: 'value' | 'valueOrThrow';
+        result: QueryColumns;
+    } ? {
+        [P in K]: {
+            as: K;
+            column: ReturnType<Arg[K]>['result']['value'];
+        };
+    } : Arg[K] extends (q: never) => {
         result: QueryColumns;
     } ? {
-        [C in keyof ReturnType<Arg[keyof Arg]>['result'] & string as `${K & string}.${C}`]: {
+        [C in keyof ReturnType<Arg[K]>['result'] & string as `${K & string}.${C}`]: {
             as: C;
-            column: ReturnType<Arg[keyof Arg]>['result'][C];
+            column: ReturnType<Arg[K]>['result'][C];
         };
     } : never;
 }[keyof Arg];
@@ -4912,14 +4861,19 @@ declare class Select {
      *   subQueryResult: Otherdb.table.select('column').take(),
      * });
      *
-     * // select raw SQL value, the first argument of `raw` is a column type, it is used for return type of the query
+     * // select raw SQL value, specify the returning type via <generic> syntax:
+     * db.table.select({
+     *   raw: sql<number>`1 + 2`,
+     * });
+     *
+     * // select raw SQL value, the resulting type can be set by providing a column type in such way:
      * db.table.select({
-     *   raw: db.table.sql((t) => t.integer())`1 + 2`,
+     *   raw: sql`1 + 2`.type((t) => t.integer()),
      * });
      *
      * // same raw SQL query as above, but raw value is returned from a callback
      * db.table.select({
-     *   raw: (q) => q.sql((t) => t.integer())`1 + 2`,
+     *   raw: (q) => q.sql`1 + 2`.type((t) => t.integer()),
      * });
      * ```
      *
@@ -5008,7 +4962,7 @@ declare class With {
      *     id: columnTypes.integer(),
      *     name: columnTypes.text(3, 100),
      *   },
-     *   db.table.sql`SELECT id, name FROM "someTable"`,
+     *   sql`SELECT id, name FROM "someTable"`,
      * );
      *
      * // accepts query:
@@ -5016,7 +4970,7 @@ declare class With {
      *
      * // accepts a callback for a query builder:
      * db.table.with('alias', (qb) =>
-     *   qb.select({ one: db.table.sql`1`.type((t) => t.integer()) }),
+     *   qb.select({ one: sql`1`.type((t) => t.integer()) }),
      * );
      *
      * // All mentioned forms can accept options as a second argument:
@@ -5062,7 +5016,7 @@ declare class Union {
      * SomeTable.select('id', 'name').union(
      *   [
      *     OtherTable.select('id', 'name'),
-     *     SomeTable.sql`SELECT id, name FROM "thirdTable"`,
+     *     sql`SELECT id, name FROM "thirdTable"`,
      *   ],
      *   true, // optional wrap parameter
      * );
@@ -5203,7 +5157,7 @@ declare class Update {
      *   column1: 123,
      *
      *   // use raw SQL to update the column
-     *   column2: db.table.sql`2 + 2`,
+     *   column2: sql`2 + 2`,
      *
      *   // use query that returns a single value
      *   // returning multiple values will result in Postgres error
@@ -5326,7 +5280,7 @@ declare class Update {
      * const updatedCount = await db.table.find(1).updateRaw`name = ${value}`;
      *
      * // or update with `sql` function:
-     * await db.table.find(1).updateRaw(db.table.sql`name = ${value}`);
+     * await db.table.find(1).updateRaw(sql`name = ${value}`);
      * ```
      * @param args - raw SQL via a template string or by using a `sql` method
      */
@@ -5899,17 +5853,17 @@ declare class QueryUpsertOrCreate {
     orCreate<T extends UpsertThis, BT extends CreateBelongsToData<T>>(this: T, data: OrCreateArg<T, BT>): UpsertResult<T>;
 }
 
-declare abstract class RawSqlMethods<ColumnTypes> {
+declare class SqlMethod<ColumnTypes> {
     /**
-     * When there is a need to use a piece of raw SQL, use the `sql` method from tables, or a `raw` function imported from `orchid-orm`.
+     * When there is a need to use a piece of raw SQL, use the `sql` exported from the `BaseTable` file, it is also attached to query objects for convenience.
      *
-     * When selecting a raw SQL, specify a resulting type with `<generic>` syntax:
+     * When selecting a custom SQL, specify a resulting type with `<generic>` syntax:
      *
      * ```ts
+     * import { sql } from './baseTable';
+     *
      * const result: { num: number }[] = await db.table.select({
-     *   num: db.table.sql<number>`
-     *     random() * 100
-     *   `,
+     *   num: sql<number>`random() * 100`,
      * });
      * ```
      *
@@ -5918,20 +5872,10 @@ declare abstract class RawSqlMethods<ColumnTypes> {
      * This example assumes that the `timestamp` column was overridden with `asDate` as shown in [Override column types](/guide/columns-overview#override-column-types).
      *
      * ```ts
-     * const result: { timestamp: Date }[] = await db.table.select({
-     *   timestamp: db.table.sql`now()`.type((t) => t.timestamp()),
-     * });
-     * ```
-     *
-     * Instead of `sql` method, you can use `raw` function from `orchid-orm` (or `pqb`) to do the same.
-     * The only difference, `raw` function don't have access to the overridden column types.
-     *
-     * ```ts
-     * import { raw } from 'orchid-orm';
+     * import { sql } from './baseTable';
      *
      * const result: { timestamp: Date }[] = await db.table.select({
-     *   // if you have overridden timestamp with `asDate` or `asNumber` it won't be parsed properly:
-     *   timestamp: raw`now()`.type((t) => t.timestamp()),
+     *   timestamp: sql`now()`.type((t) => t.timestamp()),
      * });
      * ```
      *
@@ -5947,11 +5891,11 @@ declare abstract class RawSqlMethods<ColumnTypes> {
      * const result = await db.$from(subQuery).where({ sum: { gte: 5 } });
      * ```
      *
-     * `where` and other methods don't need the return type, so it can be omitted.
-     * You can pass SQL template directly to the `where`:
+     * Many query methods have a version suffixed with `Sql`, you can pass an SQL template literal directly to these methods.
+     * These methods are: `whereSql`, `whereNotSql`, `orderSql`, `havingSql`, `fromSql`, `findBySql`.
      *
      * ```ts
-     * await db.table.where`"someValue" = random() * 100`;
+     * await db.table.whereSql`"someValue" = random() * 100`;
      * ```
      *
      * Interpolating values in template literals is completely safe:
@@ -5961,48 +5905,48 @@ declare abstract class RawSqlMethods<ColumnTypes> {
      * const { value } = req.params;
      *
      * // SQL injection is prevented by a library, this is safe:
-     * await db.table.where`column = ${value}`;
+     * await db.table.whereSql`column = ${value}`;
      * ```
      *
      * In the example above, TS cannot check if the table has `column` column, or if there are joined tables that have such column which will lead to error.
-     * Instead, use the `column` method to reference a column:
+     * Instead, use the [column](/guide/sql-expressions#column) or [ref](/guide/sql-expressions#ref) to reference a column:
      *
      * ```ts
-     * import { raw } from 'orchid-orm';
-     *
      * // ids will be prefixed with proper table names, no ambiguity:
      * db.table.join(db.otherTable, 'id', 'otherId').where`
      *   ${db.table.column('id')} = 1 AND
-     *   ${db.otherTable.column('id')} = 2
+     *   ${db.otherTable.ref('id')} = 2
      * `;
      * ```
      *
      * SQL can be passed with a simple string, it's important to note that this is not safe to interpolate values in it.
      *
      * ```ts
-     * import { raw } from 'orchid-orm';
+     * import { sql } from './baseTable';
      *
      * // no interpolation is okay
-     * await db.table.where(raw({ raw: 'column = random() * 100' }));
+     * await db.table.where(sql({ raw: 'column = random() * 100' }));
      *
      * // get value from user-provided params
      * const { value } = req.params;
      *
      * // this is NOT safe, SQL injection is possible:
-     * await db.table.where(raw({ raw: `column = random() * ${value}` }));
+     * await db.table.where(sql({ raw: `column = random() * ${value}` }));
      * ```
      *
-     * To inject values into `raw` SQL strings, denote it with `$` in the string and provide `values` object.
+     * To inject values into `sql({ raw: '...' })` SQL strings, denote it with `$` in the string and provide `values` object.
      *
-     * Use `$$` to provide column or/and table name (`column` method is more preferable). Column names will be quoted so don't quote them manually.
+     * Use `$$` to provide column or/and table name (`column` or `ref` are preferable). Column names will be quoted so don't quote them manually.
      *
      * ```ts
+     * import { sql } from './baseTable';
+     *
      * // get value from user-provided params
      * const { value } = req.params;
      *
      * // this is SAFE, SQL injection are prevented:
      * await db.table.where(
-     *   db.table.sql({
+     *   sql<boolean>({
      *     raw: '$$column = random() * $value',
      *     values: {
      *       column: 'someTable.someColumn', // or simply 'column'
@@ -6016,45 +5960,41 @@ declare abstract class RawSqlMethods<ColumnTypes> {
      * Summarizing:
      *
      * ```ts
+     * import { sql } from './baseTable';
+     *
      * // simplest form:
-     * db.table.sql`key = ${value}`;
+     * sql`key = ${value}`;
      *
      * // with resulting type:
-     * db.table.sql<boolean>`key = ${value}`;
+     * sql<boolean>`key = ${value}`;
      *
      * // with column type for select:
-     * db.table.sql`key = ${value}`.type((t) => t.boolean());
+     * sql`key = ${value}`.type((t) => t.boolean());
      *
      * // with column name via `column` method:
-     * db.table.sql`${db.table.column('column')} = ${value}`;
+     * sql`${db.table.column('column')} = ${value}`;
      *
      * // raw SQL string, not allowed to interpolate values:
-     * db.table.sql({ raw: 'random()' });
+     * sql({ raw: 'random()' });
      *
      * // with resulting type and `raw` string:
-     * db.table.sql<number>({ raw: 'random()' });
+     * sql<number>({ raw: 'random()' });
      *
      * // with column name and a value in a `raw` string:
-     * db.table.sql({
+     * sql({
      *   raw: `$$column = $value`,
      *   values: { column: 'columnName', value: 123 },
      * });
      *
      * // combine template literal, column type, and values:
-     * db.table.sql`($one + $two) / $one`
-     *   .type((t) => t.numeric())
-     *   .values({ one: 1, two: 2 });
+     * sql`($one + $two) / $one`.type((t) => t.numeric()).values({ one: 1, two: 2 });
      * ```
      *
      * @param args - template literal or an object { raw: string }
      * @return object that has `type` and `values` methods
      */
-    sql<T = unknown>(this: {
-        columnTypes: ColumnTypes;
-    }, ...args: StaticSQLArgs): RawSQL<QueryColumn<T>, ColumnTypes>;
-    sql<T = unknown>(this: {
-        columnTypes: ColumnTypes;
-    }, ...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>, ColumnTypes>;
+    sql<T = unknown>(this: PickQueryColumnTypes, ...args: StaticSQLArgs): RawSQL<QueryColumn<T>, ColumnTypes>;
+    sql<T = unknown>(this: PickQueryColumnTypes, ...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>, ColumnTypes>;
 }
 
 type QueryTransformFn<T extends Query> = (input: T['then'] extends QueryThen<infer Data> ? Data : never) => unknown;
@@ -6118,6 +6058,121 @@ declare class TransformMethods {
     transform<T extends Query, Fn extends QueryTransformFn<T>>(this: T, fn: Fn): QueryTransform<T, ReturnType<Fn>>;
 }
 
+declare class ColumnRefExpression<T extends QueryColumn> extends Expression<T> {
+    name: string;
+    result: {
+        value: T;
+    };
+    q: ExpressionData;
+    constructor(value: T, name: string);
+    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
+}
+declare class RefExpression<T extends QueryColumn> extends Expression<T> {
+    q: QueryData;
+    ref: string;
+    result: {
+        value: T;
+    };
+    constructor(value: T, q: QueryData, ref: string);
+    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
+}
+interface QueryReturnsFnAdd<T extends PickQueryColumnTypes> extends QueryMetaHasSelect {
+    type<C extends QueryColumn>(fn: (types: T['columnTypes']) => C): {
+        [K in keyof T]: K extends 'result' ? {
+            value: C;
+        } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['outputType']> : T[K];
+    } & C['operators'];
+}
+type SetQueryReturnsFn<T extends PickQueryColumnTypes, C extends PickOutputType> = {
+    [K in keyof T]: K extends 'result' ? {
+        value: C;
+    } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['outputType']> : T[K];
+} & QueryReturnsFnAdd<T>;
+declare class ExpressionMethods {
+    /**
+     * `column` references a table column, this can be used in raw SQL or when building a column expression.
+     * Only for referencing a column in the query's table. For referencing joined table's columns, see [ref](#ref).
+     *
+     * ```ts
+     * await db.table.select({
+     *   // select `("table"."id" = 1 OR "table"."name" = 'name') AS "one"`,
+     *   // returns a boolean
+     *   one: (q) =>
+     *     q.sql<boolean>`${q.column('id')} = ${1} OR ${q.column('name')} = ${'name'}`,
+     *
+     *   // selects the same as above, but by building a query
+     *   two: (q) => q.column('id').equals(1).or(q.column('name').equals('name')),
+     * });
+     * ```
+     *
+     * @param name - column name
+     */
+    column<T extends PickQueryShape, K extends keyof T['shape']>(this: T, name: K): ColumnRefExpression<T['shape'][K]> & T['shape'][K]['operators'];
+    /**
+     * `ref` is similar to [column](#column), but it also allows to reference a column of joined table,
+     * and other dynamically defined columns.
+     *
+     * ```ts
+     * await db.table.join('otherTable').select({
+     *   // select `("otherTable"."id" = 1 OR "otherTable"."name" = 'name') AS "one"`,
+     *   // returns a boolean
+     *   one: (q) =>
+     *     q.sql<boolean>`${q.ref('otherTable.id')} = ${1} OR ${q.ref(
+     *       'otherTable.name',
+     *     )} = ${'name'}`,
+     *
+     *   // selects the same as above, but by building a query
+     *   two: (q) =>
+     *     q
+     *       .ref('otherTable.id')
+     *       .equals(1)
+     *       .or(q.ref('otherTable.name').equals('name')),
+     * });
+     * ```
+     *
+     * @param arg - any available column name, such as of a joined table
+     */
+    ref<T extends PickQueryMeta, K extends keyof T['meta']['selectable'] & string>(this: T, arg: K): RefExpression<T['meta']['selectable'][K]['column']> & T['meta']['selectable'][K]['column']['operators'];
+    val(value: unknown): ValExpression;
+    /**
+     * `fn` allows to call an arbitrary SQL function.
+     *
+     * For example, calling `sqrt` function to get a square root from some numeric column:
+     *
+     * ```ts
+     * const q = await User.select({
+     *   sqrt: (q) => q.fn<number>('sqrt', ['numericColumn']),
+     * }).take();
+     *
+     * q.sqrt; // has type `number` just as provided
+     * ```
+     *
+     * If this is an aggregate function, you can specify aggregation options (see [Aggregate](/guide/aggregate.html)) via third parameter.
+     *
+     * Use `type` method to specify a column type so that its operators such as `lt` and `gt` become available:
+     *
+     * ```ts
+     * const q = await User.select({
+     *   // Produces `sqrt("numericColumn") > 5`
+     *   sqrtIsGreaterThan5: (q) =>
+     *     q
+     *       .fn('sqrt', ['numericColumn'])
+     *       .type((t) => t.float())
+     *       .gt(5),
+     * }).take();
+     *
+     * // Return type is boolean | null
+     * // todo: it should be just boolean if the column is not nullable, but for now it's always nullable
+     * q.sqrtIsGreaterThan5;
+     * ```
+     *
+     * @param fn
+     * @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>;
+}
+
 interface WindowArg<T extends OrderArgSelf> {
     [K: string]: WindowArgDeclaration<T> | Expression;
 }
@@ -6156,24 +6211,11 @@ type QueryHelper<T extends PickQueryMetaShape, Args extends unknown[], Result> =
     result: Result;
 };
 type QueryHelperResult<T extends QueryHelper<Query, unknown[], unknown>> = T['result'];
-declare class ColumnRefExpression<T extends QueryColumn> extends Expression<T> {
-    name: string;
-    result: {
-        value: T;
-    };
-    q: ExpressionData;
-    constructor(value: T, name: string);
-    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
-}
-declare class RefExpression<T extends QueryColumn> extends Expression<T> {
-    q: QueryData;
-    ref: string;
-    result: {
-        value: T;
-    };
-    constructor(value: T, q: QueryData, ref: string);
-    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
-}
+type NarrowTypeResult<T extends PickQueryMetaResultReturnType, Narrow> = {
+    [K in keyof T['result']]: K extends keyof Narrow ? {
+        [P in keyof T['result'][K]]: P extends 'outputType' ? Narrow[K] extends T['result'][K]['outputType'] ? Narrow[K] : `narrowType() error: passed type does not exist in '${K & string}'s type union` : T['result'][K][P];
+    } : T['result'][K];
+};
 type WrapQueryArg = FromQuerySelf;
 declare const _queryAll: <T extends Query>(q: T) => SetQueryReturnsAll<T>;
 declare const _queryTake: <T extends PickQueryResult>(q: T) => SetQueryReturnsOne<T>;
@@ -6182,7 +6224,7 @@ 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 _queryRows: <T extends Query>(q: T) => SetQueryReturnsRows<T>;
-interface QueryMethods<ColumnTypes> extends AsMethods, AggregateMethods, Select, From, Join, With, Union, JsonModifiers, JsonMethods, Create, Update, Delete, Transaction, For, Where, SearchMethods, Clear, Having, Then, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawSqlMethods<ColumnTypes>, TransformMethods, ScopeMethods, SoftDeleteMethods {
+interface QueryMethods<ColumnTypes> extends AsMethods, AggregateMethods, Select, From, Join, With, Union, JsonModifiers, JsonMethods, Create, Update, Delete, Transaction, For, Where, SearchMethods, Clear, Having, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, SqlMethod<ColumnTypes>, TransformMethods, ScopeMethods, SoftDeleteMethods, ExpressionMethods {
 }
 declare class QueryMethods<ColumnTypes> {
     /**
@@ -6283,11 +6325,13 @@ declare class QueryMethods<ColumnTypes> {
      * db.table.distinct().select('name');
      * ```
      *
-     * Can accept column names or raw expressions to place it to `DISTINCT ON (...)`:
+     * Can accept column names or raw SQL expressions to place it to `DISTINCT ON (...)`:
      *
      * ```ts
+     * import { sql } from './baseTable';
+     *
      * // Distinct on the name and raw SQL
-     * db.table.distinct('name', db.table.sql`raw sql`).select('id', 'name');
+     * db.table.distinct('name', sql`raw sql`).select('id', 'name');
      * ```
      *
      * @param columns - column names or a raw SQL
@@ -6405,9 +6449,11 @@ declare class QueryMethods<ColumnTypes> {
      * Also, it's possible to group by a selected value:
      *
      * ```ts
+     * import { sql } from './baseTable';
+     *
      * const results = db.product
      *   .select({
-     *     month: db.product.sql`extract(month from "createdAt")`.type((t) =>
+     *     month: sql`extract(month from "createdAt")`.type((t) =>
      *       // month is returned as string, parse it to int
      *       t.string().parse(parseInt),
      *     ),
@@ -6491,8 +6537,6 @@ declare class QueryMethods<ColumnTypes> {
      *
      * ```ts
      * db.table.orderSql`raw sql`;
-     * // or
-     * db.table.orderSql(db.table.sql`raw sql`);
      * ```
      *
      * @param args - SQL expression
@@ -6655,50 +6699,44 @@ declare class QueryMethods<ColumnTypes> {
      */
     makeHelper<T extends PickQueryMetaShape, Args extends unknown[], Result>(this: T, fn: (q: T, ...args: Args) => Result): QueryHelper<T, Args, Result>;
     /**
-     * `column` references a table column, this can be used in raw SQL or when building a column expression.
-     * Only for referencing a column in the query's table. For referencing joined table's columns, see [ref](#ref).
+     * Narrows a part of the query output type.
+     * Use with caution, type-safety isn't guaranteed with it.
+     * This is similar so using `as` keyword from TypeScript, except that it applies only to a part of the result.
      *
-     * ```ts
-     * await db.table.select({
-     *   // select `("table"."id" = 1 OR "table"."name" = 'name') AS "one"`,
-     *   // returns a boolean
-     *   one: (q) =>
-     *     q.sql<boolean>`${q.column('id')} = ${1} OR ${q.column('name')} = ${'name'}`,
-     *
-     *   // selects the same as above, but by building a query
-     *   two: (q) => q.column('id').equals(1).or(q.column('name').equals('name')),
-     * });
-     * ```
-     *
-     * @param name - column name
-     */
-    column<T extends PickQueryShape, K extends keyof T['shape']>(this: T, name: K): ColumnRefExpression<T['shape'][K]> & T['shape'][K]['operators'];
-    /**
-     * `ref` is similar to [column](#column), but it also allows to reference a column of joined table,
-     * and other dynamically defined columns.
+     * The syntax `()<{ ... }>()` is enforced by internal limitations.
      *
      * ```ts
-     * await db.table.join('otherTable').select({
-     *   // select `("otherTable"."id" = 1 OR "otherTable"."name" = 'name') AS "one"`,
-     *   // returns a boolean
-     *   one: (q) =>
-     *     q.sql<boolean>`${q.ref('otherTable.id')} = ${1} OR ${q.ref(
-     *       'otherTable.name',
-     *     )} = ${'name'}`,
+     * const rows = db.table
+     *   // filter out records where the `nullableColumn` is null
+     *   .where({ nullableColumn: { not: null } });
+     *   // narrows only a specified column, the rest of result is unchanged
+     *   .narrowType()<{ nullableColumn: string }>()
      *
-     *   // selects the same as above, but by building a query
-     *   two: (q) =>
-     *     q
-     *       .ref('otherTable.id')
-     *       .equals(1)
-     *       .or(q.ref('otherTable.name').equals('name')),
-     * });
-     * ```
+     * // the column had type `string | null`, now it is `string`
+     * rows[0].nullableColumn
      *
-     * @param arg - any available column name, such as of a joined table
+     * // imagine that table has a enum column kind with variants 'first' | 'second'
+     * // and a boolean `approved`
+     * db.table
+     *   .where({ kind: 'first', approved: true })
+     *   // after applying such `where`, it's safe to narrow the type to receive the literal values
+     *   .narrowType()<{ kind: 'first', approved: true }>();
+     * ```
      */
-    ref<T extends PickQueryMeta, K extends keyof T['meta']['selectable'] & string>(this: T, arg: K): RefExpression<T['meta']['selectable'][K]['column']> & T['meta']['selectable'][K]['column']['operators'];
+    narrowType<T extends PickQueryMetaResultReturnType>(this: T): <Narrow>() => {
+        [K in keyof T]: K extends 'result' ? NarrowTypeResult<T, Narrow> : K extends 'then' ? QueryThen<GetQueryResult<T, NarrowTypeResult<T, Narrow>>> : T[K];
+    };
+}
+
+declare const queryMethodByReturnType: {
+    [K in QueryReturnType]: '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 function queryJson<T>(self: T, coalesce?: boolean): SetQueryReturnsColumnOptional<T, QueryColumn<string>>;
 
@@ -6786,9 +6824,11 @@ interface PickQueryMetaResultRelations extends PickQueryResult, PickQueryMeta, P
 }
 interface PickQueryMetaResultRelationsWindows extends PickQueryMetaResultRelations, PickQueryWindows {
 }
-interface PickQueryMetaResultRelationsWindowsColumnTypes extends PickQueryMetaResultRelationsWindows {
+interface PickQueryColumnTypes {
     columnTypes: unknown;
 }
+interface PickQueryMetaResultRelationsWindowsColumnTypes extends PickQueryMetaResultRelationsWindows, PickQueryColumnTypes {
+}
 interface PickQueryMetaTable extends PickQueryMeta, PickQueryTable {
 }
 interface PickQueryMetaTableShape extends PickQueryMetaTable, PickQueryShape {
@@ -6842,8 +6882,8 @@ declare const queryTypeWithLimitOne: {
     void: true | undefined;
 };
 declare const isQueryReturnsAll: (q: Query) => boolean;
-type QueryReturnsAll<T extends QueryReturnType> = (QueryReturnType extends T ? 'all' : T) extends 'all' ? true : false;
-type GetQueryResult<T extends PickQueryReturnType, Result extends QueryColumns> = QueryReturnsAll<T['returnType']> extends true ? ColumnShapeOutput<Result>[] : T['returnType'] extends 'one' ? ColumnShapeOutput<Result> | undefined : T['returnType'] extends 'oneOrThrow' ? ColumnShapeOutput<Result> : T['returnType'] extends 'value' ? Result['value']['outputType'] | undefined : T['returnType'] extends 'valueOrThrow' ? Result['value']['outputType'] : T['returnType'] extends 'rows' ? ColumnShapeOutput<Result>[keyof Result][][] : T['returnType'] extends 'pluck' ? Result['pluck']['outputType'][] : T['returnType'] extends 'rowCount' ? number : T['returnType'] extends 'void' ? void : never;
+type 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 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;
@@ -7633,4 +7673,4 @@ type CopyResult<T extends PickQueryMeta> = SetQueryKind<T, 'copy'>;
  */
 declare function copyTableData<T extends PickQueryMetaShape>(query: T, arg: CopyArg<T>): CopyResult<T>;
 
-export { Adapter, AdapterConfig, AdapterOptions, AddQueryDefaults, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayColumnValue, ArrayData, AsMethods, AsQueryArg, BaseOperators, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanQueryColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, CloneSelfKeys, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfoQueryData, ColumnOperators, ColumnRefExpression, ColumnType, ColumnsByType, ColumnsShape, ColumnsShapeToNullableObject, ColumnsShapeToObject, ColumnsShapeToObjectArray, ColumnsShapeToPluck, CommonQueryData, ComputedColumnsBase, CopyOptions, CopyQueryData, Create, 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, ExpressionOutput, FnExpression, FnExpressionArgs, FnExpressionArgsPairs, FnExpressionArgsValue, For, From, FromArg, 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, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgSelf, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PickColumnData, PickQueryBaseQuery, PickQueryDataShapeAndJoinedShapes, PickQueryInternal, PickQueryMetaRelations, PickQueryMetaResultRelations, PickQueryMetaResultRelationsWindows, PickQueryMetaResultRelationsWindowsColumnTypes, PickQueryMetaResultRelationsWithDataReturnType, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryMetaResultReturnTypeWithDataWindows, PickQueryMetaResultReturnTypeWithDataWindowsTable, PickQueryMetaShapeRelationsWithData, PickQueryMetaTable, PickQueryMetaTableShape, PickQueryMetaTableShapeReturnTypeWithData, PickQueryMetaWithData, PickQueryQ, PickQueryQAndBaseQuery, PickQueryQAndInternal, PickQueryRelations, PickQueryRelationsWithData, PickQueryShapeResultSinglePrimaryKey, PickQueryShapeSinglePrimaryKey, PickQuerySinglePrimaryKey, PickQueryWindows, PickQueryWithData, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBaseThen, QueryBeforeHook, QueryData, QueryDataFromItem, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryInternal, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, RecordOfColumnsShapeBase, 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, SetQueryWith, ShapeColumnPrimaryKeys, ShapeUniqueColumns, SimpleJoinItem, SimpleJoinItemNonSubQueryArgs, SmallIntColumn, SmallSerialColumn, SortDir, SqlFn, StringColumn$1 as StringColumn, TableData, TableDataFn, TableDataInput, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TableDataMethods, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, ToSQLQuery, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UniqueConstraints, UniqueQueryTypeOrExpression, UniqueTableDataItem, UnknownColumn, Update, UpdateArg, UpdateCtx, UpdateCtxCollect, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdateSelf, UpdatedAtDataInjector, UpsertArg, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereNotArgs, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithDataItems, WithItem, WithOptions, WrapQueryArg, XMLColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryAs, _queryChangeCounter, _queryCreate, _queryCreateFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateManyRaw, _queryCreateRaw, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertManyRaw, _queryInsertRaw, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpdateRaw, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotSql, _queryWhereSql, addComputedColumns, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, checkIfASimpleQuery, cloneQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, constraintInnerToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, foreignKeyArgumentToCode, getClonedQueryData, getColumnInfo, getColumnTypes, getPrimaryKeys, getQueryAs, getShapeFromSelect, handleResult, identityToCode, indexInnerToCode, indexToCode, instantiateColumn, isDefaultTimeStamp, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeFnExpression, makeRegexToFindInSql, makeSQL, parseRecord, parseResult, parseTableData, parseTableDataInput, primaryKeyInnerToCode, processSelectArg, pushLimitSQL, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, pushTableDataCode, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quote, quoteString, raw, referencesArgsToCode, resolveSubQueryCallback, saveSearchAlias, setParserForSelectedString, setQueryObjectValue, setQueryOperators, simplifyColumnDefault, sqlFn, sqlQueryArgsToExpression, tableDataMethods, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };
+export { Adapter, AdapterConfig, AdapterOptions, AddQueryDefaults, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayColumnValue, ArrayData, AsMethods, AsQueryArg, BaseOperators, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanQueryColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, CloneSelfKeys, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfoQueryData, ColumnOperators, ColumnRefExpression, ColumnType, ColumnsByType, ColumnsShape, ColumnsShapeToNullableObject, ColumnsShapeToObject, ColumnsShapeToObjectArray, ColumnsShapeToPluck, CommonQueryData, ComputedColumnsBase, CopyOptions, CopyQueryData, Create, 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, From, FromArg, 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, 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, PickQueryQ, PickQueryQAndBaseQuery, PickQueryQAndInternal, PickQueryRelations, PickQueryRelationsWithData, PickQueryShapeResultSinglePrimaryKey, PickQueryShapeSinglePrimaryKey, PickQuerySinglePrimaryKey, PickQueryWindows, PickQueryWithData, 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, 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, SetQueryWith, 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, UniqueConstraints, UniqueQueryTypeOrExpression, UniqueTableDataItem, UnknownColumn, Update, UpdateArg, UpdateCtx, UpdateCtxCollect, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdateSelf, UpdatedAtDataInjector, UpsertArg, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereNotArgs, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithDataItems, WithItem, WithOptions, WrapQueryArg, XMLColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryAs, _queryChangeCounter, _queryCreate, _queryCreateFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateManyRaw, _queryCreateRaw, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertManyRaw, _queryInsertRaw, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpdateRaw, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotSql, _queryWhereSql, addComputedColumns, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, checkIfASimpleQuery, cloneQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, constraintInnerToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, foreignKeyArgumentToCode, getClonedQueryData, getColumnInfo, getColumnTypes, getPrimaryKeys, getQueryAs, getShapeFromSelect, handleResult, identityToCode, indexInnerToCode, indexToCode, instantiateColumn, isDefaultTimeStamp, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeFnExpression, makeRegexToFindInSql, makeSQL, parseRecord, parseResult, parseTableData, parseTableDataInput, primaryKeyInnerToCode, processSelectArg, pushLimitSQL, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, pushTableDataCode, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quote, quoteString, raw, referencesArgsToCode, resolveSubQueryCallback, saveSearchAlias, setParserForSelectedString, setQueryObjectValue, setQueryOperators, simplifyColumnDefault, sqlFn, sqlQueryArgsToExpression, tableDataMethods, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };