pqb 0.27.0 → 0.27.2

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, QueryInternal, QueryMetaBase, QueryReturnType, QueryThen, Expression, QueryColumn, MaybeArray, SelectableBase, TemplateLiteralArgs, ColumnSchemaConfig, Code, PickOutputTypeAndOperators, PickQueryResult, OperatorToSQL, ColumnsShapeBase, ColumnsParsers, RecordString, PickQueryTable, getValueKey, PickQueryShape, EmptyTuple, PickQueryMeta, QueryColumnToNullable, PickQueryMetaResultReturnType, QueryCatch, PickQueryMetaShape, SQLQueryArgs, DateColumnData, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, StringTypeData, StaticSQLArgs, PickColumnBaseData, PrimaryKeyColumn, RawSQLBase, ColumnTypeBase, ForeignKeyTable, QueryColumnsInit, TimestampHelpers, ColumnNameOfTable, BaseNumberData, ColumnWithDefault, ParseColumn, EncodeColumn, PickQueryMetaResult, ColumnShapeOutput, DefaultSelectColumns, CoreQueryScopes, DbBase, TransactionState, PickQueryMetaResultWindows, CoreBaseOperators, IsQuery, PickQueryTableMetaResult, PickQueryMetaShapeResultReturnType, MergeObjects, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, PickQueryReturnType, PickType, PickOutputType, Spread, PickQueryTableMetaShape } from 'orchid-core';
+import { QueryResultRow, AdapterConfigBase, AdapterBase, QueryInput, Sql, RecordUnknown, RecordKeyTrue, EmptyObject, QueryBaseCommon, QueryColumns, QueryInternal, QueryMetaBase, QueryReturnType, QueryThen, Expression, QueryColumn, MaybeArray, SelectableBase, TemplateLiteralArgs, PickOutputTypeAndOperators, PickQueryResult, OperatorToSQL, ColumnsShapeBase, ColumnsParsers, RecordString, PickQueryTable, getValueKey, PickQueryShape, PickQueryTableMetaResult, EmptyTuple, PickQueryMeta, PickQueryMetaResultReturnType, QueryColumnToNullable, QueryCatch, PickQueryMetaShape, PickQueryTableMetaResultShape, QueryColumnBooleanOrNull, SQLQueryArgs, ColumnSchemaConfig, DateColumnData, Code, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, StringTypeData, StaticSQLArgs, PickColumnBaseData, PrimaryKeyColumn, RawSQLBase, ColumnTypeBase, ForeignKeyTable, QueryColumnsInit, TimestampHelpers, ColumnNameOfTable, BaseNumberData, ColumnWithDefault, ParseColumn, EncodeColumn, PickQueryMetaResult, ColumnShapeOutput, DefaultSelectColumns, CoreQueryScopes, DbBase, TransactionState, PickQueryMetaResultWindows, CoreBaseOperators, IsQuery, PickQueryMetaShapeResultReturnType, MergeObjects, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, PickQueryReturnType, PickType, PickOutputType, Spread, PickQueryTableMetaShape } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'node:util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -198,17 +198,37 @@ type QuerySourceItem = {
     tsQuery: string | Expression;
 });
 type JoinItem = SimpleJoinItem | JoinLateralItem;
+type SimpleJoinItemNonSubQueryArgs = [Record<string, string | Expression> | Expression | true] | [leftColumn: string | Expression, rightColumn: string | Expression] | [
+    leftColumn: string | Expression,
+    op: string,
+    rightColumn: string | Expression
+];
+type JoinItemArgs = {
+    j: Query;
+    s: boolean;
+    r?: Query;
+} | {
+    w: string;
+    r: Query;
+    s: boolean;
+} | {
+    w: string;
+    a: SimpleJoinItemNonSubQueryArgs;
+} | {
+    q: QueryWithTable;
+    s: boolean;
+} | {
+    q: QueryWithTable;
+    r: Query;
+    s: boolean;
+} | {
+    q: QueryWithTable;
+    a: SimpleJoinItemNonSubQueryArgs;
+    s: boolean;
+};
 interface SimpleJoinItem {
     type: string;
-    first: string | QueryWithTable;
-    args: [] | [
-        conditions: Record<string, string | Expression> | Expression | ((q: unknown) => QueryBase) | true
-    ] | [leftColumn: string | Expression, rightColumn: string | Expression] | [
-        leftColumn: string | Expression,
-        op: string,
-        rightColumn: string | Expression
-    ];
-    isSubQuery: boolean;
+    args: JoinItemArgs;
 }
 type JoinLateralItem = [type: string, joined: Query, as: string];
 type WhereItem = {
@@ -217,7 +237,7 @@ type WhereItem = {
     AND?: MaybeArray<WhereItem>;
     OR?: MaybeArray<WhereItem>[];
     IN?: MaybeArray<WhereInItem>;
-    EXISTS?: MaybeArray<SimpleJoinItem['args']>;
+    EXISTS?: MaybeArray<JoinItemArgs>;
     ON?: WhereOnItem | WhereJsonPathEqualsItem;
     SEARCH?: MaybeArray<WhereSearchItem>;
 } | ((q: unknown) => QueryBase | RelationQuery | Expression) | Query | Expression;
@@ -263,15 +283,6 @@ type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT
 type OnConflictItem = string | string[] | Expression;
 type OnConflictMergeUpdate = string | string[] | RecordUnknown | Expression;
 
-type BooleanQueryColumn = QueryColumn<boolean, OperatorsBoolean>;
-declare class BooleanColumn$1<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, boolean, ReturnType<Schema['boolean']>, OperatorsBoolean> {
-    dataType: "boolean";
-    operators: OperatorsBoolean;
-    constructor(schema: Schema);
-    toCode(t: string): Code;
-    parseItem: (input: string) => boolean;
-}
-
 interface Operator<Value, Column extends PickOutputTypeAndOperators = PickOutputTypeAndOperators> {
     <T extends PickQueryResult>(this: T, arg: Value): Omit<SetQueryReturnsColumnOrThrow<T, Column>, keyof T['result']['value']['operators']> & Column['operators'];
     _opType: Value;
@@ -576,12 +587,12 @@ type WithSelectable<T extends PickQueryWithData, W extends keyof T['withData']>
  * The first argument of all `join` and `joinLateral` methods.
  * See argument of {@link join}.
  */
-type JoinFirstArg<T extends PickQueryRelationsWithData> = Query | keyof T['relations'] | keyof T['withData'] | ((q: T['relations']) => Query);
+type JoinFirstArg<T extends PickQueryRelationsWithData> = PickQueryTableMetaResult | keyof T['relations'] | keyof T['withData'] | ((q: T['relations']) => PickQueryTableMetaResult);
 /**
  * Arguments of `join` methods (not `joinLateral`).
  * See {@link join}
  */
-type JoinArgs<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>> = [JoinCallback<T, Arg>] | (Arg extends Query ? 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>> = [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',
@@ -591,9 +602,11 @@ type JoinArgs<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFir
  * ```
  * And the selection becomes available to use in the `ON` and to select from the joined table.
  */
-type JoinSelectable<Q extends Query> = keyof Q['result'] | `${AliasOrTable<Q>}.${keyof Q['result'] & string}`;
-type JoinQueryArgs<T extends PickQueryMeta, Q extends Query> = [
-    conditions: Record<JoinSelectable<Q>, keyof T['meta']['selectable'] | Expression> | Expression | true
+type JoinSelectable<Q extends PickQueryTableMetaResult> = keyof Q['result'] | `${AliasOrTable<Q>}.${keyof Q['result'] & string}`;
+type JoinQueryArgs<T extends PickQueryMeta, Q extends PickQueryTableMetaResult> = [
+    conditions: {
+        [K in JoinSelectable<Q>]: keyof T['meta']['selectable'] | Expression;
+    } | Expression | true
 ] | [
     leftColumn: JoinSelectable<Q> | Expression,
     rightColumn: keyof T['meta']['selectable'] | Expression
@@ -603,7 +616,9 @@ type JoinQueryArgs<T extends PickQueryMeta, Q extends Query> = [
     rightColumn: keyof T['meta']['selectable'] | Expression
 ];
 type JoinWithArgs<T extends PickQueryMetaWithData, W extends keyof T['withData']> = [
-    conditions: Record<WithSelectable<T, W>, keyof T['meta']['selectable'] | Expression> | Expression
+    conditions: {
+        [K in WithSelectable<T, W>]: keyof T['meta']['selectable'] | Expression;
+    } | Expression
 ] | [
     leftColumn: WithSelectable<T, W> | Expression,
     rightColumn: keyof T['meta']['selectable'] | Expression
@@ -621,22 +636,22 @@ type JoinWithArgs<T extends PickQueryMetaWithData, W extends keyof T['withData']
  * @param RequireJoined - when false, joined table shape will be mapped to make all columns optional
  * @param RequireMain - when false, main table shape will be mapped to make all columns optional (for right and full join)
  */
-type JoinResult<T extends PickQueryMetaResultRelationsWithDataReturnType, Arg extends JoinFirstArg<T>, RequireJoined extends boolean, RequireMain extends boolean, Cb extends (q: never) => unknown = () => unknown, J extends {
-    table?: string;
-    meta: QueryMetaBase;
-    shape: QueryColumns;
-} = Arg extends Query ? Arg['meta']['hasSelect'] extends true ? {
+type JoinResult<T extends PickQueryMetaResultReturnType, R extends PickQueryTableMetaResult, RequireJoined, RequireMain> = RequireMain extends true ? JoinAddSelectable<T, JoinResultSelectable<R['result'], AliasOrTable<R>, RequireJoined>> : JoinOptionalMain<T, JoinResultSelectable<R['result'], AliasOrTable<R>, RequireJoined>>;
+/**
+ * Calls {@link JoinResult} with either callback result, if join has a callback,
+ * or with a query derived from the first join argument.
+ */
+type JoinResultFromArgs<T extends PickQueryMetaResultRelationsWithDataReturnType, Arg, Args, RequireJoined, RequireMain> = JoinResult<T, Args extends GenericJoinCallbackTuple ? ReturnType<Args[0]> : Arg extends PickQueryTableMetaResultShape ? Arg['meta']['hasSelect'] extends true ? Arg : {
     table: Arg['table'];
     meta: Arg['meta'];
-    shape: Arg['result'];
-} : Arg : Arg extends keyof T['relations'] ? T['relations'][Arg]['relationConfig']['query'] : Arg extends (q: never) => Query ? ReturnType<Arg> : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
+    result: Arg['shape'];
+} : Arg extends keyof T['relations'] ? T['relations'][Arg]['relationConfig']['query'] : Arg extends GenericJoinCallback ? ReturnType<Arg> : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
     table: T['withData'][Arg]['table'];
-    shape: T['withData'][Arg]['shape'];
-    meta: QueryBase['meta'];
-} : never : never, Selectable extends SelectableBase = JoinResultSelectable<J, RequireJoined, ReturnType<Cb>>> = RequireMain extends true ? JoinAddSelectable<T, Selectable> : JoinOptionalMain<T, Selectable>;
-type JoinResultFromArgs<T extends PickQueryMetaResultRelationsWithDataReturnType, Arg extends JoinFirstArg<T>, Args, RequireJoined extends boolean, RequireMain extends boolean> = Args extends [(q: never) => {
     meta: QueryMetaBase;
-}] ? JoinResult<T, Arg, RequireJoined, RequireMain, Args[0]> : JoinResult<T, Arg, RequireJoined, RequireMain>;
+    result: T['withData'][Arg]['shape'];
+} : never : never, RequireJoined, RequireMain>;
+type GenericJoinCallback = (q: never) => PickQueryTableMetaResult;
+type GenericJoinCallbackTuple = [GenericJoinCallback];
 /**
  * Result of all `joinLateral` methods.
  * Adds joined table columns from its 'result' to the 'selectable' of the query.
@@ -645,9 +660,7 @@ type JoinResultFromArgs<T extends PickQueryMetaResultRelationsWithDataReturnType
  * @param Arg - first arg of join, see {@link JoinFirstArg}
  * @param RequireJoined - when false, joined table shape will be mapped to make all columns optional
  */
-type JoinLateralResult<T extends PickQueryMeta, R extends QueryBase, RequireJoined extends boolean, Selectable extends SelectableBase = JoinResultSelectable<R, RequireJoined, {
-    meta: QueryMetaBase;
-}>> = JoinAddSelectable<T, Selectable>;
+type JoinLateralResult<T extends PickQueryMeta, Table extends string, Meta extends QueryMetaBase, Result extends QueryColumns, RequireJoined> = JoinAddSelectable<T, JoinResultSelectable<Result, Meta['as'] extends string ? Meta['as'] : Table, RequireJoined>>;
 /**
  * Build `selectable` type for joined table.
  *
@@ -659,30 +672,25 @@ type JoinLateralResult<T extends PickQueryMeta, R extends QueryBase, RequireJoin
  * The resulting selectable receives all joined table columns prefixed with the table name or alias,
  * and a star prefixed with the table name or alias to select all joined columns.
  */
-type JoinResultSelectable<J extends {
-    table?: string;
-    meta: QueryMetaBase;
-    shape: QueryColumns;
-}, RequireJoined extends boolean, CbResult, Result extends QueryColumns = RequireJoined extends true ? J['shape'] : {
-    [K in keyof J['shape']]: QueryColumnToNullable<J['shape'][K]>;
-}, As extends string = CbResult extends {
-    meta: {
-        as: string;
-    };
-} ? CbResult['meta']['as'] : AliasOrTable<J>> = {
+type JoinResultSelectable<Result extends QueryColumns, As extends string, RequireJoined> = (RequireJoined extends true ? {
     [K in keyof Result & string as `${As}.${K}`]: {
         as: K;
         column: Result[K];
     };
-} & {
+} : {
+    [K in keyof Result & string as `${As}.${K}`]: {
+        as: K;
+        column: QueryColumnToNullable<Result[K]>;
+    };
+}) & {
     [K in As as `${As}.*`]: {
         as: K;
-        column: RequireJoined extends true ? ColumnsShapeToObject<J['shape']> : ColumnsShapeToNullableObject<J['shape']>;
+        column: RequireJoined extends true ? ColumnsShapeToObject<Result> : ColumnsShapeToNullableObject<Result>;
     };
 };
-type JoinAddSelectable<T extends PickQueryMeta, Selectable extends SelectableBase> = {
-    [K in keyof T]: K extends 'meta' ? T['meta'] & {
-        selectable: Selectable;
+type JoinAddSelectable<T extends PickQueryMeta, Selectable> = {
+    [K in keyof T]: K extends 'meta' ? {
+        [K in keyof T['meta']]: K extends 'selectable' ? T['meta']['selectable'] & Selectable : T['meta'][K];
     } : T[K];
 };
 type JoinOptionalMain<T extends PickQueryMetaResultReturnType, Selectable extends SelectableBase> = {
@@ -693,43 +701,27 @@ type JoinOptionalMain<T extends PickQueryMetaResultReturnType, Selectable extend
                 column: QueryColumnToNullable<T['meta']['selectable'][K]['column']>;
             };
         } & Selectable : T['meta'][K];
-    } : K extends 'result' ? {
-        [K in keyof T['result']]: QueryColumnToNullable<T['result'][K]>;
-    } : K extends 'then' ? QueryThen<GetQueryResult<T, {
-        [K in keyof T['result']]: QueryColumnToNullable<T['result'][K]>;
-    }>> : K extends 'catch' ? QueryCatch<GetQueryResult<T, {
-        [K in keyof T['result']]: QueryColumnToNullable<T['result'][K]>;
-    }>> : T[K];
+    } : K extends 'result' ? NullableResult<T> : K extends 'then' ? QueryThen<GetQueryResult<T, NullableResult<T>>> : K extends 'catch' ? QueryCatch<GetQueryResult<T, NullableResult<T>>> : T[K];
+};
+type NullableResult<T extends PickQueryResult> = {
+    [K in keyof T['result']]: QueryColumnToNullable<T['result'][K]>;
 };
 /**
  * Map the `with` table first argument of `join` or `joinLateral` to a query type.
  * Constructs `selectable` based on `with` table shape, and adds generic types to conform the `QueryBase` type.
  */
-type JoinWithArgToQuery<With extends WithDataItem> = {
-    __isQuery: true;
-    q: QueryData;
+interface JoinWithArgToQuery<With extends WithDataItem> extends Query {
     table: With['table'];
-    clone<T>(this: T): T;
-    selectable: {
-        [K in keyof {
-            [K in keyof With['shape'] & string]: {
+    meta: QueryMetaBase & {
+        selectable: {
+            [K in keyof With['shape'] & string as `${With['table']}.${K}`]: {
                 as: K;
                 column: With['shape'][K];
             };
-        } & string as `${With['table']}.${K}`]: {
-            as: K;
-            column: With['shape'][K];
         };
     };
-    shape: With['shape'];
     result: With['shape'];
-    baseQuery: Query;
-    relations: RelationsBase;
-    withData: WithDataBase;
-    meta: QueryBase['meta'];
-    internal: QueryInternal;
-    returnType: QueryReturnType;
-};
+}
 /**
  * Map the first argument of `join` or `joinLateral` to a query type.
  *
@@ -737,7 +729,8 @@ type JoinWithArgToQuery<With extends WithDataItem> = {
  * query arg is returned as is,
  * relation name is replaced with a relation table.
  */
-type JoinArgToQuery<T extends PickQueryRelationsWithData, Arg extends JoinFirstArg<T>> = Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? JoinWithArgToQuery<T['withData'][Arg]> : never : Arg extends Query ? Arg : Arg extends keyof T['relations'] ? T['relations'][Arg]['relationConfig']['query'] : never;
+type JoinArgToQuery<T extends PickQueryRelationsWithData, Arg extends JoinFirstArg<T>> = Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? JoinWithArgToQuery<T['withData'][Arg]> : never : Arg extends PickQueryTableMetaResult ? Arg : Arg extends keyof T['relations'] ? T['relations'][Arg]['relationConfig']['query'] : Arg extends JoinArgToQueryCallback ? ReturnType<Arg> : never;
+type JoinArgToQueryCallback = (...args: any[]) => PickQueryTableMetaResult;
 /**
  * Type of the `join` callback (not `joinLateral`).
  *
@@ -747,7 +740,7 @@ type JoinArgToQuery<T extends PickQueryRelationsWithData, Arg extends JoinFirstA
  *
  * Callback must return a query builder.
  */
-type JoinCallback<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>> = (q: OnQueryBuilder<T, JoinArgToQuery<T, Arg>>) => OnQueryBuilder;
+type JoinCallback<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>> = (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => PickQueryTableMetaResult;
 /**
  * Type of the `joinLateral`.
  *
@@ -758,7 +751,14 @@ type JoinCallback<T extends PickQueryMetaShapeRelationsWithData, Arg extends Joi
  *
  * The callback must return a query object. Its resulting type will become a type of the joined table.
  */
-type JoinLateralCallback<T extends QueryBase, Arg extends JoinFirstArg<T>, R extends QueryBase> = (q: JoinArgToQuery<T, Arg> & OnQueryBuilder<T, JoinArgToQuery<T, Arg>>) => R;
+type JoinLateralCallback<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>, Table extends string, Meta extends QueryMetaBase, Result extends QueryColumns> = (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => {
+    table: Table;
+    meta: Meta;
+    result: Result;
+};
+/**
+ * Type of {@link Join.join} query method.
+ */
 type JoinQueryMethod = <T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args) => JoinResultFromArgs<T, Arg, Args, true, true>;
 declare class Join {
     /**
@@ -922,7 +922,7 @@ declare class Join {
      *
      * Optionally, you can pass a second callback argument, it makes `on` and `orOn` methods available.
      *
-     * But remember that when joining a relation, the needed `ON` conditions are already handled automatically.
+     * But remember that when joining a relation, the relevant `ON` conditions are already handled automatically.
      *
      * ```ts
      * const result = await db.user.join(
@@ -1095,8 +1095,6 @@ declare class Join {
      * );
      * ```
      *
-     * Join query builder supports all `where` methods: `.where`, `.whereIn`, `.whereExists`, and all `.or`, `.not`, and `.orNot` forms.
-     *
      * Column names in the where conditions are applied for the joined table, but you can specify a table name to add a condition for the main table.
      *
      * ```ts
@@ -1151,10 +1149,35 @@ declare class Join {
      * ) "t" ON "t"."userId" = "user"."id"
      * ```
      *
+     * ## implicit join lateral
+     *
+     * `JOIN`'s source expression that comes before `ON` cannot access other tables, but in some cases this may be needed.
+     *
+     * For example, let's consider joining last 10 messages of a user:
+     *
+     * ```ts
+     * await db.user.join('messages', (q) => q.order({ createdAt: 'DESC' }).limit(10));
+     * ```
+     *
+     * When the `join`'s callback returns a more complex query than the one that simply applies certain conditions,
+     * it will implicitly generate a `JOIN LATERAL` SQL query, as the following:
+     *
+     * ```sql
+     * SELECT *
+     * FROM "user"
+     * JOIN LATERAL (
+     *   SELECT *
+     *   FROM "message" AS "messages"
+     *   WHERE "message"."userId" = "user"."id"
+     *   ORDER BY "message"."createdAt" DESC
+     *   LIMIT 10
+     * ) "messages" ON true
+     * ```
+     *
      * @param arg - {@link JoinFirstArg}
      * @param args - {@link JoinArgs}
      */
-    join<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<T, Arg, Args, true, true>;
+    join<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<T, Arg, Args, true, true>;
     /**
      * `leftJoin` is a method for SQL `LEFT JOIN`, which is equivalent to `OUTER JOIN`, `LEFT OUTER JOIN`.
      *
@@ -1179,7 +1202,7 @@ declare class Join {
      * @param arg - {@link JoinFirstArg}
      * @param args - {@link JoinArgs}
      */
-    leftJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<T, Arg, Args, false, true>;
+    leftJoin<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<T, Arg, Args, false, true>;
     /**
      * `rightJoin` is a method for SQL `RIGHT JOIN`, which is equivalent to `RIGHT OUTER JOIN`.
      *
@@ -1201,7 +1224,7 @@ declare class Join {
      * @param arg - {@link JoinFirstArg}
      * @param args - {@link JoinArgs}
      */
-    rightJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<T, Arg, Args, true, false>;
+    rightJoin<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<T, Arg, Args, true, false>;
     /**
      * `fullJoin` is a method for SQL `FULL JOIN`, which is equivalent to `FULL OUTER JOIN`.
      *
@@ -1223,18 +1246,16 @@ declare class Join {
      * @param arg - {@link JoinFirstArg}
      * @param args - {@link JoinArgs}
      */
-    fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<T, Arg, Args, false, false>;
+    fullJoin<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<T, Arg, Args, false, false>;
     /**
      * `joinLateral` allows joining a table with a sub-query that can reference the main table of current query and the other joined tables.
      *
-     * Regular `JOIN` also can have a sub-query in its definition, but it cannot reference other tables of this query.
-     *
-     * `JOIN LATERAL` of Postgres can have conditions in the `ON` statement, but `Orchid ORM` decided that there are no useful use-cases for such conditions, and it is only building a sub-query.
-     *
      * First argument is the other table you want to join, or a name of relation, or a name of `with` defined table.
      *
      * Second argument is a callback where you can reference other tables using `on` and `orOn`, select columns, do `where` conditions, and use any other query methods to build a sub-query.
      *
+     * Note that the regular `join` will also generate `JOIN LATERAL` SQL expression when the query returned from callback is complex enough (see the bottom of {@link join} description).
+     *
      * ```ts
      * // joinLateral a Message table, alias it as `m`
      * // without aliasing you can refer to the message by a table name
@@ -1291,7 +1312,7 @@ declare class Join {
      * @param arg - {@link JoinFirstArg}
      * @param cb - {@link JoinLateralCallback}
      */
-    joinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, true>;
+    joinLateral<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Table extends string, Meta extends QueryMetaBase, Result extends QueryColumns>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, Table, Meta, Result>): JoinLateralResult<T, Table, Meta, Result, true>;
     /**
      * The same as {@link joinLateral}, but when no records found for the join it will result in `null`:
      *
@@ -1307,47 +1328,41 @@ declare class Join {
      * @param arg - {@link JoinFirstArg}
      * @param cb - {@link JoinLateralCallback}
      */
-    leftJoinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, false>;
+    leftJoinLateral<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Table extends string, Meta extends QueryMetaBase, Result extends QueryColumns>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, Table, Meta, Result>): JoinLateralResult<T, Table, Meta, Result, false>;
 }
-type OnArgs<Q extends {
-    meta: {
-        selectable: SelectableBase;
-    };
-}> = [
-    leftColumn: keyof Q['meta']['selectable'],
-    rightColumn: keyof Q['meta']['selectable']
-] | [
-    leftColumn: keyof Q['meta']['selectable'],
-    op: string,
-    rightColumn: keyof Q['meta']['selectable']
-];
-declare const pushQueryOn: <T extends QueryBase<orchid_core.EmptyObject>>(q: T, joinFrom: QueryBase, joinTo: QueryBase, ...on: OnArgs<QueryBase>) => T;
-declare const pushQueryOrOn: typeof pushQueryOn;
-declare const addQueryOn: <T extends QueryBase<orchid_core.EmptyObject>>(q: T, joinFrom: QueryBase, joinTo: QueryBase, ...args: OnArgs<QueryBase>) => T;
-type OnJsonPathEqualsArgs<T extends QueryBase> = [
-    leftColumn: keyof T['meta']['selectable'],
+type OnArgs<S extends SelectableBase> = [leftColumn: keyof S, rightColumn: keyof S] | [leftColumn: keyof S, op: string, rightColumn: keyof S];
+declare const pushQueryOn: <T extends PickQueryMeta>(q: T, joinFrom: PickQueryMeta, joinTo: PickQueryMeta, ...on: OnArgs<SelectableBase>) => T;
+declare const pushQueryOrOn: <T extends PickQueryMeta>(q: T, joinFrom: PickQueryMeta, joinTo: PickQueryMeta, ...on: OnArgs<SelectableBase>) => PickQueryQ;
+declare const addQueryOn: <T extends PickQueryMeta>(q: T, joinFrom: PickQueryMeta, joinTo: PickQueryMeta, ...args: OnArgs<SelectableBase>) => T;
+type OnJsonPathEqualsArgs<S extends SelectableBase> = [
+    leftColumn: keyof S,
     leftPath: string,
-    rightColumn: keyof T['meta']['selectable'],
+    rightColumn: keyof S,
     rightPath: string
 ];
-declare const _queryJoinOn: <T extends OnQueryBuilder<QueryBase<orchid_core.EmptyObject>, JBase>>(q: T, args: OnArgs<T>) => T;
-declare const _queryJoinOrOn: <T extends OnQueryBuilder<QueryBase<orchid_core.EmptyObject>, JBase>>(q: T, args: OnArgs<T>) => T;
-declare const _queryJoinOnJsonPathEquals: <T extends OnQueryBuilder<QueryBase<orchid_core.EmptyObject>, JBase>>(q: T, args: OnJsonPathEqualsArgs<T>) => T;
-interface JBase {
-    relations: RelationsBase;
-    result: QueryColumns;
-    shape: QueryColumns;
-    meta: QueryMetaBase;
-    table?: string;
-}
-declare class OnQueryBuilder<S extends PickQueryMetaShape = QueryBase, J extends JBase = JBase> extends WhereQueryBase {
-    selectable: J['meta']['selectable'] & Omit<S['meta']['selectable'], keyof S['shape']>;
-    relations: J['relations'];
-    result: J['result'];
-    table: J['table'];
-    shape: J['shape'];
-    withData: {};
-    constructor(q: QueryBase, { shape, joinedShapes }: PickQueryDataShapeAndJoinedShapes, joinTo: QueryDataJoinTo);
+/**
+ * Mutative {@link OnMethods.on}
+ */
+declare const _queryJoinOn: <T extends PickQueryMeta>(q: T, args: OnArgs<T['meta']['selectable']>) => T;
+/**
+ * Mutative {@link OnMethods.orOn}
+ */
+declare const _queryJoinOrOn: <T extends PickQueryMeta>(q: T, args: OnArgs<T['meta']['selectable']>) => T;
+/**
+ * Mutative {@link OnMethods.onJsonPathEquals}
+ */
+declare const _queryJoinOnJsonPathEquals: <T extends PickQueryMeta>(q: T, args: OnJsonPathEqualsArgs<T["meta"]["selectable"]>) => T;
+/**
+ * Argument of join callback.
+ * It is a query object of table that you're joining, with ability to select main table's columns.
+ * Adds {@link OnMethods.on} method and similar to the query.
+ */
+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];
+    } : J[K];
+} & OnMethods;
+declare class OnMethods {
     /**
      * Use `on` to specify columns to join records.
      *
@@ -1367,13 +1382,13 @@ declare class OnQueryBuilder<S extends PickQueryMetaShape = QueryBase, J extends
      *
      * @param args - columns to join with
      */
-    on<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
+    on<T extends PickQueryMeta>(this: T, ...args: OnArgs<T['meta']['selectable']>): T;
     /**
      * Works as {@link on}, but the added conditions will be separated from previous with `OR`.
      *
      * @param args - columns to join with
      */
-    orOn<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
+    orOn<T extends PickQueryMeta>(this: T, ...args: OnArgs<T['meta']['selectable']>): T;
     /**
      * Use `onJsonPathEquals` to join record based on a field of their JSON column:
      *
@@ -1386,7 +1401,7 @@ declare class OnQueryBuilder<S extends PickQueryMetaShape = QueryBase, J extends
      *
      * @param args - columns and JSON paths to join with.
      */
-    onJsonPathEquals<T extends OnQueryBuilder>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
+    onJsonPathEquals<T extends PickQueryMeta>(this: T, ...args: OnJsonPathEqualsArgs<T['meta']['selectable']>): T;
 }
 
 type WhereArg<T extends PickQueryMetaRelations> = {
@@ -1394,7 +1409,7 @@ type WhereArg<T extends PickQueryMetaRelations> = {
         columns: (keyof T['meta']['selectable'])[];
         values: unknown[][] | QueryBase | Expression;
     }> : T['meta']['selectable'][K]['column']['queryType'] | null | ColumnOperators<T['meta']['selectable'], K> | Expression | QueryBase;
-} | QueryBase | Expression<QueryColumn<boolean | null>> | ((q: WhereQueryBuilder<T>) => ExpressionOrQueryReturning<boolean | null> | WhereQueryBuilder<T>);
+} | QueryBase | Expression<QueryColumnBooleanOrNull> | ((q: WhereQueryBuilder<T>) => QueryColumnBooleanOrNull | QueryBaseThen<boolean | null> | WhereQueryBuilder<T>);
 /**
  * Callback argument of `where`.
  * It has `where` methods (`where`, `whereNot`, `whereExists`, etc.),
@@ -1427,41 +1442,38 @@ interface QueryMetaHasWhere {
         hasWhere: true;
     };
 }
+/**
+ * Mutative {@link Where.where}
+ */
 declare const _queryWhere: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => WhereResult<T>;
+/**
+ * Mutative {@link Where.whereSql}
+ */
 declare const _queryWhereSql: <T>(q: T, args: SQLQueryArgs) => T;
 /**
- * Adds `where` arguments to query data with a `NOT` keyword:
- * SQL template string is added as `RawSQL` object, other arguments are added as is.
- *
- * @param q - query object to add the data to
- * @param args - `where` arguments
+ * Mutative {@link Where.whereNot}
  */
 declare const _queryWhereNot: <T extends PickQueryMetaRelations>(q: T, args: WhereNotArgs<T>) => WhereResult<T>;
+/**
+ * Mutative {@link Where.whereNotSql}
+ */
 declare const _queryWhereNotSql: <T>(q: T, args: SQLQueryArgs) => T;
 /**
- * Adds `where` arguments to query data. Arguments will be separated from each other with `OR`.
- *
- * @param q - query object to add the data to
- * @param args - `where` arguments
+ * Mutative {@link Where.orWhere}
  */
 declare const _queryOr: <T extends PickQueryMetaRelations>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
 /**
- * Adds `where` arguments to query data with a `NOT` keyword. Arguments will be separated from each other with `OR`.
- *
- * @param q - query object to add the data to
- * @param args - `where` arguments, may be a template literal
+ * Mutative {@link Where.orWhereNot}
  */
 declare const _queryOrNot: <T extends PickQueryMetaRelations>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
 /**
- * Process arguments of `whereIn` to add them to query data properly.
- *
- * @param q - query object to add the data to.
- * @param and - `true` to join arguments with `AND`, `false` to join them with `OR.
- * @param arg - `whereIn` argument: can be a single column name, tuple of column names, or object with column names and values.
- * @param values - if the `arg` is a column name or a tuple, `values` are the values for the column/columns. If `arg` is an object, `values` are `undefined`.
- * @param not - adds the `NOT` keyword.
+ * Mutative {@link Where.whereIn}
  */
 declare const _queryWhereIn: <T>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | Expression | undefined, not?: boolean) => WhereResult<T>;
+/**
+ * Mutative {@link Where.whereExists}
+ */
+declare const _queryWhereExists: <T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>>(q: T, arg: Arg, args: JoinArgs<T, Arg>) => WhereResult<T>;
 declare class Where {
     /**
      * Constructing `WHERE` conditions:
@@ -2036,10 +2048,6 @@ declare class Where {
      */
     orWhereNotExists<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
 }
-interface WhereQueryBase extends Where, QueryBase {
-}
-declare abstract class WhereQueryBase extends QueryBase {
-}
 
 interface ScopeArgumentQueryMeta<Table extends string | undefined, Shape extends QueryColumns> extends QueryMetaBase {
     selectable: SelectableFromShape<Shape, Table>;
@@ -2416,6 +2424,14 @@ declare class CitextColumn<Schema extends ColumnSchemaConfig> extends TextBaseCo
     toCode(t: string): Code;
 }
 
+declare class BooleanColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, boolean, ReturnType<Schema['boolean']>, OperatorsBoolean> {
+    dataType: "boolean";
+    operators: OperatorsBoolean;
+    constructor(schema: Schema);
+    toCode(t: string): Code;
+    parseItem: (input: string) => boolean;
+}
+
 declare class CustomTypeColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, unknown, ReturnType<Schema['unknown']>, typeof Operators.any> {
     dataType: string;
     operators: OperatorsAny;
@@ -2507,7 +2523,7 @@ interface DefaultColumnTypes<SchemaConfig extends ColumnSchemaConfig> extends Ti
     timestamp: SchemaConfig['timestamp'];
     time(precision?: number): TimeColumn<SchemaConfig>;
     interval(fields?: string, precision?: number): IntervalColumn<SchemaConfig>;
-    boolean(): BooleanColumn$1<SchemaConfig>;
+    boolean(): BooleanColumn<SchemaConfig>;
     point(): PointColumn<SchemaConfig>;
     line(): LineColumn<SchemaConfig>;
     lseg(): LsegColumn<SchemaConfig>;
@@ -2790,7 +2806,6 @@ interface Db<Table extends string | undefined = undefined, Shape extends QueryCo
     new (adapter: Adapter, queryBuilder: Db<Table, Shape, Relations, ColumnTypes>, table?: Table, shape?: Shape, options?: DbTableOptions<Table, ShapeWithComputed>): this;
     result: Pick<Shape, DefaultSelectColumns<Shape>[number]>;
     queryBuilder: Db;
-    onQueryBuilder: Query['onQueryBuilder'];
     primaryKeys: Query['primaryKeys'];
     returnType: Query['returnType'];
     then: QueryThen<QueryDefaultReturnData<Shape>>;
@@ -2982,9 +2997,8 @@ declare const makeSQL: (table: ToSQLQuery, options?: ToSqlOptionsInternal) => Sq
 declare function pushLimitSQL(sql: string[], values: unknown[], q: SelectQueryData): void;
 
 type AliasOrTable<T extends PickQueryMetaTable> = T['meta']['as'] extends string ? T['meta']['as'] : T['table'] extends string ? T['table'] : never;
-type SelectableOrExpression<T extends PickQueryMeta = QueryBase, C extends QueryColumn = QueryColumn> = '*' | keyof T['meta']['selectable'] | Expression<C>;
+type SelectableOrExpression<T extends PickQueryMeta = PickQueryMeta, C extends QueryColumn = QueryColumn> = '*' | keyof T['meta']['selectable'] | Expression<C>;
 type ExpressionOutput<T extends PickQueryMeta, Expr extends SelectableOrExpression<T>> = Expr extends keyof T['meta']['selectable'] ? T['meta']['selectable'][Expr]['column'] : Expr extends Expression ? Expr['_type'] : never;
-type ExpressionOrQueryReturning<T> = Expression<QueryColumn<T>> | QueryBaseThen<T>;
 declare const getClonedQueryData: (query: QueryData) => QueryData;
 declare const getQueryAs: (q: {
     table?: string | undefined;
@@ -3045,7 +3059,7 @@ declare class FnExpression<Q extends Query = Query, T extends QueryColumn = Quer
     makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
 }
 type ColumnExpression<C extends QueryColumn, Ops extends BaseOperators = C['operators']> = Expression<C> & {
-    [K in keyof Ops]: (arg: Ops[K]['_opType']) => ColumnExpression<QueryColumn<boolean | null>>;
+    [K in keyof Ops]: (arg: Ops[K]['_opType']) => ColumnExpression<QueryColumnBooleanOrNull>;
 };
 declare const makeExpression: <T extends Query, C extends ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>(self: T, expr: Expression) => SetQueryReturnsColumnOrThrow<T, C> & C['operators'];
 declare function makeFnExpression<T extends PickQueryMetaResultRelationsWindows, C extends QueryColumn>(self: T, type: C, fn: string, args: FnExpressionArgs<Query>, options?: AggregateOptions<T>): SetQueryReturnsColumnOrThrow<T, C> & C['operators'];
@@ -3066,7 +3080,7 @@ type CountReturn<T> = QueryReturnsAgg<T, number, OperatorsNumber> & {
 type NumberColumn = QueryColumn<number, OperatorsNumber>;
 type NumberNullable = QueryColumn<number | null, OperatorsNumber>;
 type NullableNumberReturn<T> = SetQueryReturnsColumnOrThrow<T, NumberNullable> & OperatorsNumber;
-type BooleanColumn = QueryColumn<boolean, OperatorsBoolean>;
+type BooleanQueryColumn = QueryColumn<boolean, OperatorsBoolean>;
 type BooleanNullable = QueryColumn<boolean | null, OperatorsBoolean>;
 type NullableBooleanReturn<T> = SetQueryReturnsColumnOrThrow<T, BooleanNullable> & OperatorsBoolean;
 type NullableJSONAggReturn<T extends PickQueryMeta, Arg extends SelectableOrExpression<T>> = SetQueryReturnsColumnOrThrow<T, {
@@ -3140,7 +3154,7 @@ declare class AggregateMethods {
      * const exists: boolean = await db.table.where(...conditions).exists();
      * ```
      */
-    exists<T extends QueryGetSelf>(this: T): SetQueryReturnsColumnOrThrow<T, BooleanColumn>;
+    exists<T extends QueryGetSelf>(this: T): SetQueryReturnsColumnOrThrow<T, BooleanQueryColumn>;
     /**
      * Count records with the `count` function:
      *
@@ -3308,7 +3322,7 @@ declare class AggregateMethods {
      * @param arg - boolean column or raw SQL
      * @param options - aggregation options
      */
-    boolAnd<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableOrExpressionOfType<T, BooleanColumn>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
+    boolAnd<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableOrExpressionOfType<T, BooleanQueryColumn>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
     /**
      * Aggregate booleans with `or` logic, it returns `boolean` or `null` if there are no records.
      *
@@ -3329,11 +3343,11 @@ declare class AggregateMethods {
      * @param arg - boolean column or raw SQL
      * @param options - aggregation options
      */
-    boolOr<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableOrExpressionOfType<T, BooleanColumn>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
+    boolOr<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableOrExpressionOfType<T, BooleanQueryColumn>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
     /**
      * Equivalent to {@link boolAnd}
      */
-    every<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableOrExpressionOfType<T, BooleanColumn>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
+    every<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableOrExpressionOfType<T, BooleanQueryColumn>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
     /**
      * Aggregate values into an array by using `json_agg`. Returns array of values or `null` if there are no records.
      *
@@ -4667,7 +4681,7 @@ type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = {
         [K in Columns[number] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
     }) & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : T[K];
 } & QueryMetaHasSelect;
-type SelectResultObj<T extends SelectSelf, Obj extends SelectAsArg<T>> = {
+type SelectResultObj<T extends SelectSelf, Obj> = {
     [K in keyof T]: K extends 'meta' ? T['meta'] & {
         selectable: SelectAsSelectable<Obj>;
     } : K extends 'result' ? {
@@ -4678,7 +4692,7 @@ type SelectResultObj<T extends SelectSelf, Obj extends SelectAsArg<T>> = {
         [K in keyof Obj | (T['meta']['hasSelect'] extends true ? keyof T['result'] : never)]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
     }>> : T[K];
 } & QueryMetaHasSelect;
-type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj extends SelectAsArg<T>> = {
+type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = {
     [K in keyof T]: K extends 'meta' ? T['meta'] & {
         selectable: SelectAsSelectable<Obj>;
     } : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
@@ -6497,6 +6511,13 @@ declare class QueryMethods<ColumnTypes> {
 declare function queryJson<T>(self: T, coalesce?: boolean): SetQueryReturnsColumnOptional<T, QueryColumn<string>>;
 
 declare function queryWrap<T extends PickQueryTableMetaResult, Q extends WrapQueryArg, As extends string = 't'>(self: T, query: Q, as?: As): SetQueryTableAlias<Q, As>;
+/**
+ * This function is useful when wrapping a query,
+ * such as when doing `SELECT json_agg(t.*) FROM (...) AS t`,
+ * to get rid of default scope conditions (WHERE deletedAt IS NULL)
+ * that otherwise would be duplicated inside the `FROM` and after `AS t`.
+ */
+declare function cloneQueryBaseUnscoped(query: Query): Query;
 
 type SelectableFromShape<Shape extends QueryColumns, Table extends string | undefined> = {
     [K in keyof Shape]: {
@@ -6520,7 +6541,6 @@ type WithDataBase = EmptyObject;
 interface Query extends QueryBase, QueryMethods<unknown> {
     queryBuilder: Db;
     columnTypes: unknown;
-    onQueryBuilder: typeof OnQueryBuilder;
     shape: QueryColumns;
     singlePrimaryKey: string;
     primaryKeys: string[];
@@ -7235,4 +7255,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$1 as 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, CreateColumn, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CreateRelationsData, CreateRelationsDataOmittingFKeys, CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableConstructor, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultSchemaConfig, Delete, DeleteArgs, DeleteMethodsNames, DeleteQueryData, DeleteResult, DomainColumn, DoublePrecisionColumn, DropMode, DynamicRawSQL, EnumColumn, ExpressionOrQueryReturning, ExpressionOutput, FnExpression, FnExpressionArgs, FnExpressionArgsPairs, FnExpressionArgsValue, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArg, FromArgOptions, FromQuerySelf, FromResult, GetArg, GetColumnInfo, GetQueryResult, GetResult, GetResultOptional, GetStringArg, GroupArg, Having, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinQueryMethod, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MapTableScopesOption, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumnData, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, 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, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, RelationsChain, SearchArg, SearchMethods, SearchWeight, Select, SelectArg, SelectAs, SelectItem, SelectQueryData, SelectSubQueryResult, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryReturnsAll, SetQueryReturnsAllKind, SetQueryReturnsColumnInfo, SetQueryReturnsColumnKind, SetQueryReturnsColumnOptional, SetQueryReturnsColumnOrThrow, SetQueryReturnsOne, SetQueryReturnsOneKind, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsPluckColumn, SetQueryReturnsPluckColumnKind, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValueOptional, SetQueryReturnsValueOrThrow, SetQueryReturnsVoid, SetQueryReturnsVoidKind, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SingleColumnIndexOptionsForColumn, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn$1 as StringColumn, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, ToSQLQuery, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateArg, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdateSelf, UpdatedAtDataInjector, UpsertArg, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereNotArgs, WhereOnItem, WhereOnJoinItem, WhereQueryBase, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithDataItems, WithItem, WithOptions, WrapQueryArg, XMLColumn, _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, _queryWhereIn, _queryWhereNot, _queryWhereNotSql, _queryWhereSql, addComputedColumns, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, checkIfASimpleQuery, cloneQuery, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, constraintPropsToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, foreignKeyArgumentToCode, getClonedQueryData, getColumnInfo, getColumnTypes, getConstraintKind, getQueryAs, getShapeFromSelect, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeExpression, makeFnExpression, makeRegexToFindInSql, makeSQL, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushLimitSQL, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quote, quoteString, raw, referencesArgsToCode, resetTableData, resolveSubQueryCallback, saveSearchAlias, setParserForSelectedString, setQueryObjectValue, setQueryOperators, simplifyColumnDefault, sqlQueryArgsToExpression, 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, CreateColumn, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CreateRelationsData, CreateRelationsDataOmittingFKeys, CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableConstructor, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultSchemaConfig, Delete, DeleteArgs, DeleteMethodsNames, DeleteQueryData, DeleteResult, DomainColumn, DoublePrecisionColumn, DropMode, DynamicRawSQL, EnumColumn, ExpressionOutput, FnExpression, FnExpressionArgs, FnExpressionArgsPairs, FnExpressionArgsValue, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArg, FromArgOptions, FromQuerySelf, FromResult, GetArg, GetColumnInfo, GetQueryResult, GetResult, GetResultOptional, GetStringArg, GroupArg, Having, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, 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, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, 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, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, RelationsChain, SearchArg, SearchMethods, SearchWeight, Select, SelectArg, SelectAs, SelectItem, SelectQueryData, SelectSubQueryResult, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryReturnsAll, SetQueryReturnsAllKind, SetQueryReturnsColumnInfo, SetQueryReturnsColumnKind, SetQueryReturnsColumnOptional, SetQueryReturnsColumnOrThrow, SetQueryReturnsOne, SetQueryReturnsOneKind, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsPluckColumn, SetQueryReturnsPluckColumnKind, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValueOptional, SetQueryReturnsValueOrThrow, SetQueryReturnsVoid, SetQueryReturnsVoidKind, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SimpleJoinItemNonSubQueryArgs, SingleColumnIndexOptions, SingleColumnIndexOptionsForColumn, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn$1 as StringColumn, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, ToSQLQuery, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateArg, UpdateCtx, 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, _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, constraintPropsToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, foreignKeyArgumentToCode, getClonedQueryData, getColumnInfo, getColumnTypes, getConstraintKind, getQueryAs, getShapeFromSelect, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeExpression, makeFnExpression, makeRegexToFindInSql, makeSQL, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushLimitSQL, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quote, quoteString, raw, referencesArgsToCode, resetTableData, resolveSubQueryCallback, saveSearchAlias, setParserForSelectedString, setQueryObjectValue, setQueryOperators, simplifyColumnDefault, sqlQueryArgsToExpression, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };