pqb 0.58.3 → 0.58.4

package/dist/index.d.ts

@@ -247,13 +247,13 @@ declare const _addToHookSelect: (query: IsQuery, selects: string[]) => void;
 declare const _addToHookSelectWithTable: (query: IsQuery, selects: string[], table: string) => void;
 
 type DelayedRelationSelect = {
-    query: QueryBase;
+    query: IsQuery;
     value?: {
         [K: string]: IsQuery;
     };
 };
-declare const newDelayedRelationSelect: (query: QueryBase) => {
-    query: QueryBase;
+declare const newDelayedRelationSelect: (query: IsQuery) => {
+    query: IsQuery;
 };
 declare const setDelayedRelation: (d: DelayedRelationSelect, as: string, value: IsQuery) => void;
 
@@ -333,18 +333,15 @@ interface QueryDataAliases extends PickQueryDataAliases {
     as?: string;
     outerAliases?: RecordString;
 }
-type AliasOrTable<T extends PickQueryMetaTable> = T['meta']['as'] extends string ? T['meta']['as'] : T['table'] extends string ? T['table'] : never;
-type SetQueryTableAlias<T extends PickQueryMetaTableShape, As extends string> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta'] | 'as']: K extends 'as' ? As : K extends 'selectable' ? Omit<T['meta']['selectable'], `${AliasOrTable<T>}.${keyof T['shape'] & string}`> & {
-            [K in keyof T['shape'] & string as `${As}.${K}`]: {
-                as: K;
-                column: T['shape'][K];
-            };
-        } : T['meta'][K];
-    } : T[K];
+type SetQueryTableAlias<T extends PickQuerySelectableShapeAs, As extends string> = {
+    [K in keyof T]: K extends '__selectable' ? Omit<T['__selectable'], `${T['__as']}.${keyof T['shape'] & string}`> & {
+        [K in keyof T['shape'] & string as `${As}.${K}`]: {
+            as: K;
+            column: T['shape'][K];
+        };
+    } : K extends '__as' ? As : T[K];
 };
-type AsQueryArg = PickQueryMetaTableShape;
+type AsQueryArg = PickQuerySelectableShapeAs;
 /** getters **/
 declare const getQueryAs: (q: {
     table?: string;
@@ -352,21 +349,21 @@ declare const getQueryAs: (q: {
         as?: string;
     };
 }) => string;
-declare const _getQueryAs: (q: QueryBase) => string | undefined;
+declare const _getQueryAs: (q: Query) => string | undefined;
 declare const _getQueryFreeAlias: (q: QueryDataAliases, as: string) => string;
-declare const _checkIfAliased: (q: QueryBase, as: string, name: string) => boolean;
+declare const _checkIfAliased: (q: Query, as: string, name: string) => boolean;
 declare const _getQueryAliasOrName: (q: PickQueryDataAliases, as: string) => string;
-declare const _getQueryOuterAliases: (q: QueryDataBase) => RecordString | undefined;
+declare const _getQueryOuterAliases: (q: QueryDataAliases) => RecordString | undefined;
 /** setters **/
-declare const _setQueryAs: <T extends PickQueryMetaTableShape, As extends string>(self: T, as: As) => SetQueryTableAlias<T, As>;
-declare const _setQueryAlias: (q: QueryBase, name: string, as: string) => void;
-declare const _setSubQueryAliases: (q: QueryBase) => void;
+declare const _setQueryAs: <T extends PickQuerySelectableShapeAs, As extends string>(self: T, as: As) => SetQueryTableAlias<T, As>;
+declare const _setQueryAlias: (q: Query, name: string, as: string) => void;
+declare const _setSubQueryAliases: (q: Query) => void;
 /**
  * Is used in `chain`: combines query and its relation aliases,
  * stores the result to the relation query data.
  */
-declare const _applyRelationAliases: (query: QueryBase, relQueryData: QueryDataBase) => void;
-declare const _copyQueryAliasToQuery: (fromQuery: QueryBase, toQuery: QueryBase, key: string) => string;
+declare const _applyRelationAliases: (query: Query, relQueryData: QueryData) => void;
+declare const _copyQueryAliasToQuery: (fromQuery: Query, toQuery: Query, key: string) => string;
 declare abstract class QueryAsMethods {
     /**
      * Sets table alias:
@@ -409,10 +406,8 @@ interface CteQueryBuilder<T extends PickQueryWithDataColumnTypes> extends Query
     relations: EmptyObject;
     withData: T['withData'];
 }
-type CteResult<T extends PickQueryMetaWithDataColumnTypes, Name extends string, Q extends PickQueryResult> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? 'select' : T['meta'][K];
-    } : K extends 'withData' ? {
+type CteResult<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'];
@@ -535,8 +530,8 @@ declare class CteQuery {
      *   ]);
      * ```
      */
-    with<T extends PickQueryMetaWithDataColumnTypes, Name extends string, Q>(this: T, name: Name, query: Q | ((q: CteQueryBuilder<T>) => Q)): CteResult<T, Name, Q extends PickQueryResult ? Q : never>;
-    with<T extends PickQueryMetaWithDataColumnTypes, Name extends string, Q extends PickQueryResult>(this: T, name: Name, options: CteArgsOptions, query: Q | ((q: CteQueryBuilder<T>) => Q)): CteResult<T, Name, Q>;
+    with<T extends PickQueryWithDataColumnTypes, Name extends string, Q>(this: T, name: Name, query: Q | ((q: CteQueryBuilder<T>) => Q)): CteResult<T, Name, Q extends PickQueryResult ? Q : never>;
+    with<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends PickQueryResult>(this: T, name: Name, options: CteArgsOptions, query: Q | ((q: CteQueryBuilder<T>) => Q)): CteResult<T, Name, Q>;
     /**
      * It is priceless for fetching tree-like structures, or any other recursive cases.
      *
@@ -620,10 +615,10 @@ declare class CteQuery {
      *   .where({ n: { gt: 10 } });
      * ```
      */
-    withRecursive<T extends PickQueryMetaWithDataColumnTypes, Name extends string, Q extends PickQueryResult, Result = CteResult<T, Name, Q>>(this: T, name: Name, base: Q | ((qb: CteQueryBuilder<T>) => Q), recursive: (qb: {
+    withRecursive<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends PickQueryResult, Result = CteResult<T, Name, Q>>(this: T, name: Name, base: Q | ((qb: CteQueryBuilder<T>) => Q), recursive: (qb: {
         [K in keyof Result]: K extends 'result' ? Q['result'] : Result[K];
     }) => PickQueryResult): Result;
-    withRecursive<T extends PickQueryMetaWithDataColumnTypes, Name extends string, Q extends PickQueryResult, Result = CteResult<T, Name, Q>>(this: T, name: Name, options: CteRecursiveOptions, base: Q | ((qb: CteQueryBuilder<T>) => Q), recursive: (qb: {
+    withRecursive<T extends PickQueryWithDataColumnTypes, Name extends string, Q extends PickQueryResult, Result = CteResult<T, Name, Q>>(this: T, name: Name, options: CteRecursiveOptions, base: Q | ((qb: CteQueryBuilder<T>) => Q), recursive: (qb: {
         [K in keyof Result]: K extends 'result' ? Q['result'] : Result[K];
     }) => PickQueryResult): Result;
     /**
@@ -712,7 +707,9 @@ declare namespace ColumnsShape {
         [K in keyof Shape]: Shape[K]['outputType'];
     };
     export type DefaultSelectOutput<Shape extends Column.QueryColumnsInit> = {
-        [K in keyof Shape as Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K]: Shape[K]['outputType'];
+        [K in {
+            [K in keyof Shape]: Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K;
+        }[keyof Shape]]: Shape[K]['outputType'];
     };
     export interface MapToObjectColumn<Shape extends Column.QueryColumns> {
         dataType: 'object';
@@ -760,30 +757,6 @@ declare namespace ColumnsShape {
     export {  };
 }
 
-interface QuerySelectable {
-    [K: PropertyKey]: {
-        as: string;
-        column: Column.Pick.QueryColumn;
-    };
-}
-interface QueryMetaBase<Scopes extends RecordKeyTrue = RecordKeyTrue> {
-    kind: string;
-    as?: string;
-    subQuery: boolean;
-    hasSelect?: true;
-    hasWhere?: true;
-    defaults: EmptyObject;
-    tsQuery?: string;
-    scopes: Scopes;
-    selectable: QuerySelectable;
-    defaultSelect: PropertyKey;
-}
-interface QueryMetaIsSubQuery {
-    meta: {
-        subQuery: true;
-    };
-}
-
 interface PickQueryDataParsers {
     defaultParsers?: ColumnsParsers;
     parsers?: ColumnsParsers;
@@ -830,24 +803,18 @@ declare const handleResult: HandleResult;
 declare const parseRecord: (parsers: ColumnsParsers, row: any) => unknown;
 declare const filterResult: (q: Query, returnType: QueryReturnType, queryResult: QueryResult, result: unknown, tempColumns: Set<string> | undefined, hasAfterHook?: unknown) => unknown;
 
-interface SelectSelf {
-    shape: Column.QueryColumns;
-    relations: RelationsBase;
-    result: Column.QueryColumns;
-    meta: QueryMetaBase;
-    returnType: QueryReturnType;
-    withData: EmptyObject;
+interface SelectSelf extends PickQuerySelectable, PickQueryHasSelect, PickQueryDefaultSelect, PickQueryShape, PickQueryRelations, PickQueryResult, PickQueryReturnType, PickQueryWithData {
 }
-type SelectArg<T extends SelectSelf> = '*' | keyof T['meta']['selectable'];
-type SelectArgs<T extends SelectSelf> = ('*' | keyof T['meta']['selectable'])[];
-interface SubQueryAddition<T extends PickQueryWithData> extends QueryMetaIsSubQuery {
+type SelectArg<T extends SelectSelf> = '*' | keyof T['__selectable'];
+type SelectArgs<T extends SelectSelf> = ('*' | keyof T['__selectable'])[];
+interface SubQueryAddition<T extends PickQueryWithData> extends IsSubQuery {
     withData: T['withData'];
 }
 type SelectAsFnArg<T extends PickQueryRelationsWithData> = EmptyObject extends T['relations'] ? T : {
     [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['maybeSingle'] & SubQueryAddition<T> : K extends keyof T ? T[K] : never;
 };
 interface SelectAsArg<T extends SelectSelf> {
-    [K: string]: keyof T['meta']['selectable'] | Expression | ((q: SelectAsFnArg<T>) => unknown);
+    [K: string]: keyof T['__selectable'] | Expression | ((q: SelectAsFnArg<T>) => unknown);
 }
 type SelectAsFnReturnType = {
     result: Column.QueryColumns;
@@ -858,45 +825,42 @@ interface SelectAsCheckReturnTypes {
 }
 type SelectReturnType<T extends PickQueryReturnType> = T['returnType'] extends 'valueOrThrow' ? 'oneOrThrow' : T extends 'value' ? 'one' : T['returnType'] extends 'pluck' ? 'all' : T['returnType'];
 type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = {
-    [K in keyof T]: K extends 'result' ? {
-        [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['meta']['defaultSelect'] : Columns[number] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
-    } & (T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, {
-        [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['meta']['defaultSelect'] : Columns[number] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
-    } & (T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K];
-} & QueryMetaHasSelect;
+    [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
+        [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'];
+    } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, {
+        [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'];
+    } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K];
+};
 type SelectResultObj<T extends SelectSelf, Obj> = Obj extends SelectAsCheckReturnTypes ? {
-    [K in keyof T]: K extends 'meta' ? T['meta'] & SelectAsMeta<Obj> : K extends 'result' ? {
-        [K in T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
+    [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? {
+        [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
     } : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, {
-        [K in T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
+        [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
     }> : T[K];
 } : `Invalid return type of ${{
     [K in keyof Obj]: Obj[K] extends (...args: any[]) => any ? ReturnType<Obj[K]> extends SelectAsFnReturnType ? never : K : never;
 }[keyof Obj] & string}`;
 type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = {
-    [K in keyof T]: K extends 'meta' ? T['meta'] & SelectAsMeta<Obj> : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
+    [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
     {
-        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['meta']['defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['meta']['selectable'][K]['column'];
-    } & (T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, {
-        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['meta']['defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['meta']['selectable'][K]['column'];
-    } & (T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K];
+        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'];
+    } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, {
+        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'];
+    } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K];
 };
-interface AllowedRelationOneQueryForSelectable extends QueryMetaIsSubQuery {
+interface AllowedRelationOneQueryForSelectable extends IsSubQuery {
     result: Column.QueryColumns;
     returnType: 'value' | 'valueOrThrow' | 'one' | 'oneOrThrow';
 }
-type SelectAsMeta<Obj> = {
-    hasSelect: true;
-    selectable: UnionToIntersection<{
-        [K in keyof Obj]: Obj[K] extends ((q: never) => infer R extends AllowedRelationOneQueryForSelectable) ? {
-            [C in R['returnType'] extends 'value' | 'valueOrThrow' ? K : keyof R['result'] as R['returnType'] extends 'value' | 'valueOrThrow' ? K : `${K & string}.${C & string}`]: {
-                as: C;
-                column: R['returnType'] extends 'value' | 'valueOrThrow' ? R['result']['value'] : R['result'][C & keyof R['result']];
-            };
-        } : never;
-    }[keyof Obj]>;
-};
-type SelectAsValueResult<T extends SelectSelf, Arg> = Arg extends keyof T['meta']['selectable'] ? T['meta']['selectable'][Arg]['column'] : Arg extends Expression ? Arg['result']['value'] : Arg extends (q: never) => IsQuery ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends (q: never) => Expression ? ReturnType<Arg>['result']['value'] : Arg extends (q: never) => IsQuery | Expression ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression>> | Exclude<ReturnType<Arg>, IsQuery>['result']['value'] : never;
+type SelectAsSelectable<Obj> = UnionToIntersection<{
+    [K in keyof Obj]: Obj[K] extends ((q: never) => infer R extends AllowedRelationOneQueryForSelectable) ? {
+        [C in R['returnType'] extends 'value' | 'valueOrThrow' ? K : keyof R['result'] as R['returnType'] extends 'value' | 'valueOrThrow' ? K : `${K & string}.${C & string}`]: {
+            as: C;
+            column: R['returnType'] extends 'value' | 'valueOrThrow' ? R['result']['value'] : R['result'][C & keyof R['result']];
+        };
+    } : never;
+}[keyof Obj]>;
+type SelectAsValueResult<T extends SelectSelf, Arg> = Arg extends keyof T['__selectable'] ? T['__selectable'][Arg]['column'] : Arg extends Expression ? Arg['result']['value'] : Arg extends (q: never) => IsQuery ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends (q: never) => Expression ? ReturnType<Arg>['result']['value'] : Arg extends (q: never) => IsQuery | Expression ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression>> | Exclude<ReturnType<Arg>, IsQuery>['result']['value'] : never;
 type SelectSubQueryResult<Arg extends SelectSelf> = Arg['returnType'] extends undefined | 'all' ? ColumnsShape.MapToObjectArrayColumn<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShape.MapToPluckColumn<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShape.MapToNullableObjectColumn<Arg['result']> : ColumnsShape.MapToObjectColumn<Arg['result']>;
 declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>>(q: T, columns: Columns): SelectResult<T, Columns>;
 declare function _querySelect<T extends SelectSelf, Obj extends SelectAsArg<T>>(q: T, obj: Obj): SelectResultObj<T, Obj>;
@@ -1041,7 +1005,7 @@ interface QueryBatchResult {
     parent: any;
     key: PropertyKey;
 }
-declare const addParserForSelectItem: <T extends PickQueryMeta>(query: T, as: string | getValueKey | undefined, key: string, arg: SelectableOrExpression<T> | Query, columnAlias?: string, joinQuery?: boolean) => string | Expression | Query | undefined;
+declare const addParserForSelectItem: <T extends PickQuerySelectable>(query: T, as: string | getValueKey | undefined, key: string, arg: SelectableOrExpression<T> | Query, columnAlias?: string, joinQuery?: boolean) => string | Expression | Query | undefined;
 declare const processSelectArg: <T extends SelectSelf>(q: T, as: string | undefined, arg: SelectArg<T>, columnAs?: string | getValueKey) => SelectItem | undefined | false;
 declare const setParserForSelectedString: (query: PickQueryQAndInternal, arg: string, as: string | getValueKey | undefined, columnAs?: string | getValueKey, columnAlias?: string) => string | undefined;
 declare const getShapeFromSelect: (q: IsQuery, isSubQuery?: boolean) => Column.QueryColumns;
@@ -1219,14 +1183,17 @@ type WithSelectable<W extends WithDataItem> = keyof W['shape'] | `${W['table']}.
  * The first argument of all `join` and `joinLateral` methods.
  * See argument of {@link join}.
  */
-type JoinFirstArg<T extends PickQueryRelationsWithData> = PickQueryTableMetaResult | keyof T['relations'] | keyof T['withData'] | ((q: {
+type JoinFirstArg<T extends PickQueryRelationsWithData> = PickQueryResultAs | keyof T['relations'] | keyof T['withData'] | ((q: {
     [K in keyof T['relations']]: T['relations'][K]['query'];
-}) => PickQueryTableMetaResult) | (() => PickQueryTableMetaResult);
+}) => PickQueryResultAs) | FnPickQueryResultAs;
+interface FnPickQueryResultAs {
+    (): PickQueryResultAs;
+}
 /**
  * Arguments of `join` methods (not `joinLateral`).
  * See {@link join}
  */
-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, T['withData'][Arg]> : never);
+type JoinArgs<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>> = [on?: JoinCallback<T, Arg>] | (Arg extends PickQueryResultAs ? JoinQueryArgs<T, Arg> : Arg extends keyof T['withData'] ? JoinWithArgs<T, T['withData'][Arg]> : EmptyTuple);
 /**
  * Column names of the joined table that can be used to join.
  * Derived from 'result', not from 'shape',
@@ -1236,53 +1203,47 @@ 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 PickQueryTableMetaResult> = keyof Q['result'] | `${AliasOrTable<Q>}.${keyof Q['result'] & string}`;
-type JoinQueryArgs<T extends PickQueryMeta, Q extends PickQueryTableMetaResult> = [
+type JoinSelectable<Q extends PickQueryResultAs> = keyof Q['result'] | `${Q['__as']}.${keyof Q['result'] & string}`;
+type JoinQueryArgs<T extends PickQuerySelectable, Q extends PickQueryResultAs> = [
     conditions: {
-        [K in JoinSelectable<Q>]: keyof T['meta']['selectable'] | Expression;
+        [K in JoinSelectable<Q>]: keyof T['__selectable'] | Expression;
     } | Expression | true
 ] | [
     leftColumn: JoinSelectable<Q> | Expression,
-    rightColumn: keyof T['meta']['selectable'] | Expression
+    rightColumn: keyof T['__selectable'] | Expression
 ] | [
     leftColumn: JoinSelectable<Q> | Expression,
     op: string,
-    rightColumn: keyof T['meta']['selectable'] | Expression
+    rightColumn: keyof T['__selectable'] | Expression
 ];
-type JoinWithArgs<T extends PickQueryMeta, W extends WithDataItem> = [
+type JoinWithArgs<T extends PickQuerySelectable, W extends WithDataItem> = [
     conditions: {
-        [K in WithSelectable<W>]: keyof T['meta']['selectable'] | Expression;
+        [K in WithSelectable<W>]: keyof T['__selectable'] | Expression;
     } | Expression
 ] | [
     leftColumn: WithSelectable<W> | Expression,
-    rightColumn: keyof T['meta']['selectable'] | Expression
+    rightColumn: keyof T['__selectable'] | Expression
 ] | [
     leftColumn: WithSelectable<W> | Expression,
     op: string,
-    rightColumn: keyof T['meta']['selectable'] | Expression
+    rightColumn: keyof T['__selectable'] | Expression
 ];
-type JoinResultRequireMain<T extends PickQueryMeta, JoinedSelectable> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'selectable' ? T['meta']['selectable'] & JoinedSelectable : T['meta'][K];
-    } : T[K];
+type JoinResultRequireMain<T extends PickQuerySelectable, JoinedSelectable> = {
+    [K in keyof T]: K extends '__selectable' ? T['__selectable'] & JoinedSelectable : T[K];
 };
 /**
  * Result of all `join` methods, not `joinLateral`.
- * Adds joined table columns from its 'result' to the 'selectable' of the query.
+ * Adds joined table columns from its 'result' to the '__selectable' of the query.
  */
-type JoinResult<T extends PickQueryMetaResultReturnType, JoinedSelectable, RequireMain> = RequireMain extends true ? {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'selectable' ? T['meta']['selectable'] & JoinedSelectable : T['meta'][K];
-    } : T[K];
+type JoinResult<T extends PickQuerySelectableResultReturnType, JoinedSelectable, RequireMain> = RequireMain extends true ? {
+    [K in keyof T]: K extends '__selectable' ? T['__selectable'] & JoinedSelectable : T[K];
 } : {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'selectable' ? {
-            [K in keyof T['meta']['selectable']]: {
-                as: T['meta']['selectable'][K]['as'];
-                column: Column.Modifiers.QueryColumnToNullable<T['meta']['selectable'][K]['column']>;
-            };
-        } & JoinedSelectable : T['meta'][K];
-    } : K extends 'result' ? {
+    [K in keyof T]: K extends '__selectable' ? {
+        [K in keyof T['__selectable']]: {
+            as: T['__selectable'][K]['as'];
+            column: Column.Modifiers.QueryColumnToNullable<T['__selectable'][K]['column']>;
+        };
+    } & JoinedSelectable : K extends 'result' ? {
         [K in keyof T['result']]: Column.Modifiers.QueryColumnToNullable<T['result'][K]>;
     } : K extends 'then' ? QueryThenByQuery<T, {
         [K in keyof T['result']]: Column.Modifiers.QueryColumnToNullable<T['result'][K]>;
@@ -1292,30 +1253,22 @@ type JoinResult<T extends PickQueryMetaResultReturnType, JoinedSelectable, Requi
  * 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 ? JoinResultSelectable<ReturnType<Args[0]>['result'], AliasOrTable<ReturnType<Args[0]>>, RequireJoined> : Arg extends PickQueryTableMetaResultShape ? Arg['meta']['hasSelect'] extends true ? JoinResultSelectable<Arg['result'], AliasOrTable<Arg>, RequireJoined> : JoinResultSelectable<Arg['shape'], AliasOrTable<{
-    table: Arg['table'];
-    meta: Arg['meta'];
-}>, RequireJoined> : Arg extends keyof T['relations'] ? JoinResultSelectable<T['relations'][Arg]['query']['shape'], AliasOrTable<{
-    table: T['relations'][Arg]['query']['table'];
-    meta: T['relations'][Arg]['query']['meta'];
-}>, RequireJoined> : Arg extends ((...args: any[]) => infer Q extends PickQueryTableMetaShape) ? JoinResultSelectable<Q['shape'], AliasOrTable<{
-    table: Q['table'];
-    meta: Q['meta'];
-}>, RequireJoined> : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? JoinResultSelectable<T['withData'][Arg]['shape'], AliasOrTable<{
-    table: T['withData'][Arg]['table'];
-    meta: QueryMetaBase;
-}>, RequireJoined> : never : never, RequireMain>;
-type GenericJoinCallback = (...args: any[]) => PickQueryTableMetaResult;
-type GenericJoinCallbackTuple = [GenericJoinCallback];
+type JoinResultFromArgs<T extends PickQuerySelectableResultRelationsWithDataReturnType, Arg, Args extends unknown[], RequireJoined, RequireMain> = JoinResult<T, Args[0] extends GenericJoinCallback ? JoinResultSelectable<ReturnType<Args[0]>['result'], ReturnType<Args[0]>['__as'], RequireJoined> : Arg extends PickQueryHasSelectResultShapeAs ? JoinResultSelectable<Arg['__hasSelect'] extends true ? Arg['result'] : Arg['shape'], Arg['__as'], RequireJoined> : Arg extends keyof T['relations'] ? JoinResultSelectable<T['relations'][Arg]['query']['shape'], T['relations'][Arg]['query']['__as'], RequireJoined> : Arg extends FirstArgCallback ? JoinResultSelectable<ReturnType<Arg>['shape'], ReturnType<Arg>['__as'], RequireJoined> : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? JoinResultSelectable<T['withData'][Arg]['shape'], T['withData'][Arg]['table'], RequireJoined> : never : never, RequireMain>;
+interface GenericJoinCallback {
+    (...args: any[]): PickQueryResultAs;
+}
+interface FirstArgCallback {
+    (...args: any[]): PickQueryShapeAs;
+}
 /**
  * Result of all `joinLateral` methods.
- * Adds joined table columns from its 'result' to the 'selectable' of the query.
+ * Adds joined table columns from its 'result' to the '__selectable' of the query.
  *
  * @param T - query type to join to
  * @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, Table extends string, Meta extends QueryMetaBase, Result extends Column.QueryColumns, RequireJoined> = JoinAddSelectable<T, JoinResultSelectable<Result, Meta['as'] extends string ? Meta['as'] : Table, RequireJoined>>;
+type JoinLateralResult<T extends PickQuerySelectable, As extends string, Result extends Column.QueryColumns, RequireJoined> = JoinAddSelectable<T, JoinResultSelectable<Result, As, RequireJoined>>;
 /**
  * Build `selectable` type for joined table.
  *
@@ -1327,26 +1280,25 @@ type JoinLateralResult<T extends PickQueryMeta, Table extends string, Meta exten
  * 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<Result extends Column.QueryColumns, As extends string, RequireJoined> = (RequireJoined extends true ? {
-    [K in keyof Result & string as `${As}.${K}`]: {
+type JoinResultSelectable<Result extends Column.QueryColumns, As extends string, RequireJoined> = RequireJoined extends true ? {
+    [K in '*' | (keyof Result & string) as `${As}.${K}`]: K extends '*' ? {
+        as: As;
+        column: ColumnsShape.MapToObjectColumn<Result>;
+    } : {
         as: K;
         column: Result[K];
     };
 } : {
-    [K in keyof Result & string as `${As}.${K}`]: {
+    [K in '*' | (keyof Result & string) as `${As}.${K}`]: K extends '*' ? {
+        as: As;
+        column: ColumnsShape.MapToNullableObjectColumn<Result>;
+    } : {
         as: K;
         column: Column.Modifiers.QueryColumnToNullable<Result[K]>;
     };
-}) & {
-    [K in As as `${As}.*`]: {
-        as: K;
-        column: RequireJoined extends true ? ColumnsShape.MapToObjectColumn<Result> : ColumnsShape.MapToNullableObjectColumn<Result>;
-    };
 };
-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 JoinAddSelectable<T extends PickQuerySelectable, Selectable> = {
+    [K in keyof T]: K extends '__selectable' ? T['__selectable'] & Selectable : T[K];
 };
 /**
  * Map the first argument of `join` or `joinLateral` to a query type.
@@ -1356,16 +1308,16 @@ type JoinAddSelectable<T extends PickQueryMeta, Selectable> = {
  * 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 ? {
-    [K in 'table' | 'meta' | 'result' | keyof T]: K extends 'table' ? T['withData'][Arg]['table'] : K extends 'meta' ? QueryMetaBase & {
-        selectable: {
-            [K in keyof T['withData'][Arg]['shape'] & string as `${T['withData'][Arg]['table']}.${K}`]: {
-                as: K;
-                column: T['withData'][Arg]['shape'][K];
-            };
+    [K in 'result' | '__as' | keyof T]: K extends '__as' ? T['withData'][Arg]['table'] : K extends '__selectable' ? {
+        [K in keyof T['withData'][Arg]['shape'] & string as `${T['withData'][Arg]['table']}.${K}`]: {
+            as: K;
+            column: T['withData'][Arg]['shape'][K];
         };
     } : K extends 'result' ? T['withData'][Arg]['shape'] : K extends keyof T ? T[K] : never;
-} : never : Arg extends PickQueryTableMetaResult ? Arg : Arg extends keyof T['relations'] ? T['relations'][Arg]['query'] : Arg extends JoinArgToQueryCallback ? ReturnType<Arg> : never;
-type JoinArgToQueryCallback = (...args: any[]) => PickQueryTableMetaResult;
+} : never : Arg extends PickQuerySelectableResultAs ? Arg : Arg extends keyof T['relations'] ? T['relations'][Arg]['query'] : Arg extends JoinArgToQueryCallback ? ReturnType<Arg> : never;
+interface JoinArgToQueryCallback {
+    (...args: any[]): IsQuery;
+}
 /**
  * Type of the `join` callback (not `joinLateral`).
  *
@@ -1375,11 +1327,15 @@ type JoinArgToQueryCallback = (...args: any[]) => PickQueryTableMetaResult;
  *
  * Callback must return a query builder.
  */
-type JoinCallback<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>> = (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => PickQueryTableMetaResult;
+interface JoinCallback<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>> {
+    (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>): IsQuery;
+}
 /**
  * Type of {@link QueryJoin.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>;
+interface JoinQueryMethod {
+    <T extends PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<T, Arg, Args, true, true>;
+}
 /**
  * After getting a query from a sub-query callback,
  * join it to the main query in case it's a relation query.
@@ -1390,7 +1346,7 @@ type JoinQueryMethod = <T extends PickQueryMetaResultRelationsWithDataReturnType
  * @param sub - sub-query query object
  */
 declare const joinSubQuery: (q: ToSQLQuery, sub: ToSQLQuery) => SubQueryForSql;
-declare const _joinReturningArgs: <T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, RequireJoined extends boolean>(query: T, require: RequireJoined, first: JoinFirstArg<never> | {
+declare const _joinReturningArgs: <T extends PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs, RequireJoined extends boolean>(query: T, require: RequireJoined, first: JoinFirstArg<never> | {
     _internalJoin: Query;
 }, args: JoinArgs<Query, JoinFirstArg<Query>>, forbidLateral?: boolean) => JoinItemArgs | undefined;
 /**
@@ -1405,12 +1361,11 @@ declare const _joinReturningArgs: <T extends PickQueryMetaResultRelationsWithDat
  * @param first - the first argument of join: join target
  * @param args - rest join arguments: columns to join with, or a callback
  */
-declare const _join: <T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, R extends PickQueryTableMetaResult, RequireJoined extends boolean, RequireMain extends boolean>(query: T, require: RequireJoined, type: string, first: JoinFirstArg<never> | {
+declare const _join: <T extends PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs, R extends PickQueryResult, RequireJoined extends boolean, RequireMain extends boolean>(query: T, require: RequireJoined, type: string, first: JoinFirstArg<never> | {
     _internalJoin: Query;
 }, args: JoinArgs<Query, JoinFirstArg<Query>>) => JoinResult<T, R, RequireMain>;
-declare const _joinLateralProcessArg: (q: Query, arg: JoinFirstArg<any>, cb: (q: JoinQueryBuilder<PickQueryMetaShape, JoinArgToQuery<PickQueryRelationsWithData, JoinFirstArg<PickQueryRelationsWithData>>>) => {
+declare const _joinLateralProcessArg: (q: Query, arg: JoinFirstArg<any>, cb: (q: JoinQueryBuilder<PickQuerySelectableShape, PickQuerySelectableResultAs>) => {
     table: string;
-    meta: QueryMetaBase;
     result: Column.QueryColumns;
 }) => Query;
 /**
@@ -1425,7 +1380,7 @@ declare const _joinLateralProcessArg: (q: Query, arg: JoinFirstArg<any>, cb: (q:
  * @param as - alias of the joined table, it is set the join lateral happens when selecting a relation in `select`
  * @param innerJoinLateral - add `ON p.r IS NOT NULL` check to have INNER JOIN like experience when sub-selecting arrays.
  */
-declare const _joinLateral: (self: PickQueryMetaResultRelationsWithDataReturnTypeShape, type: string, joinQuery: Query, as?: string, innerJoinLateral?: boolean) => string | undefined;
+declare const _joinLateral: (self: PickQueryResultRelationsWithDataReturnTypeShape, type: string, joinQuery: Query, as?: string, innerJoinLateral?: boolean) => string | undefined;
 declare class QueryJoin {
     /**
      * ## Select relation
@@ -1841,7 +1796,7 @@ declare class QueryJoin {
      * @param arg - {@link JoinFirstArg}
      * @param args - {@link JoinArgs}
      */
-    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>;
+    join<T extends PickQuerySelectableShapeRelationsWithDataAsResultReturnType, 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`.
      *
@@ -1866,7 +1821,7 @@ declare class QueryJoin {
      * @param arg - {@link JoinFirstArg}
      * @param args - {@link JoinArgs}
      */
-    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>;
+    leftJoin<T extends PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs, 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`.
      *
@@ -1888,7 +1843,7 @@ declare class QueryJoin {
      * @param arg - {@link JoinFirstArg}
      * @param args - {@link JoinArgs}
      */
-    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>;
+    rightJoin<T extends PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs, 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`.
      *
@@ -1910,7 +1865,7 @@ declare class QueryJoin {
      * @param arg - {@link JoinFirstArg}
      * @param args - {@link JoinArgs}
      */
-    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>;
+    fullJoin<T extends PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs, 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.
      *
@@ -1975,11 +1930,10 @@ declare class QueryJoin {
      * @param arg - {@link JoinFirstArg}
      * @param cb - {@link JoinLateralCallback}
      */
-    joinLateral<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Table extends string, Meta extends QueryMetaBase, Result extends Column.QueryColumns>(this: T, arg: Arg, cb: (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => {
-        table: Table;
-        meta: Meta;
+    joinLateral<T extends PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs, Arg extends JoinFirstArg<T>, As extends string, Result extends Column.QueryColumns>(this: T, arg: Arg, cb: (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => {
+        __as: As;
         result: Result;
-    }): JoinLateralResult<T, Table, Meta, Result, true>;
+    }): JoinLateralResult<T, As, Result, true>;
     /**
      * The same as {@link joinLateral}, but when no records found for the join it will result in `null`:
      *
@@ -1995,11 +1949,10 @@ declare class QueryJoin {
      * @param arg - {@link JoinFirstArg}
      * @param cb - {@link JoinLateralCallback}
      */
-    leftJoinLateral<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Table extends string, Meta extends QueryMetaBase, Result extends Column.QueryColumns>(this: T, arg: Arg, cb: (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => {
-        table: Table;
-        meta: Meta;
+    leftJoinLateral<T extends PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs, Arg extends JoinFirstArg<T>, As extends string, Result extends Column.QueryColumns>(this: T, arg: Arg, cb: (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>) => {
+        __as: As;
         result: Result;
-    }): JoinLateralResult<T, Table, Meta, Result, false>;
+    }): JoinLateralResult<T, As, Result, false>;
     /**
      * This method may be useful
      * for combining with [createForEachFrom](/guide/create-update-delete.html#createForEachFrom-insertForEachFrom).
@@ -2034,22 +1987,20 @@ declare class QueryJoin {
      * @param fn - declare column types
      * @param data - array of data to join
      */
-    joinData<T extends PickQueryMetaColumnTypes, As extends string, RecordType extends Column.QueryColumnsInit, Item extends ColumnsShape.Input<RecordType>>(this: T, as: As, fn: (types: T['columnTypes']) => RecordType, data: Item[]): {
-        [K in keyof T]: K extends 'meta' ? {
-            [K in keyof T['meta']]: K extends 'selectable' ? T['meta']['selectable'] & {
-                [K in keyof RecordType & string as `${As}.${K}`]: {
-                    as: K;
-                    column: RecordType[K];
-                };
-            } : T['meta'][K];
+    joinData<T extends PickQuerySelectableColumnTypes, As extends string, RecordType extends Column.QueryColumnsInit, Item extends ColumnsShape.Input<RecordType>>(this: T, as: As, fn: (types: T['columnTypes']) => RecordType, data: Item[]): {
+        [K in keyof T]: K extends '__selectable' ? T['__selectable'] & {
+            [K in keyof RecordType & string as `${As}.${K}`]: {
+                as: K;
+                column: RecordType[K];
+            };
         } : T[K];
     };
 }
 type OnArgs<S extends QuerySelectable> = [leftColumn: keyof S, rightColumn: keyof S] | [leftColumn: keyof S, op: string, rightColumn: keyof S];
-declare const pushQueryOnForOuter: <T extends PickQueryMeta>(q: T, joinFrom: PickQueryMeta, joinTo: PickQueryMeta, leftColumn: string, rightColumn: string) => T;
-declare const pushQueryOn: <T extends PickQueryMeta>(q: T, joinFrom: PickQueryMeta, joinTo: PickQueryMeta, ...on: OnArgs<QuerySelectable>) => T;
-declare const pushQueryOrOn: <T extends PickQueryMeta>(q: T, joinFrom: PickQueryMeta, joinTo: PickQueryMeta, ...on: OnArgs<QuerySelectable>) => never;
-declare const addQueryOn: <T extends PickQueryMeta>(query: T, joinFrom: PickQueryMeta, joinTo: PickQueryMeta, ...args: OnArgs<QuerySelectable>) => T;
+declare const pushQueryOnForOuter: <T extends PickQuerySelectable>(q: T, joinFrom: PickQuerySelectable, joinTo: PickQuerySelectable, leftColumn: string, rightColumn: string) => T;
+declare const pushQueryOn: <T extends PickQuerySelectable>(q: T, joinFrom: PickQuerySelectable, joinTo: PickQuerySelectable, ...on: OnArgs<QuerySelectable>) => T;
+declare const pushQueryOrOn: <T extends PickQuerySelectable>(q: T, joinFrom: PickQuerySelectable, joinTo: PickQuerySelectable, ...on: OnArgs<QuerySelectable>) => never;
+declare const addQueryOn: <T extends PickQuerySelectable>(query: T, joinFrom: PickQuerySelectable, joinTo: PickQuerySelectable, ...args: OnArgs<QuerySelectable>) => T;
 type OnJsonPathEqualsArgs<S extends QuerySelectable> = [
     leftColumn: keyof S,
     leftPath: string,
@@ -2059,25 +2010,23 @@ type OnJsonPathEqualsArgs<S extends QuerySelectable> = [
 /**
  * Mutative {@link OnMethods.prototype.on}
  */
-declare const _queryJoinOn: <T extends PickQueryMeta>(q: T, args: OnArgs<T['meta']['selectable']>) => T;
+declare const _queryJoinOn: <T extends PickQuerySelectable>(q: T, args: OnArgs<T['__selectable']>) => T;
 /**
  * Mutative {@link OnMethods.prototype.orOn}
  */
-declare const _queryJoinOrOn: <T extends PickQueryMeta>(q: T, args: OnArgs<T['meta']['selectable']>) => T;
+declare const _queryJoinOrOn: <T extends PickQuerySelectable>(q: T, args: OnArgs<T['__selectable']>) => T;
 /**
  * Mutative {@link OnMethods.prototype.onJsonPathEquals}
  */
-declare const _queryJoinOnJsonPathEquals: <T extends PickQueryMeta>(q: T, args: OnJsonPathEqualsArgs<T["meta"]["selectable"]>) => T;
+declare const _queryJoinOnJsonPathEquals: <T extends PickQuerySelectable>(q: T, args: OnJsonPathEqualsArgs<T["__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.prototype.on} method and similar to the query.
  */
-type JoinQueryBuilder<T extends PickQueryMetaShape = PickQueryMetaShape, J extends PickQueryTableMetaResult = PickQueryTableMetaResult> = {
-    [K in keyof J]: K extends 'meta' ? {
-        [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;
+type JoinQueryBuilder<T extends PickQuerySelectableShape, J extends PickQuerySelectableResultAs> = {
+    [K in keyof J | keyof OnMethods]: K extends '__selectable' ? SelectableFromShape<J['result'], J['__as']> & Omit<T['__selectable'], keyof T['shape']> : K extends keyof OnMethods ? OnMethods[K] : K extends keyof J ? J[K] : never;
+};
 declare class OnMethods {
     /**
      * Use `on` to specify columns to join records.
@@ -2095,13 +2044,13 @@ declare class OnMethods {
      *
      * @param args - columns to join with
      */
-    on<T extends PickQueryMeta>(this: T, ...args: OnArgs<T['meta']['selectable']>): T;
+    on<T extends PickQuerySelectable>(this: T, ...args: OnArgs<T['__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 PickQueryMeta>(this: T, ...args: OnArgs<T['meta']['selectable']>): T;
+    orOn<T extends PickQuerySelectable>(this: T, ...args: OnArgs<T['__selectable']>): T;
     /**
      * Use `onJsonPathEquals` to join record based on a field of their JSON column:
      *
@@ -2114,7 +2063,7 @@ declare class OnMethods {
      *
      * @param args - columns and JSON paths to join with.
      */
-    onJsonPathEquals<T extends PickQueryMeta>(this: T, ...args: OnJsonPathEqualsArgs<T['meta']['selectable']>): T;
+    onJsonPathEquals<T extends PickQuerySelectable>(this: T, ...args: OnJsonPathEqualsArgs<T['__selectable']>): T;
 }
 
 declare class ValExpression extends Expression {
@@ -2127,7 +2076,7 @@ declare class ValExpression extends Expression {
     makeSQL(ctx: ToSqlValues): string;
 }
 
-interface QueryReturnsFnAdd<T extends PickQueryColumTypes> extends QueryMetaHasSelect {
+interface QueryReturnsFnAdd<T extends PickQueryColumTypes> extends PickQueryHasSelect {
     type<C extends Column.Pick.QueryColumn>(fn: (types: T['columnTypes']) => C): {
         [K in keyof T]: K extends 'result' ? {
             value: C;
@@ -2187,7 +2136,7 @@ declare class QueryExpressions {
      *
      * @param arg - any available column name, such as of a joined table
      */
-    ref<T extends PickQueryMeta, K extends keyof T['meta']['selectable'] & string>(this: T, arg: K): RefExpression<T['meta']['selectable'][K]['column']> & T['meta']['selectable'][K]['column']['operators'];
+    ref<T extends PickQuerySelectable, K extends keyof T['__selectable'] & string>(this: T, arg: K): RefExpression<T['__selectable'][K]['column']> & T['__selectable'][K]['column']['operators'];
     val(value: unknown): ValExpression;
     /**
      * `fn` allows to call an arbitrary SQL function.
@@ -2225,21 +2174,18 @@ declare class QueryExpressions {
      * @param args
      * @param options
      */
-    fn<T extends PickQueryMetaResultRelationsWindowsColumnTypes, Type = unknown, C extends Column.Pick.QueryColumn = Column.Pick.QueryColumnOfType<Type>>(this: T, fn: string, args: SelectableOrExpressions<T>, options?: AggregateOptions<T>): SetQueryReturnsFn<T, C>;
+    fn<T extends PickQueryMetaSelectableResultRelationsWindowsColumnTypes, Type = unknown, C extends Column.Pick.QueryColumn = Column.Pick.QueryColumnOfType<Type>>(this: T, fn: string, args: SelectableOrExpressions<T>, options?: AggregateOptions<T>): SetQueryReturnsFn<T, C>;
     or(...args: [OrExpressionArg, ...OrExpressionArg[]]): OrExpression;
 }
 
 type QueryScopes<Keys extends string> = {
     [K in Keys]: unknown;
 };
-interface ScopeArgumentQueryMeta<Table extends string | undefined, Shape extends Column.QueryColumns> extends QueryMetaBase {
-    selectable: SelectableFromShape<Shape, Table>;
-}
-interface ScopeArgumentQuery<Table extends string | undefined, Shape extends Column.QueryColumns> extends Where, PickQueryMetaShapeRelationsWithData {
+interface ScopeArgumentQuery<Table extends string | undefined, Shape extends Column.QueryColumns> extends Where, PickQuerySelectableShapeRelationsWithData {
     __isQuery: true;
     table: Table;
     shape: Shape;
-    meta: ScopeArgumentQueryMeta<Table, Shape>;
+    __selectable: SelectableFromShape<Shape, Table>;
 }
 /**
  * This feature allows defining a set of query modifiers to use it later.
@@ -2287,7 +2233,7 @@ declare class QueryScope {
      *
      * @param scope - name of the scope to apply
      */
-    scope<T extends PickQueryMeta>(this: T, scope: keyof T['meta']['scopes']): WhereResult<T>;
+    scope<T extends PickQueryScopes>(this: T, scope: keyof T['__scopes']): T & QueryHasWhere;
     /**
      * See {@link QueryScope}
      *
@@ -2300,7 +2246,7 @@ declare class QueryScope {
      *
      * @param scope - name of the scope to remove from the query
      */
-    unscope<T extends PickQueryMeta>(this: T, scope: keyof T['meta']['scopes']): T;
+    unscope<T extends PickQueryScopes>(this: T, scope: keyof T['__scopes']): T;
 }
 
 /**
@@ -2758,9 +2704,9 @@ interface DefaultSchemaConfig extends ColumnSchemaConfig<Column> {
 declare const defaultSchemaConfig: DefaultSchemaConfig;
 
 type DeleteMethodsNames = 'delete';
-type DeleteArgs<T extends PickQueryMetaResult> = T['meta']['hasWhere'] extends true ? EmptyTuple : [never];
-type DeleteResult<T extends PickQueryMetaResultReturnType> = T['meta']['hasSelect'] extends true ? SetQueryKind<T, 'delete'> : T['returnType'] extends undefined | 'all' ? SetQueryReturnsRowCountMany<T, 'delete'> : SetQueryReturnsRowCount<T, 'delete'>;
-declare const _queryDelete: <T extends PickQueryMetaResultReturnType>(query: T) => DeleteResult<T>;
+type DeleteArgs<T extends PickQueryHasWhere> = T['__hasWhere'] extends true ? EmptyTuple : [never];
+type DeleteResult<T extends PickQueryHasSelectResultReturnType> = T['__hasSelect'] extends true ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsRowCountMany<T> : SetQueryReturnsRowCount<T>;
+declare const _queryDelete: <T extends PickQueryHasSelectResultReturnType>(query: T) => DeleteResult<T>;
 declare class Delete {
     /**
      * This method deletes one or more rows, based on other conditions specified in the query.
@@ -2821,14 +2767,15 @@ declare class Delete {
      *   .from('b');
      * ```
      */
-    delete<T extends PickQueryMetaResultReturnType>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
+    delete<T extends PickQueryHasSelectHasWhereResultReturnType>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
 }
 
 type SoftDeleteOption<Shape extends Column.QueryColumns> = true | keyof Shape;
-interface QueryWithSoftDelete extends PickQueryMetaResultReturnType {
-    meta: QueryMetaBase<{
-        nonDeleted: true;
-    }>;
+interface QueryWithSoftDelete extends PickQueryResult, PickQueryReturnType, PickQueryHasSelect, PickQueryHasWhere {
+    __scopes: NonDeletedScope;
+}
+interface NonDeletedScope {
+    nonDeleted: true;
 }
 /**
  * `softDelete` configures the table to set `deletedAt` to current time instead of deleting records.
@@ -2907,6 +2854,37 @@ declare class QueryLog {
     log<T>(this: T, log?: boolean): T;
 }
 
+interface QueryInternalColumnNameToKey {
+    columnNameToKeyMap?: Map<string, string>;
+}
+/**
+ * In snake case mode, or when columns have custom names,
+ * use this method to exchange a db column name to its runtime key.
+ */
+declare const queryColumnNameToKey: (q: Query, name: string) => string | undefined;
+
+interface QueryInternal<SinglePrimaryKey = any, UniqueColumns = any, UniqueColumnNames = any, UniqueColumnTuples = any, UniqueConstraints = any> extends QueryInternalColumnNameToKey {
+    runtimeDefaultColumns?: string[];
+    transactionStorage: AsyncLocalStorage<TransactionState>;
+    scopes?: RecordUnknown;
+    snakeCase?: boolean;
+    noPrimaryKey: boolean;
+    comment?: string;
+    primaryKeys?: string[];
+    singlePrimaryKey: SinglePrimaryKey;
+    uniqueColumns: UniqueColumns;
+    uniqueColumnNames: UniqueColumnNames;
+    uniqueColumnTuples: UniqueColumnTuples;
+    uniqueConstraints: UniqueConstraints;
+    extensions?: DbExtension[];
+    domains?: DbDomainArgRecord;
+    generatorIgnore?: GeneratorIgnore;
+    tableData: TableData;
+    nowSQL?: string;
+    callbackArg?: Query;
+    selectAllCount: number;
+}
+
 type ShapeColumnPrimaryKeys<Shape extends Column.QueryColumnsInit> = {
     [K in {
         [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? K : never;
@@ -2979,20 +2957,10 @@ interface DbTableOptions<ColumnTypes, Table extends string | undefined, Shape ex
 type DbTableOptionScopes<Table extends string | undefined, Shape extends Column.QueryColumns, Keys extends string = string> = {
     [K in Keys]: (q: ScopeArgumentQuery<Table, Shape>) => IsQuery;
 };
-interface TableMeta<Table extends string | undefined, Shape extends Column.QueryColumnsInit, ShapeWithComputed extends Column.QueryColumnsInit, Scopes extends RecordUnknown | undefined> extends QueryMetaBase<{
-    [K in keyof Scopes]: true;
-}> {
-    kind: 'select';
-    defaults: {
-        [K in keyof Shape as unknown extends Shape[K]['data']['default'] ? never : K]: true;
-    };
-    selectable: SelectableFromShape<ShapeWithComputed, Table>;
-    defaultSelect: ColumnsShape.DefaultSelectKeys<Shape>;
-}
 interface QueryBuilder extends Query {
     returnType: undefined;
 }
-declare class Db<Table extends string | undefined = undefined, Shape extends Column.QueryColumnsInit = Column.QueryColumnsInit, PrimaryKeys = never, UniqueColumns = never, UniqueColumnTuples = never, UniqueConstraints = never, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends Column.QueryColumnsInit = Shape, Scopes extends RecordUnknown | undefined = EmptyObject> extends QueryMethods<ColumnTypes> implements Query {
+declare class Db<Table extends string | undefined = undefined, Shape extends Column.QueryColumnsInit = Column.QueryColumnsInit, PrimaryKeys = never, UniqueColumns = never, UniqueColumnTuples = never, UniqueConstraints = never, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends Column.QueryColumnsInit = Shape, Scopes extends RecordUnknown | undefined = EmptyObject, DefaultSelect extends keyof Shape = keyof Shape> extends QueryMethods<ColumnTypes> implements Query {
     adapter: AdapterBase;
     qb: QueryBuilder;
     table: Table;
@@ -3000,11 +2968,26 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
     columnTypes: ColumnTypes;
     q: QueryData;
     __isQuery: true;
+    __as: Table & string;
+    __selectable: SelectableFromShape<ShapeWithComputed, Table>;
+    __hasSelect: boolean;
+    __hasWhere: boolean;
+    __defaults: {
+        [K in {
+            [K in keyof Shape]: unknown extends Shape[K]['data']['default'] ? never : K;
+        }[keyof Shape]]: true;
+    };
+    __scopes: {
+        [K in keyof Scopes]: true;
+    };
+    __defaultSelect: DefaultSelect;
     baseQuery: Query;
     columns: (keyof Shape)[];
     outputType: ColumnsShape.DefaultSelectOutput<Shape>;
     inputType: ColumnsShape.Input<Shape>;
-    result: Pick<Shape, ColumnsShape.DefaultSelectKeys<Shape>>;
+    result: {
+        [K in DefaultSelect]: Shape[K];
+    };
     returnType: undefined;
     then: QueryThenShallowSimplifyArr<ColumnsShape.DefaultOutput<Shape>>;
     windows: EmptyObject;
@@ -3012,7 +2995,6 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
     relationQueries: EmptyObject;
     withData: EmptyObject;
     error: new (message: string, length: number, name: QueryErrorName) => QueryError<this>;
-    meta: TableMeta<Table, Shape, ShapeWithComputed, Scopes>;
     internal: QueryInternal<{
         [K in keyof PrimaryKeys]: (keyof PrimaryKeys extends K ? never : keyof PrimaryKeys) extends never ? PrimaryKeys[K] : never;
     }[keyof PrimaryKeys], PrimaryKeys | UniqueColumns, {
@@ -3081,7 +3063,7 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
     queryArrays<R extends any[] = any[]>(...args: SQLQueryArgs): Promise<QueryArraysResult<R>>;
 }
 interface DbTableConstructor<ColumnTypes> {
-    <Table extends string, Shape extends Column.QueryColumnsInit, Data extends MaybeArray$1<TableDataItem>, Options extends DbTableOptions<ColumnTypes, Table, Shape>>(table: Table, shape?: ((t: ColumnTypes) => Shape) | Shape, tableData?: TableDataFn<Shape, Data>, options?: Options): Db<Table, Shape, keyof ShapeColumnPrimaryKeys<Shape> extends never ? never : ShapeColumnPrimaryKeys<Shape>, ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>, ColumnTypes, Shape & ComputedColumnsFromOptions<Options['computed']>, MapTableScopesOption<Options>> & {
+    <Table extends string, Shape extends Column.QueryColumnsInit, Data extends MaybeArray$1<TableDataItem>, Options extends DbTableOptions<ColumnTypes, Table, Shape>>(table: Table, shape?: ((t: ColumnTypes) => Shape) | Shape, tableData?: TableDataFn<Shape, Data>, options?: Options): Db<Table, Shape, keyof ShapeColumnPrimaryKeys<Shape> extends never ? never : ShapeColumnPrimaryKeys<Shape>, ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>, ColumnTypes, Shape & ComputedColumnsFromOptions<Options['computed']>, MapTableScopesOption<Options>, ColumnsShape.DefaultSelectKeys<Shape>> & {
         ko: Shape;
     };
 }
@@ -3089,9 +3071,7 @@ type MapTableScopesOption<T> = T extends {
     scopes: RecordUnknown;
 } ? T extends {
     softDelete: true | PropertyKey;
-} ? T['scopes'] & {
-    nonDeleted: unknown;
-} : T['scopes'] : T extends {
+} ? T['scopes'] & NonDeletedScope : T['scopes'] : T extends {
     softDelete: true | PropertyKey;
 } ? {
     nonDeleted: unknown;
@@ -3251,22 +3231,22 @@ declare const performQuery: <Result = QueryResult<any>>(q: {
     q: QueryData;
 }, args: SQLQueryArgs, method: 'query' | 'arrays') => Promise<Result>;
 
-type WhereArg<T extends PickQueryMetaRelations> = {
-    [K in keyof T['meta']['selectable'] | 'NOT' | 'OR' | 'IN']?: K extends 'NOT' ? WhereArg<T> | WhereArgs<T> : K extends 'OR' ? (WhereArg<T> | WhereArgs<T>)[] : K extends 'IN' ? MaybeArray<{
-        columns: (keyof T['meta']['selectable'])[];
+type WhereArg<T extends PickQuerySelectableRelations> = {
+    [K in keyof T['__selectable'] | 'NOT' | 'OR' | 'IN']?: K extends 'NOT' ? WhereArg<T> | WhereArgs<T> : K extends 'OR' ? (WhereArg<T> | WhereArgs<T>)[] : K extends 'IN' ? MaybeArray<{
+        columns: (keyof T['__selectable'])[];
         values: unknown[][] | IsQuery | Expression;
-    }> : T['meta']['selectable'][K]['column']['queryType'] | null | {
-        [O in keyof T['meta']['selectable'][K]['column']['operators']]?: T['meta']['selectable'][K]['column']['operators'][O]['_opType'];
+    }> : T['__selectable'][K]['column']['queryType'] | null | {
+        [O in keyof T['__selectable'][K]['column']['operators']]?: T['__selectable'][K]['column']['operators'][O]['_opType'];
     } | {
         result: {
             value: {
-                queryType: T['meta']['selectable'][K]['column']['queryType'] | null;
+                queryType: T['__selectable'][K]['column']['queryType'] | null;
             };
         };
     } | ((q: T) => {
         result: {
             value: {
-                queryType: T['meta']['selectable'][K]['column']['queryType'] | null;
+                queryType: T['__selectable'][K]['column']['queryType'] | null;
             };
         };
     });
@@ -3280,42 +3260,37 @@ type WhereArg<T extends PickQueryMetaRelations> = {
  * ```
  */
 type WhereQueryBuilder<T extends PickQueryRelations> = EmptyObject extends T['relations'] ? {
-    [K in keyof T]: K extends keyof Where | keyof QueryExpressions | 'table' | 'get' | 'columnTypes' | 'meta' | 'relations' | 'useHelper' | 'modify' | 'result' | 'returnType' | 'withData' | 'windows' | 'then' ? T[K] : never;
+    [K in keyof T]: K extends keyof Where | keyof QueryExpressions | 'table' | 'get' | 'columnTypes' | '__selectable' | 'relations' | 'useHelper' | 'modify' | 'result' | 'returnType' | 'withData' | 'windows' | 'then' ? T[K] : never;
 } : {
-    [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T & (keyof Where | keyof QueryExpressions | 'table' | 'get' | 'columnTypes' | 'meta' | 'relations' | 'useHelper' | 'modify' | 'result' | 'returnType' | 'withData' | 'windows' | 'then') ? T[K] : never;
+    [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T & (keyof Where | keyof QueryExpressions | 'table' | 'get' | 'columnTypes' | '__selectable' | 'relations' | 'useHelper' | 'modify' | 'result' | 'returnType' | 'withData' | 'windows' | 'then') ? T[K] : never;
 };
-type WhereArgs<T extends PickQueryMetaRelations> = WhereArg<T>[];
-type WhereNotArgs<T extends PickQueryMetaRelations> = [WhereArg<T>];
-type WhereInColumn<T extends PickQueryMetaRelations> = keyof T['meta']['selectable'] | [keyof T['meta']['selectable'], ...(keyof T['meta']['selectable'])[]];
-type WhereInValues<T extends PickQueryMetaRelations, Column> = Column extends keyof T['meta']['selectable'] ? Iterable<T['meta']['selectable'][Column]['column']['queryType']> | IsQuery | Expression : ({
-    [I in keyof Column]: Column[I] extends keyof T['meta']['selectable'] ? T['meta']['selectable'][Column[I]]['column']['queryType'] : never;
+type WhereArgs<T extends PickQuerySelectableRelations> = WhereArg<T>[];
+type WhereNotArgs<T extends PickQuerySelectableRelations> = [
+    WhereArg<T>
+];
+type WhereInColumn<T extends PickQuerySelectableRelations> = keyof T['__selectable'] | [keyof T['__selectable'], ...(keyof T['__selectable'])[]];
+type WhereInValues<T extends PickQuerySelectableRelations, Column> = Column extends keyof T['__selectable'] ? Iterable<T['__selectable'][Column]['column']['queryType']> | IsQuery | Expression : ({
+    [I in keyof Column]: Column[I] extends keyof T['__selectable'] ? T['__selectable'][Column[I]]['column']['queryType'] : never;
 } & {
     length: Column extends {
         length: number;
     } ? Column['length'] : never;
 })[] | IsQuery | Expression;
-type WhereInArg<T extends PickQueryMeta> = {
-    [K in keyof T['meta']['selectable']]?: Iterable<T['meta']['selectable'][K]['column']['queryType']> | IsQuery | Expression;
+type WhereInArg<T extends PickQuerySelectableRelations> = {
+    [K in keyof T['__selectable']]?: Iterable<T['__selectable'][K]['column']['queryType']> | IsQuery | Expression;
 };
-type WhereResult<T> = T & QueryMetaHasWhere;
-interface QueryMetaHasWhere {
-    meta: {
-        hasWhere: true;
-    };
+interface QueryHasWhere {
+    __hasWhere: true;
 }
 interface QueryFnReturningSelect {
-    (q: never): {
-        meta: {
-            hasSelect: true;
-        };
-    };
+    (q: never): QueryHasSelect;
 }
 /**
  * Mutative {@link Where.prototype.where}
  */
-declare const _queryWhere: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => WhereResult<T>;
-declare const _queryFindBy: <T extends PickQueryMetaRelationsResultReturnType>(q: T, arg: WhereArg<T>) => QueryTake<WhereResult<T>>;
-declare const _queryFindByOptional: <T extends PickQueryMetaRelationsResultReturnType>(q: T, arg: WhereArg<T>) => QueryTakeOptional<WhereResult<T>>;
+declare const _queryWhere: <T extends PickQuerySelectableRelations>(q: T, args: WhereArgs<T>) => T & QueryHasWhere;
+declare const _queryFindBy: <T extends PickQuerySelectableRelationsResultReturnType>(q: T, arg: WhereArg<T>) => QueryTake<T & QueryHasWhere>;
+declare const _queryFindByOptional: <T extends PickQuerySelectableRelationsResultReturnType>(q: T, arg: WhereArg<T>) => QueryTakeOptional<T & QueryHasWhere>;
 /**
  * Mutative {@link Where.prototype.whereSql}
  */
@@ -3323,7 +3298,7 @@ declare const _queryWhereSql: <T>(q: T, args: SQLQueryArgs) => T;
 /**
  * Mutative {@link Where.prototype.whereNot}
  */
-declare const _queryWhereNot: <T extends PickQueryMetaRelations>(q: T, args: WhereNotArgs<T>) => WhereResult<T>;
+declare const _queryWhereNot: <T extends PickQuerySelectableRelations>(q: T, args: WhereNotArgs<T>) => T & QueryHasWhere;
 /**
  * Mutative {@link Where.prototype.whereNotSql}
  */
@@ -3332,24 +3307,24 @@ declare const _queryWhereNotSql: <T>(q: T, args: SQLQueryArgs) => T;
  * Mutative {@link Where.prototype.whereNotExists}
  */
 declare const _queryWhereNotExists: (q: Query, arg: unknown, args: unknown) => never;
-declare const _queryWhereOneOf: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => T;
-declare const _queryWhereNotOneOf: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => T;
+declare const _queryWhereOneOf: <T extends PickQuerySelectableRelations>(q: T, args: WhereArgs<T>) => T;
+declare const _queryWhereNotOneOf: <T extends PickQuerySelectableRelations>(q: T, args: WhereArgs<T>) => T;
 /**
  * Mutative {@link Where.prototype.orWhere}
  */
-declare const _queryOr: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => WhereResult<T>;
+declare const _queryOr: <T extends PickQuerySelectableRelations>(q: T, args: WhereArgs<T>) => T & QueryHasWhere;
 /**
  * Mutative {@link Where.prototype.orWhereNot}
  */
-declare const _queryOrNot: <T extends PickQueryMetaRelations>(q: T, args: WhereArgs<T>) => WhereResult<T>;
+declare const _queryOrNot: <T extends PickQuerySelectableRelations>(q: T, args: WhereArgs<T>) => T & QueryHasWhere;
 /**
  * Mutative {@link Where.prototype.whereIn}
  */
-declare const _queryWhereIn: <T>(q: T, and: boolean, arg: unknown, values: unknown[] | Iterable<unknown> | IsQuery | Expression | undefined, not?: boolean) => WhereResult<T>;
+declare const _queryWhereIn: <T>(q: T, and: boolean, arg: unknown, values: unknown[] | Iterable<unknown> | IsQuery | Expression | undefined, not?: boolean) => T & QueryHasWhere;
 /**
  * Mutative {@link Where.prototype.whereExists}
  */
-declare const _queryWhereExists: <T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>>(q: T, arg: Arg, args: JoinArgs<T, Arg>) => WhereResult<T>;
+declare const _queryWhereExists: <T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>>(q: T, arg: Arg, args: JoinArgs<T, Arg>) => T & QueryHasWhere;
 declare class Where {
     /**
      * Constructing `WHERE` conditions:
@@ -3731,7 +3706,7 @@ declare class Where {
      *
      * @param args - {@link WhereArgs}
      */
-    where<T extends PickQueryMetaRelations>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    where<T extends PickQuerySelectableRelations>(this: T, ...args: WhereArgs<T>): T & QueryHasWhere;
     /**
      * Use a custom SQL expression in `WHERE` statement:
      *
@@ -3757,7 +3732,7 @@ declare class Where {
      *
      * @param args - {@link WhereArgs}
      */
-    whereNot<T extends PickQueryMetaRelations>(this: T, ...args: WhereNotArgs<T>): WhereResult<T>;
+    whereNot<T extends PickQuerySelectableRelations>(this: T, ...args: WhereNotArgs<T>): T & QueryHasWhere;
     /**
      * `whereNotSql` is a version of `whereNot` accepting SQL expression:
      *
@@ -3795,7 +3770,7 @@ declare class Where {
      *
      * @param args - same arguments as in {@link where}, joined with `OR`
      */
-    whereOneOf<T extends PickQueryMetaRelations>(this: T, ...args: WhereArgs<T>): T;
+    whereOneOf<T extends PickQuerySelectableRelations>(this: T, ...args: WhereArgs<T>): T;
     /**
      * Negative {@link whereOneOf}:
      *
@@ -3810,7 +3785,7 @@ declare class Where {
      *
      * @param args - same arguments as in {@link where}, joined with `OR`
      */
-    whereNotOneOf<T extends PickQueryMetaRelations>(this: T, ...args: WhereArgs<T>): T;
+    whereNotOneOf<T extends PickQuerySelectableRelations>(this: T, ...args: WhereArgs<T>): T;
     /**
      * `orWhere` stands for "...**or** where one of the given is true".
      *
@@ -3829,13 +3804,13 @@ declare class Where {
      *
      * @param args - same arguments as in {@link where}, joined with `OR`
      */
-    orWhere<T extends PickQueryMetaRelations>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    orWhere<T extends PickQuerySelectableRelations>(this: T, ...args: WhereArgs<T>): T & QueryHasWhere;
     /**
      * `orWhereNot` takes the same arguments as {@link orWhere}, and prepends each condition with `NOT` just as {@link whereNot} does.
      *
      * @param args - {@link WhereArgs} will be prefixed with `NOT` and joined with `OR`
      */
-    orWhereNot<T extends PickQueryMetaRelations>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    orWhereNot<T extends PickQuerySelectableRelations>(this: T, ...args: WhereArgs<T>): T & QueryHasWhere;
     /**
      * `whereIn` and related methods are for the `IN` operator to check for inclusion in a list of values.
      *
@@ -3882,7 +3857,7 @@ declare class Where {
      * db.table.whereIn({ id: [] })
      * ```
      */
-    whereIn<T extends PickQueryMetaRelations, Column extends WhereInColumn<T>>(this: T, ...args: [column: Column, values: WhereInValues<T, Column>] | [arg: WhereInArg<T>]): WhereResult<T>;
+    whereIn<T extends PickQuerySelectableRelations, Column extends WhereInColumn<T>>(this: T, ...args: [column: Column, values: WhereInValues<T, Column>] | [arg: WhereInArg<T>]): T & QueryHasWhere;
     /**
      * Takes the same arguments as {@link whereIn}.
      * Add a `WHERE IN` condition prefixed with `OR` to the query:
@@ -3891,7 +3866,7 @@ declare class Where {
      * db.table.whereIn('a', [1, 2, 3]).orWhereIn('b', ['one', 'two']);
      * ```
      */
-    orWhereIn<T extends PickQueryMetaRelations, Column extends WhereInColumn<T>>(this: T, ...args: [column: Column, values: WhereInValues<T, Column>] | [WhereInArg<T>]): WhereResult<T>;
+    orWhereIn<T extends PickQuerySelectableRelations, Column extends WhereInColumn<T>>(this: T, ...args: [column: Column, values: WhereInValues<T, Column>] | [WhereInArg<T>]): T & QueryHasWhere;
     /**
      * Acts as `whereIn`, but negates the condition with `NOT`:
      *
@@ -3899,7 +3874,7 @@ declare class Where {
      * db.table.whereNotIn('color', ['red', 'green', 'blue']);
      * ```
      */
-    whereNotIn<T extends PickQueryMetaRelations, Column extends WhereInColumn<T>>(this: T, ...args: [column: Column, values: WhereInValues<T, Column>] | [arg: WhereInArg<T>]): WhereResult<T>;
+    whereNotIn<T extends PickQuerySelectableRelations, Column extends WhereInColumn<T>>(this: T, ...args: [column: Column, values: WhereInValues<T, Column>] | [arg: WhereInArg<T>]): T & QueryHasWhere;
     /**
      * Acts as `whereIn`, but prepends `OR` to the condition and negates it with `NOT`:
      *
@@ -3907,7 +3882,7 @@ declare class Where {
      * db.table.whereNotIn('a', [1, 2, 3]).orWhereNoIn('b', ['one', 'two']);
      * ```
      */
-    orWhereNotIn<T extends PickQueryMetaRelations, Column extends WhereInColumn<T>>(this: T, ...args: [column: Column, values: WhereInValues<T, Column>] | [arg: WhereInArg<T>]): WhereResult<T>;
+    orWhereNotIn<T extends PickQuerySelectableRelations, Column extends WhereInColumn<T>>(this: T, ...args: [column: Column, values: WhereInValues<T, Column>] | [arg: WhereInArg<T>]): T & QueryHasWhere;
     /**
      * `whereExists` is for support of the `WHERE EXISTS (query)` clause.
      *
@@ -3929,11 +3904,11 @@ declare class Where {
      * db.user.whereExists(db.account, (q) => q.on('account.id', '=', 'user.id'));
      * ```
      */
-    whereExists<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): Arg extends QueryFnReturningSelect ? {
+    whereExists<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): Arg extends QueryFnReturningSelect ? {
         error: 'Cannot select in whereExists';
     } : Args[0] extends QueryFnReturningSelect ? {
         error: 'Cannot select in whereExists';
-    } : WhereResult<T>;
+    } : T & QueryHasWhere;
     /**
      * Acts as `whereExists`, but prepends the condition with `OR`:
      *
@@ -3943,7 +3918,7 @@ declare class Where {
      * db.user.whereExist('account').orWhereExists('profile');
      * ```
      */
-    orWhereExists<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
+    orWhereExists<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): T & QueryHasWhere;
     /**
      * Acts as `whereExists`, but negates the condition with `NOT`:
      *
@@ -3956,7 +3931,7 @@ declare class Where {
      * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
      * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
      */
-    whereNotExists<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
+    whereNotExists<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): T & QueryHasWhere;
     /**
      * Acts as `whereExists`, but prepends the condition with `OR` and negates it with `NOT`:
      *
@@ -3966,7 +3941,7 @@ declare class Where {
      * db.user.whereNotExists('account').orWhereNotExists('profile');
      * ```
      */
-    orWhereNotExists<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
+    orWhereNotExists<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): T & QueryHasWhere;
 }
 
 type SortDir = 'ASC' | 'DESC' | 'ASC NULLS FIRST' | 'DESC NULLS LAST';
@@ -4024,15 +3999,16 @@ declare const searchSourcesToSql: (ctx: ToSQLCtx, data: QueryData, sources: Quer
 declare const getSearchLang: (ctx: ToSQLCtx, data: QueryData, source: QuerySourceItem, quotedAs?: string) => string;
 declare const getSearchText: (ctx: ToSQLCtx, data: QueryData, source: QuerySourceItem, quotedAs?: string, forHeadline?: boolean) => MaybeArray<string>;
 
-type OrderArgSelf = PickQueryMetaResult;
+interface OrderArgSelf extends PickQuerySelectable, PickQueryResult, PickQueryTsQuery {
+}
 type OrderArg<T extends OrderArgSelf> = OrderArgKey<T> | OrderArgTsQuery<T> | {
     [K in OrderArgKey<T> | OrderArgTsQuery<T>]?: K extends OrderArgTsQuery<T> ? OrderTsQueryConfig : SortDir;
 } | Expression;
 type OrderArgs<T extends OrderArgSelf> = OrderArg<T>[];
-type OrderArgTsQuery<T extends OrderArgSelf> = string | undefined extends T['meta']['tsQuery'] ? never : Exclude<T['meta']['tsQuery'], undefined>;
+type OrderArgTsQuery<T extends OrderArgSelf> = string | undefined extends T['__tsQuery'] ? never : Exclude<T['__tsQuery'], undefined>;
 type OrderArgKey<T extends OrderArgSelf> = {
-    [K in keyof T['meta']['selectable']]: T['meta']['selectable'][K]['column']['queryType'] extends undefined ? never : K;
-}[keyof T['meta']['selectable']] | {
+    [K in keyof T['__selectable']]: T['__selectable'][K]['column']['queryType'] extends undefined ? never : K;
+}[keyof T['__selectable']] | {
     [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K;
 }[keyof T['result']];
 declare class QueryOrder {
@@ -4128,7 +4104,7 @@ declare class QueryWindow {
     window<T extends OrderArgSelf, W extends WindowArg<T>>(this: T, arg: W): WindowResult<T, W>;
 }
 
-interface AggregateOptions<T extends PickQueryMetaResultRelationsWindows> {
+interface AggregateOptions<T extends PickQuerySelectableResultRelationsWindows> {
     distinct?: boolean;
     order?: OrderArg<T> | OrderArgs<T>;
     filter?: WhereArg<T>;
@@ -4136,9 +4112,9 @@ interface AggregateOptions<T extends PickQueryMetaResultRelationsWindows> {
     withinGroup?: boolean;
     over?: Over<T>;
 }
-type Over<T extends PickQueryMetaResultWindows> = keyof T['windows'] | WindowArgDeclaration<T>;
-type FnExpressionArgs<Q extends PickQueryMeta> = (SelectableOrExpression<Q> | FnExpressionArgsPairs<Q> | FnExpressionArgsValue)[];
-interface FnExpressionArgsPairs<Q extends PickQueryMeta> {
+type Over<T extends PickQuerySelectableResultWindows> = keyof T['windows'] | WindowArgDeclaration<T>;
+type FnExpressionArgs<Q extends PickQuerySelectable> = (SelectableOrExpression<Q> | FnExpressionArgsPairs<Q> | FnExpressionArgsValue)[];
+interface FnExpressionArgsPairs<Q extends PickQuerySelectable> {
     pairs: {
         [K: string]: SelectableOrExpression<Q>;
     };
@@ -4165,11 +4141,11 @@ declare class FnExpression<Q extends Query = Query, T extends Column.Pick.QueryC
     constructor(query: Q, fn: string, args: FnExpressionArgs<Q>, options: AggregateOptions<Q>, value: T);
     makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
 }
-declare function makeFnExpression<T extends PickQueryMetaResultRelationsWindows, C extends Column.Pick.QueryColumn>(self: T, type: C, fn: string, args: FnExpressionArgs<Query>, options?: AggregateOptions<T>): SetQueryReturnsColumnOrThrow<T, C> & C['operators'];
+declare function makeFnExpression<T extends PickQuerySelectableResultRelationsWindows, C extends Column.Pick.QueryColumn>(self: T, type: C, fn: string, args: FnExpressionArgs<Query>, options?: AggregateOptions<T>): SetQueryReturnsColumnOrThrow<T, C> & C['operators'];
 
-type QueryGetSelf = PickQueryMetaTable;
+type QueryGetSelf = PickQuerySelectable;
 type GetArg<T extends QueryGetSelf> = GetStringArg<T> | Expression;
-type GetStringArg<T extends PickQueryMeta> = keyof T['meta']['selectable'] & string;
+type GetStringArg<T extends PickQuerySelectable> = keyof T['__selectable'] & string;
 type GetResult<T extends QueryGetSelf, Arg extends GetArg<T>> = Arg extends string ? SetQueryReturnsValueOrThrow<T, Arg> : Arg extends Expression ? SetQueryReturnsColumnOrThrow<T, Arg['result']['value']> : never;
 type GetResultOptional<T extends QueryGetSelf, Arg extends GetArg<T>> = Arg extends string ? SetQueryReturnsValueOptional<T, Arg> : Arg extends Expression ? SetQueryReturnsColumnOptional<T, Arg['result']['value']> : never;
 
@@ -4178,25 +4154,25 @@ interface OperatorsCount extends OperatorsNumber {
 }
 type CountColumn = Column.Pick.QueryColumnOfTypeAndOps<'int8', number, OperatorsCount>;
 type CountReturn<T> = SetQueryReturnsColumnOrThrow<T, CountColumn> & OperatorsCount;
-type SelectableDataType<T extends PickQueryMeta, DataType extends string> = {
-    [K in keyof T['meta']['selectable']]: T['meta']['selectable'][K]['column']['dataType'] extends DataType ? K : never;
-}[keyof T['meta']['selectable']] | Expression<Column.Pick.QueryColumnOfDataType<DataType>>;
-type NumericReturn<T extends PickQueryMeta, Arg> = Arg extends keyof T['meta']['selectable'] ? SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<T['meta']['selectable'][Arg]['column']['dataType'], T['meta']['selectable'][Arg]['column']['type'] | null, OperatorsNumber>> & OperatorsNumber : Arg extends Expression ? SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<Arg['result']['value']['dataType'], Arg['result']['value']['type'] | null, OperatorsNumber>> & OperatorsNumber : never;
+type SelectableDataType<T extends PickQuerySelectable, DataType extends string> = {
+    [K in keyof T['__selectable']]: T['__selectable'][K]['column']['dataType'] extends DataType ? K : never;
+}[keyof T['__selectable']] | Expression<Column.Pick.QueryColumnOfDataType<DataType>>;
+type NumericReturn<T extends PickQuerySelectable, Arg> = Arg extends keyof T['__selectable'] ? SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<T['__selectable'][Arg]['column']['dataType'], T['__selectable'][Arg]['column']['type'] | null, OperatorsNumber>> & OperatorsNumber : Arg extends Expression ? SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<Arg['result']['value']['dataType'], Arg['result']['value']['type'] | null, OperatorsNumber>> & OperatorsNumber : never;
 type NullableNumberReturn<T, DataType> = SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfTypeAndOps<DataType, number | null, OperatorsNumber>> & OperatorsNumber;
 type BooleanQueryColumn = Column.Pick.QueryColumnOfTypeAndOps<'bool', boolean, OperatorsBoolean>;
 type BooleanNullable = Column.Pick.QueryColumnOfTypeAndOps<'bool', boolean | null, OperatorsBoolean>;
 type NullableBooleanReturn<T> = SetQueryReturnsColumnOrThrow<T, BooleanNullable> & OperatorsBoolean;
-type NullableJSONAggReturn<T extends PickQueryMeta, Arg extends SelectableOrExpression<T>> = SetQueryReturnsColumnOrThrow<T, {
+type NullableJSONAggReturn<T extends PickQuerySelectable, Arg extends SelectableOrExpression<T>> = SetQueryReturnsColumnOrThrow<T, {
     dataType: 'json';
     type: (ExpressionOutput<T, Arg>['type'] | null)[] | null;
     outputType: (ExpressionOutput<T, Arg>['outputType'] | null)[] | null;
     queryType: (ExpressionOutput<T, Arg>['queryType'] | null)[] | null;
     operators: OperatorsArray<never>;
 }> & OperatorsArray<never>;
-interface RecordSelectableOrExpression<T extends PickQueryMeta> {
+interface RecordSelectableOrExpression<T extends PickQuerySelectable> {
     [K: string]: SelectableOrExpression<T>;
 }
-type NullableJSONObjectReturn<T extends PickQueryMeta, Obj extends RecordSelectableOrExpression<T>> = SetQueryReturnsColumnOrThrow<T, {
+type NullableJSONObjectReturn<T extends PickQuerySelectable, Obj extends RecordSelectableOrExpression<T>> = SetQueryReturnsColumnOrThrow<T, {
     dataType: 'json';
     type: {
         [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
@@ -4256,7 +4232,7 @@ declare class AggregateMethods {
      * @param arg - optionally, provide a column or a raw SQL for the `count` argument
      * @param options - aggregation options
      */
-    count<T extends PickQueryMetaResultRelationsWindows>(this: T, arg?: SelectableOrExpression<T>, options?: AggregateOptions<T>): CountReturn<T>;
+    count<T extends PickQuerySelectableResultRelationsWindows>(this: T, arg?: SelectableOrExpression<T>, options?: AggregateOptions<T>): CountReturn<T>;
     /**
      * Get the minimum value for the specified numeric column, returns number or `null` if there are no records.
      *
@@ -4278,7 +4254,7 @@ declare class AggregateMethods {
      * @param arg - numeric column or raw SQL
      * @param options - aggregation options
      */
-    min<T extends PickQueryMetaResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['minMax']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
+    min<T extends PickQuerySelectableResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['minMax']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
     /**
      * Gets the maximum value for the specified numeric column, returns number or `null` if there are no records.
      *
@@ -4300,7 +4276,7 @@ declare class AggregateMethods {
      * @param arg - numeric column or raw SQL
      * @param options - aggregation options
      */
-    max<T extends PickQueryMetaResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['minMax']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
+    max<T extends PickQuerySelectableResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['minMax']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
     /**
      * Retrieve the sum of the values of a given numeric column, returns number or `null` if there are no records.
      *
@@ -4321,7 +4297,7 @@ declare class AggregateMethods {
      * @param arg - numeric column or raw SQL
      * @param options - aggregation options
      */
-    sum<T extends PickQueryMetaResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['sum']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
+    sum<T extends PickQuerySelectableResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['sum']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
     /**
      * Retrieve the average value of a numeric column, it returns a number or `null` if there are no records.
      *
@@ -4339,7 +4315,7 @@ declare class AggregateMethods {
      * @param arg - numeric column or raw SQL
      * @param options - aggregation options
      */
-    avg<T extends PickQueryMetaResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['avg']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
+    avg<T extends PickQuerySelectableResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['avg']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
     /**
      * Bitwise `and` aggregation, returns `number` or `null` if there are no records.
      *
@@ -4360,7 +4336,7 @@ declare class AggregateMethods {
      * @param arg - numeric column or raw SQL
      * @param options - aggregation options
      */
-    bitAnd<T extends PickQueryMetaResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['bit']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
+    bitAnd<T extends PickQuerySelectableResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['bit']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
     /**
      * Bitwise `or` aggregation, returns `number` or `null` if there are no records.
      *
@@ -4378,7 +4354,7 @@ declare class AggregateMethods {
      * @param arg - numeric column or raw SQL
      * @param options - aggregation options
      */
-    bitOr<T extends PickQueryMetaResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['bit']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
+    bitOr<T extends PickQuerySelectableResultRelationsWindows, Arg extends SelectableDataType<T, AggregateArgTypes['bit']>>(this: T, arg: Arg, options?: AggregateOptions<T>): NumericReturn<T, Arg>;
     /**
      * Aggregate booleans with `and` logic, it returns `boolean` or `null` if there are no records.
      *
@@ -4399,7 +4375,7 @@ declare class AggregateMethods {
      * @param arg - boolean column or raw SQL
      * @param options - aggregation options
      */
-    boolAnd<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableDataType<T, AggregateArgTypes['bool']>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
+    boolAnd<T extends PickQuerySelectableResultRelationsWindows>(this: T, arg: SelectableDataType<T, AggregateArgTypes['bool']>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
     /**
      * Aggregate booleans with `or` logic, it returns `boolean` or `null` if there are no records.
      *
@@ -4420,11 +4396,11 @@ declare class AggregateMethods {
      * @param arg - boolean column or raw SQL
      * @param options - aggregation options
      */
-    boolOr<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableDataType<T, AggregateArgTypes['bool']>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
+    boolOr<T extends PickQuerySelectableResultRelationsWindows>(this: T, arg: SelectableDataType<T, AggregateArgTypes['bool']>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
     /**
      * Equivalent to {@link boolAnd}
      */
-    every<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableDataType<T, AggregateArgTypes['bool']>, options?: AggregateOptions<T>): NullableBooleanReturn<T>;
+    every<T extends PickQuerySelectableResultRelationsWindows>(this: T, arg: SelectableDataType<T, AggregateArgTypes['bool']>, 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.
      *
@@ -4449,11 +4425,11 @@ declare class AggregateMethods {
      * @param arg - any column or raw SQL
      * @param options - aggregation options
      */
-    jsonAgg<T extends PickQueryMetaResultRelationsWindows, Arg extends SelectableOrExpression<T>>(this: T, arg: Arg, options?: AggregateOptions<T>): NullableJSONAggReturn<T, Arg>;
+    jsonAgg<T extends PickQuerySelectableResultRelationsWindows, Arg extends SelectableOrExpression<T>>(this: T, arg: Arg, options?: AggregateOptions<T>): NullableJSONAggReturn<T, Arg>;
     /**
      * See {@link jsonAgg}
      */
-    jsonbAgg<T extends PickQueryMetaResultRelationsWindows, Arg extends SelectableOrExpression<T>>(this: T, arg: Arg, options?: AggregateOptions<T>): NullableJSONAggReturn<T, Arg>;
+    jsonbAgg<T extends PickQuerySelectableResultRelationsWindows, Arg extends SelectableOrExpression<T>>(this: T, arg: Arg, options?: AggregateOptions<T>): NullableJSONAggReturn<T, Arg>;
     /**
      * It does the construction of JSON objects, keys are provided strings and values can be table columns or raw SQL expressions, and returns `object` or `null` if no records.
      *
@@ -4486,11 +4462,11 @@ declare class AggregateMethods {
      * @param arg - object where values are column names or SQL
      * @param options - aggregation options
      */
-    jsonObjectAgg<T extends PickQueryMetaResultRelationsWindows, Obj extends RecordSelectableOrExpression<T>>(this: T, arg: Obj, options?: AggregateOptions<T>): NullableJSONObjectReturn<T, Obj>;
+    jsonObjectAgg<T extends PickQuerySelectableResultRelationsWindows, Obj extends RecordSelectableOrExpression<T>>(this: T, arg: Obj, options?: AggregateOptions<T>): NullableJSONObjectReturn<T, Obj>;
     /**
      * See {@link jsonObjectAgg}
      */
-    jsonbObjectAgg<T extends PickQueryMetaResultRelationsWindows, Obj extends RecordSelectableOrExpression<T>>(this: T, arg: Obj, options?: AggregateOptions<T>): NullableJSONObjectReturn<T, Obj>;
+    jsonbObjectAgg<T extends PickQuerySelectableResultRelationsWindows, Obj extends RecordSelectableOrExpression<T>>(this: T, arg: Obj, options?: AggregateOptions<T>): NullableJSONObjectReturn<T, Obj>;
     /**
      * Select joined strings, it returns a string or `null` if no records.
      *
@@ -4513,7 +4489,7 @@ declare class AggregateMethods {
      * @param delimiter - string to join with
      * @param options - aggration options
      */
-    stringAgg<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableDataType<T, AggregateArgTypes['stringAgg']>, delimiter: string, options?: AggregateOptions<T>): NullableStringReturn<T>;
+    stringAgg<T extends PickQuerySelectableResultRelationsWindows>(this: T, arg: SelectableDataType<T, AggregateArgTypes['stringAgg']>, delimiter: string, options?: AggregateOptions<T>): NullableStringReturn<T>;
     /**
      * Concatenates `xml` columns, returns a `string` or `null` if no records.
      *
@@ -4531,7 +4507,7 @@ declare class AggregateMethods {
      * @param arg - column or SQL with XML
      * @param options - aggregation options
      */
-    xmlAgg<T extends PickQueryMetaResultRelationsWindows>(this: T, arg: SelectableOrExpressionOfType<T, StringColumn>, options?: AggregateOptions<T>): NullableStringReturn<T>;
+    xmlAgg<T extends PickQuerySelectableResultRelationsWindows>(this: T, arg: SelectableOrExpressionOfType<T, StringColumn>, options?: AggregateOptions<T>): NullableStringReturn<T>;
     /**
      * Selects the` row_number` window function.
      *
@@ -4550,7 +4526,7 @@ declare class AggregateMethods {
      *
      * @param over - OVER clause config
      */
-    rowNumber<T extends PickQueryMetaResultRelationsWindows>(this: T, over?: Over<T>): NullableNumberReturn<T, 'int8'>;
+    rowNumber<T extends PickQuerySelectableResultRelationsWindows>(this: T, over?: Over<T>): NullableNumberReturn<T, 'int8'>;
     /**
      * Selects the` rank` window function.
      *
@@ -4569,7 +4545,7 @@ declare class AggregateMethods {
      *
      * @param over - OVER clause config
      */
-    rank<T extends PickQueryMetaResultRelationsWindows>(this: T, over?: Over<T>): NullableNumberReturn<T, 'int8'>;
+    rank<T extends PickQuerySelectableResultRelationsWindows>(this: T, over?: Over<T>): NullableNumberReturn<T, 'int8'>;
     /**
      * Selects the` dense_rank` window function.
      *
@@ -4588,7 +4564,7 @@ declare class AggregateMethods {
      *
      * @param over - OVER clause config
      */
-    denseRank<T extends PickQueryMetaResultRelationsWindows>(this: T, over?: Over<T>): NullableNumberReturn<T, 'int8'>;
+    denseRank<T extends PickQuerySelectableResultRelationsWindows>(this: T, over?: Over<T>): NullableNumberReturn<T, 'int8'>;
     /**
      * Selects the `percent_rank` window function.
      *
@@ -4607,7 +4583,7 @@ declare class AggregateMethods {
      *
      * @param over - OVER clause config
      */
-    percentRank<T extends PickQueryMetaResultRelationsWindows>(this: T, over?: Over<T>): NullableNumberReturn<T, 'float8'>;
+    percentRank<T extends PickQuerySelectableResultRelationsWindows>(this: T, over?: Over<T>): NullableNumberReturn<T, 'float8'>;
     /**
      * Selects the `cume_dist` window function.
      *
@@ -4626,7 +4602,7 @@ declare class AggregateMethods {
      *
      * @param over - OVER clause config
      */
-    cumeDist<T extends PickQueryMetaResultRelationsWindows>(this: T, over?: Over<T>): NullableNumberReturn<T, 'float8'>;
+    cumeDist<T extends PickQuerySelectableResultRelationsWindows>(this: T, over?: Over<T>): NullableNumberReturn<T, 'float8'>;
 }
 
 type OrExpressionArg = QueryOrExpressionBooleanOrNullResult | undefined;
@@ -4642,30 +4618,25 @@ declare class OrExpression extends Expression<BooleanQueryColumn> {
     makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
 }
 
-type FromQuerySelf = PickQueryMetaTableShapeReturnTypeWithData;
-type FromArg<T extends FromQuerySelf> = PickQueryTableMetaResult | Exclude<keyof T['withData'], symbol | number>;
+interface FromQuerySelf extends PickQuerySelectable, PickQueryShape, PickQueryReturnType, PickQueryWithData, PickQueryAs, PickQueryHasSelect {
+}
+type FromArg<T extends FromQuerySelf> = IsQuery | Exclude<keyof T['withData'], symbol | number>;
 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> : K extends 'kind' ? 'select' : T['meta'][K];
-    } : K extends 'result' ? T['withData'][Arg]['shape'] : K extends 'then' ? QueryThenByQuery<T, T['withData'][Arg]['shape']> : T[K];
-} : SetQueryTableAlias<T, Arg> : Arg extends PickQueryTableMetaResultInputType ? {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'as' ? AliasOrTable<Arg> : K extends 'selectable' ? SelectableFromShape<Arg['result'], AliasOrTable<Arg>> : K extends 'kind' ? 'select' : K extends 'defaultSelect' ? keyof Arg['result'] : T['meta'][K];
-    } : K extends 'result' ? Arg['result'] : K extends 'shape' ? Arg['result'] : K extends 'inputType' ? Arg['inputType'] : K extends 'then' ? QueryThenByQuery<T, Arg['result']> : T[K];
+    [K in keyof T]: K extends '__selectable' ? SelectableFromShape<T['withData'][Arg]['shape'], Arg> : K extends 'result' ? T['withData'][Arg]['shape'] : K extends 'then' ? QueryThenByQuery<T, T['withData'][Arg]['shape']> : T[K];
+} : SetQueryTableAlias<T, Arg> : Arg extends PickQuerySelectableResultInputTypeAs ? {
+    [K in keyof T]: K extends '__defaultSelect' ? keyof Arg['result'] : K extends '__selectable' ? SelectableFromShape<Arg['result'], Arg['__as']> : K extends '__as' ? Arg['__as'] : K extends 'result' ? Arg['result'] : K extends 'shape' ? Arg['result'] : K extends 'inputType' ? Arg['inputType'] : K extends 'then' ? QueryThenByQuery<T, Arg['result']> : T[K];
 } : Arg extends (infer A)[] ? {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'selectable' ? UnionToIntersection<A extends string ? T['withData'] extends WithDataItems ? {
-            [K in keyof T['withData'][A]['shape'] & string as `${A}.${K}`]: {
-                as: K;
-                column: T['withData'][A]['shape'][K];
-            };
-        } : never : A extends PickQueryTableMetaResult ? {
-            [K in keyof A['result'] & string as `${AliasOrTable<A>}.${K}`]: K extends string ? {
-                as: K;
-                column: A['result'][K];
-            } : never;
-        } : never> : T['meta'][K];
-    } : T[K];
+    [K in keyof T]: K extends '__selectable' ? UnionToIntersection<A extends string ? T['withData'] extends WithDataItems ? {
+        [K in keyof T['withData'][A]['shape'] & string as `${A}.${K}`]: {
+            as: K;
+            column: T['withData'][A]['shape'][K];
+        };
+    } : never : A extends PickQueryResultAs ? {
+        [K in keyof A['result'] & string as `${A['__as']}.${K}`]: K extends string ? {
+            as: K;
+            column: A['result'][K];
+        } : never;
+    } : never> : T[K];
 } : 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;
@@ -4701,7 +4672,7 @@ declare class FromMethods {
      *
      * @param arg - query or name of CTE table
      */
-    from<T extends FromQuerySelf, Arg extends MaybeArray<FromArg<T>>>(this: T, arg: T['meta']['hasSelect'] extends true ? '`select` must be placed after `from`' : Arg): FromResult<T, Arg>;
+    from<T extends FromQuerySelf, Arg extends MaybeArray<FromArg<T>>>(this: T, arg: T['__hasSelect'] extends true ? '`select` must be placed after `from`' : Arg): FromResult<T, Arg>;
     /**
      * Set the `FROM` value with custom SQL:
      *
@@ -5214,14 +5185,14 @@ declare abstract class QueryHooks {
     catchAfterCommitError<T>(this: T, fn: AfterCommitErrorHandler): T;
 }
 
-type MergeQuery<T extends PickQueryMetaResultReturnTypeWithDataWindowsThen, Q extends PickQueryMetaResultReturnTypeWithDataWindowsThen> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta'] | keyof Q['meta']]: K extends 'selectable' ? Q['meta']['selectable'] & Omit<T['meta']['selectable'], keyof Q['meta']['selectable']> : K extends 'hasWhere' | 'hasSelect' ? T['meta'][K] & Q['meta'][K] : K extends keyof Q['meta'] ? Q['meta'][K] : T['meta'][K];
-    } : K extends 'result' ? MergeQueryResult<T, Q> : K extends 'returnType' ? Q['returnType'] extends undefined ? T['returnType'] : Q['returnType'] : K extends 'then' ? Q['returnType'] extends undefined ? QueryThenByQuery<T, MergeQueryResult<T, Q>> : Q['returnType'] extends 'all' | 'one' | 'oneOrThrow' | 'rows' ? QueryThenByQuery<Q, MergeQueryResult<T, Q>> : Q['meta']['hasSelect'] extends true ? Q['then'] : T['meta']['hasSelect'] extends true ? T['then'] : Q['then'] : K extends 'windows' ? Q['windows'] & Omit<T['windows'], keyof Q['windows']> : K extends 'withData' ? Q['withData'] & Omit<T['withData'], keyof Q['withData']> : T[K];
+interface MergeQueryArg extends PickQueryTable, PickQuerySelectable, PickQueryResult, PickQueryReturnType, PickQueryWithData, PickQueryWindows, PickQueryThen, PickQueryHasSelect, PickQueryHasWhere {
+}
+type MergeQuery<T extends MergeQueryArg, Q extends MergeQueryArg> = {
+    [K in keyof T]: K extends '__hasWhere' | '__hasSelect' ? T[K] & Q[K] : K extends '__selectable' | 'windows' | 'withData' ? Q[K] & Omit<T[K], keyof Q[K]> : K extends 'result' ? MergeQueryResult<T, Q> : K extends 'returnType' ? Q['returnType'] extends undefined ? T['returnType'] : Q['returnType'] : K extends 'then' ? Q['returnType'] extends undefined ? QueryThenByQuery<T, MergeQueryResult<T, Q>> : Q['returnType'] extends 'all' | 'one' | 'oneOrThrow' | 'rows' ? QueryThenByQuery<Q, MergeQueryResult<T, Q>> : Q['__hasSelect'] extends true ? Q['then'] : T['__hasSelect'] extends true ? T['then'] : Q['then'] : T[K];
 };
-type MergeQueryResult<T extends PickQueryMetaResult, Q extends PickQueryMetaResult> = T['meta']['hasSelect'] extends true ? Q['meta']['hasSelect'] extends true ? Omit<T['result'], keyof Q['result']> & Q['result'] : T['result'] : Q['result'];
+type MergeQueryResult<T extends PickQueryHasSelectResult, Q extends PickQueryHasSelectResult> = T['__hasSelect'] extends true ? Q['__hasSelect'] extends true ? Omit<T['result'], keyof Q['result']> & Q['result'] : T['result'] : Q['result'];
 declare class MergeQueryMethods {
-    merge<T extends PickQueryMetaResultReturnTypeWithDataWindowsThen, Q extends PickQueryMetaResultReturnTypeWithDataWindowsThen>(this: T, q: Q): MergeQuery<T, Q>;
+    merge<T extends MergeQueryArg, Q extends MergeQueryArg>(this: T, q: Q): MergeQuery<T, Q>;
 }
 
 type CreateFromMethodNames = 'createOneFrom' | 'insertOneFrom' | CreateManyFromMethodNames;
@@ -5232,12 +5203,12 @@ interface QueryReturningOne extends IsQuery {
 }
 type CreateRawOrFromResult<T extends CreateSelf> = T extends {
     isCount: true;
-} ? SetQueryKind<T, 'create'> : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKind<T, 'create'> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKind<T, 'create'> : SetQueryKind<T, 'create'>;
-type InsertRawOrFromResult<T extends CreateSelf> = T['meta']['hasSelect'] extends true ? T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKind<T, 'create'> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKind<T, 'create'> : SetQueryKind<T, 'create'> : SetQueryReturnsRowCount<T, 'create'>;
+} ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOne<T> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumn<T> : T;
+type InsertRawOrFromResult<T extends CreateSelf> = T['__hasSelect'] extends true ? T['returnType'] extends undefined | 'all' ? SetQueryReturnsOne<T> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumn<T> : T : SetQueryReturnsRowCount<T>;
 type CreateManyFromResult<T extends CreateSelf> = T extends {
     isCount: true;
-} ? SetQueryKind<T, 'create'> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKind<T, 'create'> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKind<T, 'create'> : SetQueryKind<T, 'create'>;
-type InsertManyFromResult<T extends CreateSelf> = T['meta']['hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKind<T, 'create'> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKind<T, 'create'> : SetQueryKind<T, 'create'> : SetQueryReturnsRowCountMany<T, 'create'>;
+} ? T : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAll<T> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetValueQueryReturnsPluckColumn<T> : T;
+type InsertManyFromResult<T extends CreateSelf> = T['__hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAll<T> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetValueQueryReturnsPluckColumn<T> : T : SetQueryReturnsRowCountMany<T>;
 /**
  * Function to collect column names from the inner query of create `from` methods.
  *
@@ -5413,10 +5384,9 @@ declare class QueryCreateFrom {
     insertForEachFrom<T extends CreateSelf>(this: T, query: IsQuery): InsertManyFromResult<T>;
 }
 
-interface CreateSelf extends IsQuery, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryUniqueProperties {
-    inputType: RecordUnknown;
+interface CreateSelf extends IsQuery, PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryUniqueProperties, PickQueryInputType {
 }
-type CreateData<T extends CreateSelf> = EmptyObject extends T['relations'] ? CreateDataWithDefaults<T, keyof T['meta']['defaults']> : CreateRelationsData<T>;
+type CreateData<T extends CreateSelf> = EmptyObject extends T['relations'] ? CreateDataWithDefaults<T, keyof T['__defaults']> : CreateRelationsData<T>;
 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, K>;
 } & {
@@ -5428,25 +5398,25 @@ type CreateDataWithDefaultsForRelations<T extends CreateSelf, Defaults extends k
     [K in Defaults as K extends OmitFKeys ? never : K]?: CreateColumn<T, K>;
 };
 type CreateColumn<T extends CreateSelf, K extends keyof T['inputType']> = T['inputType'][K] | ((q: T) => QueryOrExpression<T['inputType'][K]>);
-type CreateRelationsData<T extends CreateSelf> = CreateDataWithDefaultsForRelations<T, keyof T['meta']['defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateBelongsToData<T> & T['relations'][keyof T['relations']]['optionalDataForCreate'];
+type CreateRelationsData<T extends CreateSelf> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateBelongsToData<T> & T['relations'][keyof T['relations']]['optionalDataForCreate'];
 type CreateBelongsToData<T extends CreateSelf> = [
     T['relations'][keyof T['relations']]['dataForCreate']
 ] extends [never] ? EmptyObject : CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['dataForCreate']>;
-type CreateRelationsDataOmittingFKeys<T extends CreateSelf, Union> = (Union extends RelationConfigDataForCreate ? (u: Union['columns'] extends keyof T['meta']['defaults'] ? {
-    [P in Exclude<Union['columns'] & keyof T['inputType'], keyof T['meta']['defaults']>]: CreateColumn<T, P>;
+type CreateRelationsDataOmittingFKeys<T extends CreateSelf, Union> = (Union extends RelationConfigDataForCreate ? (u: Union['columns'] extends keyof T['__defaults'] ? {
+    [P in Exclude<Union['columns'] & keyof T['inputType'], keyof T['__defaults']>]: CreateColumn<T, P>;
 } & {
-    [P in keyof T['meta']['defaults'] & Union['columns']]?: CreateColumn<T, P>;
+    [P in keyof T['__defaults'] & Union['columns']]?: CreateColumn<T, P>;
 } & Partial<Union['nested']> : {
     [P in Union['columns'] & keyof T['inputType']]: CreateColumn<T, P>;
 } | Union['nested']) => void : never) extends (u: infer Obj) => void ? Obj : never;
 type CreateResult<T extends CreateSelf> = T extends {
     isCount: true;
-} ? SetQueryKind<T, 'create'> : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKindResult<T, 'create', NarrowCreateResult<T>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T>>;
-type InsertResult<T extends CreateSelf> = T['meta']['hasSelect'] extends true ? T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneKindResult<T, 'create', NarrowCreateResult<T>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryReturnsRowCount<T, 'create'>;
+} ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneResult<T, NarrowCreateResult<T>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnResult<T, NarrowCreateResult<T>> : SetQueryResult<T, NarrowCreateResult<T>>;
+type InsertResult<T extends CreateSelf> = T['__hasSelect'] extends true ? T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneResult<T, NarrowCreateResult<T>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnResult<T, NarrowCreateResult<T>> : SetQueryResult<T, NarrowCreateResult<T>> : SetQueryReturnsRowCount<T>;
 type CreateManyResult<T extends CreateSelf> = T extends {
     isCount: true;
-} ? SetQueryKindResult<T, 'create', NarrowCreateResult<T>> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKindResult<T, 'create', NarrowCreateResult<T>> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T>>;
-type InsertManyResult<T extends CreateSelf> = T['meta']['hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllKindResult<T, 'create', NarrowCreateResult<T>> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryKindResult<T, 'create', NarrowCreateResult<T>> : SetQueryReturnsRowCountMany<T, 'create'>;
+} ? SetQueryResult<T, NarrowCreateResult<T>> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllResult<T, NarrowCreateResult<T>> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnResult<T, NarrowCreateResult<T>> : SetQueryResult<T, NarrowCreateResult<T>>;
+type InsertManyResult<T extends CreateSelf> = T['__hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllResult<T, NarrowCreateResult<T>> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnResult<T, NarrowCreateResult<T>> : SetQueryResult<T, NarrowCreateResult<T>> : SetQueryReturnsRowCountMany<T>;
 /**
  * When creating a record with a *belongs to* nested record,
  * un-nullify foreign key columns of the result.
@@ -5460,9 +5430,9 @@ type IgnoreResult<T extends CreateSelf> = T['returnType'] extends 'oneOrThrow' ?
 type OnConflictArg<T extends PickQueryUniqueProperties> = T['internal']['uniqueColumnNames'] | T['internal']['uniqueColumnTuples'] | Expression | {
     constraint: T['internal']['uniqueConstraints'];
 };
-type AddQueryDefaults<T extends CreateSelf, Defaults> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'defaults' ? T['meta']['defaults'] & Defaults : T['meta'][K];
+type AddQueryDefaults<T extends CreateSelf, DefaultKeys extends PropertyKey> = {
+    [K in keyof T]: K extends '__defaults' ? {
+        [K in keyof T['__defaults'] | DefaultKeys]: true;
     } : T[K];
 };
 /**
@@ -5526,7 +5496,7 @@ declare const _queryCreate: <T extends CreateSelf>(q: T, data: CreateData<T>) =>
 declare const _queryInsert: <T extends CreateSelf>(query: T, data: CreateData<T>) => InsertResult<T>;
 declare const _queryCreateMany: <T extends CreateSelf>(q: T, data: CreateData<T>[]) => CreateManyResult<T>;
 declare const _queryInsertMany: <T extends CreateSelf>(q: T, data: CreateData<T>[]) => InsertManyResult<T>;
-declare const _queryDefaults: <T extends CreateSelf, Data extends Partial<CreateData<T>>>(q: T, data: Data) => AddQueryDefaults<T, { [K in keyof Data]: true; }>;
+declare const _queryDefaults: <T extends CreateSelf, Data extends Partial<CreateData<T>>>(q: T, data: Data) => AddQueryDefaults<T, keyof Data>;
 /**
  * Names of all create methods,
  * is used in relational query to remove these methods if chained relation shouldn't have them,
@@ -5661,9 +5631,7 @@ declare class QueryCreate {
      *
      * @param data - default values for `create` and `createMany` which will follow `defaults`
      */
-    defaults<T extends CreateSelf, Data extends Partial<CreateData<T>>>(this: T, data: Data): AddQueryDefaults<T, {
-        [K in keyof Data]: true;
-    }>;
+    defaults<T extends CreateSelf, Data extends Partial<CreateData<T>>>(this: T, data: Data): AddQueryDefaults<T, keyof Data>;
     /**
      * By default, violating unique constraint will cause the creative query to throw,
      * you can define what to do on a conflict: to ignore it, or to merge the existing record with a new data.
@@ -5891,8 +5859,7 @@ type OnConflictMerge = string | string[] | {
 declare const makeInsertSql: (ctx: ToSQLCtx, q: ToSQLQuery, query: QueryData, quotedAs: string, isSubSql?: boolean) => Sql;
 declare const makeReturningSql: (ctx: ToSQLCtx, q: ToSQLQuery, data: QueryData, quotedAs: string, delayedRelationSelect: DelayedRelationSelect | undefined, hookPurpose?: HookPurpose, addHookPurpose?: HookPurpose, isSubSql?: boolean) => string | undefined;
 
-interface UpdateSelf extends PickQueryMetaResultRelationsWithDataReturnTypeShape {
-    inputType: RecordUnknown;
+interface UpdateSelf extends PickQuerySelectable, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryInputType, PickQueryShape, PickQueryAs, PickQueryHasSelect, PickQueryHasWhere {
 }
 type UpdateData<T extends UpdateSelf> = EmptyObject extends T['relations'] ? {
     [K in keyof T['inputType']]?: UpdateColumn<T, K>;
@@ -5903,8 +5870,8 @@ type UpdateColumn<T extends UpdateSelf, Key extends keyof T['inputType']> = T['i
     [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T ? T[K] : never;
 }) => QueryOrExpression<T['inputType'][Key]>);
 type UpdateRelationData<T extends UpdateSelf, Rel extends RelationConfigBase> = T['returnType'] extends undefined | 'all' ? Rel['dataForUpdate'] : Rel['dataForUpdateOne'];
-type UpdateArg<T extends UpdateSelf> = T['meta']['hasWhere'] extends true ? UpdateData<T> : 'Update statement must have where conditions. To update all prefix `update` with `all()`';
-type UpdateResult<T extends UpdateSelf> = T['meta']['hasSelect'] extends true ? SetQueryKind<T, 'update'> : T['returnType'] extends undefined | 'all' ? SetQueryReturnsRowCountMany<T, 'update'> : SetQueryReturnsRowCount<T, 'update'>;
+type UpdateArg<T extends UpdateSelf> = T['__hasWhere'] extends true ? UpdateData<T> : 'Update statement must have where conditions. To update all prefix `update` with `all()`';
+type UpdateResult<T extends UpdateSelf> = T['__hasSelect'] extends true ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsRowCountMany<T> : SetQueryReturnsRowCount<T>;
 type NumericColumns<T extends UpdateSelf> = {
     [K in keyof T['inputType']]: Exclude<T['shape'][K]['queryType'], string> extends number | bigint | null ? K : never;
 }[keyof T['inputType']];
@@ -6196,7 +6163,7 @@ declare class Update {
      *   .set({ authorName: (q) => q.ref('author.name') });
      * ```
      */
-    updateFrom<T extends PickQueryMetaResultRelationsWithDataReturnTypeShape, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<WhereResult<T>, Arg, Args, true, true>;
+    updateFrom<T extends UpdateSelf, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResultFromArgs<T, Arg, Args, true, true> & QueryHasWhere;
     /**
      * Use after {@link updateFrom}
      */
@@ -6286,14 +6253,11 @@ type UpsertCreate<DataKey extends PropertyKey, CD> = {
 } & {
     [K in DataKey]?: K extends keyof CD ? CD[K] : never;
 };
-type UpsertResult<T extends PickQueryMetaResultReturnType> = T['meta']['hasSelect'] extends true ? T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsValueOrThrowKind<T, 'upsert'> : SetQueryReturnsOneKind<T, 'upsert'> : SetQueryReturnsVoidKind<T, 'upsert'>;
+type UpsertResult<T extends PickQueryHasSelectResultReturnType> = T['__hasSelect'] extends true ? T['returnType'] extends 'value' | 'valueOrThrow' ? SetValueQueryReturnsValueOrThrow<T> : SetQueryReturnsOne<T> : SetQueryReturnsVoid<T>;
 interface UpsertThis extends UpdateSelf, CreateSelf {
-    meta: MetaPropHasWhere;
+    __hasWhere: true;
     returnType: 'one' | 'oneOrThrow' | 'value' | 'valueOrThrow' | 'void';
 }
-interface MetaPropHasWhere extends QueryMetaBase {
-    hasWhere: true;
-}
 interface QueryUpsert {
     /**
      * `upsert` tries to update a single record, and then it creates the record if it doesn't yet exist.
@@ -6413,7 +6377,7 @@ interface QueryUpsert {
 declare const QueryUpsert: QueryUpsert;
 
 type OrCreateArg<Data> = Data | (() => Data);
-declare function _orCreate<T extends PickQueryMetaResultReturnType>(query: T, data: unknown | FnUnknownToUnknown, updateData?: unknown, mergeData?: unknown): UpsertResult<T>;
+declare function _orCreate<T extends PickQueryHasSelectResultReturnType>(query: T, data: unknown | FnUnknownToUnknown, updateData?: unknown, mergeData?: unknown): UpsertResult<T>;
 interface QueryOrCreate {
     /**
      * `orCreate` creates a record only if it was not found by conditions.
@@ -6485,17 +6449,8 @@ interface QueryOrCreate {
 }
 declare const QueryOrCreate: QueryOrCreate;
 
-interface QueryInternalColumnNameToKey {
-    columnNameToKeyMap?: Map<string, string>;
-}
-/**
- * In snake case mode, or when columns have custom names,
- * use this method to exchange a db column name to its runtime key.
- */
-declare const queryColumnNameToKey: (q: QueryBase, name: string) => string | undefined;
-
-declare const getPrimaryKeys: (q: QueryBase) => string[];
-declare const requirePrimaryKeys: (q: QueryBase, message: string) => string[];
+declare const getPrimaryKeys: (q: Query) => string[];
+declare const requirePrimaryKeys: (q: Query, message: string) => string[];
 
 declare const checkIfASimpleQuery: (q: PickQueryQ) => boolean;
 
@@ -6586,7 +6541,7 @@ interface WindowDeclaration {
 declare const windowToSql: (ctx: ToSQLCtx, data: QueryData, window: string | WindowDeclaration | Expression, quotedAs?: string) => string;
 
 type WrapQueryArg = FromQuerySelf;
-declare function queryWrap<T extends PickQueryTableMetaResult, Q extends WrapQueryArg, As extends string = 't'>(self: T, query: Q, as?: As): SetQueryTableAlias<Q, As>;
+declare function queryWrap<T extends IsQuery, 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`,
@@ -6595,7 +6550,7 @@ declare function queryWrap<T extends PickQueryTableMetaResult, Q extends WrapQue
  */
 declare function cloneQueryBaseUnscoped(query: Query): Query;
 declare class QueryWrap {
-    wrap<T extends PickQueryTableMetaResult, Q extends WrapQueryArg, As extends string = 't'>(this: T, query: Q, as?: As): SetQueryTableAlias<Q, As>;
+    wrap<T extends IsQuery, Q extends WrapQueryArg, As extends string = 't'>(this: T, query: Q, as?: As): SetQueryTableAlias<Q, As>;
 }
 
 /**
@@ -6642,24 +6597,6 @@ declare const _queryExec: <T extends IsQuery>(q: T) => never;
 declare const _queryRows: <T extends PickQueryResult>(q: T) => SetQueryReturnsRows<T>;
 declare const getFullColumnTable: (q: IsQuery, column: string, index: number, as: string | getValueKey | undefined) => string;
 
-interface QueryInternalTableDataPrimaryKey {
-    columns: string[];
-    name?: string;
-}
-interface QueryInternalTableDataBase {
-    primaryKey?: QueryInternalTableDataPrimaryKey;
-}
-interface QueryInternalBase extends QueryInternalColumnNameToKey {
-    runtimeDefaultColumns?: string[];
-    transactionStorage: AsyncLocalStorage<TransactionState>;
-    scopes?: RecordUnknown;
-    snakeCase?: boolean;
-    noPrimaryKey: boolean;
-    comment?: string;
-    primaryKeys?: string[];
-    tableData: QueryInternalTableDataBase;
-}
-
 interface TableData {
     primaryKey?: TableData.PrimaryKey;
     indexes?: TableData.Index[];
@@ -7486,12 +7423,17 @@ interface OperatorToSQL {
     (key: string, args: [unknown], ctx: unknown, quotedAs?: string): string;
 }
 interface Operator<Value, Column extends Column.Pick.OutputTypeAndOperators = Column.Pick.OutputTypeAndOperators> {
-    <T extends PickQueryResult>(this: T, arg: Value): Omit<SetQueryReturnsColumnOrThrow<T, Column>, keyof T['result']['value']['operators']> & Column['operators'];
+    <T extends PickQueryResult>(this: T, arg: Value): {
+        [K in Exclude<keyof T, keyof T['result']['value']['operators']>]: K extends 'result' ? {
+            value: Column;
+        } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['outputType']> : T[K];
+    } & Column['operators'];
     _opType: Value;
 }
 declare function setQueryOperators(query: IsQuery, operators: RecordUnknown): IsQuery;
 declare const prepareOpArg: (q: unknown, arg: unknown) => SubQueryForSql | undefined;
 interface Base<Value> {
+    __hasSelect: true;
     equals: Operator<Value | IsQuery | Expression, BooleanQueryColumn>;
     not: Operator<Value | IsQuery | Expression, BooleanQueryColumn>;
     in: Operator<Value[] | IsQuery | Expression, BooleanQueryColumn>;
@@ -7710,7 +7652,7 @@ interface OperatorsArray<T> extends Ord<T[]> {
     containedIn: Operator<T[] | IsQuery | Expression, BooleanQueryColumn>;
     length: {
         _opType: number | {
-            [K in keyof OperatorsNumber]?: OperatorsNumber[K]['_opType'];
+            [K in Exclude<keyof OperatorsNumber, '__hasSelect'>]?: OperatorsNumber[K]['_opType'];
         };
     };
 }
@@ -7726,17 +7668,9 @@ declare const Operators: {
     array: OperatorsArray<unknown>;
 };
 
-type SelectableOrExpression<T extends PickQueryMeta = PickQueryMeta, C extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> = '*' | keyof T['meta']['selectable'] | Expression<C>;
-type SelectableOrExpressions<T extends {
-    meta: {
-        selectable: unknown;
-    };
-} = {
-    meta: {
-        selectable: unknown;
-    };
-}, C extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> = ('*' | keyof T['meta']['selectable'] | Expression<C>)[];
-type ExpressionOutput<T extends PickQueryMeta, Expr extends SelectableOrExpression<T>> = Expr extends keyof T['meta']['selectable'] ? T['meta']['selectable'][Expr]['column'] : Expr extends Expression ? Expr['result']['value'] : never;
+type SelectableOrExpression<T extends PickQuerySelectable = PickQuerySelectable, C extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> = '*' | keyof T['__selectable'] | Expression<C>;
+type SelectableOrExpressions<T extends PickQuerySelectable = PickQuerySelectable, C extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> = ('*' | keyof T['__selectable'] | Expression<C>)[];
+type ExpressionOutput<T extends PickQuerySelectable, Expr extends SelectableOrExpression<T>> = Expr extends keyof T['__selectable'] ? T['__selectable'][Expr]['column'] : Expr extends Expression ? Expr['result']['value'] : never;
 type ExpressionChain = (OperatorToSQL | unknown)[];
 interface ExpressionData extends HasBeforeAndBeforeSet {
     chain?: ExpressionChain;
@@ -8004,7 +7938,7 @@ declare namespace Column {
         explicitSelect?: boolean;
         as?: Column.Pick.Data;
         unique?: string;
-        modifyQuery?(q: QueryBaseCommon, column: Column.Pick.Data): void;
+        modifyQuery?(q: Query, column: Column.Pick.Data): void;
         checks?: Column.Data.Check[];
         isOfCustomType?: boolean;
         errors?: RecordString;
@@ -8978,12 +8912,10 @@ interface QueryComputedArg<ColumnTypes, Shape extends Column.QueryColumns> exten
     windows: EmptyObject;
     relations: RelationsBase;
     result: EmptyObject;
-    meta: Omit<QueryMetaBase, 'selectable'> & {
-        selectable: {
-            [K in keyof Shape]: {
-                as: string;
-                column: Column.Pick.QueryColumn;
-            };
+    __selectable: {
+        [K in keyof Shape]: {
+            as: string;
+            column: Column.Pick.QueryColumn;
         };
     };
 }
@@ -9045,15 +8977,11 @@ interface HandleResult {
     (q: Query, returnType: QueryReturnType, result: QueryResult, sql: Sql, isSubQuery?: true): unknown;
 }
 type WithItems = CteItem[];
-interface QueryDataBase extends QueryDataAliases, PickQueryDataParsers, HasHookSelect {
-    shape: Column.QueryColumnsInit;
-    select?: unknown;
-}
 interface JoinValueDedupItem {
     q: Query;
     a: string;
 }
-interface QueryData extends QueryDataBase {
+interface QueryData extends QueryDataAliases, PickQueryDataParsers, HasHookSelect {
     type: undefined | null | 'upsert' | 'insert' | 'update' | 'delete' | 'truncate' | 'columnInfo' | 'copy';
     adapter: AdapterBase;
     shape: ColumnsShape;
@@ -9257,7 +9185,6 @@ interface ToSQLQuery {
     withData: Query['withData'];
     clone: Query['clone'];
     baseQuery: Query['baseQuery'];
-    meta: Query['meta'];
     returnType: Query['returnType'];
     result: Query['result'];
     shape: Query['shape'];
@@ -9387,8 +9314,8 @@ declare class For {
     forKeyShare<T extends IsQuery>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
 }
 
-type HeadlineSearchArg<T extends PickQueryMeta> = Exclude<T['meta']['tsQuery'], undefined>;
-interface HeadlineParams<T extends PickQueryMeta> {
+type HeadlineSearchArg<T extends PickQueryTsQuery> = Exclude<T['__tsQuery'], undefined>;
+interface HeadlineParams<T extends PickQuerySelectable> {
     text?: SelectableOrExpressionOfType<T, Column.Pick.QueryColumnOfType<string>>;
     options?: string | Expression;
 }
@@ -9464,26 +9391,26 @@ declare module '../../basic-features/aggregate/aggregate' {
          * @param search - name of the search to use the query from
          * @param options - `text` for a text source, `options` for `ts_headline` options
          */
-        headline<T extends PickQueryMeta>(this: T, search: HeadlineSearchArg<T>, options?: HeadlineParams<T>): SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfType<string>>;
+        headline<T extends OrderArgSelf>(this: T, search: HeadlineSearchArg<T>, options?: HeadlineParams<T>): SetQueryReturnsColumnOrThrow<T, Column.Pick.QueryColumnOfType<string>>;
     }
 }
-type SearchArg<T extends PickQueryMeta, As extends string> = {
+type SearchArg<T extends PickQuerySelectable, As extends string> = {
     as?: As;
     order?: OrderTsQueryConfig;
 } & ({
     language?: string | Expression;
 } | {
-    languageColumn?: keyof T['meta']['selectable'];
+    languageColumn?: keyof T['__selectable'];
 }) & ({
     text: string | Expression;
 } | {
-    in: MaybeArray<keyof T['meta']['selectable']> | {
-        [K in keyof T['meta']['selectable']]?: SearchWeight;
+    in: MaybeArray<keyof T['__selectable']> | {
+        [K in keyof T['__selectable']]?: SearchWeight;
     };
 } | {
     vector: {
-        [K in keyof T['meta']['selectable']]: T['meta']['selectable'][K]['column']['dataType'] extends 'tsvector' ? K : never;
-    }[keyof T['meta']['selectable']];
+        [K in keyof T['__selectable']]: T['__selectable'][K]['column']['dataType'] extends 'tsvector' ? K : never;
+    }[keyof T['__selectable']];
 }) & ({
     query: string | Expression;
 } | {
@@ -9494,9 +9421,7 @@ type SearchArg<T extends PickQueryMeta, As extends string> = {
     tsQuery: string | Expression;
 });
 type WhereSearchResult<T, As extends string> = T & {
-    meta: {
-        tsQuery: string extends As ? never : As;
-    };
+    __tsQuery: string extends As ? never : As;
 };
 declare class SearchMethods {
     /**
@@ -9687,7 +9612,7 @@ declare class SearchMethods {
      *
      * @param arg - search config
      */
-    search<T extends PickQueryMeta, As extends string>(this: T, arg: SearchArg<T, As>): WhereSearchResult<T, As>;
+    search<T extends PickQuerySelectable, As extends string>(this: T, arg: SearchArg<T, As>): WhereSearchResult<T, As>;
 }
 
 type ClearStatement = 'with' | 'select' | 'where' | 'union' | 'using' | 'join' | 'group' | 'order' | 'having' | 'limit' | 'offset' | 'counters';
@@ -9857,10 +9782,10 @@ declare class QueryDistinct {
      *
      * @param columns - column names or a raw SQL
      */
-    distinct<T extends PickQueryMeta>(this: T, ...columns: SelectableOrExpressions<T>): T;
+    distinct<T extends PickQuerySelectable>(this: T, ...columns: SelectableOrExpressions<T>): T;
 }
 
-interface SubQueryReturningSingle extends QueryMetaIsSubQuery {
+interface SubQueryReturningSingle extends IsSubQuery {
     returnType: 'one' | 'oneOrThrow';
 }
 declare class QueryLimitOffset {
@@ -9903,20 +9828,18 @@ declare class QueryTruncate {
      *
      * @param options - truncate options, may have `cascade: true` and `restartIdentity: true`
      */
-    truncate<T extends PickQueryMeta>(this: T, options?: {
+    truncate<T>(this: T, options?: {
         restartIdentity?: boolean;
         cascade?: boolean;
-    }): SetQueryReturnsVoidKind<T, 'truncate'>;
+    }): SetQueryReturnsVoid<T>;
 }
 
 type GroupArgs<T extends PickQueryResult> = ({
     [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K;
 }[keyof T['result']] | Expression)[];
-interface QueryHelperQuery<T extends PickQueryMetaShape> {
+interface QueryHelperQuery<T extends PickQuerySelectableShapeAs> extends MergeQueryArg {
     returnType: QueryReturnType;
-    meta: QueryMetaBase & {
-        selectable: Omit<T['meta']['selectable'], `${AliasOrTable<T>}.${Extract<keyof T['shape'], string>}`>;
-    };
+    __selectable: Omit<T['__selectable'], `${T['__as']}.${Extract<keyof T['shape'], string>}`>;
     result: Column.QueryColumns;
     windows: EmptyObject;
     withData: WithDataItems;
@@ -9931,35 +9854,36 @@ interface IsQueryHelper {
 interface IsQueryHelperForTable<Table extends string | undefined> extends IsQueryHelper {
     table: Table;
 }
-interface QueryHelper<T extends PickQueryTableMetaShape, Args extends any[], Result> extends IsQueryHelper {
-    <Q extends QueryHelperQuery<T>>(q: Q, ...args: Args): Result extends PickQueryMetaResultReturnTypeWithDataWindowsThen ? MergeQuery<Q, Result> : Result;
+interface QueryHelper<T extends PickQueryTableMetaShapeTableAs, Args extends any[], Result> extends IsQueryHelper {
+    <Q extends QueryHelperQuery<T>>(q: Q, ...args: Args): Result extends MergeQueryArg ? MergeQuery<Q, Result> : Result;
+    __as: T['__as'];
     table: T['table'];
     args: Args;
     result: Result;
 }
-type QueryHelperResult<T extends QueryHelper<PickQueryMetaShape, any[], unknown>> = T['result'];
-interface NarrowTypeSelf extends PickQueryMetaResultReturnType {
+type QueryHelperResult<T extends QueryHelper<PickQueryTableMetaShapeTableAs, any[], MergeQueryArg>> = T['result'];
+interface NarrowTypeSelf extends PickQueryResultReturnType {
     returnType: undefined | 'all' | 'one' | 'oneOrThrow' | 'value' | 'valueOrThrow' | 'pluck';
 }
 type NarrowInvalidKeys<T extends PickQueryResult, Narrow> = {
     [K in keyof Narrow]: K extends keyof T['result'] ? Narrow[K] extends T['result'][K]['outputType'] ? never : K : K;
 }[keyof Narrow];
-interface NarrowValueTypeResult<T extends PickQueryMetaResultReturnType, Narrow> extends Column.QueryColumns {
+interface NarrowValueTypeResult<T extends PickQueryResultReturnType, Narrow> extends Column.QueryColumns {
     value: {
         [K in keyof T['result']['value']]: K extends 'outputType' ? Narrow : T['result']['value'][K];
     };
 }
-interface NarrowPluckTypeResult<T extends PickQueryMetaResultReturnType, Narrow> extends Column.QueryColumns {
+interface NarrowPluckTypeResult<T extends PickQueryResultReturnType, Narrow> extends Column.QueryColumns {
     pluck: {
         [K in keyof T['result']['pluck']]: K extends 'outputType' ? Narrow extends unknown[] ? Narrow[number] : Narrow : T['result']['pluck'][K];
     };
 }
-type QueryIfResult<T extends PickQueryMetaResultReturnType, R extends PickQueryResult> = {
+type QueryIfResult<T extends PickQueryResultReturnType, R extends PickQueryResult> = {
     [K in keyof T]: K extends 'result' ? {
         [K in keyof T['result'] | keyof R['result']]: K extends keyof T['result'] ? K extends keyof R['result'] ? R['result'][K] | T['result'][K] : T['result'][K] : R['result'][K];
     } : K extends 'then' ? QueryIfResultThen<T, R> : T[K];
 };
-type QueryIfResultThen<T extends PickQueryMetaResultReturnType, R extends PickQueryResult> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<{
+type QueryIfResultThen<T extends PickQueryResultReturnType, R extends PickQueryResult> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<{
     [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['outputType'] | R['result'][K]['outputType'] : T['result'][K]['outputType'];
 } & {
     [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['outputType'];
@@ -10037,7 +9961,7 @@ declare class QueryMethods<ColumnTypes> {
      * ```
      * @param select - column name or a raw SQL
      */
-    pluck<T extends PickQueryMeta, S extends SelectableOrExpression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
+    pluck<T extends PickQuerySelectable, S extends SelectableOrExpression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
     /**
      * `.exec` won't parse the response at all, and returns undefined:
      *
@@ -10081,7 +10005,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param value - primary key value to find by
      */
-    find<T extends PickQueryShapeResultReturnTypeSinglePrimaryKey>(this: T, value: T['internal']['singlePrimaryKey'] | Expression): QueryTake<T> & QueryMetaHasWhere;
+    find<T extends PickQueryShapeResultReturnTypeSinglePrimaryKey>(this: T, value: T['internal']['singlePrimaryKey'] | Expression): QueryTake<T> & QueryHasWhere;
     /**
      * Finds a single record with a given SQL, throws {@link NotFoundError} if not found:
      *
@@ -10094,7 +10018,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param args - SQL expression
      */
-    findBySql<T extends PickQueryResultReturnType>(this: T, ...args: SQLQueryArgs): QueryTake<T> & QueryMetaHasWhere;
+    findBySql<T extends PickQueryResultReturnType>(this: T, ...args: SQLQueryArgs): QueryTake<T> & QueryHasWhere;
     /**
      * Finds a single record by the primary key (id), returns `undefined` when not found.
      * Not available if the table has no or multiple primary keys.
@@ -10105,7 +10029,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param value - primary key value to find by, or a raw SQL
      */
-    findOptional<T extends PickQueryShapeResultReturnTypeSinglePrimaryKey>(this: T, value: T['internal']['singlePrimaryKey'] | Expression): QueryTakeOptional<T> & QueryMetaHasWhere;
+    findOptional<T extends PickQueryShapeResultReturnTypeSinglePrimaryKey>(this: T, value: T['internal']['singlePrimaryKey'] | Expression): QueryTakeOptional<T> & QueryHasWhere;
     /**
      * Finds a single record with a given SQL.
      * Returns `undefined` when not found.
@@ -10119,7 +10043,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param args - SQL expression
      */
-    findBySqlOptional<T extends PickQueryResultReturnType>(this: T, ...args: SQLQueryArgs): QueryTakeOptional<T> & QueryMetaHasWhere;
+    findBySqlOptional<T extends PickQueryResultReturnType>(this: T, ...args: SQLQueryArgs): QueryTakeOptional<T> & QueryHasWhere;
     /**
      * Finds a single unique record, throws [NotFoundError](/guide/error-handling.html) if not found.
      * It accepts values of primary keys or unique indexes defined on the table.
@@ -10133,7 +10057,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param uniqueColumnValues - is derived from primary keys and unique indexes in the table
      */
-    findBy<T extends PickQueryResultReturnTypeUniqueColumns>(this: T, uniqueColumnValues: T['internal']['uniqueColumns']): QueryTake<T> & QueryMetaHasWhere;
+    findBy<T extends PickQueryResultReturnTypeUniqueColumns>(this: T, uniqueColumnValues: T['internal']['uniqueColumns']): QueryTake<T> & QueryHasWhere;
     /**
      * Finds a single unique record, returns `undefined` if not found.
      * It accepts values of primary keys or unique indexes defined on the table.
@@ -10147,7 +10071,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param uniqueColumnValues - is derived from primary keys and unique indexes in the table
      */
-    findByOptional<T extends PickQueryResultReturnTypeUniqueColumns>(this: T, uniqueColumnValues: T['internal']['uniqueColumns']): QueryTakeOptional<T> & QueryMetaHasWhere;
+    findByOptional<T extends PickQueryResultReturnTypeUniqueColumns>(this: T, uniqueColumnValues: T['internal']['uniqueColumns']): QueryTakeOptional<T> & QueryHasWhere;
     /**
      * Specifies the schema to be used as a prefix of a table name.
      *
@@ -10203,7 +10127,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param columns - column names or a raw SQL
      */
-    group<T extends PickQueryMetaResult>(this: T, ...columns: T['meta']['hasSelect'] extends true ? GroupArgs<T> : {
+    group<T extends PickQueryHasSelectResult>(this: T, ...columns: T['__hasSelect'] extends true ? GroupArgs<T> : {
         error: 'select is required for group';
     }[]): T;
     /**
@@ -10325,7 +10249,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param fn - helper function
      */
-    makeHelper<T extends PickQueryMetaShape, Args extends unknown[], Result>(this: T, fn: (q: T, ...args: Args) => Result): QueryHelper<T, Args, Result>;
+    makeHelper<T extends PickQuerySelectableShapeAs, Args extends unknown[], Result extends MergeQueryArg>(this: T, fn: (q: T, ...args: Args) => Result): QueryHelper<T, Args, Result>;
     /**
      * `useHelper` allows to use {@link makeHelper} in different queries:
      *
@@ -10382,7 +10306,7 @@ declare class QueryMethods<ColumnTypes> {
      *
      * @param fn - function to useHelper the query with. The result type will be merged with the main query as if the `merge` method was used.
      */
-    useHelper<T extends PickQueryTableMetaResultReturnTypeWithDataWindowsThen, Fn extends IsQueryHelperForTable<T['table']>>(this: T, fn: Fn, ...args: Fn['args']): Fn['result'] extends PickQueryMetaResultReturnTypeWithDataWindowsThen ? MergeQuery<T, Fn['result']> : Fn['result'];
+    useHelper<T extends MergeQueryArg, Fn extends IsQueryHelperForTable<T['table']>>(this: T, fn: Fn, ...args: Fn['args']): Fn['result'] extends MergeQueryArg ? MergeQuery<T, Fn['result']> : Fn['result'];
     /**
      * `modify` is useful when you'd like to modify the query based on some condition.
      *
@@ -10443,19 +10367,17 @@ declare class QueryMethods<ColumnTypes> {
     } : `narrowType() error: provided type does not extend the '${NarrowInvalidKeys<T, Narrow> & string}' column type` : (T['returnType'] extends 'pluck' ? Narrow extends unknown[] ? Narrow[number] : Narrow : Narrow) extends (T['returnType'] extends 'pluck' ? T['result']['pluck']['outputType'] : T['result']['value']['outputType']) ? {
         [K in keyof T]: K extends 'result' ? T['returnType'] extends 'value' | 'valueOrThrow' ? NarrowValueTypeResult<T, Narrow> : NarrowPluckTypeResult<T, Narrow> : K extends 'then' ? QueryThenByQuery<T, T['returnType'] extends 'value' | 'valueOrThrow' ? NarrowValueTypeResult<T, Narrow> : NarrowPluckTypeResult<T, Narrow>> : T[K];
     } : 'narrowType() error: provided type does not extend the returning column column type';
-    if<T extends PickQueryMetaResultReturnType, R extends PickQueryResult>(this: T, condition: boolean | null | undefined, fn: (q: T) => R & {
+    if<T extends PickQueryResultReturnType, R extends PickQueryResult>(this: T, condition: boolean | null | undefined, fn: (q: T) => R & {
         returnType: T['returnType'];
     }): QueryIfResult<T, R>;
     queryRelated<T extends PickQueryRelations, RelName extends keyof T['relations']>(this: T, relName: RelName, params: T['relations'][RelName]['params']): T['relations'][RelName]['maybeSingle'];
-    chain<T extends PickQueryMetaShapeRelationsReturnType, RelName extends keyof T['relations']>(this: T, relName: RelName): [
-        T['meta']['subQuery'],
+    chain<T extends PickQuerySelectableShapeRelationsReturnTypeIsSubQuery, RelName extends keyof T['relations']>(this: T, relName: RelName): [
+        T['__subQuery'],
         T['returnType'],
         T['relations'][RelName]['returnsOne']
-    ] extends [true, 'one' | 'oneOrThrow', true] ? {
-        [K in keyof T['relations'][RelName]['maybeSingle']]: K extends 'meta' ? {
-            [K in keyof T['relations'][RelName]['maybeSingle']['meta']]: K extends 'selectable' ? T['relations'][RelName]['maybeSingle']['meta']['selectable'] & Omit<T['meta']['selectable'], keyof T['shape']> : K extends 'subQuery' ? true : T['relations'][RelName]['maybeSingle']['meta'][K];
-        } : T['relations'][RelName]['maybeSingle'][K];
-    } : JoinResultRequireMain<T['relations'][RelName]['query'], Omit<T['meta']['selectable'], keyof T['shape']>>;
+    ] extends [true | undefined, 'one' | 'oneOrThrow', true] ? {
+        [K in keyof T['relations'][RelName]['maybeSingle']]: K extends '__selectable' ? T['relations'][RelName]['maybeSingle']['__selectable'] & Omit<T['__selectable'], keyof T['shape']> : T['relations'][RelName]['maybeSingle'][K];
+    } & IsSubQuery : JoinResultRequireMain<T['relations'][RelName]['query'], Omit<T['__selectable'], keyof T['shape']>>;
 }
 
 interface DbExtension {
@@ -10475,20 +10397,6 @@ interface DbDomainArg<ColumnTypes> {
 interface DbDomainArgRecord {
     [K: string]: DbDomainArg<any>;
 }
-interface QueryInternal<SinglePrimaryKey = any, UniqueColumns = any, UniqueColumnNames = any, UniqueColumnTuples = any, UniqueConstraints = any> extends QueryInternalBase {
-    singlePrimaryKey: SinglePrimaryKey;
-    uniqueColumns: UniqueColumns;
-    uniqueColumnNames: UniqueColumnNames;
-    uniqueColumnTuples: UniqueColumnTuples;
-    uniqueConstraints: UniqueConstraints;
-    extensions?: DbExtension[];
-    domains?: DbDomainArgRecord;
-    generatorIgnore?: GeneratorIgnore;
-    tableData: TableData;
-    nowSQL?: string;
-    callbackArg?: Query;
-    selectAllCount: number;
-}
 type SelectableFromShape<Shape extends Column.QueryColumns, Table extends string | undefined> = {
     [K in keyof Shape]: {
         as: K;
@@ -10503,32 +10411,40 @@ type SelectableFromShape<Shape extends Column.QueryColumns, Table extends string
 type QueryReturnType = QueryReturnTypeAll | 'one' | 'oneOrThrow' | 'rows' | 'pluck' | 'value' | 'valueOrThrow' | 'void';
 type QueryReturnTypeAll = undefined | 'all';
 type QueryReturnTypeOptional = 'one' | 'value';
+interface QueryHasSelect {
+    __hasSelect: true;
+}
 interface IsQuery {
     __isQuery: true;
 }
+interface IsSubQuery {
+    __subQuery: true;
+}
 interface IsQueries {
     [K: string]: IsQuery;
 }
-interface QueryBase extends IsQuery, PickQueryShape {
-    internal: QueryInternalBase;
-    q: QueryDataBase;
-    table?: string;
-}
-interface QueryBaseCommon<Scopes extends RecordKeyTrue = RecordKeyTrue> extends QueryBase {
-    meta: QueryMetaBase<Scopes>;
-}
 interface QueryOrExpression<T> {
     result: {
         value: Column.Pick.QueryColumnOfType<T>;
     };
 }
-interface Query extends QueryBase, QueryMethods<unknown> {
-    __isQuery: true;
+interface QuerySelectable {
+    [K: PropertyKey]: {
+        as: string;
+        column: Column.Pick.QueryColumn;
+    };
+}
+interface Query extends IsQuery, PickQueryTable, PickQueryShape, PickQuerySelectable, QueryMethods<unknown> {
+    __as: string;
+    __hasSelect: boolean;
+    __hasWhere: boolean;
+    __defaults: EmptyObject;
+    __scopes: EmptyObject;
+    __defaultSelect: PropertyKey;
     result: Column.QueryColumns;
     withData: WithDataItems;
     baseQuery: Query;
     internal: QueryInternal;
-    meta: QueryMetaBase<EmptyObject>;
     returnType: QueryReturnType;
     qb: QueryBuilder;
     columnTypes: unknown;
@@ -10541,136 +10457,103 @@ interface Query extends QueryBase, QueryMethods<unknown> {
     relationQueries: IsQueries;
     error: new (message: string, length: number, name: QueryErrorName) => QueryError;
 }
-type SelectableOfType<T extends PickQueryMeta, Type> = {
-    [K in keyof T['meta']['selectable']]: T['meta']['selectable'][K]['column']['type'] extends Type | null ? K : never;
-}[keyof T['meta']['selectable']];
-type SelectableOrExpressionOfType<T extends PickQueryMeta, C extends Column.Pick.Type> = SelectableOfType<T, C['type']> | Expression<Column.Pick.QueryColumnOfType<C['type'] | null>>;
+type SelectableOfType<T extends PickQuerySelectable, Type> = {
+    [K in keyof T['__selectable']]: T['__selectable'][K]['column']['type'] extends Type | null ? K : never;
+}[keyof T['__selectable']];
+type SelectableOrExpressionOfType<T extends PickQuerySelectable, C extends Column.Pick.Type> = SelectableOfType<T, C['type']> | Expression<Column.Pick.QueryColumnOfType<C['type'] | null>>;
 declare const queryTypeWithLimitOne: RecordKeyTrue;
-interface QueryMetaHasSelect {
-    meta: {
-        hasSelect: true;
-    };
-}
 type SetQueryReturnsAll<T extends PickQueryResult> = {
     [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'then' ? QueryThenShallowSimplifyArr<ColumnsShape.Output<T['result']>> : T[K];
-} & QueryMetaHasWhere;
-type SetQueryReturnsAllKind<T extends PickQueryMetaResult, Kind extends string> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'all' : K extends 'then' ? QueryThenShallowSimplifyArr<ColumnsShape.Output<T['result']>> : T[K];
-} & QueryMetaHasWhere;
-type SetQueryReturnsAllKindResult<T extends PickQueryMetaResult, Kind extends string, Result extends Column.QueryColumns> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'all' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplifyArr<T['result']> : T[K];
-} & QueryMetaHasWhere;
+} & QueryHasWhere;
+type SetQueryReturnsAllResult<T extends PickQueryResult, Result extends Column.QueryColumns> = {
+    [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplifyArr<T['result']> : T[K];
+} & QueryHasWhere;
 type QueryTakeOptional<T extends PickQueryResultReturnType> = T['returnType'] extends 'value' | 'pluck' | 'void' ? T : T['returnType'] extends 'valueOrThrow' ? {
     [K in keyof T]: K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<T['result']['value']['outputType'] | undefined> : T[K];
 } : {
     [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<T['result']>> : T[K];
 };
+type QueryManyTakeOptional<T extends PickQueryResultReturnType> = {
+    [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<T['result']>> : T[K];
+};
 type QueryTake<T extends PickQueryResultReturnType> = T['returnType'] extends 'valueOrThrow' | 'pluck' | 'void' ? T : T['returnType'] extends 'value' ? {
     [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Exclude<T['result']['value']['outputType'], undefined>> : T[K];
 } : {
     [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K];
 };
-type SetQueryReturnsOneKind<T extends PickQueryMetaResult, Kind extends string> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K];
+type QueryManyTake<T extends PickQueryResultReturnType> = {
+    [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K];
+};
+type SetQueryReturnsOne<T extends PickQueryResult> = {
+    [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K];
 };
-type SetQueryReturnsOneKindResult<T extends PickQueryMetaResult, Kind extends string, Result extends Column.QueryColumns> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'oneOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<Result>> : T[K];
+type SetQueryReturnsOneResult<T extends PickQueryResult, Result extends Column.QueryColumns> = {
+    [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<Result>> : T[K];
 };
 type SetQueryReturnsRows<T extends PickQueryResult> = {
     [K in keyof T]: K extends 'returnType' ? 'rows' : K extends 'then' ? QueryThen<ColumnsShape.Output<T['result']>[keyof T['result']][][]> : T[K];
 };
-type SetQueryReturnsPluck<T extends PickQueryMeta, S extends keyof T['meta']['selectable'] | Expression> = SetQueryReturnsPluckColumn<T, S extends keyof T['meta']['selectable'] ? T['meta']['selectable'][S]['column'] : S extends Expression ? S['result']['value'] : never>;
-type SetQueryReturnsPluckColumn<T, C extends Column.Pick.QueryColumn> = {
+type SetQueryReturnsPluck<T extends PickQuerySelectable, S extends keyof T['__selectable'] | Expression> = S extends keyof T['__selectable'] ? {
+    [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
+        pluck: T['__selectable'][S]['column'];
+    } : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['__selectable'][S]['column']['outputType'][]> : T[K];
+} : {
+    [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? {
+        pluck: S extends Expression ? S['result']['value'] : never;
+    } : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<(S extends Expression ? S['result']['value']['outputType'] : never)[]> : T[K];
+};
+type SetValueQueryReturnsPluckColumn<T extends PickQueryResult> = {
     [K in keyof T]: K extends 'result' ? {
-        pluck: C;
-    } : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<C['outputType'][]> : T[K];
-} & QueryMetaHasSelect;
-type SetQueryReturnsPluckColumnKind<T extends PickQueryMetaResult, Kind extends string> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'result' ? {
         pluck: T['result']['value'];
     } : K extends 'returnType' ? 'pluck' : K extends 'then' ? QueryThen<T['result']['value']['outputType'][]> : T[K];
-} & QueryMetaHasSelect;
-type SetQueryReturnsPluckColumnKindResult<T extends PickQueryMetaResult, Kind extends string, Result extends Column.QueryColumns> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'result' ? {
+} & QueryHasSelect;
+type SetQueryReturnsPluckColumnResult<T extends PickQueryResult, Result extends Column.QueryColumns> = {
+    [K in keyof T]: K extends 'result' ? {
         pluck: T['result']['value'];
     } : K extends 'returnType' ? 'pluck' : K extends 'result' ? Result : K extends 'then' ? QueryThen<T['result']['value']['outputType'][]> : T[K];
-} & QueryMetaHasSelect;
-type SetQueryReturnsValueOrThrow<T extends PickQueryMeta, Arg extends keyof T['meta']['selectable']> = SetQueryReturnsColumnOrThrow<T, T['meta']['selectable'][Arg]['column']> & T['meta']['selectable'][Arg]['column']['operators'];
-type SetQueryReturnsValueOrThrowKind<T extends PickQueryMetaResult, Kind extends string> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['value']['outputType']> : T[K];
+} & QueryHasSelect;
+type SetQueryReturnsValueOrThrow<T extends PickQuerySelectable, Arg extends keyof T['__selectable']> = SetQueryReturnsColumnOrThrow<T, T['__selectable'][Arg]['column']> & T['__selectable'][Arg]['column']['operators'];
+type SetValueQueryReturnsValueOrThrow<T extends PickQueryResult> = {
+    [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['value']['outputType']> : T[K];
 };
-type SetQueryReturnsValueOptional<T extends PickQueryMeta, Arg extends GetStringArg<T>> = SetQueryReturnsColumnOptional<T, {
-    [K in keyof T['meta']['selectable'][Arg]['column']]: K extends 'outputType' ? T['meta']['selectable'][Arg]['column'][K] | undefined : T['meta']['selectable'][Arg]['column'][K];
-}> & Omit<T['meta']['selectable'][Arg]['column']['operators'], 'equals' | 'not'> & Column.Modifiers.OperatorsNullable<T['meta']['selectable'][Arg]['column']>;
+type SetQueryReturnsValueOptional<T extends PickQuerySelectable, Arg extends GetStringArg<T>> = SetQueryReturnsColumnOptional<T, {
+    [K in keyof T['__selectable'][Arg]['column']]: K extends 'outputType' ? T['__selectable'][Arg]['column'][K] | undefined : T['__selectable'][Arg]['column'][K];
+}> & Omit<T['__selectable'][Arg]['column']['operators'], 'equals' | 'not'> & Column.Modifiers.OperatorsNullable<T['__selectable'][Arg]['column']>;
 type SetQueryReturnsColumnOrThrow<T, Column extends Column.Pick.OutputType> = {
     [K in keyof T]: K extends 'result' ? {
         value: Column;
     } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Column['outputType']> : T[K];
-} & QueryMetaHasSelect;
+} & QueryHasSelect;
 type SetQueryReturnsColumnOptional<T, Column extends Column.Pick.OutputType> = {
     [K in keyof T]: K extends 'result' ? {
         value: Column;
     } : K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<Column['outputType'] | undefined> : T[K];
-} & QueryMetaHasSelect;
-type SetQueryReturnsColumnKind<T extends PickQueryMetaResult, Kind extends string> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'result' ? {
+} & QueryHasSelect;
+type SetQueryReturnsColumn<T extends PickQueryResult> = {
+    [K in keyof T]: K extends 'result' ? {
         value: T['result']['pluck'];
     } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<T['result']['pluck']['outputType']> : T[K];
-} & QueryMetaHasSelect;
-type SetQueryReturnsColumnKindResult<T extends PickQueryMetaResult, Kind extends string, Result extends Column.QueryColumns> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'result' ? {
+} & QueryHasSelect;
+type SetQueryReturnsColumnResult<T extends PickQueryResult, Result extends Column.QueryColumns> = {
+    [K in keyof T]: K extends 'result' ? {
         value: T['result']['pluck'];
     } : K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? Result : K extends 'then' ? QueryThen<Result['pluck']['outputType']> : T[K];
-} & QueryMetaHasSelect;
-type SetQueryReturnsRowCount<T extends PickQueryMetaResult, Kind extends string> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
+} & QueryHasSelect;
+type SetQueryReturnsRowCount<T extends PickQueryResult> = {
+    [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'result' ? {
         value: Column.Pick.QueryColumnOfType<number>;
     } : K extends 'then' ? QueryThen<number> : T[K];
 };
-type SetQueryReturnsRowCountMany<T extends PickQueryMetaResult, Kind extends string> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'pluck' : K extends 'result' ? {
+type SetQueryReturnsRowCountMany<T extends PickQueryResult> = {
+    [K in keyof T]: K extends 'returnType' ? 'pluck' : K extends 'result' ? {
         pluck: Column.Pick.QueryColumnOfType<number>;
     } : K extends 'then' ? QueryThen<number> : T[K];
 };
 type SetQueryReturnsVoid<T> = {
     [K in keyof T]: K extends 'returnType' ? 'void' : K extends 'then' ? QueryThen<void> : T[K];
 };
-type SetQueryReturnsVoidKind<T extends PickQueryMeta, Kind extends string> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'returnType' ? 'void' : K extends 'then' ? QueryThen<void> : T[K];
-};
-type SetQueryKind<T extends PickQueryMeta, Kind extends string> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : T[K];
-};
-type SetQueryKindResult<T extends PickQueryMetaReturnType, Kind extends string, Result extends Column.QueryColumns> = {
-    [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'kind' ? Kind : T['meta'][K];
-    } : K extends 'result' ? Result : K extends 'then' ? QueryThenByQuery<T, Result> : T[K];
+type SetQueryResult<T extends PickQueryReturnType, Result extends Column.QueryColumns> = {
+    [K in keyof T]: K extends 'result' ? Result : K extends 'then' ? QueryThenByQuery<T, Result> : T[K];
 };
 interface ReturnsQueryOrExpression<T> {
     (): QueryOrExpression<T>;
@@ -10686,7 +10569,7 @@ declare const isQuery: (q: unknown) => q is IsQuery;
 interface RelationJoinQuery {
     (joiningQuery: IsQuery, baseQuery: IsQuery): IsQuery;
 }
-interface RelationConfigQuery extends PickQueryTableMetaResult, PickQueryShape, PickQueryTable {
+interface RelationConfigQuery extends PickQueryResult, PickQuerySelectable, PickQueryShape, PickQueryTable, PickQueryAs {
 }
 interface RelationConfigBase extends IsQuery {
     returnsOne: boolean;
@@ -10696,7 +10579,7 @@ interface RelationConfigBase extends IsQuery {
     params: unknown;
     queryRelated(params: unknown): unknown;
     modifyRelatedQuery?(relatedQuery: IsQuery): (query: IsQuery) => void;
-    maybeSingle: PickQueryMetaReturnType;
+    maybeSingle: PickQuerySelectableReturnType;
     omitForeignKeyInCreate: PropertyKey;
     dataForCreate?: RelationConfigDataForCreate;
     optionalDataForCreate: unknown;
@@ -10716,8 +10599,80 @@ declare const isRelationQuery: (q: IsQuery) => q is RelationConfigBase;
 interface PickQueryTable {
     table?: string;
 }
-interface PickQueryMeta {
-    meta: QueryMetaBase;
+interface PickQueryThen {
+    then: unknown;
+}
+interface PickQueryHasSelect {
+    __hasSelect: boolean;
+}
+interface PickQueryHasWhere {
+    __hasWhere: boolean;
+}
+interface PickQueryDefaults {
+    __defaults: EmptyObject;
+}
+interface PickQueryTsQuery {
+    __tsQuery?: string;
+}
+interface PickQueryScopes {
+    __scopes: EmptyObject;
+}
+interface PickQueryDefaultSelect {
+    __defaultSelect: PropertyKey;
+}
+interface PickQueryHasSelectResultReturnType extends PickQueryHasSelect, PickQueryResult, PickQueryReturnType {
+}
+interface PickQueryHasSelectResultShapeAs extends PickQueryHasSelect, PickQueryResult, PickQueryShape, PickQueryAs {
+}
+interface PickQueryHasSelectHasWhereResultReturnType extends PickQueryHasSelect, PickQueryHasWhere, PickQueryResult, PickQueryReturnType {
+}
+interface PickQueryHasSelectResult extends PickQueryHasSelect, PickQueryResult {
+}
+interface PickQuerySelectable {
+    __selectable: QuerySelectable;
+}
+interface PickQuerySelectableResult extends PickQuerySelectable, PickQueryResult {
+}
+interface PickQuerySelectableRelations extends PickQuerySelectable, PickQueryRelations {
+}
+interface PickQuerySelectableRelationsResultReturnType extends PickQuerySelectableRelations, PickQueryResult, PickQueryReturnType {
+}
+interface PickQuerySelectableResultWindows extends PickQuerySelectable, PickQueryResult, PickQueryWindows {
+}
+interface PickQuerySelectableResultRelationsWindows extends PickQuerySelectableResult, PickQueryRelations, PickQueryWindows {
+}
+interface PickQueryMetaSelectableResultRelationsWindowsColumnTypes extends PickQuerySelectableResultRelationsWindows, PickQueryColumTypes {
+}
+interface PickQuerySelectableShapeAs extends PickQuerySelectable, PickQueryShape, PickQueryAs {
+}
+interface PickQueryTableMetaShapeTableAs extends PickQuerySelectableShapeAs, PickQueryTable {
+}
+interface PickQuerySelectableShapeRelationsWithData extends PickQuerySelectable, PickQueryShape, PickQueryRelations, PickQueryWithData {
+}
+interface PickQuerySelectableShapeRelationsWithDataAs extends PickQuerySelectableShapeRelationsWithData, PickQueryAs {
+}
+interface PickQuerySelectableShapeRelationsWithDataAsResultReturnType extends PickQuerySelectableShapeRelationsWithDataAs, PickQueryResult, PickQueryReturnType {
+}
+interface PickQuerySelectableResultReturnType extends PickQuerySelectable, PickQueryResult, PickQueryReturnType {
+}
+interface PickQuerySelectableResultRelationsWithDataReturnType extends PickQuerySelectable, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType {
+}
+interface PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs extends PickQuerySelectableResultRelationsWithDataReturnType, PickQueryShape, PickQueryAs {
+}
+interface PickQuerySelectableShape extends PickQuerySelectable, PickQueryShape {
+}
+interface PickQuerySelectableColumnTypes extends PickQuerySelectable, PickQueryColumTypes {
+}
+interface PickQuerySelectableShapeRelationsReturnTypeIsSubQuery extends PickQueryIsSubQuery, PickQuerySelectable, PickQueryShape, PickQueryRelations, PickQueryReturnType {
+}
+interface PickQuerySelectableReturnType extends PickQuerySelectable, PickQueryReturnType {
+}
+interface PickQuerySelectableResultInputTypeAs extends PickQuerySelectableResult, PickQueryInputType, PickQueryAs {
+}
+interface PickQuerySelectableResultAs extends PickQuerySelectable, PickQueryResult, PickQueryAs {
+}
+interface PickQueryIsSubQuery {
+    __subQuery?: boolean;
 }
 interface PickQueryResult {
     result: Column.QueryColumns;
@@ -10730,10 +10685,6 @@ interface PickQueryReturnType {
 }
 interface PickQueryResultReturnType extends PickQueryResult, PickQueryReturnType {
 }
-interface PickQueryMetaShape extends PickQueryMeta, PickQueryShape {
-}
-interface PickQueryMetaResult extends PickQueryMeta, PickQueryResult {
-}
 interface PickQueryResultUniqueColumns extends PickQueryResult {
     internal: {
         uniqueColumns: unknown;
@@ -10748,23 +10699,8 @@ interface PickQueryUniqueProperties {
         uniqueConstraints: unknown;
     };
 }
-interface PickQueryMetaResultWindows extends PickQueryMetaResult {
-    windows: EmptyObject;
-}
-interface PickQueryTableMetaResult extends PickQueryTable, PickQueryMetaResult {
-}
 interface PickQueryInputType {
-    inputType: unknown;
-}
-interface PickQueryTableMetaResultInputType extends PickQueryTableMetaResult, PickQueryInputType {
-}
-interface PickQueryTableMetaShape extends PickQueryTable, PickQueryMetaShape {
-}
-interface PickQueryTableMetaResultShape extends PickQueryTableMetaResult, PickQueryMetaShape {
-}
-interface PickQueryMetaReturnType extends PickQueryMeta, PickQueryReturnType {
-}
-interface PickQueryMetaResultReturnType extends PickQueryMetaResult, PickQueryReturnType {
+    inputType: RecordUnknown;
 }
 interface PickQueryWithData {
     withData: WithDataItems;
@@ -10778,55 +10714,25 @@ interface PickQueryRelations {
 interface PickQueryRelationQueries {
     relationQueries: IsQueries;
 }
-interface PickQueryMetaRelations extends PickQueryMeta, PickQueryRelations {
-}
-interface PickQueryMetaRelationsResult extends PickQueryMetaRelations, PickQueryResult {
-}
-interface PickQueryMetaRelationsReturnType extends PickQueryMetaRelationsResult, PickQueryResultReturnType {
-}
-interface PickQueryMetaShapeRelationsReturnType extends PickQueryMetaRelationsReturnType, PickQueryShape {
-}
-interface PickQueryMetaRelationsResultReturnType extends PickQueryMetaRelationsReturnType, PickQueryResult {
-}
-interface PickQueryMetaResultRelations extends PickQueryResult, PickQueryMeta, PickQueryRelations {
-}
-interface PickQueryMetaResultRelationsWindows extends PickQueryMetaResultRelations, PickQueryWindows {
-}
 interface PickQueryColumTypes {
     columnTypes: unknown;
 }
-interface PickQueryMetaColumnTypes extends PickQueryMeta, PickQueryColumTypes {
-}
-interface PickQueryMetaResultRelationsWindowsColumnTypes extends PickQueryMetaResultRelationsWindows, PickQueryColumTypes {
-}
 interface PickQueryWithDataColumnTypes extends PickQueryWithData, PickQueryColumTypes {
 }
 interface PickQueryResultColumnTypes extends PickQueryResult, PickQueryColumTypes {
 }
-interface PickQueryMetaWithDataColumnTypes extends PickQueryMeta, PickQueryWithData, PickQueryColumTypes {
+interface PickQueryAs {
+    __as: string;
 }
-interface PickQueryMetaTable extends PickQueryMeta, PickQueryTable {
+interface PickQueryResultRelationsWithDataReturnTypeShape extends PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape {
 }
-interface PickQueryMetaTableShape extends PickQueryMetaTable, PickQueryShape {
+interface PickQueryMetaSelectableResultRelationsWithDataReturnTypeShapeAs extends PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQuerySelectable, PickQueryAs {
 }
-interface PickQueryMetaWithData extends PickQueryMeta, PickQueryWithData {
-}
-interface PickQueryRelationsWithData extends PickQueryWithData, PickQueryRelations {
+interface PickQueryResultAs extends PickQueryResult, PickQueryAs {
 }
-interface PickQueryMetaShapeRelationsWithData extends PickQueryMeta, PickQueryShape, PickQueryRelations, PickQueryWithData {
+interface PickQueryShapeAs extends PickQueryShape, PickQueryAs {
 }
-interface PickQueryMetaResultRelationsWithDataReturnType extends PickQueryMeta, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType {
-}
-interface PickQueryMetaTableShapeReturnTypeWithData extends PickQueryMetaTableShape, PickQueryReturnType, PickQueryMetaWithData {
-}
-interface PickQueryMetaResultRelationsWithDataReturnTypeShape extends PickQueryMetaResultRelationsWithDataReturnType, PickQueryShape {
-}
-interface PickQueryMetaResultReturnTypeWithDataWindows extends PickQueryMetaResultReturnType, PickQueryWithData, PickQueryWindows {
-}
-interface PickQueryMetaResultReturnTypeWithDataWindowsThen extends PickQueryMetaResultReturnTypeWithDataWindows {
-    then: unknown;
-}
-interface PickQueryTableMetaResultReturnTypeWithDataWindowsThen extends PickQueryMetaResultReturnTypeWithDataWindowsThen, PickQueryTable {
+interface PickQueryRelationsWithData extends PickQueryWithData, PickQueryRelations {
 }
 interface PickQuerySinglePrimaryKey {
     internal: {
@@ -10866,13 +10772,13 @@ declare abstract class OrchidOrmError extends Error {
 declare class NotFoundError extends OrchidOrmError {
     #private;
     constructor(query: IsQuery, message?: string);
-    get query(): QueryBase;
+    get query(): Query;
 }
 declare class OrchidOrmInternalError extends Error {
     #private;
     data?: RecordUnknown | undefined;
     constructor(query: IsQuery, message?: string, data?: RecordUnknown | undefined);
-    get query(): QueryBase;
+    get query(): Query;
 }
 type QueryErrorName = 'parseComplete' | 'bindComplete' | 'closeComplete' | 'noData' | 'portalSuspended' | 'replicationStart' | 'emptyQuery' | 'copyDone' | 'copyData' | 'rowDescription' | 'parameterDescription' | 'parameterStatus' | 'backendKeyData' | 'notification' | 'readyForQuery' | 'commandComplete' | 'dataRow' | 'copyInResponse' | 'copyOutResponse' | 'authenticationOk' | 'authenticationMD5Password' | 'authenticationCleartextPassword' | 'authenticationSASL' | 'authenticationSASLContinue' | 'authenticationSASLFinal' | 'error' | 'notice';
 declare abstract class QueryError<T extends PickQueryShape = PickQueryShape> extends OrchidOrmInternalError {
@@ -11032,9 +10938,9 @@ interface TransactionState {
 /**
  * Element of `afterCommit` transaction array. See {@link TransactionState.afterCommit}.
  */
-type TransactionAfterCommitHook = unknown[] | QueryBaseCommon | AfterCommitHook[] | AfterCommitStandaloneHook;
+type TransactionAfterCommitHook = unknown[] | Query | AfterCommitHook[] | AfterCommitStandaloneHook;
 interface AfterCommitHook {
-    (data: unknown[], q: QueryBaseCommon): unknown | Promise<unknown>;
+    (data: unknown[], q: Query): unknown | Promise<unknown>;
 }
 interface AfterCommitStandaloneHook {
     (): unknown | Promise<unknown>;
@@ -11073,4 +10979,4 @@ declare const testTransaction: {
     close(arg: Arg): Promise<void>;
 };
 
-export { type AdapterBase, type AdapterConfigBase, type AdapterConfigConnectRetry, type AddQueryDefaults, type AdditionalDateData, type AdditionalNumberData, type AdditionalStringData, AfterCommitError, type AfterCommitErrorFulfilledResult, type AfterCommitErrorHandler, type AfterCommitErrorRejectedResult, type AfterCommitErrorResult, type AfterCommitHook, type AfterCommitStandaloneHook, type AfterHook, type AggregateOptions, type AliasOrTable, type ArgWithBeforeAndBeforeSet, ArrayColumn, type ArrayColumnValue, type ArrayData, type ArrayMethodsData, type ArrayMethodsDataForBaseColumn, type AsQueryArg, type BaseNumberData, type BatchSql, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, type ChangeCountArg, CidrColumn, CircleColumn, CitextColumn, type Code, type Codes, Column, type ColumnFromDbParams, ColumnRefExpression, type ColumnSchemaConfig, type ColumnSchemaGetterColumns, type ColumnSchemaGetterTableClass, type ColumnToCodeCtx, type ColumnTypeSchemaArg, type ColumnsByType, ColumnsShape, ComputedColumn, type ComputedColumns, type ComputedColumnsFromOptions, type ComputedMethods, type ComputedOptionsConfig, type ComputedOptionsFactory, type CreateBelongsToData, type CreateColumn, type CreateCtx, type CreateData, type CreateFromMethodNames, type CreateManyFromMethodNames, type CreateManyMethodsNames, type CreateMethodsNames, type CreateRelationsData, type CreateRelationsDataOmittingFKeys, type CreateResult, type CreateSelf, type CteArgsOptions, type CteHooks, type CteItem, type CteOptions, CteQuery, type CteQueryBuilder, type CteRecursiveOptions, type CteResult, type CteSqlResult, type CteTableHook, type CteTableHooks, CustomTypeColumn, DateBaseColumn, DateColumn, type DateColumnData, type DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, type DbDomainArg, type DbDomainArgRecord, type DbExtension, type DbOptions, type DbOptionsWithAdapter, type DbResult, type DbSharedOptions, type DbSqlQuery, type DbStructureDomainsMap, type DbTableConstructor, type DbTableOptionScopes, type DbTableOptions, DecimalColumn, type DecimalColumnData, type DefaultColumnTypes, type DefaultSchemaConfig, type DelayedRelationSelect, Delete, type DeleteArgs, type DeleteMethodsNames, type DeleteResult, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, type DynamicSQLArg, type EmptyObject, type EmptyTuple, EnumColumn, Expression, type ExpressionChain, type ExpressionData, type ExpressionOutput, ExpressionTypeMethod, FnExpression, type FnExpressionArgs, type FnExpressionArgsPairs, type FnExpressionArgsValue, type FnUnknownToUnknown, type FromArg, FromMethods, type FromQuerySelf, type FromResult, type GeneratorIgnore, type GroupArgs, type HandleResult, type HasBeforeAndBeforeSet, type HasCteHooks, type HasHookSelect, type HasTableHook, type HavingItem, type HookAction, type HookSelect, type HookSelectArg, type HookSelectValue, type IdentityColumn, InetColumn, type InsertQueryDataObjectValues, IntegerBaseColumn, IntegerColumn, IntervalColumn, type IsQueries, type IsQuery, type IsolationLevel, JSONColumn, JSONTextColumn, type JoinArgToQuery, type JoinArgs, type JoinCallback, type JoinFirstArg, type JoinItem, type JoinItemArgs, type JoinLateralResult, type JoinQueryBuilder, type JoinQueryMethod, type JoinResult, type JoinResultFromArgs, type JoinResultRequireMain, type JoinResultSelectable, type JoinValueDedupItem, type JoinedParsers, type JoinedShapes, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, type MoveMutativeQueryToCte, type NoPrimaryKeyOption, type NonUniqDataItem, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, type NumberColumnData, type NumericColumns, type OnConflictMerge, OnConflictQueryBuilder, type OnConflictSet, type OnConflictTarget, OnMethods, type Operator, type OperatorToSQL, Operators, type OperatorsAny, type OperatorsArray, type OperatorsBoolean, type OperatorsDate, type OperatorsJson, type OperatorsNumber, type OperatorsOrdinalText, type OperatorsText, type OperatorsTime, type OrCreateArg, OrExpression, type OrExpressionArg, OrchidOrmError, OrchidOrmInternalError, type OrderItem, type OrderTsQueryConfig, type Over, PathColumn, type PickQueryBaseQuery, type PickQueryColumTypes, type PickQueryDataShapeAndJoinedShapes, type PickQueryDataShapeAndJoinedShapesAndAliases, type PickQueryInputType, type PickQueryInternal, type PickQueryMeta, type PickQueryMetaColumnTypes, type PickQueryMetaRelations, type PickQueryMetaRelationsResult, type PickQueryMetaRelationsResultReturnType, type PickQueryMetaRelationsReturnType, type PickQueryMetaResult, type PickQueryMetaResultRelations, type PickQueryMetaResultRelationsWindows, type PickQueryMetaResultRelationsWindowsColumnTypes, type PickQueryMetaResultRelationsWithDataReturnType, type PickQueryMetaResultRelationsWithDataReturnTypeShape, type PickQueryMetaResultReturnType, type PickQueryMetaResultReturnTypeWithDataWindows, type PickQueryMetaResultReturnTypeWithDataWindowsThen, type PickQueryMetaResultWindows, type PickQueryMetaReturnType, type PickQueryMetaShape, type PickQueryMetaShapeRelationsReturnType, type PickQueryMetaShapeRelationsWithData, type PickQueryMetaTable, type PickQueryMetaTableShape, type PickQueryMetaTableShapeReturnTypeWithData, type PickQueryMetaWithData, type PickQueryMetaWithDataColumnTypes, type PickQueryQ, type PickQueryQAndBaseQuery, type PickQueryQAndInternal, type PickQueryRelationQueries, type PickQueryRelations, type PickQueryRelationsWithData, type PickQueryResult, type PickQueryResultColumnTypes, type PickQueryResultReturnType, type PickQueryResultReturnTypeUniqueColumns, type PickQueryResultUniqueColumns, type PickQueryReturnType, type PickQueryShape, type PickQueryShapeResultReturnTypeSinglePrimaryKey, type PickQueryShapeResultSinglePrimaryKey, type PickQueryShapeSinglePrimaryKey, type PickQuerySinglePrimaryKey, type PickQueryTable, type PickQueryTableMetaResult, type PickQueryTableMetaResultInputType, type PickQueryTableMetaResultReturnTypeWithDataWindowsThen, type PickQueryTableMetaResultShape, type PickQueryTableMetaShape, type PickQueryUniqueProperties, type PickQueryWindows, type PickQueryWithData, type PickQueryWithDataColumnTypes, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type PostgisPoint, type PrepareSubQueryForSql, type PrepareSubQueryForSqlArg, type Query, type QueryAfterHook, type QueryArraysResult, QueryAsMethods, type QueryBase, type QueryBaseCommon, type QueryBatchResult, type QueryBeforeHook, type QueryBeforeHookInternal, type QueryBuilder, type QueryCatch, type QueryCatchers, QueryClone, type QueryComputedArg, QueryCreate, QueryCreateFrom, type QueryData, type QueryDataAliases, type QueryDataBase, type QueryDataFromItem, type QueryDataJoinTo, type QueryDataScopes, type QueryDataSources, type QueryDataTransform, type QueryDataUnion, QueryError, type QueryErrorName, QueryExpressions, QueryGet, type QueryHelperResult, QueryHookUtils, QueryHooks, type QueryIfResultThen, type QueryInternal, type QueryInternalBase, type QueryInternalColumnNameToKey, type QueryInternalTableDataBase, QueryJoin, QueryLog, type QueryLogObject, type QueryLogOptions, type QueryLogger, type QueryMetaBase, type QueryMetaHasSelect, type QueryMetaHasWhere, type QueryMetaIsSubQuery, QueryMethods, QueryOrCreate, type QueryOrExpression, type QueryOrExpressionBooleanOrNullResult, type QueryResult, type QueryResultRow, type QueryReturnType, type QueryReturnTypeAll, type QueryReturnTypeOptional, QueryScope, type QueryScopeData, type QueryScopes, type QuerySelectable, type QuerySourceItem, QuerySql, type QueryTake, type QueryTakeOptional, type QueryThen, type QueryThenByQuery, type QueryThenByReturnType, type QueryThenShallowSimplify, type QueryThenShallowSimplifyArr, type QueryThenShallowSimplifyOptional, QueryTransform, QueryWrap, type RawSQLValues, RawSql, type RawSqlBase, RealColumn, type RecordBoolean, type RecordKeyTrue, type RecordOfColumnsShapeBase, type RecordOptionalString, type RecordString, type RecordUnknown, RefExpression, type RelationConfigBase, type RelationConfigDataForCreate, type RelationConfigQuery, type RelationJoinQuery, type RelationsBase, type ReturnsQueryOrExpression, type RunAfterQuery, type RuntimeComputedQueryColumn, type SQLArgs, type SQLQueryArgs, type ScopeArgumentQuery, type SearchWeight, type SearchWeightRecord, Select, type SelectArg, type SelectArgs, type SelectAs, type SelectAsArg, type SelectAsFnArg, type SelectAsValue, type SelectItem, type SelectSelf, type SelectSubQueryResult, type SelectableFromShape, type SelectableOfType, type SelectableOrExpression, type SelectableOrExpressionOfType, type SelectableOrExpressions, SerialColumn, type SerialColumnData, type SetQueryKind, type SetQueryKindResult, type SetQueryReturnsAll, type SetQueryReturnsAllKind, type SetQueryReturnsAllKindResult, type SetQueryReturnsColumnKind, type SetQueryReturnsColumnKindResult, type SetQueryReturnsColumnOptional, type SetQueryReturnsColumnOrThrow, type SetQueryReturnsOneKind, type SetQueryReturnsOneKindResult, type SetQueryReturnsPluck, type SetQueryReturnsPluckColumn, type SetQueryReturnsPluckColumnKind, type SetQueryReturnsPluckColumnKindResult, type SetQueryReturnsRowCount, type SetQueryReturnsRowCountMany, type SetQueryReturnsRows, type SetQueryReturnsValueOptional, type SetQueryReturnsValueOrThrow, type SetQueryReturnsValueOrThrowKind, type SetQueryReturnsVoid, type SetQueryReturnsVoidKind, type SetQueryTableAlias, type ShallowSimplify, type ShapeColumnPrimaryKeys, type ShapeUniqueColumns, type SimpleJoinItemNonSubQueryArgs, type SingleSql, type SingleSqlItem, SmallIntColumn, SmallSerialColumn, type SortDir, type Sql, type SqlCommonOptions, type SqlFn, type StaticSQLArgs, StringColumn$1 as StringColumn, type StringData, type SubQueryForSql, TableData, type TableDataFn, type TableDataInput, type TableDataItem, type TableDataItemsUniqueColumnTuples, type TableDataItemsUniqueColumns, type TableDataItemsUniqueConstraints, type TableDataMethods, type TableHook, type TemplateLiteralArgs, TextBaseColumn, TextColumn, type TextColumnData, Then, TimeColumn, type TimeInterval, TimestampColumn, type TimestampHelpers, TimestampTZColumn, type Timestamps, type TopCTE, Transaction, type TransactionAfterCommitHook, type TransactionOptions, type TransactionState, TsQueryColumn, TsVectorColumn, UUIDColumn, UnhandledTypeError, type UnionItem, type UnionKind, type UnionSet, type UnionToIntersection, type UniqueConstraints, type UniqueQueryTypeOrExpression, type UniqueTableDataItem, UnknownColumn, Update, type UpdateArg, type UpdateCtx, type UpdateCtxCollect, type UpdateData, type UpdateQueryDataItem, type UpdateQueryDataObject, type UpdateSelf, type UpdatedAtDataInjector, VarCharColumn, VirtualColumn, Where, type WhereArg, type WhereArgs, type WhereInArg, type WhereInColumn, type WhereInItem, type WhereInValues, type WhereItem, type WhereJsonPathEqualsItem, type WhereNotArgs, type WhereOnItem, type WhereOnJoinItem, type WhereQueryBuilder, type WhereResult, type WhereSearchItem, type WindowDeclaration, type WindowItem, type WithConfig, type WithConfigs, type WithDataItem, type WithDataItems, type WithItems, type WrapQueryArg, XMLColumn, _addToHookSelect, _addToHookSelectWithTable, _applyRelationAliases, _checkIfAliased, _clone, _copyQueryAliasToQuery, _getQueryAliasOrName, _getQueryAs, _getQueryFreeAlias, _getQueryOuterAliases, _initQueryBuilder, _join, _joinLateral, _joinLateralProcessArg, _joinReturningArgs, _orCreate, _queryAfterSaveCommit, _queryAll, _queryChangeCounter, _queryCreate, _queryCreateForEachFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateOneFrom, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertForEachFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertOneFrom, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _querySelectAll, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotExists, _queryWhereNotOneOf, _queryWhereNotSql, _queryWhereOneOf, _queryWhereSql, _runAfterCommitHooks, _setQueryAlias, _setQueryAs, _setSubQueryAliases, _with, addCode, addColumnParserToQuery, addParserForRawExpression, addParserForSelectItem, addQueryOn, addTopCte, addValue, addWithToSql, anyShape, applyBatchTransforms, applyComputedColumns, applyMixins, applyTransforms, arrayDataToCode, arrayMethodNames, assignDbDataToColumn, backtickQuote, callWithThis, checkIfASimpleQuery, cloneQueryBaseUnscoped, codeToString, colors, columnCheckToCode, columnCode, columnDefaultArgumentToCode, columnErrorMessagesToCode, columnExcludesToCode, columnForeignKeysToCode, columnIndexesToCode, columnMethodsToCode, columnsShapeToCode, commitSql, composeCteSingleSql, constraintInnerToCode, constraintToCode, consumeColumnName, countSelect, createCtx, createDbWithAdapter, createSelect, cteToSql, ctesToSql, dateDataToCode, dateMethodNames, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForLog, escapeForMigration, escapeString, excludeInnerToCode, excludeToCode, exhaustive, extendQuery, filterResult, finalizeNestedHookSelect, foreignKeyArgumentToCode, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnTypes, getDefaultLanguage, getDefaultNowFn, getFreeAlias, getFreeSetAlias, getFromSelectColumns, getFullColumnTable, getImportPath, getPrimaryKeys, getQueryAs, getSearchLang, getSearchText, getShapeFromSelect, getSqlText, getStackTrace, getTopCteSize, handleManyData, handleOneData, handleResult, havingToSql, identityToCode, indexInnerToCode, indexToCode, insert, isDefaultTimeStamp, isExpression, isInUserTransaction, isIterable, isObjectEmpty, isQuery, isQueryReturnsAll, isRawSQL, isRelationQuery, isTemplateLiteralArgs, joinSubQuery, joinTruthy, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeFnExpression, makeInsertSql, makeReturningSql, makeRowToJson, moveMutativeQueryToCte, newDelayedRelationSelect, noop, numberDataToCode, numberMethodNames, objectHasValues, omit, orderByToSql, parseRecord, parseTableData, parseTableDataInput, pathToLog, performQuery, pick, pluralize, postgisTypmodToSql, prepareOpArg, prepareSubQueryForSql, prependTopCte, primaryKeyInnerToCode, processComputedBatches, processComputedResult, processJoinItem, processSelectArg, pushColumnData, pushHavingSql, pushJoinSql, pushOrNewArray, pushOrNewArrayToObjectImmutable, pushOrderBySql, pushQueryArrayImmutable, pushQueryOn, pushQueryOnForOuter, pushQueryOrOn, pushQueryValueImmutable, pushTableDataCode, pushUnionSql, pushWhereStatementSql, pushWhereToSql, queryColumnNameToKey, queryFrom, queryFromSql, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quoteObjectKey, quoteSchemaAndTable, raw, rawSqlToCode, referencesArgsToCode, requirePrimaryKeys, resetDefaultNowFn, resolveSubQueryCallback, returnArg, rollbackSql, saveAliasedShape, searchSourcesToSql, selectAllSql, selectToSql, selectToSqlList, setColumnData, setColumnDefaultParse, setColumnEncode, setColumnParse, setColumnParseNull, setConnectRetryConfig, setCurrentColumnName, setDataValue, setDb, setDefaultLanguage, setDefaultNowFn, setDelayedRelation, setFreeAlias, setMoveMutativeQueryToCte, setObjectValueImmutable, setParserForSelectedString, setPrepareSubQueryForSql, setQueryObjectValueImmutable, setQueryOperators, setRawSqlPrepareSubQueryForSql, setSqlCtxSelectList, setTopCteSize, singleQuote, singleQuoteArray, snakeCaseKey, spreadObjectValues, sqlFn, sqlQueryArgsToExpression, stringDataToCode, stringMethodNames, tableDataMethods, templateLiteralSQLToCode, templateLiteralToSQL, testTransaction, throwIfJoinLateral, throwIfNoWhere, throwOnReadOnly, timestampHelpers, toArray, toCamelCase, toPascalCase, toSnakeCase, whereToSql, windowToSql, wrapAdapterFnWithConnectRetry };
+export { type AdapterBase, type AdapterConfigBase, type AdapterConfigConnectRetry, type AddQueryDefaults, type AdditionalDateData, type AdditionalNumberData, type AdditionalStringData, AfterCommitError, type AfterCommitErrorFulfilledResult, type AfterCommitErrorHandler, type AfterCommitErrorRejectedResult, type AfterCommitErrorResult, type AfterCommitHook, type AfterCommitStandaloneHook, type AfterHook, type AggregateOptions, type ArgWithBeforeAndBeforeSet, ArrayColumn, type ArrayColumnValue, type ArrayData, type ArrayMethodsData, type ArrayMethodsDataForBaseColumn, type AsQueryArg, type BaseNumberData, type BatchSql, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, type ChangeCountArg, CidrColumn, CircleColumn, CitextColumn, type Code, type Codes, Column, type ColumnFromDbParams, ColumnRefExpression, type ColumnSchemaConfig, type ColumnSchemaGetterColumns, type ColumnSchemaGetterTableClass, type ColumnToCodeCtx, type ColumnTypeSchemaArg, type ColumnsByType, ColumnsShape, ComputedColumn, type ComputedColumns, type ComputedColumnsFromOptions, type ComputedMethods, type ComputedOptionsConfig, type ComputedOptionsFactory, type CreateBelongsToData, type CreateColumn, type CreateCtx, type CreateData, type CreateFromMethodNames, type CreateManyFromMethodNames, type CreateManyMethodsNames, type CreateMethodsNames, type CreateRelationsData, type CreateRelationsDataOmittingFKeys, type CreateResult, type CreateSelf, type CteArgsOptions, type CteHooks, type CteItem, type CteOptions, CteQuery, type CteQueryBuilder, type CteRecursiveOptions, type CteResult, type CteSqlResult, type CteTableHook, type CteTableHooks, CustomTypeColumn, DateBaseColumn, DateColumn, type DateColumnData, type DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, type DbDomainArg, type DbDomainArgRecord, type DbExtension, type DbOptions, type DbOptionsWithAdapter, type DbResult, type DbSharedOptions, type DbSqlQuery, type DbStructureDomainsMap, type DbTableConstructor, type DbTableOptionScopes, type DbTableOptions, DecimalColumn, type DecimalColumnData, type DefaultColumnTypes, type DefaultSchemaConfig, type DelayedRelationSelect, Delete, type DeleteArgs, type DeleteMethodsNames, type DeleteResult, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, type DynamicSQLArg, type EmptyObject, type EmptyTuple, EnumColumn, Expression, type ExpressionChain, type ExpressionData, type ExpressionOutput, ExpressionTypeMethod, FnExpression, type FnExpressionArgs, type FnExpressionArgsPairs, type FnExpressionArgsValue, type FnUnknownToUnknown, type FromArg, FromMethods, type FromQuerySelf, type FromResult, type GeneratorIgnore, type GroupArgs, type HandleResult, type HasBeforeAndBeforeSet, type HasCteHooks, type HasHookSelect, type HasTableHook, type HavingItem, type HookAction, type HookSelect, type HookSelectArg, type HookSelectValue, type IdentityColumn, InetColumn, type InsertQueryDataObjectValues, IntegerBaseColumn, IntegerColumn, IntervalColumn, type IsQueries, type IsQuery, type IsSubQuery, type IsolationLevel, JSONColumn, JSONTextColumn, type JoinArgToQuery, type JoinArgs, type JoinCallback, type JoinFirstArg, type JoinItem, type JoinItemArgs, type JoinLateralResult, type JoinQueryBuilder, type JoinQueryMethod, type JoinResult, type JoinResultFromArgs, type JoinResultRequireMain, type JoinResultSelectable, type JoinValueDedupItem, type JoinedParsers, type JoinedShapes, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, type MergeQueryArg, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, type MoveMutativeQueryToCte, type NoPrimaryKeyOption, type NonUniqDataItem, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, type NumberColumnData, type NumericColumns, type OnConflictMerge, OnConflictQueryBuilder, type OnConflictSet, type OnConflictTarget, OnMethods, type Operator, type OperatorToSQL, Operators, type OperatorsAny, type OperatorsArray, type OperatorsBoolean, type OperatorsDate, type OperatorsJson, type OperatorsNumber, type OperatorsOrdinalText, type OperatorsText, type OperatorsTime, type OrCreateArg, OrExpression, type OrExpressionArg, OrchidOrmError, OrchidOrmInternalError, type OrderItem, type OrderTsQueryConfig, type Over, PathColumn, type PickQueryAs, type PickQueryBaseQuery, type PickQueryColumTypes, type PickQueryDataShapeAndJoinedShapes, type PickQueryDataShapeAndJoinedShapesAndAliases, type PickQueryDefaultSelect, type PickQueryDefaults, type PickQueryHasSelect, type PickQueryHasSelectHasWhereResultReturnType, type PickQueryHasSelectResult, type PickQueryHasSelectResultReturnType, type PickQueryHasSelectResultShapeAs, type PickQueryHasWhere, type PickQueryInputType, type PickQueryInternal, type PickQueryIsSubQuery, type PickQueryMetaSelectableResultRelationsWindowsColumnTypes, type PickQueryMetaSelectableResultRelationsWithDataReturnTypeShapeAs, type PickQueryQ, type PickQueryQAndBaseQuery, type PickQueryQAndInternal, type PickQueryRelationQueries, type PickQueryRelations, type PickQueryRelationsWithData, type PickQueryResult, type PickQueryResultAs, type PickQueryResultColumnTypes, type PickQueryResultRelationsWithDataReturnTypeShape, type PickQueryResultReturnType, type PickQueryResultReturnTypeUniqueColumns, type PickQueryResultUniqueColumns, type PickQueryReturnType, type PickQueryScopes, type PickQuerySelectable, type PickQuerySelectableColumnTypes, type PickQuerySelectableRelations, type PickQuerySelectableRelationsResultReturnType, type PickQuerySelectableResult, type PickQuerySelectableResultAs, type PickQuerySelectableResultInputTypeAs, type PickQuerySelectableResultRelationsWindows, type PickQuerySelectableResultRelationsWithDataReturnType, type PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs, type PickQuerySelectableResultReturnType, type PickQuerySelectableResultWindows, type PickQuerySelectableReturnType, type PickQuerySelectableShape, type PickQuerySelectableShapeAs, type PickQuerySelectableShapeRelationsReturnTypeIsSubQuery, type PickQuerySelectableShapeRelationsWithData, type PickQuerySelectableShapeRelationsWithDataAs, type PickQuerySelectableShapeRelationsWithDataAsResultReturnType, type PickQueryShape, type PickQueryShapeAs, type PickQueryShapeResultReturnTypeSinglePrimaryKey, type PickQueryShapeResultSinglePrimaryKey, type PickQueryShapeSinglePrimaryKey, type PickQuerySinglePrimaryKey, type PickQueryTable, type PickQueryTableMetaShapeTableAs, type PickQueryThen, type PickQueryTsQuery, type PickQueryUniqueProperties, type PickQueryWindows, type PickQueryWithData, type PickQueryWithDataColumnTypes, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type PostgisPoint, type PrepareSubQueryForSql, type PrepareSubQueryForSqlArg, type Query, type QueryAfterHook, type QueryArraysResult, QueryAsMethods, type QueryBatchResult, type QueryBeforeHook, type QueryBeforeHookInternal, type QueryBuilder, type QueryCatch, type QueryCatchers, QueryClone, type QueryComputedArg, QueryCreate, QueryCreateFrom, type QueryData, type QueryDataAliases, type QueryDataFromItem, type QueryDataJoinTo, type QueryDataScopes, type QueryDataSources, type QueryDataTransform, type QueryDataUnion, QueryError, type QueryErrorName, QueryExpressions, QueryGet, type QueryHasSelect, type QueryHasWhere, type QueryHelperResult, QueryHookUtils, QueryHooks, type QueryIfResultThen, type QueryInternal, type QueryInternalColumnNameToKey, QueryJoin, QueryLog, type QueryLogObject, type QueryLogOptions, type QueryLogger, type QueryManyTake, type QueryManyTakeOptional, QueryMethods, QueryOrCreate, type QueryOrExpression, type QueryOrExpressionBooleanOrNullResult, type QueryResult, type QueryResultRow, type QueryReturnType, type QueryReturnTypeAll, type QueryReturnTypeOptional, QueryScope, type QueryScopeData, type QueryScopes, type QuerySelectable, type QuerySourceItem, QuerySql, type QueryTake, type QueryTakeOptional, type QueryThen, type QueryThenByQuery, type QueryThenByReturnType, type QueryThenShallowSimplify, type QueryThenShallowSimplifyArr, type QueryThenShallowSimplifyOptional, QueryTransform, QueryWrap, type RawSQLValues, RawSql, type RawSqlBase, RealColumn, type RecordBoolean, type RecordKeyTrue, type RecordOfColumnsShapeBase, type RecordOptionalString, type RecordString, type RecordUnknown, RefExpression, type RelationConfigBase, type RelationConfigDataForCreate, type RelationConfigQuery, type RelationJoinQuery, type RelationsBase, type ReturnsQueryOrExpression, type RunAfterQuery, type RuntimeComputedQueryColumn, type SQLArgs, type SQLQueryArgs, type ScopeArgumentQuery, type SearchWeight, type SearchWeightRecord, Select, type SelectArg, type SelectArgs, type SelectAs, type SelectAsArg, type SelectAsFnArg, type SelectAsValue, type SelectItem, type SelectSelf, type SelectSubQueryResult, type SelectableFromShape, type SelectableOfType, type SelectableOrExpression, type SelectableOrExpressionOfType, type SelectableOrExpressions, SerialColumn, type SerialColumnData, type SetQueryResult, type SetQueryReturnsAll, type SetQueryReturnsAllResult, type SetQueryReturnsColumn, type SetQueryReturnsColumnOptional, type SetQueryReturnsColumnOrThrow, type SetQueryReturnsColumnResult, type SetQueryReturnsOne, type SetQueryReturnsOneResult, type SetQueryReturnsPluck, type SetQueryReturnsPluckColumnResult, type SetQueryReturnsRowCount, type SetQueryReturnsRowCountMany, type SetQueryReturnsRows, type SetQueryReturnsValueOptional, type SetQueryReturnsValueOrThrow, type SetQueryReturnsVoid, type SetQueryTableAlias, type SetValueQueryReturnsPluckColumn, type SetValueQueryReturnsValueOrThrow, type ShallowSimplify, type ShapeColumnPrimaryKeys, type ShapeUniqueColumns, type SimpleJoinItemNonSubQueryArgs, type SingleSql, type SingleSqlItem, SmallIntColumn, SmallSerialColumn, type SortDir, type Sql, type SqlCommonOptions, type SqlFn, type StaticSQLArgs, StringColumn$1 as StringColumn, type StringData, type SubQueryForSql, TableData, type TableDataFn, type TableDataInput, type TableDataItem, type TableDataItemsUniqueColumnTuples, type TableDataItemsUniqueColumns, type TableDataItemsUniqueConstraints, type TableDataMethods, type TableHook, type TemplateLiteralArgs, TextBaseColumn, TextColumn, type TextColumnData, Then, TimeColumn, type TimeInterval, TimestampColumn, type TimestampHelpers, TimestampTZColumn, type Timestamps, type TopCTE, Transaction, type TransactionAfterCommitHook, type TransactionOptions, type TransactionState, TsQueryColumn, TsVectorColumn, UUIDColumn, UnhandledTypeError, type UnionItem, type UnionKind, type UnionSet, type UnionToIntersection, type UniqueConstraints, type UniqueQueryTypeOrExpression, type UniqueTableDataItem, UnknownColumn, Update, type UpdateArg, type UpdateCtx, type UpdateCtxCollect, type UpdateData, type UpdateQueryDataItem, type UpdateQueryDataObject, type UpdateSelf, type UpdatedAtDataInjector, VarCharColumn, VirtualColumn, Where, type WhereArg, type WhereArgs, type WhereInArg, type WhereInColumn, type WhereInItem, type WhereInValues, type WhereItem, type WhereJsonPathEqualsItem, type WhereNotArgs, type WhereOnItem, type WhereOnJoinItem, type WhereQueryBuilder, type WhereSearchItem, type WindowDeclaration, type WindowItem, type WithConfig, type WithConfigs, type WithDataItem, type WithDataItems, type WithItems, type WrapQueryArg, XMLColumn, _addToHookSelect, _addToHookSelectWithTable, _applyRelationAliases, _checkIfAliased, _clone, _copyQueryAliasToQuery, _getQueryAliasOrName, _getQueryAs, _getQueryFreeAlias, _getQueryOuterAliases, _initQueryBuilder, _join, _joinLateral, _joinLateralProcessArg, _joinReturningArgs, _orCreate, _queryAfterSaveCommit, _queryAll, _queryChangeCounter, _queryCreate, _queryCreateForEachFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateOneFrom, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertForEachFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertOneFrom, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _querySelectAll, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotExists, _queryWhereNotOneOf, _queryWhereNotSql, _queryWhereOneOf, _queryWhereSql, _runAfterCommitHooks, _setQueryAlias, _setQueryAs, _setSubQueryAliases, _with, addCode, addColumnParserToQuery, addParserForRawExpression, addParserForSelectItem, addQueryOn, addTopCte, addValue, addWithToSql, anyShape, applyBatchTransforms, applyComputedColumns, applyMixins, applyTransforms, arrayDataToCode, arrayMethodNames, assignDbDataToColumn, backtickQuote, callWithThis, checkIfASimpleQuery, cloneQueryBaseUnscoped, codeToString, colors, columnCheckToCode, columnCode, columnDefaultArgumentToCode, columnErrorMessagesToCode, columnExcludesToCode, columnForeignKeysToCode, columnIndexesToCode, columnMethodsToCode, columnsShapeToCode, commitSql, composeCteSingleSql, constraintInnerToCode, constraintToCode, consumeColumnName, countSelect, createCtx, createDbWithAdapter, createSelect, cteToSql, ctesToSql, dateDataToCode, dateMethodNames, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForLog, escapeForMigration, escapeString, excludeInnerToCode, excludeToCode, exhaustive, extendQuery, filterResult, finalizeNestedHookSelect, foreignKeyArgumentToCode, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnTypes, getDefaultLanguage, getDefaultNowFn, getFreeAlias, getFreeSetAlias, getFromSelectColumns, getFullColumnTable, getImportPath, getPrimaryKeys, getQueryAs, getSearchLang, getSearchText, getShapeFromSelect, getSqlText, getStackTrace, getTopCteSize, handleManyData, handleOneData, handleResult, havingToSql, identityToCode, indexInnerToCode, indexToCode, insert, isDefaultTimeStamp, isExpression, isInUserTransaction, isIterable, isObjectEmpty, isQuery, isQueryReturnsAll, isRawSQL, isRelationQuery, isTemplateLiteralArgs, joinSubQuery, joinTruthy, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeFnExpression, makeInsertSql, makeReturningSql, makeRowToJson, moveMutativeQueryToCte, newDelayedRelationSelect, noop, numberDataToCode, numberMethodNames, objectHasValues, omit, orderByToSql, parseRecord, parseTableData, parseTableDataInput, pathToLog, performQuery, pick, pluralize, postgisTypmodToSql, prepareOpArg, prepareSubQueryForSql, prependTopCte, primaryKeyInnerToCode, processComputedBatches, processComputedResult, processJoinItem, processSelectArg, pushColumnData, pushHavingSql, pushJoinSql, pushOrNewArray, pushOrNewArrayToObjectImmutable, pushOrderBySql, pushQueryArrayImmutable, pushQueryOn, pushQueryOnForOuter, pushQueryOrOn, pushQueryValueImmutable, pushTableDataCode, pushUnionSql, pushWhereStatementSql, pushWhereToSql, queryColumnNameToKey, queryFrom, queryFromSql, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quoteObjectKey, quoteSchemaAndTable, raw, rawSqlToCode, referencesArgsToCode, requirePrimaryKeys, resetDefaultNowFn, resolveSubQueryCallback, returnArg, rollbackSql, saveAliasedShape, searchSourcesToSql, selectAllSql, selectToSql, selectToSqlList, setColumnData, setColumnDefaultParse, setColumnEncode, setColumnParse, setColumnParseNull, setConnectRetryConfig, setCurrentColumnName, setDataValue, setDb, setDefaultLanguage, setDefaultNowFn, setDelayedRelation, setFreeAlias, setMoveMutativeQueryToCte, setObjectValueImmutable, setParserForSelectedString, setPrepareSubQueryForSql, setQueryObjectValueImmutable, setQueryOperators, setRawSqlPrepareSubQueryForSql, setSqlCtxSelectList, setTopCteSize, singleQuote, singleQuoteArray, snakeCaseKey, spreadObjectValues, sqlFn, sqlQueryArgsToExpression, stringDataToCode, stringMethodNames, tableDataMethods, templateLiteralSQLToCode, templateLiteralToSQL, testTransaction, throwIfJoinLateral, throwIfNoWhere, throwOnReadOnly, timestampHelpers, toArray, toCamelCase, toPascalCase, toSnakeCase, whereToSql, windowToSql, wrapAdapterFnWithConnectRetry };