pqb 0.30.6 → 0.31.0

package/dist/index.d.ts

@@ -106,11 +106,12 @@ interface QueryBaseThen<T> extends QueryBase {
 }
 
 declare const checkIfASimpleQuery: (q: Query) => boolean;
-type WithItem = [
-    as: string,
-    options: WithOptions,
-    query: Query | Expression
-];
+type WithItem = {
+    n: string;
+    o?: WithOptions;
+    q?: Query;
+    s?: Expression;
+};
 interface WithOptions {
     columns?: string[];
     recursive?: true;
@@ -288,7 +289,14 @@ interface WindowDeclaration {
     partitionBy?: SelectableOrExpression | SelectableOrExpression[];
     order?: OrderItem;
 }
-type UnionItem = Query | Expression;
+interface UnionItem {
+    a: Query | Expression;
+    k: UnionKind;
+}
+interface UnionSet {
+    b: Query;
+    u: UnionItem[];
+}
 type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT' | 'EXCEPT ALL';
 type OnConflictTarget = string | string[] | Expression | {
     constraint: string;
@@ -461,10 +469,9 @@ interface SelectQueryData extends CommonQueryData {
     having?: HavingItem[];
     window?: WindowItem[];
     union?: {
-        arg: UnionItem;
-        kind: UnionKind;
-        wrap?: boolean;
-    }[];
+        b: Query;
+        u: UnionItem[];
+    };
     order?: OrderItem[];
     returnsOne?: true;
     limit?: number;
@@ -615,7 +622,7 @@ type JoinFirstArg<T extends PickQueryRelationsWithData> = PickQueryTableMetaResu
  * Arguments of `join` methods (not `joinLateral`).
  * See {@link join}
  */
-type JoinArgs<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>> = [JoinCallback<T, Arg>] | (Arg extends PickQueryTableMetaResult ? JoinQueryArgs<T, Arg> : Arg extends keyof T['relations'] ? EmptyTuple : Arg extends keyof T['withData'] ? JoinWithArgs<T, Arg> : never);
+type JoinArgs<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>> = [on?: JoinCallback<T, Arg>] | (Arg extends PickQueryTableMetaResult ? JoinQueryArgs<T, Arg> : Arg extends keyof T['relations'] ? EmptyTuple : Arg extends keyof T['withData'] ? JoinWithArgs<T, Arg> : never);
 /**
  * Column names of the joined table that can be used to join.
  * Derived from 'result', not from 'shape',
@@ -1382,7 +1389,7 @@ declare const _queryJoinOnJsonPathEquals: <T extends PickQueryMeta>(q: T, args:
  */
 type JoinQueryBuilder<T extends PickQueryMetaShape = PickQueryMetaShape, J extends PickQueryTableMetaResult = PickQueryTableMetaResult> = {
     [K in keyof J]: K extends 'meta' ? {
-        [K in keyof J['meta']]: K extends 'selectable' ? J['meta']['selectable'] & Omit<T['meta']['selectable'], keyof T['shape']> : J['meta'][K];
+        [K in keyof J['meta']]: K extends 'selectable' ? SelectableFromShape<J['result'], AliasOrTable<J>> & Omit<T['meta']['selectable'], keyof T['shape']> : J['meta'][K];
     } : J[K];
 } & OnMethods;
 declare class OnMethods {
@@ -3798,19 +3805,16 @@ interface CreateSelf extends QueryBase {
 }
 type CreateData<T extends CreateSelf, BelongsToData = CreateBelongsToData<T>> = RelationsBase extends T['relations'] ? CreateDataWithDefaults<T, keyof T['meta']['defaults']> : CreateRelationsData<T, BelongsToData>;
 type CreateDataWithDefaults<T extends CreateSelf, Defaults extends PropertyKey> = {
-    [K in keyof T['inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T['inputType'], K>;
+    [K in keyof T['inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T, K>;
 } & {
-    [K in Defaults]?: K extends keyof T['inputType'] ? CreateColumn<T['inputType'], K> : never;
+    [K in Defaults]?: K extends keyof T['inputType'] ? CreateColumn<T, K> : never;
 };
 type CreateDataWithDefaultsForRelations<T extends CreateSelf, Defaults extends keyof T['inputType'], OmitFKeys extends PropertyKey> = {
-    [K in keyof T['inputType'] as K extends Defaults | OmitFKeys ? never : K]: K extends Defaults | OmitFKeys ? never : CreateColumn<T['inputType'], K>;
+    [K in keyof T['inputType'] as K extends Defaults | OmitFKeys ? never : K]: K extends Defaults | OmitFKeys ? never : CreateColumn<T, K>;
 } & {
-    [K in Defaults as K extends OmitFKeys ? never : K]?: CreateColumn<T['inputType'], K>;
-};
-type CreateColumn<InputType, Key extends keyof InputType> = Expression | InputType[Key] | {
-    __isQuery: true;
-    then: QueryThen<InputType[Key]>;
+    [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 CreateRelationsDataOmittingFKeys<T extends CreateSelf, Union> = (Union extends RelationConfigDataForCreate ? (u: keyof Union['columns'] extends keyof T['meta']['defaults'] ? Omit<Union['columns'], keyof T['meta']['defaults']> & {
@@ -3918,7 +3922,7 @@ declare class Create {
      *
      * await db.table.create({
      *   // raw SQL
-     *   column1: sql`'John' || ' ' || 'Doe'`,
+     *   column1: (q) => q.sql`'John' || ' ' || 'Doe'`,
      *
      *   // query that returns a single value
      *   // returning multiple values will result in Postgres error
@@ -4403,15 +4407,10 @@ type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (
 type FromResult<T extends FromQuerySelf, Arg extends MaybeArray<FromArg<T>>> = Arg extends string ? T['withData'] extends WithDataItems ? {
     [K in keyof T]: K extends 'meta' ? {
         [K in keyof T['meta']]: K extends 'as' ? string | undefined : K extends 'selectable' ? SelectableFromShape<T['withData'][Arg]['shape'], Arg> : T['meta'][K];
-    } : T[K];
+    } : K extends 'result' ? T['withData'][Arg]['shape'] : K extends 'then' ? QueryThen<GetQueryResult<T, T['withData'][Arg]['shape']>> : T[K];
 } : SetQueryTableAlias<T, Arg> : Arg extends PickQueryTableMetaResult ? {
     [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'as' ? AliasOrTable<Arg> : K extends 'selectable' ? {
-            [K in keyof Arg['result']]: K extends string ? {
-                as: K;
-                column: Arg['result'][K];
-            } : never;
-        } : T['meta'][K];
+        [K in keyof T['meta']]: K extends 'as' ? AliasOrTable<Arg> : K extends 'selectable' ? SelectableFromShape<Arg['result'], AliasOrTable<Arg>> : T['meta'][K];
     } : K extends 'result' ? Arg['result'] : K extends 'shape' ? Arg['result'] : K extends 'then' ? QueryThen<GetQueryResult<T, Arg['result']>> : T[K];
 } : Arg extends (infer A)[] ? {
     [K in keyof T]: K extends 'meta' ? {
@@ -4430,7 +4429,7 @@ type FromResult<T extends FromQuerySelf, Arg extends MaybeArray<FromArg<T>>> = A
 } : T;
 declare function queryFrom<T extends FromQuerySelf, Arg extends MaybeArray<FromArg<T>>>(self: T, arg: Arg): FromResult<T, Arg>;
 declare function queryFromSql<T extends FromQuerySelf>(self: T, args: SQLQueryArgs): T;
-declare class From {
+declare class FromMethods {
     /**
      * Set the `FROM` value, by default the table name is used.
      *
@@ -5094,16 +5093,178 @@ declare class Select {
     selectAll<T extends SelectSelf>(this: T): SelectResult<T, ['*']>;
 }
 
-type WithArgsOptions = {
-    [K in keyof WithOptions]: K extends 'columns' ? boolean | string[] : WithOptions[K];
+declare class SqlMethod<ColumnTypes> {
+    /**
+     * 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 custom SQL, specify a resulting type with `<generic>` syntax:
+     *
+     * ```ts
+     * import { sql } from './baseTable';
+     *
+     * const result: { num: number }[] = await db.table.select({
+     *   num: sql<number>`random() * 100`,
+     * });
+     * ```
+     *
+     * In a situation when you want the result to be parsed, such as when returning a timestamp that you want to be parsed into a `Date` object, provide a column type in such a way:
+     *
+     * This example assumes that the `timestamp` column was overridden with `asDate` as shown in [Override column types](/guide/columns-overview#override-column-types).
+     *
+     * ```ts
+     * import { sql } from './baseTable';
+     *
+     * const result: { timestamp: Date }[] = await db.table.select({
+     *   timestamp: sql`now()`.type((t) => t.timestamp()),
+     * });
+     * ```
+     *
+     * In some cases such as when using [from](/guide/orm-and-query-builder.html#from), setting column type via callback allows for special `where` operations:
+     *
+     * ```ts
+     * const subQuery = db.someTable.select({
+     *   sum: (q) => q.sql`$a + $b`.type((t) => t.decimal()).values({ a: 1, b: 2 }),
+     * });
+     *
+     * // `gt`, `gte`, `min`, `lt`, `lte`, `max` in `where`
+     * // are allowed only for numeric columns:
+     * const result = await db.$from(subQuery).where({ sum: { gte: 5 } });
+     * ```
+     *
+     * 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.whereSql`"someValue" = random() * 100`;
+     * ```
+     *
+     * Interpolating values in template literals is completely safe:
+     *
+     * ```ts
+     * // get value from user-provided params
+     * const { value } = req.params;
+     *
+     * // SQL injection is prevented by a library, this is safe:
+     * 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](/guide/sql-expressions#column) or [ref](/guide/sql-expressions#ref) to reference a column:
+     *
+     * ```ts
+     * // 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.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 { sql } from './baseTable';
+     *
+     * // no interpolation is okay
+     * 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(sql({ raw: `column = random() * ${value}` }));
+     * ```
+     *
+     * 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` 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(
+     *   sql<boolean>({
+     *     raw: '$$column = random() * $value',
+     *     values: {
+     *       column: 'someTable.someColumn', // or simply 'column'
+     *       one: value,
+     *       two: 123,
+     *     },
+     *   }),
+     * );
+     * ```
+     *
+     * Summarizing:
+     *
+     * ```ts
+     * import { sql } from './baseTable';
+     *
+     * // simplest form:
+     * sql`key = ${value}`;
+     *
+     * // with resulting type:
+     * sql<boolean>`key = ${value}`;
+     *
+     * // with column type for select:
+     * sql`key = ${value}`.type((t) => t.boolean());
+     *
+     * // with column name via `column` method:
+     * sql`${db.table.column('column')} = ${value}`;
+     *
+     * // raw SQL string, not allowed to interpolate values:
+     * sql({ raw: 'random()' });
+     *
+     * // with resulting type and `raw` string:
+     * sql<number>({ raw: 'random()' });
+     *
+     * // with column name and a value in a `raw` string:
+     * sql({
+     *   raw: `$$column = $value`,
+     *   values: { column: 'columnName', value: 123 },
+     * });
+     *
+     * // combine template literal, column type, and values:
+     * 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: PickQueryColumnTypes, ...args: StaticSQLArgs): RawSQL<QueryColumn<T>, ColumnTypes>;
+    sql<T = unknown>(this: PickQueryColumnTypes, ...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>, ColumnTypes>;
+}
+
+interface WithArgsOptions {
+    columns?: string[] | boolean;
+    materialized?: true;
+    notMaterialized?: true;
+}
+interface WithRecursiveOptions extends WithArgsOptions {
+    union?: 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT' | 'EXCEPT ALL';
+}
+type WithQueryBuilder<T extends PickQueryWithDataColumnTypes> = {
+    [K in keyof Query]: K extends 'sql' ? SqlMethod<T['columnTypes']>['sql'] : K extends 'relations' ? EmptyObject : K extends 'withData' ? T['withData'] : Query[K];
 };
-type WithArgs = [string, ColumnsShapeBase, Expression] | [string, WithArgsOptions, ColumnsShapeBase, Expression] | [string, Query | ((qb: Db) => Query)] | [string, WithArgsOptions, Query | ((qb: Db) => Query)];
-type WithShape<Args extends WithArgs> = Args[1] extends Query ? Args[1]['result'] : Args[1] extends (qb: Db) => Query ? ReturnType<Args[1]>['result'] : Args[2] extends Query ? Args[2]['result'] : Args[2] extends (qb: Db) => Query ? ReturnType<Args[2]>['result'] : Args[1] extends ColumnsShapeBase ? Args[1] : Args[2] extends ColumnsShapeBase ? Args[2] : Args[2] extends (t: DefaultColumnTypes<ColumnSchemaConfig>) => ColumnsShapeBase ? ReturnType<Args[2]> extends ColumnsShapeBase ? ReturnType<Args[2]> : never : never;
-type WithResult<T extends PickQueryWithData, Args extends WithArgs, Shape extends QueryColumns> = AddQueryWith<T, {
-    table: Args[0];
-    shape: Shape;
-}>;
-declare class With {
+type WithResult<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends PickQueryResult> = {
+    [K in keyof T]: K extends 'withData' ? {
+        [K in keyof T['withData'] | Name]: K extends Name ? {
+            table: Name;
+            shape: Q['result'];
+        } : K extends keyof T['withData'] ? T['withData'][K] : never;
+    } : T[K];
+};
+type WithSqlResult<T extends PickQueryWithDataColumnTypes, Name extends string, Shape extends ColumnsShapeBase> = {
+    [K in keyof T]: K extends 'withData' ? {
+        [K in Name | keyof T['withData']]: K extends Name ? {
+            table: Name;
+            shape: Shape;
+        } : K extends keyof T['withData'] ? T['withData'][K] : never;
+    } : T[K];
+};
+declare class WithMethods {
     /**
      * Add Common Table Expression (CTE) to the query.
      *
@@ -5167,96 +5328,134 @@ declare class With {
      *   .join('alias', 'alias.id', 'user.id')
      *   .select('alias.id');
      * ```
-     *
-     * @param args - first argument is an alias for this CTE, other arguments can be column shape, query object, or raw SQL.
      */
-    with<T extends PickQueryWithData, Args extends WithArgs, Shape extends QueryColumns = WithShape<Args>>(this: T, ...args: Args): WithResult<T, Args, Shape>;
+    with<T extends PickQueryWithDataColumnTypes, Name extends string, Q>(this: T, name: Name, query: Q | ((q: WithQueryBuilder<T>) => Q)): WithResult<T, Name, Q extends Query ? Q : never>;
+    with<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends Query>(this: T, name: Name, options: WithArgsOptions, query: Q | ((qb: WithQueryBuilder<T>) => Q)): WithResult<T, Name, Q>;
+    withRecursive<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends Query, Result = WithResult<T, Name, Q>>(this: T, name: Name, base: Q | ((qb: WithQueryBuilder<T>) => Q), recursive: (qb: {
+        [K in keyof Result]: K extends 'result' ? Q['result'] : Result[K];
+    }) => Query): Result;
+    withRecursive<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends Query, Result = WithResult<T, Name, Q>>(this: T, name: Name, options: WithRecursiveOptions, base: Q | ((qb: WithQueryBuilder<T>) => Q), recursive: (qb: {
+        [K in keyof Result]: K extends 'result' ? Q['result'] : Result[K];
+    }) => Query): Result;
+    withSql<T extends PickQueryWithDataColumnTypes, Name extends string, Shape extends ColumnsShapeBase>(this: T, name: Name, options: WithOptions, shape: (t: T['columnTypes']) => Shape, expr: (q: T) => Expression): WithSqlResult<T, Name, Shape>;
+    withSql<T extends PickQueryWithDataColumnTypes, Name extends string, Shape extends ColumnsShapeBase>(this: T, name: Name, shape: (t: T['columnTypes']) => Shape, expr: (q: T) => Expression): WithSqlResult<T, Name, Shape>;
 }
 
 type UnionArg<T extends PickQueryResult> = {
     result: {
         [K in keyof T['result']]: {
-            dataType: T['result'][K]['dataType'];
+            queryType: T['result'][K]['queryType'];
         };
     };
-} | Expression;
+} | ((q: T) => Expression);
+declare const _queryUnion: <T extends Query>(base: T, args: UnionArg<T>[], k: UnionKind) => T;
 declare class Union {
     /**
-     * Creates a union query, taking an array or a list of callbacks, builders, or raw statements to build the union statement, with optional boolean `wrap`.
-     * If the `wrap` parameter is true, the queries will be individually wrapped in parentheses.
+     * Creates a union query, takes one or more queries or SQL expressions.
      *
      * ```ts
-     * SomeTable.select('id', 'name').union(
-     *   [
-     *     OtherTable.select('id', 'name'),
-     *     sql`SELECT id, name FROM "thirdTable"`,
-     *   ],
-     *   true, // optional wrap parameter
-     * );
+     * // The first query of the union
+     * db.one
+     *   .select('id', 'name')
+     *   // add two more queries to the union
+     *   .union(
+     *     db.two.select('id', 'name'),
+     *     (q = q.sql`SELECT id, name FROM "thirdTable"`),
+     *   )
+     *   // sub-sequent `union` is equivalent to passing multiple queries into a single `union`
+     *   .union(db.three.select('id', 'name'));
      * ```
      *
-     * @param args - array of queries or raw SQLs
-     * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+     * `order`, `limit`, `offset` are special, it matters if you place them **before** or **after** the `union`, it also have a meaning to place them before and after.
+     *
+     * ```ts
+     * // order, limit, offset are applied ONLY to 'one'
+     * db.one
+     *   .order('x')
+     *   .limit(1)
+     *   .offset(1)
+     *   // 'two' also has order, limit, and offset
+     *   .unionAll(db.two.order('y').limit(2).offset(2))
+     *   // sets order, limit, offset for all records
+     *   .order('z')
+     *   .limit(3)
+     *   .offset(3);
+     * ```
+     *
+     * Equivalent SQL:
+     *
+     * ```sql
+     * -- both union parts have their own order, limit, offset
+     * ( SELECT * FROM one ORDER x ASC LIMIT 1 OFFSET 1 )
+     * UNION ALL
+     * ( SELECT * FROM two ORDER y ASC LIMIT 2 OFFSET 2 )
+     * -- order, limit, offset of the whole query
+     * ORDER BY z ASC LIMIT 3 OFFSET 3
+     * ```
+     *
+     * All the listed methods have the same signature, they are only different by SQL keyword:
+     *
+     * - `union` - union of all queries, performs deduplication
+     * - `unionAll` - `union` that allows duplicated rows
+     * - `intersect` - get only rows that are present in all queries
+     * - `intersectAll` - `intersect` that allows duplicated rows
+     * - `except` - get only rows that are in the first query but not in the second
+     * - `exceptAll` - `except` that allows duplicated rows
+     *
+     * @param args - array of queries or SQL expressions
      */
-    union<T extends PickQueryResult>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    union<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
     /**
-     * Same as `union`, but allows duplicated rows.
+     * Same as {@link union}, but allows duplicated rows.
      *
-     * @param args - array of queries or raw SQLs
-     * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+     * @param args - array of queries or SQL expressions
      */
-    unionAll<T extends PickQueryResult>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    unionAll<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
     /**
-     * Same as `union`, but uses a `INTERSECT` SQL keyword instead
+     * Same as {@link union}, but uses a `INTERSECT` SQL keyword instead
      *
-     * @param args - array of queries or raw SQLs
-     * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+     * @param args - array of queries or SQL expressions
      */
-    intersect<T extends PickQueryResult>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    intersect<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
     /**
-     * Same as `intersect`, but allows duplicated rows.
+     * Same as {@link intersect}, but allows duplicated rows.
      *
-     * @param args - array of queries or raw SQLs
-     * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+     * @param args - array of queries or SQL expressions
      */
-    intersectAll<T extends PickQueryResult>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    intersectAll<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
     /**
-     * Same as `union`, but uses an `EXCEPT` SQL keyword instead
+     * Same as {@link union}, but uses an `EXCEPT` SQL keyword instead
      *
-     * @param args - array of queries or raw SQLs
-     * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+     * @param args - array of queries or SQL expressions
      */
-    except<T extends PickQueryResult>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    except<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
     /**
-     * Same as `except`, but allows duplicated rows.
+     * Same as {@link except}, but allows duplicated rows.
      *
-     * @param args - array of queries or raw SQLs
-     * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+     * @param args - array of queries or SQL expressions
      */
-    exceptAll<T extends PickQueryResult>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    exceptAll<T extends PickQueryResult>(this: T, ...args: UnionArg<T>[]): T;
 }
 
 type UpdateSelf = {
-    [K in 'meta' | 'inputType' | 'relations' | 'shape' | 'result' | 'returnType' | keyof JsonModifiers]: Query[K];
+    [K in 'inputType' | 'relations' | UpdateColumnArgKeys]: Query[K];
 };
 type UpdateData<T extends UpdateSelf> = {
     [K in keyof T['inputType']]?: UpdateColumn<T, K>;
 } & {
     [K in keyof T['relations']]?: UpdateRelationData<T, T['relations'][K]['relationConfig']>;
 };
-type UpdateColumnArgKeys = keyof JsonModifiers | 'meta' | 'shape' | 'result' | 'returnType';
-type UpdateColumnCallbackResult = JsonItem | ResultRelationQueryBase;
-interface ResultRelationQueryBaseMeta extends QueryMetaBase {
-    kind: 'select';
-}
-interface ResultRelationQueryBase extends RelationQueryBase {
-    meta: ResultRelationQueryBaseMeta;
+type UpdateColumnArgKeys = keyof JsonModifiers | keyof ExpressionMethods | 'sql' | 'meta' | 'shape' | 'result' | 'returnType' | 'columnTypes';
+interface UpdateQueryOrExpression<T> extends QueryOrExpression<T> {
+    meta: {
+        kind: 'select';
+    };
 }
-type UpdateColumn<T extends UpdateSelf, Key extends keyof T['inputType']> = T['inputType'][Key] | Expression | {
+type UpdateColumn<T extends UpdateSelf, Key extends keyof T['inputType']> = T['inputType'][Key] | QueryOrExpression<T['inputType'][Key]> | {
     [K in keyof Query]: K extends 'then' ? QueryThen<T['inputType'][Key]> : Query[K];
 } | ((q: {
     [K in keyof T['relations'] | UpdateColumnArgKeys]: K extends keyof T['relations'] ? T['relations'][K] : K extends UpdateColumnArgKeys ? T[K] : never;
-}) => UpdateColumnCallbackResult);
+}) => JsonItem | UpdateQueryOrExpression<T['inputType'][Key]>);
 type UpdateRelationData<T extends UpdateSelf, Rel extends RelationConfigBase> = QueryReturnsAll<T['returnType']> extends true ? Rel['dataForUpdate'] : Rel['one'] extends true ? Rel['dataForUpdate'] | Rel['dataForUpdateOne'] : Rel['dataForUpdate'] & Rel['dataForUpdateOne'];
 type UpdateArg<T extends UpdateSelf> = T['meta']['hasWhere'] extends true ? UpdateData<T> : never;
 type UpdateRawArgs<T extends UpdateSelf> = T['meta']['hasWhere'] extends true ? SQLQueryArgs : never;
@@ -5330,7 +5529,7 @@ declare class Update {
      *   column1: 123,
      *
      *   // use raw SQL to update the column
-     *   column2: sql`2 + 2`,
+     *   column2: (q) => q.sql`2 + 2`,
      *
      *   // use query that returns a single value
      *   // returning multiple values will result in Postgres error
@@ -5439,7 +5638,7 @@ declare class Update {
      */
     update<T extends UpdateSelf>(this: T, arg: UpdateArg<T>): UpdateResult<T>;
     /**
-     * `updateRaw` is for updating records with raw expression.
+     * `updateSql` is for updating records with raw expression.
      *
      * The behavior is the same as a regular `update` method has:
      * `find` or `where` must precede calling this method,
@@ -5450,14 +5649,14 @@ declare class Update {
      * const value = 'new name';
      *
      * // update with SQL template string
-     * const updatedCount = await db.table.find(1).updateRaw`name = ${value}`;
+     * const updatedCount = await db.table.find(1).updateSql`name = ${value}`;
      *
      * // or update with `sql` function:
-     * await db.table.find(1).updateRaw(sql`name = ${value}`);
+     * await db.table.find(1).updateSql(sql`name = ${value}`);
      * ```
      * @param args - raw SQL via a template string or by using a `sql` method
      */
-    updateRaw<T extends UpdateSelf>(this: T, ...args: UpdateRawArgs<T>): UpdateResult<T>;
+    updateSql<T extends UpdateSelf>(this: T, ...args: UpdateRawArgs<T>): UpdateResult<T>;
     /**
      * To make sure that at least one row was updated use `updateOrThrow`:
      *
@@ -6026,150 +6225,6 @@ declare class QueryUpsertOrCreate {
     orCreate<T extends UpsertThis, BT extends CreateBelongsToData<T>>(this: T, data: OrCreateArg<T, BT>): UpsertResult<T>;
 }
 
-declare class SqlMethod<ColumnTypes> {
-    /**
-     * 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 custom SQL, specify a resulting type with `<generic>` syntax:
-     *
-     * ```ts
-     * import { sql } from './baseTable';
-     *
-     * const result: { num: number }[] = await db.table.select({
-     *   num: sql<number>`random() * 100`,
-     * });
-     * ```
-     *
-     * In a situation when you want the result to be parsed, such as when returning a timestamp that you want to be parsed into a `Date` object, provide a column type in such a way:
-     *
-     * This example assumes that the `timestamp` column was overridden with `asDate` as shown in [Override column types](/guide/columns-overview#override-column-types).
-     *
-     * ```ts
-     * import { sql } from './baseTable';
-     *
-     * const result: { timestamp: Date }[] = await db.table.select({
-     *   timestamp: sql`now()`.type((t) => t.timestamp()),
-     * });
-     * ```
-     *
-     * In some cases such as when using [from](/guide/orm-and-query-builder.html#from), setting column type via callback allows for special `where` operations:
-     *
-     * ```ts
-     * const subQuery = db.someTable.select({
-     *   sum: (q) => q.sql`$a + $b`.type((t) => t.decimal()).values({ a: 1, b: 2 }),
-     * });
-     *
-     * // `gt`, `gte`, `min`, `lt`, `lte`, `max` in `where`
-     * // are allowed only for numeric columns:
-     * const result = await db.$from(subQuery).where({ sum: { gte: 5 } });
-     * ```
-     *
-     * 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.whereSql`"someValue" = random() * 100`;
-     * ```
-     *
-     * Interpolating values in template literals is completely safe:
-     *
-     * ```ts
-     * // get value from user-provided params
-     * const { value } = req.params;
-     *
-     * // SQL injection is prevented by a library, this is safe:
-     * 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](/guide/sql-expressions#column) or [ref](/guide/sql-expressions#ref) to reference a column:
-     *
-     * ```ts
-     * // 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.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 { sql } from './baseTable';
-     *
-     * // no interpolation is okay
-     * 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(sql({ raw: `column = random() * ${value}` }));
-     * ```
-     *
-     * 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` 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(
-     *   sql<boolean>({
-     *     raw: '$$column = random() * $value',
-     *     values: {
-     *       column: 'someTable.someColumn', // or simply 'column'
-     *       one: value,
-     *       two: 123,
-     *     },
-     *   }),
-     * );
-     * ```
-     *
-     * Summarizing:
-     *
-     * ```ts
-     * import { sql } from './baseTable';
-     *
-     * // simplest form:
-     * sql`key = ${value}`;
-     *
-     * // with resulting type:
-     * sql<boolean>`key = ${value}`;
-     *
-     * // with column type for select:
-     * sql`key = ${value}`.type((t) => t.boolean());
-     *
-     * // with column name via `column` method:
-     * sql`${db.table.column('column')} = ${value}`;
-     *
-     * // raw SQL string, not allowed to interpolate values:
-     * sql({ raw: 'random()' });
-     *
-     * // with resulting type and `raw` string:
-     * sql<number>({ raw: 'random()' });
-     *
-     * // with column name and a value in a `raw` string:
-     * sql({
-     *   raw: `$$column = $value`,
-     *   values: { column: 'columnName', value: 123 },
-     * });
-     *
-     * // combine template literal, column type, and values:
-     * 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: 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;
 type QueryTransform<T extends QueryBase, Data> = {
     [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
@@ -6282,7 +6337,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, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, SqlMethod<ColumnTypes>, TransformMethods, ScopeMethods, SoftDeleteMethods, ExpressionMethods {
+interface QueryMethods<ColumnTypes> extends AsMethods, AggregateMethods, Select, FromMethods, Join, WithMethods, Union, JsonModifiers, JsonMethods, Create, Update, Delete, Transaction, For, Where, SearchMethods, Clear, Having, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, SqlMethod<ColumnTypes>, TransformMethods, ScopeMethods, SoftDeleteMethods, ExpressionMethods {
 }
 declare class QueryMethods<ColumnTypes> {
     /**
@@ -6690,10 +6745,7 @@ declare class QueryMethods<ColumnTypes> {
      *   pets: (q) => q.pets.join().none(),
      * });
      *
-     * await db.user.join(
-     *   (q) => q.pets.none(),
-     *   (q) => q,
-     * );
+     * await db.user.join((q) => q.pets.none());
      *
      * await db.user.join('pets', (q) => q.none());
      * ```
@@ -6936,6 +6988,8 @@ interface PickQueryColumnTypes {
 }
 interface PickQueryMetaResultRelationsWindowsColumnTypes extends PickQueryMetaResultRelationsWindows, PickQueryColumnTypes {
 }
+interface PickQueryWithDataColumnTypes extends PickQueryWithData, PickQueryColumnTypes {
+}
 interface PickQueryMetaTable extends PickQueryMeta, PickQueryTable {
 }
 interface PickQueryMetaTableShape extends PickQueryMetaTable, PickQueryShape {
@@ -7114,12 +7168,6 @@ type SetQueryTableAlias<T extends PickQueryMetaTableShape, As extends string> =
         } : T['meta'][K];
     } : T[K];
 };
-type SetQueryWith<T, WithData> = {
-    [K in keyof T]: K extends 'withData' ? WithData : T[K];
-};
-type AddQueryWith<T extends PickQueryWithData, With extends WithDataItem> = SetQueryWith<T, {
-    [K in keyof T['withData'] | With['table']]: K extends With['table'] ? With : K extends keyof T['withData'] ? T['withData'][K] : never;
-}>;
 interface QueryOrExpression<T> {
     result: {
         value: QueryColumn<T>;
@@ -7788,4 +7836,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, 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, 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, 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, QueryOrExpression, QueryOrExpressionBooleanOrNullResult, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RealColumn, RecordOfColumnsShapeBase, RefExpression, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, SearchArg, SearchMethods, SearchWeight, SearchWeightRecord, Select, SelectArg, SelectAs, SelectItem, SelectQueryData, SelectSubQueryResult, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryKindResult, SetQueryReturnsAll, SetQueryReturnsAllKind, SetQueryReturnsAllKindResult, SetQueryReturnsColumnInfo, SetQueryReturnsColumnKind, SetQueryReturnsColumnKindResult, SetQueryReturnsColumnOptional, SetQueryReturnsColumnOrThrow, SetQueryReturnsOne, SetQueryReturnsOneKind, SetQueryReturnsOneKindResult, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsPluckColumn, SetQueryReturnsPluckColumnKind, SetQueryReturnsPluckColumnKindResult, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValueOptional, SetQueryReturnsValueOrThrow, SetQueryReturnsVoid, SetQueryReturnsVoidKind, SetQueryTableAlias, 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 };
+export { Adapter, AdapterConfig, AdapterOptions, AddQueryDefaults, AddQuerySelect, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayColumnValue, ArrayData, AsMethods, AsQueryArg, BaseOperators, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanQueryColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, CloneSelfKeys, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfoQueryData, ColumnOperators, ColumnRefExpression, ColumnType, ColumnsByType, ColumnsShape, ColumnsShapeToNullableObject, ColumnsShapeToObject, ColumnsShapeToObjectArray, ColumnsShapeToPluck, CommonQueryData, ComputedColumnsBase, CopyOptions, CopyQueryData, Create, CreateBelongsToData, CreateColumn, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CreateRelationsData, CreateRelationsDataOmittingFKeys, CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbDomainArg, DbDomainArgRecord, DbExtension, DbOptions, DbResult, DbSharedOptions, DbTableConstructor, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultSchemaConfig, Delete, DeleteArgs, DeleteMethodsNames, DeleteQueryData, DeleteResult, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, EnumColumn, ExpressionMethods, ExpressionOutput, FnExpression, FnExpressionArgs, FnExpressionArgsPairs, FnExpressionArgsValue, For, FromArg, FromMethods, FromQuerySelf, FromResult, GetArg, GetColumnInfo, GetQueryResult, GetResult, GetResultOptional, GetStringArg, GroupArg, Having, HavingItem, HookAction, HookSelect, IdentityColumn, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinItemArgs, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinQueryBuilder, JoinQueryMethod, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MapTableScopesOption, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumnData, OnConflictMerge, OnConflictQueryBuilder, OnConflictSet, OnConflictTarget, OnMethods, Operator, Operators, OperatorsAny, OperatorsArray, OperatorsBoolean, OperatorsDate, OperatorsJson, OperatorsNumber, OperatorsText, OperatorsTime, OrCreateArg, OrExpression, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgSelf, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PickColumnData, PickQueryBaseQuery, PickQueryColumnTypes, PickQueryDataShapeAndJoinedShapes, PickQueryInternal, PickQueryMetaRelations, PickQueryMetaResultRelations, PickQueryMetaResultRelationsWindows, PickQueryMetaResultRelationsWindowsColumnTypes, PickQueryMetaResultRelationsWithDataReturnType, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryMetaResultReturnTypeWithDataWindows, PickQueryMetaResultReturnTypeWithDataWindowsTable, PickQueryMetaShapeRelationsWithData, PickQueryMetaTable, PickQueryMetaTableShape, PickQueryMetaTableShapeReturnTypeWithData, PickQueryMetaWithData, PickQueryQ, PickQueryQAndBaseQuery, PickQueryQAndInternal, PickQueryRelations, PickQueryRelationsWithData, PickQueryShapeResultSinglePrimaryKey, PickQueryShapeSinglePrimaryKey, PickQuerySinglePrimaryKey, PickQueryWindows, PickQueryWithData, PickQueryWithDataColumnTypes, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBaseThen, QueryBeforeHook, QueryData, QueryDataFromItem, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryInternal, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryOrExpression, QueryOrExpressionBooleanOrNullResult, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RealColumn, RecordOfColumnsShapeBase, RefExpression, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, SearchArg, SearchMethods, SearchWeight, SearchWeightRecord, Select, SelectArg, SelectAs, SelectItem, SelectQueryData, SelectSubQueryResult, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryKindResult, SetQueryReturnsAll, SetQueryReturnsAllKind, SetQueryReturnsAllKindResult, SetQueryReturnsColumnInfo, SetQueryReturnsColumnKind, SetQueryReturnsColumnKindResult, SetQueryReturnsColumnOptional, SetQueryReturnsColumnOrThrow, SetQueryReturnsOne, SetQueryReturnsOneKind, SetQueryReturnsOneKindResult, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsPluckColumn, SetQueryReturnsPluckColumnKind, SetQueryReturnsPluckColumnKindResult, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValueOptional, SetQueryReturnsValueOrThrow, SetQueryReturnsVoid, SetQueryReturnsVoidKind, SetQueryTableAlias, ShapeColumnPrimaryKeys, ShapeUniqueColumns, SimpleJoinItem, SimpleJoinItemNonSubQueryArgs, SmallIntColumn, SmallSerialColumn, SortDir, SqlFn, SqlMethod, StringColumn$1 as StringColumn, TableData, TableDataFn, TableDataInput, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TableDataMethods, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, ToSQLQuery, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnionSet, UniqueConstraints, UniqueQueryTypeOrExpression, UniqueTableDataItem, UnknownColumn, Update, UpdateArg, UpdateCtx, UpdateCtxCollect, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdateSelf, UpdatedAtDataInjector, UpsertArg, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereNotArgs, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, WithArgsOptions, WithDataBase, WithDataItem, WithDataItems, WithItem, WithMethods, WithOptions, WithQueryBuilder, WithRecursiveOptions, WithResult, WithSqlResult, WrapQueryArg, XMLColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryAs, _queryChangeCounter, _queryCreate, _queryCreateFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateManyRaw, _queryCreateRaw, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertManyRaw, _queryInsertRaw, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUnion, _queryUpdate, _queryUpdateOrThrow, _queryUpdateRaw, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotSql, _queryWhereSql, addComputedColumns, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, checkIfASimpleQuery, cloneQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, 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 };