pqb 0.17.0 → 0.17.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { QueryResultRow, AdapterBase, QueryInput, Sql, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, QueryThen, QueryCatch, TransactionState, SQLQueryArgs, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, ColumnTypeBase, Expression, MaybeArray, TemplateLiteralArgs, ColumnsParsers, getValueKey, StringKey, NullableColumn, EmptyTuple, SetOptional, MergeObjects, RawSQLBase, RawSQLValues, RawSQLArgs, Spread, ColumnOperatorBase, ColumnOperatorFnBase, Code, ArrayMethodsData, arrayTypeMethods, JSONType, JSONUnknown, JSONTypes, StringTypeData, PrimaryKeyColumn, stringTypeMethods, ForeignKeyTable, name, ColumnNameOfTable, BaseNumberData, NumberTypeMethods, ColumnWithDefault, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, ValidationContext, ErrorMessage, ColumnDataBase } from 'orchid-core';
+import { QueryResultRow, AdapterBase, QueryInput, Sql, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, StringKey, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, QueryThen, QueryCatch, TransactionState, SQLQueryArgs, ColumnTypeBase, Expression, MaybeArray, TemplateLiteralArgs, ColumnsParsers, getValueKey, NullableColumn, SetOptional, EmptyTuple, MergeObjects, RawSQLBase, RawSQLValues, RawSQLArgs, Spread, ColumnOperatorBase, ColumnOperatorFnBase, Code, ArrayMethodsData, arrayTypeMethods, JSONType, JSONUnknown, JSONTypes, StringTypeData, PrimaryKeyColumn, stringTypeMethods, ForeignKeyTable, name, ColumnNameOfTable, BaseNumberData, NumberTypeMethods, ColumnWithDefault, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, ValidationContext, ErrorMessage, ColumnDataBase } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -108,6 +108,79 @@ declare class UnhandledTypeError extends OrchidOrmInternalError {
     constructor(query: Query, value: never);
 }
 
+declare abstract class QueryBase implements QueryBaseCommon {
+    /**
+     * Clones the current query chain, useful for re-using partial query snippets in other queries without mutating the original.
+     *
+     * Used under the hood, and not really needed on the app side.
+     */
+    clone<T extends QueryBase>(this: T): T;
+    abstract result: ColumnsShapeBase;
+    q: QueryData;
+    table?: string;
+    selectable: SelectableBase;
+    shape: ColumnsShapeBase;
+    relations: RelationsBase;
+    withData: WithDataBase;
+    baseQuery: Query;
+    internal: QueryInternal;
+    meta: QueryMetaBase;
+    returnType: QueryReturnType;
+}
+
+/**
+ * Used to build relation sub queries where agg methods such as `count` can be chained with column operators such as `gt`, `lt`.
+ * See {@link RelationSubQueries}.
+ */
+type SubQueryBuilder<T extends Query, Agg = SelectAggMethods<T>> = Omit<T, keyof Agg> & Agg;
+/**
+ * Build and memoize a query builder to use in the argument of select callback.
+ * See {@link SubQueryBuilder}
+ *
+ * @param q - query object to base the query builder upon
+ */
+declare const getSubQueryBuilder: <T extends Query>(q: T) => SubQueryBuilder<T, SelectAggMethods<T>>;
+
+type RelationConfigBase = {
+    table: QueryWithTable;
+    query: QueryWithTable;
+    joinQuery(fromQuery: QueryBase, toQuery: Query): Query;
+    one: boolean;
+    required: boolean;
+    omitForeignKeyInCreate: PropertyKey;
+    dataForCreate: unknown;
+    dataForUpdate: unknown;
+    dataForUpdateOne: unknown;
+    params: Record<string, unknown>;
+    populate: string;
+    chainedCreate: boolean;
+    chainedDelete: boolean;
+};
+type RelationsBase = Record<string, RelationQueryBase>;
+type RelationQueryBase = Query & {
+    relationConfig: RelationConfigBase;
+};
+type RelationQuery<Name extends PropertyKey = PropertyKey, Config extends RelationConfigBase = RelationConfigBase, T extends Query = Query, Q extends Query = (Config['chainedCreate'] extends true ? T : T & {
+    [K in CreateMethodsNames]: never;
+}) & (Config['chainedDelete'] extends true ? EmptyObject : {
+    [K in DeleteMethodsNames]: never;
+})> = ((params: Config['params']) => Q) & Q & {
+    meta: Omit<T['meta'], 'as'> & {
+        as: StringKey<Name>;
+        defaults: Record<Config['populate'], true>;
+        hasWhere: true;
+    };
+    relationConfig: Config;
+    join<T extends Query>(this: T): T;
+};
+/**
+ * Map relations into a Record where each relation aggregate methods can be chained with column operators.
+ * Used in `where` callback argument, see {@link WhereQueryBuilder}.
+ */
+type RelationSubQueries<T extends QueryBase> = {
+    [K in keyof T['relations']]: SubQueryBuilder<T['relations'][K]>;
+};
+
 type NoPrimaryKeyOption = 'error' | 'warning' | 'ignore';
 type DbOptions<CT extends ColumnTypesBase> = ({
     adapter: Adapter;
@@ -126,7 +199,7 @@ type DbTableOptions = {
     language?: string;
 } & QueryLogOptions;
 declare const anyShape: Record<string, ColumnType<unknown, BaseOperators, unknown, unknown, unknown>>;
-interface Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends Query['relations'] = Query['relations'], CT extends ColumnTypesBase = DefaultColumnTypes, Data = Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]> extends DbBase<Adapter, Table, Shape, CT>, QueryMethods<CT> {
+interface Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends RelationsBase = EmptyObject, CT extends ColumnTypesBase = DefaultColumnTypes, Data = Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]> extends DbBase<Adapter, Table, Shape, CT>, QueryMethods<CT> {
     new (adapter: Adapter, queryBuilder: Db<Table, Shape, Relations, CT>, table?: Table, shape?: Shape, options?: DbTableOptions): this;
     internal: Query['internal'];
     queryBuilder: Db;
@@ -140,7 +213,6 @@ interface Db<Table extends string | undefined = undefined, Shape extends Columns
     windows: Query['windows'];
     defaultSelectColumns: DefaultSelectColumns<Shape>;
     relations: Relations;
-    relationsQueries: Record<string, Query>;
     withData: Query['withData'];
     error: new (message: string, length: number, name: QueryErrorName) => QueryError<this>;
     isSubQuery: false;
@@ -151,7 +223,7 @@ interface Db<Table extends string | undefined = undefined, Shape extends Columns
         }[keyof Shape], true>;
     };
 }
-declare class Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends Query['relations'] = Query['relations'], CT extends ColumnTypesBase = DefaultColumnTypes> implements Query {
+declare class Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends RelationsBase = EmptyObject, CT extends ColumnTypesBase = DefaultColumnTypes> implements Query {
     adapter: Adapter;
     queryBuilder: Db;
     table: Table;
@@ -217,8 +289,8 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
      */
     queryArrays<R extends any[] = any[]>(...args: SQLQueryArgs): Promise<QueryArraysResult<R>>;
 }
-type DbResult<CT extends ColumnTypesBase> = Db<string, Record<string, never>, Query['relations'], ColumnTypesBase extends CT ? DefaultColumnTypes : CT> & {
-    <Table extends string, Shape extends ColumnsShape = ColumnsShape>(table: Table, shape?: ((t: ColumnTypesBase extends CT ? DefaultColumnTypes : CT) => Shape) | Shape, options?: DbTableOptions): Db<Table, Shape>;
+type DbResult<CT extends ColumnTypesBase> = Db<string, Record<string, never>, EmptyObject, ColumnTypesBase extends CT ? DefaultColumnTypes : CT> & {
+    <Table extends string, Shape extends ColumnsShape = ColumnsShape>(table: Table, shape?: ((t: ColumnTypesBase extends CT ? DefaultColumnTypes : CT) => Shape) | Shape, options?: DbTableOptions): Db<Table, Shape, EmptyObject>;
     adapter: Adapter;
     close: Adapter['close'];
 };
@@ -242,135 +314,6 @@ type ToSqlOptionsInternal = ToSQLOptions & {
 declare const toSQL: (table: Query, options?: ToSQLOptions) => Sql;
 declare const makeSQL: (table: Query, options?: ToSqlOptionsInternal) => Sql;
 
-declare abstract class QueryBase implements QueryBaseCommon {
-    /**
-     * Clones the current query chain, useful for re-using partial query snippets in other queries without mutating the original.
-     *
-     * Used under the hood, and not really needed on the app side.
-     */
-    clone<T extends QueryBase>(this: T): T;
-    abstract result: ColumnsShapeBase;
-    q: QueryData;
-    table?: string;
-    selectable: SelectableBase;
-    shape: ColumnsShapeBase;
-    relations: RelationsBase;
-    withData: WithDataBase;
-    baseQuery: Query;
-    internal: QueryInternal;
-    meta: QueryMetaBase;
-    returnType: QueryReturnType;
-}
-
-/**
- * Used to build relation sub queries where agg methods such as `count` can be chained with column operators such as `gt`, `lt`.
- * See {@link RelationSubQueries}.
- */
-type SubQueryBuilder<T extends Query, Agg = SelectAggMethods<T>> = Omit<T, keyof Agg> & Agg;
-/**
- * Build and memoize a query builder to use in the argument of select callback.
- * See {@link SubQueryBuilder}
- *
- * @param q - query object to base the query builder upon
- */
-declare const getSubQueryBuilder: <T extends Query>(q: T) => SubQueryBuilder<T, SelectAggMethods<T>>;
-
-type BaseRelation = {
-    type: string;
-    key: string;
-    table: QueryWithTable;
-    query: QueryWithTable;
-    joinQuery(fromQuery: QueryBase, toQuery: Query): Query;
-    nestedCreateQuery: Query;
-    primaryKey: string;
-    options: {
-        scope?(q: QueryWithTable): QueryWithTable;
-        required?: boolean;
-    };
-};
-interface BelongsToRelation extends BaseRelation {
-    type: 'belongsTo';
-    returns: 'one';
-    options: BaseRelation['options'] & {
-        primaryKey: string;
-        foreignKey: string;
-    };
-}
-interface HasOneRelation extends BaseRelation {
-    type: 'hasOne';
-    returns: 'one';
-    options: BaseRelation['options'] & ({
-        primaryKey: string;
-        foreignKey: string;
-    } | {
-        through: string;
-        source: string;
-    });
-}
-interface HasManyRelation extends BaseRelation {
-    type: 'hasMany';
-    returns: 'many';
-    options: BaseRelation['options'] & ({
-        primaryKey: string;
-        foreignKey: string;
-    } | {
-        through: string;
-        source: string;
-    });
-}
-interface HasAndBelongsToManyRelation extends BaseRelation {
-    type: 'hasAndBelongsToMany';
-    returns: 'many';
-    options: BaseRelation['options'] & {
-        primaryKey: string;
-        foreignKey: string;
-        associationPrimaryKey: string;
-        associationForeignKey: string;
-        joinTable: string;
-    };
-}
-type Relation = BelongsToRelation | HasOneRelation | HasManyRelation | HasAndBelongsToManyRelation;
-type RelationsBase = Record<never, Relation>;
-type relationQueryKey = typeof relationQueryKey;
-declare const relationQueryKey: unique symbol;
-type isRequiredRelationKey = typeof isRequiredRelationKey;
-declare const isRequiredRelationKey: unique symbol;
-type RelationQueryData = {
-    relationName: string;
-    sourceQuery: Query;
-    relationQuery: Query;
-    joinQuery(fromQuery: Query, toQuery: Query): Query;
-};
-type RelationQueryBase = Query & {
-    [relationQueryKey]: RelationQueryData;
-    [isRequiredRelationKey]: boolean;
-};
-type PrepareRelationQuery<T extends Query, RelationName extends PropertyKey, Required extends boolean, Populate extends string> = Omit<T, 'meta'> & {
-    meta: Omit<T['meta'], 'as'> & {
-        as: RelationName extends string ? RelationName : never;
-        defaults: Record<Populate, true>;
-    };
-    [isRequiredRelationKey]: Required;
-    [relationQueryKey]: RelationQueryData;
-};
-type RelationQuery<Name extends PropertyKey = string, Params extends Record<string, unknown> = never, Populate extends string = never, T extends Query = Query, Required extends boolean = boolean, ChainedCreate extends boolean = false, ChainedDelete extends boolean = false, Q extends RelationQueryBase = (ChainedCreate extends true ? PrepareRelationQuery<T, Name, Required, Populate> : PrepareRelationQuery<T, Name, Required, Populate> & {
-    [K in CreateMethodsNames]: never;
-}) & (ChainedDelete extends true ? EmptyObject : {
-    [K in DeleteMethodsNames]: never;
-})> = ((params: Params) => Q) & Q & {
-    meta: {
-        hasWhere: true;
-    };
-    join<T extends Query>(this: T): T;
-};
-/**
- * Map relations into a Record where each relation aggregate methods can be chained with column operators.
- * Used in `where` callback argument, see {@link WhereQueryBuilder}.
- */
-type RelationSubQueries<T extends QueryBase> = {
-    [K in keyof T['relations']]: T[K] extends Query ? SubQueryBuilder<T[K]> : never;
-};
-
 type AggregateOptions<T extends Query> = {
     distinct?: boolean;
     order?: OrderArg<T> | OrderArg<T>[];
@@ -578,7 +521,6 @@ type CommonQueryData = {
     patchResult?(q: Query, queryResult: QueryResult): Promise<void>;
     handleResult(q: Query, returnType: QueryReturnType, result: QueryResult, isSubQuery?: true): unknown;
     returnType: QueryReturnType;
-    [relationQueryKey]?: RelationQueryData;
     wrapInTransaction?: boolean;
     throwOnNotFound?: boolean;
     with?: WithItem[];
@@ -1398,1774 +1340,1738 @@ declare class CopyMethods {
     _copy<T extends Query>(this: T, arg: CopyArg<T>): CopyResult<T>;
 }
 
-type WithSelectable<T extends QueryBase, W extends keyof T['withData']> = T['withData'][W] extends WithDataItem ? StringKey<keyof T['withData'][W]['shape']> | `${T['withData'][W]['table']}.${StringKey<keyof T['withData'][W]['shape']>}` : never;
-/**
- * The first argument of all `join` and `joinLateral` methods.
- * See argument of {@link Join.join}.
- */
-type JoinFirstArg<T extends QueryBase> = Query | keyof T['relations'] | keyof T['withData'] | ((q: Pick<T, keyof T['relations']>) => Query);
-/**
- * Arguments of `join` methods (not `joinLateral`).
- * See {@link Join.join}
- */
-type JoinArgs<T extends QueryBase, Arg extends JoinFirstArg<T>> = Arg extends Query ? JoinQueryArgs<T, Arg> : Arg extends keyof T['relations'] ? EmptyTuple : Arg extends keyof T['withData'] ? JoinWithArgs<T, Arg> : never;
-/**
- * Column names of the joined table that can be used to join.
- * Derived from 'result', not from 'shape',
- * because if the joined table has a specific selection, it will be wrapped like:
- * ```sql
- * JOIN (SELECT something FROM joined) joined ON joined.something = ...
- * ```
- * And the selection becomes available to use in the `ON` and to select from the joined table.
- */
-type JoinSelectable<Q extends Query> = keyof Q['result'] | `${AliasOrTable<Q>}.${StringKey<keyof Q['result']>}`;
-type JoinQueryArgs<T extends QueryBase, Q extends Query> = [
-    conditions: Record<JoinSelectable<Q>, Selectable<T> | Expression> | Expression | true
-] | [
-    leftColumn: JoinSelectable<Q> | Expression,
-    rightColumn: Selectable<T> | Expression
-] | [
-    leftColumn: JoinSelectable<Q> | Expression,
-    op: string,
-    rightColumn: Selectable<T> | Expression
-];
-type JoinWithArgs<T extends QueryBase, W extends keyof T['withData']> = [
-    conditions: Record<WithSelectable<T, W>, Selectable<T> | Expression> | Expression
-] | [
-    leftColumn: WithSelectable<T, W> | Expression,
-    rightColumn: Selectable<T> | Expression
-] | [
-    leftColumn: WithSelectable<T, W> | Expression,
-    op: string,
-    rightColumn: Selectable<T> | Expression
-];
-/**
- * Result of all `join` methods, not `joinLateral`.
- * 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
- * @param RequireMain - when false, main table shape will be mapped to make all columns optional (for right and full join)
- */
-type JoinResult<T extends Query, Arg extends JoinFirstArg<T>, RequireJoined extends boolean, RequireMain extends boolean, Cb extends (q: never) => {
-    meta: QueryMetaBase;
-} = () => {
-    meta: QueryMetaBase;
-}, J extends Pick<Query, 'result' | 'table' | 'meta'> = Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['table'] : Arg extends (q: never) => Query ? ReturnType<Arg> : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
-    table: T['withData'][Arg]['table'];
-    result: T['withData'][Arg]['shape'];
-    meta: QueryBase['meta'];
-} : never : never : never, Selectable extends SelectableBase = JoinResultSelectable<J, RequireJoined, ReturnType<Cb>>> = RequireMain extends true ? JoinAddSelectable<T, Selectable> : JoinOptionalMain<T, Selectable>;
-/**
- * Result of all `joinLateral` methods.
- * 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 Query, R extends QueryBase, RequireJoined extends boolean, Selectable extends SelectableBase = JoinResultSelectable<R, RequireJoined, {
-    meta: QueryMetaBase;
-}>> = JoinAddSelectable<T, Selectable>;
+type CreateData<T extends Query, Data = SetOptional<{
+    [K in keyof T['inputType']]: CreateColumn<T, K>;
+}, keyof T['meta']['defaults']>> = [keyof T['relations']] extends [never] ? Data : OmitForeignKeysForRelations<T['relations'], Data> & CreateRelationsData<T>;
+type CreateColumn<T extends Query, Key extends keyof T['inputType']> = Expression | T['inputType'][Key] | {
+    [K in keyof Query]: K extends 'then' ? QueryThen<T['inputType'][Key]> : Query[K];
+};
 /**
- * Build `selectable` type for joined table.
- *
- * When `RequireJoined` parameter is false,
- * the result type of the joined table will be mapped to make all columns optional.
- *
- * Callback may override the joined table alias.
- *
- * 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.
+ * Omit `belongsTo` foreign keys, see {@link BaseRelation.omitForeignKeyInCreate}.
  */
-type JoinResultSelectable<J extends Pick<Query, 'result' | 'table' | 'meta'>, RequireJoined extends boolean, CbResult extends {
-    meta: QueryMetaBase;
-}, Result extends ColumnsShapeBase = RequireJoined extends true ? J['result'] : {
-    [K in keyof J['result']]: NullableColumn<J['result'][K]>;
-}, As extends string = CbResult extends {
-    meta: QueryMetaBase & {
-        as: string;
-    };
-} ? CbResult['meta']['as'] : AliasOrTable<J>> = {
-    [K in keyof Result as `${As}.${StringKey<K>}`]: {
-        as: K;
-        column: Result[K];
-    };
-} & {
-    [K in As as `${As}.*`]: {
-        as: K;
-        column: RequireJoined extends true ? ColumnsObject<J['result']> : NullableColumn<ColumnsObject<J['result']>>;
+type OmitForeignKeysForRelations<R extends RelationsBase, Data> = Omit<Data, {
+    [K in keyof R]: R[K]['relationConfig']['omitForeignKeyInCreate'];
+}[keyof R]>;
+type CreateRelationsData<T extends Query> = {
+    [K in keyof T['relations']]: CreateRelationData<T, K, T['relations'][K]['relationConfig']>;
+}[keyof T['relations']];
+type CreateRelationData<T extends Query, K extends PropertyKey, R extends RelationConfigBase> = [R['omitForeignKeyInCreate']] extends [never] ? CreateRelationDataWithoutFKeys<K, R> : CreateRelationDataWithFKeys<T, K, R>;
+type CreateRelationDataWithFKeys<T extends Query, K extends PropertyKey, R extends RelationConfigBase, FKeys = {
+    [K in R['omitForeignKeyInCreate']]: R['omitForeignKeyInCreate'] extends keyof T['inputType'] ? T['inputType'][R['omitForeignKeyInCreate']] : never;
+}> = {
+    [K in keyof FKeys]: K extends keyof T['meta']['defaults'] ? {
+        [L in K]?: FKeys[L];
+    } : {
+        [L in K]: FKeys[L];
     };
+}[keyof FKeys] | {
+    [Key in K]: R['dataForCreate'];
 };
-type JoinAddSelectable<T extends Query, Selectable extends SelectableBase> = {
-    [K in keyof T]: K extends 'selectable' ? T['selectable'] & Selectable : T[K];
+type CreateRelationDataWithoutFKeys<K extends PropertyKey, R extends RelationConfigBase> = {
+    [Key in K]?: R['dataForCreate'];
 };
-type JoinOptionalMain<T extends Query, Selectable extends SelectableBase, Result extends ColumnsShapeBase = {
-    [K in keyof T['result']]: NullableColumn<T['result'][K]>;
-}, Data = GetQueryResult<T['returnType'], Result>> = {
-    [K in keyof T]: K extends 'selectable' ? {
-        [K in keyof T['selectable']]: {
-            as: T['selectable'][K]['as'];
-            column: NullableColumn<T['selectable'][K]['column']>;
-        };
-    } & Selectable : K extends 'result' ? Result : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : T[K];
+type CreateResult<T extends Query> = T extends {
+    isCount: true;
+} ? SetQueryKind<T, 'create'> : QueryReturnsAll<T['returnType']> extends true ? SetQueryReturnsOne<SetQueryKind<T, 'create'>> : SetQueryKind<T, 'create'>;
+type CreateManyResult<T extends Query> = T extends {
+    isCount: true;
+} ? SetQueryKind<T, 'create'> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAll<SetQueryKind<T, 'create'>> : SetQueryKind<T, 'create'>;
+type CreateRawData<T extends Query> = {
+    columns: (keyof T['shape'])[];
+    values: Expression;
 };
-/**
- * Map the `with` table first argument of `join` or `joinLateral` to a query type.
- * Constructs `selectable` based on `with` table shape, and adds generic types to conform the `QueryBase` type.
- */
-type JoinWithArgToQuery<With extends WithDataItem, Selectable extends SelectableBase = {
-    [K in keyof With['shape']]: {
-        as: StringKey<K>;
-        column: With['shape'][K];
-    };
-}> = {
-    q: QueryData;
-    table: With['table'];
-    clone<T extends QueryBase>(this: T): T;
-    selectable: Selectable & {
-        [K in keyof Selectable as `${With['table']}.${StringKey<K>}`]: Selectable[K];
-    };
-    shape: With['shape'];
-    result: With['shape'];
-    baseQuery: Query;
-    relations: RelationsBase;
-    withData: WithDataBase;
-    meta: QueryBase['meta'];
-    internal: QueryInternal;
-    returnType: QueryReturnType;
+type CreateManyRawData<T extends Query> = {
+    columns: (keyof T['shape'])[];
+    values: Expression[];
 };
-/**
- * Map the first argument of `join` or `joinLateral` to a query type.
- *
- * `with` table arg is mapped into `QueryBase`,
- * query arg is returned as is,
- * relation name is replaced with a relation table.
- */
-type JoinArgToQuery<T extends QueryBase, Arg extends JoinFirstArg<T>> = Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? JoinWithArgToQuery<T['withData'][Arg]> : never : Arg extends Query ? Arg : Arg extends keyof T['relations'] ? T['relations'][Arg] extends Relation ? T['relations'][Arg]['table'] : never : never;
-/**
- * Type of the `join` callback (not `joinLateral`).
- *
- * Receives a query builder that can access columns of both the main and the joined table.
- *
- * The query builder is limited to `or` and `where` methods only.
- *
- * Callback must return a query builder.
- */
-type JoinCallback<T extends QueryBase, Arg extends JoinFirstArg<T>> = (q: OnQueryBuilder<T, JoinArgToQuery<T, Arg>>) => OnQueryBuilder;
-/**
- * Type of the `joinLateral`.
- *
- * Receives a query builder that can access columns of both the main and the joined table.
- *
- * Query builder inside callback is the query derived from the `joinLateral` first argument,
- * all query methods are allowed, `on` methods are available.
- *
- * The callback must return a query object. Its resulting type will become a type of the joined table.
- */
-type JoinLateralCallback<T extends QueryBase, Arg extends JoinFirstArg<T>, R extends QueryBase, Q extends QueryBase = JoinArgToQuery<T, Arg>> = (q: Q & OnQueryBuilder<T, Q>) => R;
-declare class Join {
-    /**
-     * TODO: write docs
-     *
-     * @param arg - can be a query object, a name of a relation, a name of `with` table, or a callback to join a relation
-     * @param args - arguments depend on the first argument, it can be object with columns, list of columns, `true` literal.
-     */
-    join<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, true, true>;
-    join<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, true, true, Cb>;
-    _join<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, true, true>;
-    _join<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, true, true, Cb>;
-    leftJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, false, true>;
-    leftJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, false, true, Cb>;
-    _leftJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, false, true>;
-    _leftJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, false, true, Cb>;
-    rightJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, true, false>;
-    rightJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, true, false, Cb>;
-    _rightJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, true, false>;
-    _rightJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, true, false, Cb>;
-    fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, false, false>;
-    fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, false, false, Cb>;
-    _fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, false, false>;
-    _fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, false, false, Cb>;
-    joinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, true>;
-    _joinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, true>;
-    leftJoinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, false>;
-    _leftJoinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, false>;
-}
-type OnArgs<Q extends {
-    selectable: SelectableBase;
-}> = [leftColumn: keyof Q['selectable'], rightColumn: keyof Q['selectable']] | [
-    leftColumn: keyof Q['selectable'],
-    op: string,
-    rightColumn: keyof Q['selectable']
-];
-declare const pushQueryOn: <T extends QueryBase>(q: T, joinFrom: QueryBase, joinTo: QueryBase, ...on: OnArgs<QueryBase>) => T;
-declare const pushQueryOrOn: typeof pushQueryOn;
-declare const addQueryOn: <T extends QueryBase>(q: T, joinFrom: QueryBase, joinTo: QueryBase, ...args: OnArgs<QueryBase>) => T;
-declare const addQueryOrOn: typeof pushQueryOrOn;
-type OnJsonPathEqualsArgs<T extends QueryBase> = [
-    leftColumn: keyof T['selectable'],
-    leftPath: string,
-    rightColumn: keyof T['selectable'],
-    rightPath: string
-];
-declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBase = QueryBase> extends WhereQueryBase {
-    selectable: J['selectable'] & Omit<S['selectable'], keyof S['shape']>;
-    relations: J['relations'];
-    result: J['result'];
-    shape: J['shape'];
-    baseQuery: Query;
-    withData: {};
-    internal: QueryInternal;
-    constructor(q: QueryBase, { shape, joinedShapes }: Pick<QueryData, 'shape' | 'joinedShapes'>, joinTo: QueryBase);
-    on<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
-    _on<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
-    orOn<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
-    _orOn<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
-    onJsonPathEquals<T extends OnQueryBuilder>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
-    _onJsonPathEquals<T extends OnQueryBuilder>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
-}
-
-type WhereArg<T extends WhereQueryBase> = {
-    [K in keyof T['selectable'] | 'NOT' | 'OR' | 'IN' | 'EXISTS']?: K extends 'NOT' ? MaybeArray<WhereArg<T>> : K extends 'OR' ? MaybeArray<WhereArg<T>>[] : K extends 'IN' ? MaybeArray<{
-        columns: (keyof T['selectable'])[];
-        values: unknown[][] | Query | Expression;
-    }> : K extends keyof T['selectable'] ? T['selectable'][K]['column']['queryType'] | null | ColumnOperators<T['selectable'], K> | Expression | Query : never;
-} | QueryBase | Expression | ((q: WhereQueryBuilder<T>) => QueryBase | ColumnExpression<BooleanNullable>);
-/**
- * Callback argument of `where`.
- * It has `where` methods (`where`, `whereNot`, `whereExists`, etc.),
- * and it has relations that you can aggregate and use a boolean comparison with, such as:
- * ```ts
- * db.table.where((q) => q.relation.count().equals(10))
- * ```
- */
-type WhereQueryBuilder<T extends WhereQueryBase> = Pick<T, keyof WhereQueryBase> & RelationSubQueries<T>;
-type WhereArgs<T extends WhereQueryBase> = WhereArg<T>[] | TemplateLiteralArgs;
-type WhereInColumn<T extends QueryBase> = keyof T['selectable'] | [keyof T['selectable'], ...(keyof T['selectable'])[]];
-type WhereInValues<T extends QueryBase, Column extends WhereInColumn<T>> = Column extends keyof T['selectable'] ? T['selectable'][Column]['column']['queryType'][] | Query | 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;
-})[] | Query | Expression;
-type WhereInArg<T extends Pick<Query, 'selectable'>> = {
-    [K in keyof T['selectable']]?: T['selectable'][K]['column']['queryType'][] | Query | Expression;
+type RawRequiredColumns<T extends Query> = {
+    [K in keyof T['inputType'] as K extends keyof T['meta']['defaults'] ? never : null extends T['inputType'][K] ? never : undefined extends T['inputType'][K] ? never : K]: true;
 };
-type WhereResult<T extends QueryBase> = T & {
-    meta: {
-        hasWhere: true;
-    };
+type CreateRawArgs<T extends Query, Arg extends {
+    columns: (keyof T['shape'])[];
+}> = keyof RawRequiredColumns<T> extends Arg['columns'][number] ? [data: Arg] : [
+    `Missing required columns: ${Exclude<StringKey<keyof RawRequiredColumns<T>>, Arg['columns'][number]>}`
+];
+type OnConflictArg<T extends Query> = keyof T['shape'] | (keyof T['shape'])[] | Expression;
+type CreateCtx = {
+    columns: Map<string, number>;
+    returnTypeAll?: true;
+    resultAll: Record<string, unknown>[];
 };
-/**
- * Adds `where` arguments to query data: SQL template string is added as `RawSQL` object, other arguments are added as is.
- *
- * @param q - query object to add the data to
- * @param args - `where` arguments, may be a template literal
- */
-declare const addWhere: <T extends WhereQueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
-/**
- * Adds `where` arguments to query data with a `NOT` keyword: SQL template string is added as `RawSQL` object, other arguments are added as is.
- *
- * @param q - query object to add the data to
- * @param args - `where` arguments, may be a template literal
- */
-declare const addWhereNot: <T extends WhereQueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
-/**
- * Adds `where` arguments to query data. Arguments will be separated from each other with `OR`.
- *
- * @param q - query object to add the data to
- * @param args - `where` arguments, may be a template literal
- */
-declare const addOr: <T extends WhereQueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
-/**
- * Adds `where` arguments to query data with a `NOT` keyword. Arguments will be separated from each other with `OR`.
- *
- * @param q - query object to add the data to
- * @param args - `where` arguments, may be a template literal
- */
-declare const addOrNot: <T extends WhereQueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
-/**
- * Process arguments of `whereIn` to add them to query data properly.
- *
- * @param q - query object to add the data to.
- * @param and - `true` to join arguments with `AND`, `false` to join them with `OR.
- * @param arg - `whereIn` argument: can be a single column name, tuple of column names, or object with column names and values.
- * @param values - if the `arg` is a column name or a tuple, `values` are the values for the column/columns. If `arg` is an object, `values` are `undefined`.
- * @param not - adds the `NOT` keyword.
- */
-declare const addWhereIn: <T extends QueryBase>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | Expression | undefined, not?: boolean) => WhereResult<T>;
-declare abstract class Where {
+type CreateMethodsNames = 'create' | '_create' | 'createMany' | '_createMany' | 'createRaw' | '_createRaw' | 'createFrom' | '_createFrom';
+declare class Create {
     /**
-     * Constructing `WHERE` conditions:
+     * `create` will create one record.
+     *
+     * Each column may accept a specific value, a raw SQL, or a query that returns a single value.
      *
      * ```ts
-     * db.table.where({
-     *   // column of the current table
+     * const oneRecord = await db.table.create({
      *   name: 'John',
+     *   password: '1234',
+     * });
      *
-     *   // table name may be specified, it can be the name of a joined table
-     *   'table.lastName': 'Johnsonuk',
-     *
-     *   // object with operators, see the "column operators" section to see a full list of them:
-     *   age: {
-     *     gt: 30,
-     *     lt: 70,
-     *   },
+     * await db.table.create({
+     *   // raw SQL
+     *   column1: db.table.sql`'John' | 'Doe'`,
      *
-     *   // where column equals to raw SQL
-     *   column: db.table.sql`raw expression`,
+     *   // query that returns a single value
+     *   // returning multiple values will result in Postgres error
+     *   column2: db.otherTable.get('someColumn'),
      * });
      * ```
      *
-     * `undefined` values are ignored, so you can supply a partial object with conditions:
-     *
-     * ```ts
-     * type Params = {
-     *   // allow providing exact age, or lower or greate than
-     *   age?: number | { lt?: number; gt?: number };
-     * };
+     * @param data - data for the record, may have values, raw SQL, queries, relation operations
+     */
+    create<T extends Query>(this: T, data: CreateData<T>): CreateResult<T>;
+    _create<T extends Query>(this: T, data: CreateData<T>): CreateResult<T>;
+    /**
+     * `createMany` will create a batch of records.
      *
-     * const loadRecords = async (params: Params) => {
-     *   // this will load all records if params is an empty object
-     *   const records = await db.table.where(params);
-     * };
-     * ```
+     * Each column may be set with a specific value, a raw SQL, or a query, the same as in [create](#create).
      *
-     * It supports a sub-query that is selecting a single value to compare it with a column:
+     * In case one of the objects has fewer fields, the `DEFAULT` SQL keyword will be placed in its place in the `VALUES` statement.
      *
      * ```ts
-     * db.table.where({
-     *   // compare `someColumn` in one table with the `column` value returned from another query.
-     *   someColumn: db.otherTable.where(...conditions).get('column'),
-     * });
+     * const manyRecords = await db.table.createMany([
+     *   { key: 'value', otherKey: 'other value' },
+     *   { key: 'value' }, // default will be used for `otherKey`
+     * ]);
      * ```
      *
-     * `where` can accept other queries and merge their conditions:
+     * @param data - data for the record, may have values, raw SQL, queries, relation operations
+     */
+    createMany<T extends Query>(this: T, data: CreateData<T>[]): CreateManyResult<T>;
+    _createMany<T extends Query>(this: T, data: CreateData<T>[]): CreateManyResult<T>;
+    /**
+     * `createRaw` is for creating one record with a raw expression.
      *
-     * ```ts
-     * const otherQuery = db.table.where({ name: 'John' });
+     * Provided SQL will be wrapped into parens for a single `VALUES` record.
      *
-     * db.table.where({ id: 1 }, otherQuery);
-     * // this will produce WHERE "table"."id" = 1 AND "table"."name' = 'John'
-     * ```
+     * If the table has a column with runtime defaults (defined with callbacks), the value will be appended to your SQL.
      *
-     * `where` supports raw SQL:
+     * `columns` are type-checked to contain all required columns.
      *
      * ```ts
-     * db.table.where`a = b`;
+     * const oneRecord = await db.table.createRaw({
+     *   columns: ['name', 'amount'],
+     *   values: db.table.sql`'name', random()`,
+     * });
+     * ```
      *
-     * // or
-     * db.table.where(db.table.sql`a = b`);
+     * @param args - object with columns list and raw SQL for values
+     */
+    createRaw<T extends Query, Arg extends CreateRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateResult<T>;
+    _createRaw<T extends Query, Arg extends CreateRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateResult<T>;
+    /**
+     * `createRaw` is for creating many record with raw expressions.
      *
-     * // or
-     * import { raw } from 'orchid-orm';
+     * Takes array of SQL expressions, each of them will be wrapped into parens for `VALUES` records.
      *
-     * db.table.where(raw`a = b`);
-     * ```
+     * If the table has a column with runtime defaults (defined with callbacks), function will be called for each SQL and the value will be appended.
      *
-     * `where` can accept a callback with a specific query builder containing all "where" methods such as `where`, `or`, `whereNot`, `whereIn`, `whereExists`:
+     * `columns` are type-checked to contain all required columns.
      *
      * ```ts
-     * db.table.where((q) =>
-     *   q
-     *     .where({ name: 'Name' })
-     *     .or({ id: 1 }, { id: 2 })
-     *     .whereIn('letter', ['a', 'b', 'c'])
-     *     .whereExists(Message, 'authorId', 'id'),
-     * );
+     * const manyRecords = await db.table.createManyRaw({
+     *   columns: ['name', 'amount'],
+     *   values: [db.table.sql`'one', 2`, db.table.sql`'three', 4`],
+     * });
      * ```
      *
-     * `where` can accept multiple arguments, conditions are joined with `AND`:
+     * @param args - object with columns list and array of raw SQL for values
+     */
+    createManyRaw<T extends Query, Arg extends CreateManyRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateManyResult<T>;
+    _createManyRaw<T extends Query, Arg extends CreateManyRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateManyResult<T>;
+    /**
+     * This method is for creating a single record, for batch creating see `createManyFrom`.
      *
-     * ```ts
-     * db.table.where(
-     *   { id: 1 },
-     *   db.table.where({ name: 'John' }),
-     *   db.table.sql`a = b`,
-     * );
-     * ```
+     * `createFrom` is to perform the `INSERT ... SELECT ...` SQL statement, it does select and insert in a single query.
      *
-     * ## where sub query
+     * The first argument is a query for a **single** record, it should have `find`, `take`, or similar.
      *
-     * `where` handles a special callback where you can query a relation to get some value and filter by that value.
+     * The second optional argument is a data which will be merged with columns returned from the select query.
      *
-     * It is useful for a faceted search. For instance, posts have tags, and we want to find all posts that have all the given tags.
+     * The data for the second argument is the same as in [create](#create) and [createMany](#createMany).
      *
-     * ```ts
-     * const givenTags = ['typescript', 'node.js'];
+     * Columns with runtime defaults (defined with a callback) are supported here.
+     * The value for such a column will be injected unless selected from a related table or provided in a data object.
      *
-     * const posts = await db.post.where(
-     *   (post) =>
-     *     post.tags // query tags of the post
-     *       .whereIn('tagName', givenTags) // where name of the tag is inside array
-     *       .count() // count how many such tags were found
-     *       .equals(wantedTags.length), // the count must be exactly the length of array
-     *   // if the post has ony `typescript` tag but not the `node.js` it will be omitted
+     * ```ts
+     * const oneRecord = await db.table.createFrom(
+     *   // In the select, key is a related table column, value is a column to insert as
+     *   RelatedTable.select({ relatedId: 'id' }).findBy({ key: 'value' }),
+     *   // optional argument:
+     *   {
+     *     key: 'value',
+     *   },
      * );
      * ```
      *
-     * This will produce an efficient SQL query:
+     * The query above will produce such SQL:
      *
      * ```sql
-     * SELECT * FROM "post"
-     * WHERE (
-     *   SELECT count(*) = 3
-     *   FROM "tag" AS "tags"
-     *   WHERE "tag"."tagName" IN ('typescript', 'node.js')
-     *     -- join tags to the post via "postTag" table
-     *     AND EXISTS (
-     *       SELECT 1 FROM "postTag"
-     *       WHERE "postTag"."postId" = "post"."id"
-     *         AND "postTag"."tagId" = "tag"."id"
-     *     )
-     * )
+     * INSERT INTO "table"("relatedId", "key")
+     * SELECT "relatedTable"."id" AS "relatedId", 'value'
+     * FROM "relatedTable"
+     * WHERE "relatedTable"."key" = 'value'
+     * LIMIT 1
+     * RETURNING *
      * ```
      *
-     * In the example above we use `count()`, you can also use any other aggregate method instead, such as `min`, `max`, `avg`.
-     *
-     * The `count()` is chained with `equals` to check for a strict equality, any other operation is also allowed, such as `not`, `lt`, `gt`.
-     *
-     * ## where special keys
-     *
-     * The object passed to `where` can contain special keys, each of the keys corresponds to its own method and takes the same value as the type of argument of the method.
+     * @param query - query to create new records from
+     * @param data - additionally you can set some columns
+     */
+    createFrom<T extends Query, Q extends Query & {
+        returnType: 'one' | 'oneOrThrow';
+    }>(this: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>): CreateResult<T>;
+    _createFrom<T extends Query, Q extends Query & {
+        returnType: 'one' | 'oneOrThrow';
+    }>(this: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>): CreateResult<T>;
+    /**
+     * Similar to `createFrom`, but intended to create many records.
      *
-     * For example:
+     * Unlike `createFrom`, it doesn't accept second argument with data, and runtime defaults cannot work with it.
      *
      * ```ts
-     * db.table.where({
-     *   NOT: { key: 'value' },
-     *   OR: [{ name: 'a' }, { name: 'b' }],
-     *   IN: {
-     *     columns: ['id', 'name'],
-     *     values: [
-     *       [1, 'a'],
-     *       [2, 'b'],
-     *     ],
-     *   },
-     * });
+     * const manyRecords = await db.table.createManyFrom(
+     *   RelatedTable.select({ relatedId: 'id' }).where({ key: 'value' }),
+     * );
      * ```
      *
-     * Using methods `whereNot`, `or`, `whereIn` instead of this is a shorter and cleaner way, but in some cases, such object keys way may be more convenient.
+     * @param query - query to create new records from
+     */
+    createManyFrom<T extends Query, Q extends Query>(this: T, query: Q): CreateManyResult<T>;
+    _createManyFrom<T extends Query, Q extends Query>(this: T, query: Q): CreateManyResult<T>;
+    /**
+     * `defaults` allows setting values that will be used later in `create`.
      *
-     * ```ts
-     * db.table.where({
-     *   // see .whereNot
-     *   NOT: { id: 1 },
-     *   // can be an array:
-     *   NOT: [{ id: 1 }, { id: 2 }],
+     * Columns provided in `defaults` are marked as optional in the following `create`.
      *
-     *   // see .or
-     *   OR: [{ name: 'a' }, { name: 'b' }],
-     *   // can be an array:
-     *   // this will give id = 1 AND id = 2 OR id = 3 AND id = 4
-     *   OR: [
-     *     [{ id: 1 }, { id: 2 }],
-     *     [{ id: 3 }, { id: 4 }],
-     *   ],
+     * Default data is the same as in [create](#create) and [createMany](#createMany),
+     * so you can provide a raw SQL, or a query with a query.
      *
-     *   // see .in, the key syntax requires an object with columns and values
-     *   IN: {
-     *     columns: ['id', 'name'],
-     *     values: [
-     *       [1, 'a'],
-     *       [2, 'b'],
-     *     ],
-     *   },
-     *   // can be an array:
-     *   IN: [
-     *     {
-     *       columns: ['id', 'name'],
-     *       values: [
-     *         [1, 'a'],
-     *         [2, 'b'],
-     *       ],
-     *     },
-     *     { columns: ['someColumn'], values: [['foo', 'bar']] },
-     *   ],
-     * });
+     * ```ts
+     * // Will use firstName from defaults and lastName from create argument:
+     * db.table
+     *   .defaults({
+     *     firstName: 'first name',
+     *     lastName: 'last name',
+     *   })
+     *   .create({
+     *     lastName: 'override the last name',
+     *   });
      * ```
      *
-     * ## column operators
-     *
-     * `where` argument can take an object where the key is the name of the operator and the value is its argument.
-     *
-     * Different types of columns support different sets of operators.
-     *
-     * All column operators can take a value of the same type as the column, a sub-query, or a raw SQL expression:
+     * @param data - default values for `create` and `createMany` which will follow `defaults`
+     */
+    defaults<T extends Query, Data extends Partial<CreateData<T>>>(this: T, data: Data): T & {
+        meta: {
+            defaults: Record<keyof Data, true>;
+        };
+    };
+    _defaults<T extends Query, Data extends Partial<CreateData<T>>>(this: T, data: Data): T & {
+        meta: {
+            defaults: Record<keyof Data, true>;
+        };
+    };
+    /**
+     * A modifier for creating queries that specify alternative behavior in the case of a conflict.
+     * A conflict occurs when a table has a `PRIMARY KEY` or a `UNIQUE` index on a column
+     * (or a composite index on a set of columns) and a row being created has the same value as a row
+     * that already exists in the table in this column(s).
+     * The default behavior in case of conflict is to raise an error and abort the query.
+     * Using this method you can change this behavior to either silently ignore the error by using .onConflict().ignore()
+     * or to update the existing row with new data (perform an "UPSERT") by using .onConflict().merge().
      *
      * ```ts
-     * import { sql } from 'orchid-orm';
+     * // leave without argument to ignore or merge on any conflict
+     * Target.create(data).onConflict().ignore();
      *
-     * db.table.where({
-     *   numericColumn: {
-     *     // lower than 5
-     *     lt: 5,
+     * // single column:
+     * db.table.create(data).onConfict('email');
      *
-     *     // lower than the value returned by sub-query
-     *     lt: OtherTable.select('someNumber').take(),
+     * // array of columns:
+     * db.table.create(data).onConfict(['email', 'name']);
      *
-     *     // raw SQL expression produces WHERE "numericColumn" < "otherColumn" + 10
-     *     lt: sql`"otherColumn" + 10`,
-     *   },
-     * });
+     * // raw expression:
+     * db.table.create(data).onConfict(db.table.sql`(email) where condition`);
      * ```
      *
-     * ### Any type of column operators
+     * ::: info
+     * The column(s) specified by this method must either be the table's PRIMARY KEY or have a UNIQUE index on them, or the query will fail to execute.
+     * When specifying multiple columns, they must be a composite PRIMARY KEY or have a composite UNIQUE index.
      *
-     * `equals` is a simple `=` operator, it may be useful for comparing column value with JSON object:
+     * You can use the db.table.sql function in onConflict.
+     * It can be useful to specify a condition when you have a partial index:
      *
      * ```ts
-     * db.table.where({
-     *  // when searching for an exact same JSON value, this won't work:
-     *   jsonColumn: someObject,
-     *
-     *   // use `{ equals: ... }` instead:
-     *   jsonColumn: { equals: someObject },
-     * });
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *     active: true,
+     *   })
+     *   // ignore only on email conflict and active is true.
+     *   .onConflict(db.table.sql`(email) where active`)
+     *   .ignore();
      * ```
      *
-     * `not` is `!=` (aka `<>`) not equal operator:
+     * :::
      *
-     * ```ts
-     * db.table.where({
-     *   anyColumn: { not: value },
-     * });
-     * ```
+     * See the documentation on the .ignore() and .merge() methods for more details.
      *
-     * `in` is for the `IN` operator to check if the column value is included in a list of values.
+     * @param arg - optionally provide an array of columns
+     */
+    onConflict<T extends Query, Arg extends OnConflictArg<T>>(this: T, arg?: Arg): OnConflictQueryBuilder<T, Arg>;
+    _onConflict<T extends Query, Arg extends OnConflictArg<T> | undefined = undefined>(this: T, arg?: Arg): OnConflictQueryBuilder<T, Arg>;
+}
+declare class OnConflictQueryBuilder<T extends Query, Arg extends OnConflictArg<T> | undefined> {
+    private query;
+    private onConflict;
+    constructor(query: T, onConflict: Arg);
+    /**
+     * Available only after `onConflict`.
      *
-     * Takes an array of the same type as a column, a sub-query that returns a list of values, or a raw SQL expression that returns a list.
+     * Modifies a create query, and causes it to be silently dropped without an error if a conflict occurs.
      *
-     * ```ts
-     * db.table.where({
-     *   column: {
-     *     in: ['a', 'b', 'c'],
+     * Adds the `ON CONFLICT (columns) DO NOTHING` clause to the insert statement.
      *
-     *     // WHERE "column" IN (SELECT "column" FROM "otherTable")
-     *     in: OtherTable.select('column'),
+     * It produces `ON CONFLICT DO NOTHING` when no `onConflict` argument provided.
      *
-     *     in: db.table.sql`('a', 'b')`,
-     *   },
-     * });
+     * ```ts
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *   })
+     *   .onConflict('email')
+     *   .ignore();
      * ```
+     */
+    ignore(): T;
+    /**
+     * Available only after `onConflict`.
      *
-     * `notIn` is for the `NOT IN` operator, and takes the same arguments as `in`
+     * Modifies a create query, to turn it into an 'upsert' operation.
      *
-     * ### Numeric, Date, and Time column operators
+     * Adds an `ON CONFLICT (columns) DO UPDATE` clause to the insert statement.
      *
-     * To compare numbers, dates, and times.
+     * When no `onConflict` argument provided,
+     * it will automatically collect all table columns that have unique index and use them as a conflict target.
      *
-     * `lt` is for `<` (lower than)
+     * ```ts
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *   })
+     *   .onConflict('email')
+     *   .merge();
+     * ```
      *
-     * `lte` is for `<=` (lower than or equal)
+     * This also works with batch creates:
      *
-     * `gt` is for `>` (greater than)
+     * ```ts
+     * db.table
+     *   .createMany([
+     *     { email: 'john@example.com', name: 'John Doe' },
+     *     { email: 'jane@example.com', name: 'Jane Doe' },
+     *     { email: 'alex@example.com', name: 'Alex Doe' },
+     *   ])
+     *   .onConflict('email')
+     *   .merge();
+     * ```
      *
-     * `gte` is for `>=` (greater than or equal)
+     * It is also possible to specify a subset of the columns to merge when a conflict occurs.
+     * For example, you may want to set a `createdAt` column when creating but would prefer not to update it if the row already exists:
      *
      * ```ts
-     * db.table.where({
-     *   numericColumn: {
-     *     gt: 5,
-     *     lt: 10,
-     *   },
-     *
-     *   date: {
-     *     lte: new Date(),
-     *   },
+     * const timestamp = Date.now();
      *
-     *   time: {
-     *     gte: new Date(),
-     *   },
-     * });
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *     createdAt: timestamp,
+     *     updatedAt: timestamp,
+     *   })
+     *   .onConflict('email')
+     *   // string argument for a single column:
+     *   .merge('email')
+     *   // array of strings for multiple columns:
+     *   .merge(['email', 'name', 'updatedAt']);
      * ```
      *
-     * `between` also works with numeric, dates, and time columns, it takes an array of two elements.
-     *
-     * Both elements can be of the same type as a column, a sub-query, or a raw SQL expression.
+     * It is also possible to specify data to update separately from the data to create.
+     * This is useful if you want to make an update with different data than in creating.
+     * For example, you may want to change a value if the row already exists:
      *
      * ```ts
-     * db.table.where({
-     *   column: {
-     *     // simple values
-     *     between: [1, 10],
+     * const timestamp = Date.now();
      *
-     *     // sub-query and raw SQL expression
-     *     between: [OtherTable.select('column').take(), db.table.sql`2 + 2`],
-     *   },
-     * });
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *     createdAt: timestamp,
+     *     updatedAt: timestamp,
+     *   })
+     *   .onConflict('email')
+     *   .merge({
+     *     name: 'John Doe The Second',
+     *   });
      * ```
      *
-     * ### Text column operators
+     * It is also possible to add a WHERE clause to conditionally update only the matching rows:
      *
-     * For `text`, `char`, `varchar`, and `json` columns.
+     * ```ts
+     * const timestamp = Date.now();
      *
-     * `json` is stored as text, so it has text operators. Use the `jsonb` type for JSON operators.
+     * db.table
+     *   .create({
+     *     email: 'ignore@example.com',
+     *     name: 'John Doe',
+     *     createdAt: timestamp,
+     *     updatedAt: timestamp,
+     *   })
+     *   .onConflict('email')
+     *   .merge({
+     *     name: 'John Doe',
+     *     updatedAt: timestamp,
+     *   })
+     *   .where({ updatedAt: { lt: timestamp } });
+     * ```
      *
-     * Takes a string, or sub-query returning string, or raw SQL expression as well as other operators.
+     * `merge` also accepts raw expression:
      *
      * ```ts
-     * db.table.where({
-     *   textColumn: {
-     *     // WHERE "textColumn" LIKE '%string%'
-     *     contains: 'string',
-     *     // WHERE "textColumn" ILIKE '%string%'
-     *     containsInsensitive: 'string',
-     *     // WHERE "textColumn" LIKE 'string%'
-     *     startsWith: 'string',
-     *     // WHERE "textColumn" ILIKE 'string%'
-     *     startsWithInsensitive: 'string',
-     *     // WHERE "textColumn" LIKE '%string'
-     *     endsWith: 'string',
-     *     // WHERE "textColumn" ILIKE '%string'
-     *     endsWithInsensitive: 'string',
-     *   },
-     * });
+     * db.table
+     *   .create(data)
+     *   .onConflict()
+     *   .merge(db.table.sql`raw SQL expression`);
      * ```
      *
-     * ### JSONB column operators
+     * @param update - column, or array of columns, or object for new column values, or raw SQL
+     */
+    merge(update?: keyof T['shape'] | (keyof T['shape'])[] | Partial<T['inputType']> | Expression): T;
+}
+
+type DeleteMethodsNames = 'del' | '_del' | 'delete' | '_delete';
+type DeleteArgs<T extends Query> = T['meta']['hasWhere'] extends true ? [] : [never];
+type DeleteResult<T extends Query> = T['meta']['hasSelect'] extends true ? SetQueryKind<T, 'delete'> : SetQueryReturnsRowCount<SetQueryKind<T, 'delete'>>;
+declare class Delete {
+    /**
+     * Alias for `delete` method
+     */
+    del<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
+    _del<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
+    /**
+     * It is aliased to `del` because `delete` is a reserved word in JavaScript.
      *
-     * For the `jsonb` column, note that the `json` type has text operators instead.
+     * This method deletes one or more rows, based on other conditions specified in the query.
      *
-     * `jsonPath` operator: compare a column value under a given JSON path with the provided value.
+     * By default, `delete` will return a count of deleted records.
      *
-     * Value can be of any type to compare with JSON value, or it can be a sub-query or a raw SQL expression.
+     * Place `select`, `selectAll`, or `get` before `delete` to specify returning columns.
+     *
+     * Need to provide `where`, `findBy`, or `find` conditions before calling `delete`.
+     * To prevent accidental deletion of all records, deleting without where will result in TypeScript and a runtime error.
+     *
+     * Use `all()` to delete ALL records without conditions:
      *
      * ```ts
-     * db.table.where({
-     *   jsonbColumn: {
-     *     jsonPath: [
-     *       '$.name', // first element is JSON path
-     *       '=', // second argument is comparison operator
-     *       'value', // third argument is a value to compare with
-     *     ],
-     *   },
-     * });
+     * await db.table.all().delete();
      * ```
      *
-     * `jsonSupersetOf`: check if the column value is a superset of provided value.
+     * ```ts
+     * // deletedCount is the number of deleted records
+     * const deletedCount = await db.table.where(...conditions).delete();
+     *
+     * // returns a single value, throws if not found
+     * const id: number | undefined = await db.table
+     *   .findBy(...conditions)
+     *   .get('id')
+     *   .delete();
+     *
+     * // returns an array of records with specified columns
+     * const deletedRecord = await db.table
+     *   .select('id', 'name', 'age')
+     *   .where(...conditions)
+     *   .delete();
      *
-     * For instance, it is true if the column has JSON `{ "a": 1, "b": 2 }` and provided value is `{ "a": 1 }`.
+     * // returns an array of fully deleted records
+     * const deletedUsersFull = await db.table
+     *   .selectAll()
+     *   .where(...conditions)
+     *   .delete();
+     * ```
      *
-     * Takes the value of any type, or sub query which returns a single value, or a raw SQL expression.
+     * `delete` supports joining, under the hood the join is transformed to `USING` and `WHERE` statements:
      *
      * ```ts
-     * db.table.where({
-     *   jsonbColumn: {
-     *     jsonSupersetOf: { a: 1 },
-     *   },
-     * });
+     * // delete all users who have corresponding profile records:
+     * db.table.join(Profile, 'profile.userId', 'user.id').all().delete();
      * ```
+     */
+    delete<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
+    _delete<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
+}
+
+type ForQueryBuilder<Q extends Query> = Q & {
+    noWait<T extends ForQueryBuilder<Q>>(this: T): T;
+    _noWait<T extends ForQueryBuilder<Q>>(this: T): T;
+    skipLocked<T extends ForQueryBuilder<Q>>(this: T): T;
+    _skipLocked<T extends ForQueryBuilder<Q>>(this: T): T;
+};
+declare class For {
+    forUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    _forUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    _forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    forShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    _forShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    forKeyShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+    _forKeyShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
+}
+
+type FromArgs<T extends Query> = [
+    first: Query | Expression | Exclude<keyof T['withData'], symbol | number>,
+    second?: {
+        only?: boolean;
+    }
+] | TemplateLiteralArgs;
+type FromResult<T extends Query, Args extends FromArgs<T>> = Args extends TemplateStringsArray ? T : Args[0] extends string ? T['withData'] extends Record<string, WithDataItem> ? Args[0] extends keyof T['withData'] ? Omit<T, 'meta' | 'selectable'> & {
+    meta: Omit<T['meta'], 'as'> & {
+        as?: string;
+    };
+    selectable: SelectableFromShape<T['withData'][Args[0]]['shape'], Args[0]>;
+} : SetQueryTableAlias<T, Args[0]> : SetQueryTableAlias<T, Args[0]> : Args[0] extends Query ? FromQueryResult<T, Args[0]> : T;
+type FromQueryResult<T extends Query, Q extends Query, Selectable extends SelectableBase = {
+    [K in keyof Q['result']]: K extends string ? {
+        as: K;
+        column: Q['result'][K];
+    } : never;
+}, Data = GetQueryResult<T['returnType'], Q['result']>> = {
+    [K in keyof T]: K extends 'meta' ? Omit<T['meta'], 'hasSelect' | 'as'> & {
+        as: AliasOrTable<Q>;
+    } : K extends 'selectable' ? Selectable : K extends 'result' | 'shape' ? Q['result'] : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : T[K];
+};
+declare class From {
+    /**
+     * Set the `FROM` value, by default the table name is used.
      *
-     * `jsonSubsetOf`: check if the column value is a subset of provided value.
+     * ```ts
+     * // accepts sub-query:
+     * db.table.from(Otherdb.table.select('foo', 'bar'));
      *
-     * For instance, it is true if the column has JSON `{ "a": 1 }` and provided value is `{ "a": 1, "b": 2 }`.
+     * // accepts raw sql by template literal:
+     * const value = 123;
+     * db.table.from`value = ${value}`;
      *
-     * Takes the value of any type, or sub query which returns a single value, or a raw SQL expression.
+     * // accepts raw sql:
+     * db.table.from(db.table.sql`value = ${value}`);
+     *
+     * // accepts alias of `WITH` expression:
+     * q.with('foo', Otherdb.table.select('id', 'name')).from('foo');
+     * ```
+     *
+     * Optionally takes a second argument of type `{ only?: boolean }`, (see `FROM ONLY` in Postgres docs, this is related to table inheritance).
      *
      * ```ts
-     * db.table.where({
-     *   jsonbColumn: {
-     *     jsonSupersetOf: { a: 1 },
-     *   },
+     * db.table.from(Otherdb.table.select('foo', 'bar'), {
+     *   only: true,
      * });
      * ```
      *
-     * @param args - {@link WhereArgs}
+     * @param args - query, raw SQL, name of CTE table, or a template string
      */
-    where<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
-    _where<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    from<T extends Query, Args extends FromArgs<T>>(this: T, ...args: Args): FromResult<T, Args>;
+    _from<T extends Query, Args extends FromArgs<T>>(this: T, ...args: Args): FromResult<T, Args>;
+}
+
+type GetArg<T extends QueryBase> = GetStringArg<T> | Expression;
+type GetStringArg<T extends QueryBase> = StringKey<keyof T['selectable']>;
+type GetResult<T extends Query, Arg extends GetArg<T>> = Arg extends GetStringArg<T> ? SetQueryReturnsValue<T, Arg> : Arg extends Expression ? SetQueryReturnsColumn<T, Arg['_type']> : never;
+type GetResultOptional<T extends Query, Arg extends GetArg<T>> = Arg extends GetStringArg<T> ? SetQueryReturnsValueOptional<T, Arg> : Arg extends Expression ? SetQueryReturnsColumnOptional<T, Arg['_type']> : never;
+declare class QueryGet {
     /**
-     * `whereNot` takes the same arguments as `where` and prepends them with `NOT` in SQL
+     * `.get` returns a single value, it will add `LIMIT 1` to the query, and accepts a column name or a raw expression.
+     * It will throw `NotFoundError` when not found.
      *
      * ```ts
-     * // find records of different colors than red
-     * db.table.whereNot({ color: 'red' });
+     * import { NumberColumn } from 'pqb';
+     *
+     * const firstName: string = await db.table.get('name');
+     *
+     * const rawResult: number = await db.table.get(
+     *   db.table.sql((t) => t.integer())`1 + 1`,
+     * );
      * ```
      *
-     * @param args - {@link WhereArgs}
+     * @param arg - string for a column to get, or a raw SQL
      */
-    whereNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
-    _whereNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    get<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResult<T, Arg>;
+    _get<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResult<T, Arg>;
     /**
-     * `and` is an alias for {@link where} to make it look closer to SQL:
+     * `.getOptional` returns a single value or undefined when not found:
      *
      * ```ts
-     * db.table.where({ id: 1 }).and({ name: 'John' });
+     * const firstName: string | undefined = await db.table.getOptional('name');
      * ```
      *
-     * @param args - {@link WhereArgs}
-     */
-    and<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
-    _and<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
-    /**
-     * `andNot` is an alias for `whereNot`.
-     *
-     * @param args - {@link WhereArgs}
+     * @param arg - string for a column to get, or a raw SQL
      */
-    andNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
-    _andNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResultOptional<T, Arg>;
+    _getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResultOptional<T, Arg>;
+}
+
+type HavingArgs<T extends Query> = TemplateLiteralArgs | HavingArgFn<T>[];
+type HavingArgFn<T extends Query> = (q: SelectAggMethods<T>) => Expression<ColumnTypeBase<boolean | null>>;
+declare class Having {
     /**
-     * `or` is accepting the same arguments as {@link where}, joining arguments with `OR`.
-     *
-     * Columns in single arguments are still joined with `AND`.
+     * Build a `HAVING` clause to the query to filter records by results of [aggregate functions](#aggregate-functions).
      *
-     * The database is processing `AND` before `OR`, so this should be intuitively clear.
+     * The argument of `having` is a function where you call the aggregate function and compare it with some value by using [column operators](/guide/where.html#column-operators).
      *
      * ```ts
-     * db.table.or({ id: 1, color: 'red' }, { id: 2, color: 'blue' });
-     * ```
-     *
-     * This query will produce such SQL (simplified):
-     *
-     * ```sql
-     * SELECT * FROM "table"
-     * WHERE id = 1 AND color = 'red'
-     *    OR id = 2 AND color = 'blue'
+     * db.table.having((q) => q.count().gte(10));
+     * // HAVING count(*) >= 10
      * ```
      *
-     * @param args - {@link WhereArgs} will be joined with `OR`
-     */
-    or<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    _or<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    /**
-     * `orNot` takes the same arguments as {@link or}, and prepends each condition with `NOT` just as {@link whereNot} does.
-     *
-     * @param args - {@link WhereArgs} will be prefixed with `NOT` and joined with `OR`
-     */
-    orNot<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    _orNot<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    /**
-     * `whereIn` and related methods are for the `IN` operator to check for inclusion in a list of values.
-     *
-     * When used with a single column it works equivalent to the `in` column operator:
+     * Alternatively, it accepts a raw SQL template:
      *
      * ```ts
-     * db.table.whereIn('column', [1, 2, 3]);
-     * // the same as:
-     * db.table.where({ column: [1, 2, 3] });
+     * db.table.having`count(*) >= ${10}`;
      * ```
      *
-     * `whereIn` can support a tuple of columns, that's what the `in` operator cannot support:
+     * Multiple having conditions will be combined with `AND`:
      *
      * ```ts
-     * db.table.whereIn(
-     *   ['id', 'name'],
-     *   [
-     *     [1, 'Alice'],
-     *     [2, 'Bob'],
-     *   ],
+     * db.table.having(
+     *   (q) => q.sum('column').gt(5),
+     *   (q) => q.avg('column').lt(10),
      * );
+     * // HAVING sum(column) > 5 AND avg(column) < 10
      * ```
      *
-     * It supports sub query which should return records with columns of the same type:
+     * After applying a comparison, `or` and `and` methods become available:
      *
      * ```ts
-     * db.table.whereIn(['id', 'name'], OtherTable.select('id', 'name'));
+     * db.table.having((q) =>
+     *   q.sum('column').equals(5).or(q.min('column').gt(1), q.max('column').lt(10)),
+     * );
+     * // HAVING (sum(column) = 5) OR (min(column) > 1 AND max(column) < 10)
      * ```
      *
-     * It supports raw SQL expression:
+     * Aggregate functions are exactly the same functions described in [aggregate functions](#aggregate-functions), they can accept aggregation options:
      *
      * ```ts
-     * db.table.whereIn(['id', 'name'], db.table.sql`((1, 'one'), (2, 'two'))`);
+     * db.table.having((q) =>
+     *   q
+     *     .count('id', {
+     *       distinct: true,
+     *       order: { createdAt: 'DESC', filter: { someColumn: { not: null } } },
+     *     })
+     *     .gte(10),
+     * );
      * ```
      *
-     * @param column - one column name, or array of column names
-     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
-     */
-    whereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    /**
-     * See {@link whereIn}.
-     *
-     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
-     */
-    whereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _whereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _whereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    /**
-     * Takes the same arguments as {@link whereIn}.
-     * Add a `WHERE IN` condition prefixed with `OR` to the query:
+     * Arguments of the aggregate function and of the comparison can be raw SQL:
      *
      * ```ts
-     * db.table.whereIn('a', [1, 2, 3]).orWhereIn('b', ['one', 'two']);
+     * db.table.having((q) => q.count(q.sql('coalesce(one, two)')).gte(q.sql`2 + 2`));
      * ```
      *
-     * @param column - one column name, or array of column names
-     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
-     */
-    orWhereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    /**
-     * See {@link orWhereIn}.
-     *
-     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
+     * @param args - raw SQL template string or one or multiple callbacks returning a boolean expression
      */
-    orWhereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _orWhereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _orWhereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    having<T extends Query>(this: T, ...args: HavingArgs<T>): T;
+    _having<T extends Query>(this: T, ...args: HavingArgs<T>): T;
+}
+
+type AfterHook<Select extends PropertyKey[], Shape extends ColumnsShapeBase, Selected extends ColumnsShapeBase = Pick<Shape, StringKey<Select[number]>>, Item = {
+    [K in keyof Selected]: Selected[K]['outputType'];
+}> = QueryAfterHook<Item[]>;
+type HookSelect<T extends QueryBase> = (keyof T['shape'])[];
+type HookAction = 'Create' | 'Update' | 'Delete';
+declare abstract class QueryHooks extends QueryBase {
     /**
-     * Acts as `whereIn`, but negates the condition with `NOT`:
-     *
-     * ```ts
-     * db.table.whereNotIn('color', ['red', 'green', 'blue']);
-     * ```
+     * Run the function before any kind of query.
      *
-     * @param column - one column name, or array of column names
-     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
+     * @param cb - function to call, first argument is a query object
      */
-    whereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    beforeQuery<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
+    _beforeQuery<T extends QueryBase>(this: T, cb: QueryBeforeHook): T;
     /**
-     * See {@link whereNotIn}.
+     * Run the function after any kind of query.
+     * Enforces wrapping the query into a transaction.
+     * The function will run after the query is succeeded, but before the transaction commit.
      *
-     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
+     * @param cb - function to call, first argument is the query result of type `unknown`, second argument is a query object
      */
-    whereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _whereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _whereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    afterQuery<T extends QueryHooks>(this: T, cb: QueryAfterHook): T;
+    _afterQuery<T extends QueryBase>(this: T, cb: QueryAfterHook): T;
     /**
-     * Acts as `whereIn`, but prepends `OR` to the condition and negates it with `NOT`:
-     *
-     * ```ts
-     * db.table.whereNotIn('a', [1, 2, 3]).orWhereNoIn('b', ['one', 'two']);
-     * ```
+     * Run the function before a `create` kind of query.
      *
-     * @param column - one column name, or array of column names
-     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
+     * @param cb - function to call, first argument is a query object
      */
-    orWhereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    beforeCreate<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
+    _beforeCreate<T extends QueryBase>(this: T, cb: QueryBeforeHook): T;
     /**
-     * See {@link orWhereNotIn}.
+     * Run the function after a `create` kind of query.
+     * Enforces wrapping the query into a transaction.
+     * The function will run after the query is succeeded, but before the transaction commit.
+     * Queries inside the function will run in the same transaction as the target query.
      *
-     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
+     * @param select - list of columns to select for the hook
+     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    orWhereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _orWhereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _orWhereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    afterCreate<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    _afterCreate<T extends QueryBase, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
-     * `whereExists` is for support of the `WHERE EXISTS (query)` clause.
-     *
-     * This method is accepting the same arguments as `join`, see the {@link Join.join} section for more details.
-     *
-     * ```ts
-     * // find users who have accounts
-     * // find by a relation name if it's defined
-     * db.user.whereExists('account');
-     *
-     * // find using a table and a join conditions
-     * db.user.whereExists(db.account, 'account.id', 'user.id');
-     *
-     * // find using a query builder in a callback:
-     * db.user.whereExists(db.account, (q) => q.on('account.id', '=', 'user.id'));
-     * ```
+     * Run the function after transaction for a `create` kind of query will be committed.
+     * If the query wasn't wrapped in a transaction, will run after the query.
      *
-     * @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.
+     * @param select - list of columns to select for the hook
+     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
+    afterCreateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    _afterCreateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
-     * See {@link whereExists}.
+     * Run the function before an `update` kind of query.
      *
-     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
-     * @param cb - callback with a query builder to join the table.
+     * @param cb - function to call, first argument is a query object
      */
-    whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
-    _whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    beforeUpdate<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
+    _beforeUpdate<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
     /**
-     * Acts as `whereExists`, but prepends the condition with `OR`:
-     *
-     * ```ts
-     * // find users who have an account or a profile,
-     * // imagine that the user has both `account` and `profile` relations defined.
-     * db.user.whereExist('account').orWhereExists('profile');
-     * ```
+     * Run the function after an `update` kind of query.
+     * Enforces wrapping the query into a transaction.
+     * The function will run after the query is succeeded, but before the transaction commit.
+     * Queries inside the function will run in the same transaction as the target query.
+     * If no records were updated, the hook *won't* run.
      *
-     * @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.
+     * @param select - list of columns to select for the hook
+     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    afterUpdate<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    _afterUpdate<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
-     * See {@link orWhereExists}.
+     * Run the function after transaction for an `update` kind of query will be committed.
+     * If the query wasn't wrapped in a transaction, will run after the query.
+     * If no records were updated, the hook *won't* run.
      *
-     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
-     * @param cb - callback with a query builder to join the table.
+     * @param select - list of columns to select for the hook
+     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
-    _orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    afterUpdateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    _afterUpdateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
-     * Acts as `whereExists`, but negates the condition with `NOT`:
+     * Run the function before a `create` or an `update` kind of query.
      *
-     * ```ts
-     * // find users who don't have an account,
-     * // image that the user `belongsTo` or `hasOne` account.
-     * db.user.whereNotExist('account');
-     * ```
+     * @param cb - function to call, first argument is a query object
+     */
+    beforeSave<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
+    _beforeSave<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
+    /**
+     * Run the function after a `create` or an `update` kind of query.
+     * Enforces wrapping the query into a transaction.
+     * The function will run after the query is succeeded, but before the transaction commit.
+     * Queries inside the function will run in the same transaction as the target query.
+     * For the `update` query, if no records were updated, the hook *won't* run.
      *
-     * @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.
+     * @param select - list of columns to select for the hook
+     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    afterSave<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    _afterSave<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
-     * See {@link whereNotExists}.
+     * Run the function after transaction for a `create` or an `update` kind of query will be committed.
+     * If the query wasn't wrapped in a transaction, will run after the query.
+     * For the `update` query, if no records were updated, the hook *won't* run.
      *
-     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
-     * @param cb - callback with a query builder to join the table.
+     * @param select - list of columns to select for the hook
+     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
-    _whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    afterSaveCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    _afterSaveCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
-     * Acts as `whereExists`, but prepends the condition with `OR` and negates it with `NOT`:
+     * Run the function before a `delete` kind of query.
      *
-     * ```ts
-     * // find users who don't have an account OR who don't have a profile
-     * // imagine that the user has both `account` and `profile` relations defined.
-     * db.user.whereNotExists('account').orWhereNotExists('profile');
-     * ```
+     * @param cb - function to call, first argument is a query object
+     */
+    beforeDelete<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
+    _beforeDelete<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
+    /**
+     * Run the function after a `delete` kind of query.
+     * Enforces wrapping the query into a transaction.
+     * The function will run after the query is succeeded, but before the transaction commit.
+     * Queries inside the function will run in the same transaction as the target query.
+     * If no records were deleted, the hook *won't* run.
      *
-     * @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.
+     * @param select - list of columns to select for the hook
+     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    afterDelete<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    _afterDelete<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
     /**
-     * See {@link orWhereNotExists}.
+     * Run the function after transaction for a `delete` kind of query will be committed.
+     * If the query wasn't wrapped in a transaction, will run after the query.
+     * If no records were deleted, the hook *won't* run.
      *
-     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
-     * @param cb - callback with a query builder to join the table.
+     * @param select - list of columns to select for the hook
+     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
      */
-    orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
-    _orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-}
-interface WhereQueryBase extends Where, QueryBase {
-}
-declare abstract class WhereQueryBase extends QueryBase {
+    afterDeleteCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    _afterDeleteCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
 }
 
-type CreateData<T extends Query, Data = SetOptional<{
-    [K in keyof T['inputType']]: CreateColumn<T, K>;
-}, keyof T['meta']['defaults']>> = [keyof T['relations']] extends [never] ? Data : OmitBelongsToForeignKeys<T['relations'], Data> & CreateRelationData<T>;
-type CreateColumn<T extends Query, Key extends keyof T['inputType']> = Expression | T['inputType'][Key] | {
-    [K in keyof Query]: K extends 'then' ? QueryThen<T['inputType'][Key]> : Query[K];
-};
-type OmitBelongsToForeignKeys<R extends RelationsBase, Data> = Omit<Data, {
-    [K in keyof R]: R[K] extends BelongsToRelation ? R[K]['options']['foreignKey'] : never;
-}[keyof R]>;
-type CreateRelationData<T extends Query> = {
-    [K in keyof T['relations']]: T['relations'][K] extends BelongsToRelation ? CreateBelongsToData<T, K, T['relations'][K]> : T['relations'][K] extends HasOneRelation ? CreateHasOneData<T, K, T['relations'][K]> : T['relations'][K] extends HasManyRelation | HasAndBelongsToManyRelation ? CreateHasManyData<T, K, T['relations'][K]> : EmptyObject;
-}[keyof T['relations']];
-type CreateBelongsToData<T extends Query, Key extends keyof T['relations'], Rel extends BelongsToRelation, FKeys = {
-    [K in Rel['options']['foreignKey']]: Rel['options']['foreignKey'] extends keyof T['inputType'] ? T['inputType'][Rel['options']['foreignKey']] : never;
-}> = {
-    [K in keyof FKeys]: K extends keyof T['meta']['defaults'] ? {
-        [L in K]?: FKeys[L];
-    } : {
-        [L in K]: FKeys[L];
-    };
-}[keyof FKeys] | {
-    [K in Key]: {
-        create: CreateData<Rel['nestedCreateQuery']>;
-        connect?: never;
-        connectOrCreate?: never;
-    } | {
-        create?: never;
-        connect: WhereArg<Rel['table']>;
-        connectOrCreate?: never;
-    } | {
-        create?: never;
-        connect?: never;
-        connectOrCreate: {
-            where: WhereArg<Rel['table']>;
-            create: CreateData<Rel['nestedCreateQuery']>;
-        };
-    };
-};
-type CreateHasOneData<T extends Query, Key extends keyof T['relations'], Rel extends HasOneRelation> = 'through' extends Rel['options'] ? {} : {
-    [K in Key]?: {
-        create: CreateData<Rel['nestedCreateQuery']>;
-        connect?: never;
-        connectOrCreate?: never;
-    } | {
-        create?: never;
-        connect: WhereArg<Rel['table']>;
-        connectOrCreate?: never;
-    } | {
-        create?: never;
-        connect?: never;
-        connectOrCreate: {
-            where?: WhereArg<Rel['table']>;
-            create?: CreateData<Rel['nestedCreateQuery']>;
-        };
-    };
-};
-type CreateHasManyData<T extends Query, Key extends keyof T['relations'], Rel extends HasManyRelation | HasAndBelongsToManyRelation> = 'through' extends Rel['options'] ? {} : {
-    [K in Key]?: {
-        create?: CreateData<Rel['nestedCreateQuery']>[];
-        connect?: WhereArg<Rel['table']>[];
-        connectOrCreate?: {
-            where: WhereArg<Rel['table']>;
-            create: CreateData<Rel['nestedCreateQuery']>;
-        }[];
-    };
-};
-type CreateResult<T extends Query> = T extends {
-    isCount: true;
-} ? SetQueryKind<T, 'create'> : QueryReturnsAll<T['returnType']> extends true ? SetQueryReturnsOne<SetQueryKind<T, 'create'>> : SetQueryKind<T, 'create'>;
-type CreateManyResult<T extends Query> = T extends {
-    isCount: true;
-} ? SetQueryKind<T, 'create'> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAll<SetQueryKind<T, 'create'>> : SetQueryKind<T, 'create'>;
-type CreateRawData<T extends Query> = {
-    columns: (keyof T['shape'])[];
-    values: Expression;
-};
-type CreateManyRawData<T extends Query> = {
-    columns: (keyof T['shape'])[];
-    values: Expression[];
-};
-type RawRequiredColumns<T extends Query> = {
-    [K in keyof T['inputType'] as K extends keyof T['meta']['defaults'] ? never : null extends T['inputType'][K] ? never : undefined extends T['inputType'][K] ? never : K]: true;
-};
-type CreateRawArgs<T extends Query, Arg extends {
-    columns: (keyof T['shape'])[];
-}> = keyof RawRequiredColumns<T> extends Arg['columns'][number] ? [data: Arg] : [
-    `Missing required columns: ${Exclude<StringKey<keyof RawRequiredColumns<T>>, Arg['columns'][number]>}`
-];
-type OnConflictArg<T extends Query> = keyof T['shape'] | (keyof T['shape'])[] | Expression;
-type CreateCtx = {
-    columns: Map<string, number>;
-    returnTypeAll?: true;
-    resultAll: Record<string, unknown>[];
+type WhereArg<T extends WhereQueryBase> = {
+    [K in keyof T['selectable'] | 'NOT' | 'OR' | 'IN' | 'EXISTS']?: K extends 'NOT' ? MaybeArray<WhereArg<T>> : K extends 'OR' ? MaybeArray<WhereArg<T>>[] : K extends 'IN' ? MaybeArray<{
+        columns: (keyof T['selectable'])[];
+        values: unknown[][] | Query | Expression;
+    }> : K extends keyof T['selectable'] ? T['selectable'][K]['column']['queryType'] | null | ColumnOperators<T['selectable'], K> | Expression | Query : never;
+} | QueryBase | Expression | ((q: WhereQueryBuilder<T>) => QueryBase | ColumnExpression<BooleanNullable>);
+/**
+ * Callback argument of `where`.
+ * It has `where` methods (`where`, `whereNot`, `whereExists`, etc.),
+ * and it has relations that you can aggregate and use a boolean comparison with, such as:
+ * ```ts
+ * db.table.where((q) => q.relation.count().equals(10))
+ * ```
+ */
+type WhereQueryBuilder<T extends WhereQueryBase> = Pick<T, keyof WhereQueryBase> & RelationSubQueries<T>;
+type WhereArgs<T extends WhereQueryBase> = WhereArg<T>[] | TemplateLiteralArgs;
+type WhereInColumn<T extends QueryBase> = keyof T['selectable'] | [keyof T['selectable'], ...(keyof T['selectable'])[]];
+type WhereInValues<T extends QueryBase, Column extends WhereInColumn<T>> = Column extends keyof T['selectable'] ? T['selectable'][Column]['column']['queryType'][] | Query | 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;
+})[] | Query | Expression;
+type WhereInArg<T extends Pick<Query, 'selectable'>> = {
+    [K in keyof T['selectable']]?: T['selectable'][K]['column']['queryType'][] | Query | Expression;
 };
-type CreateMethodsNames = 'create' | '_create' | 'createMany' | '_createMany' | 'createRaw' | '_createRaw' | 'createFrom' | '_createFrom';
-declare class Create {
+type WhereResult<T extends QueryBase> = T & {
+    meta: {
+        hasWhere: true;
+    };
+};
+/**
+ * Adds `where` arguments to query data: SQL template string is added as `RawSQL` object, other arguments are added as is.
+ *
+ * @param q - query object to add the data to
+ * @param args - `where` arguments, may be a template literal
+ */
+declare const addWhere: <T extends WhereQueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
+/**
+ * Adds `where` arguments to query data with a `NOT` keyword: SQL template string is added as `RawSQL` object, other arguments are added as is.
+ *
+ * @param q - query object to add the data to
+ * @param args - `where` arguments, may be a template literal
+ */
+declare const addWhereNot: <T extends WhereQueryBase>(q: T, args: WhereArgs<T>) => WhereResult<T>;
+/**
+ * Adds `where` arguments to query data. Arguments will be separated from each other with `OR`.
+ *
+ * @param q - query object to add the data to
+ * @param args - `where` arguments, may be a template literal
+ */
+declare const addOr: <T extends WhereQueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+/**
+ * Adds `where` arguments to query data with a `NOT` keyword. Arguments will be separated from each other with `OR`.
+ *
+ * @param q - query object to add the data to
+ * @param args - `where` arguments, may be a template literal
+ */
+declare const addOrNot: <T extends WhereQueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+/**
+ * Process arguments of `whereIn` to add them to query data properly.
+ *
+ * @param q - query object to add the data to.
+ * @param and - `true` to join arguments with `AND`, `false` to join them with `OR.
+ * @param arg - `whereIn` argument: can be a single column name, tuple of column names, or object with column names and values.
+ * @param values - if the `arg` is a column name or a tuple, `values` are the values for the column/columns. If `arg` is an object, `values` are `undefined`.
+ * @param not - adds the `NOT` keyword.
+ */
+declare const addWhereIn: <T extends QueryBase>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | Expression | undefined, not?: boolean) => WhereResult<T>;
+declare abstract class Where {
     /**
-     * `create` will create one record.
-     *
-     * Each column may accept a specific value, a raw SQL, or a query that returns a single value.
+     * Constructing `WHERE` conditions:
      *
      * ```ts
-     * const oneRecord = await db.table.create({
+     * db.table.where({
+     *   // column of the current table
      *   name: 'John',
-     *   password: '1234',
-     * });
      *
-     * await db.table.create({
-     *   // raw SQL
-     *   column1: db.table.sql`'John' | 'Doe'`,
+     *   // table name may be specified, it can be the name of a joined table
+     *   'table.lastName': 'Johnsonuk',
      *
-     *   // query that returns a single value
-     *   // returning multiple values will result in Postgres error
-     *   column2: db.otherTable.get('someColumn'),
+     *   // object with operators, see the "column operators" section to see a full list of them:
+     *   age: {
+     *     gt: 30,
+     *     lt: 70,
+     *   },
+     *
+     *   // where column equals to raw SQL
+     *   column: db.table.sql`raw expression`,
      * });
      * ```
      *
-     * @param data - data for the record, may have values, raw SQL, queries, relation operations
-     */
-    create<T extends Query>(this: T, data: CreateData<T>): CreateResult<T>;
-    _create<T extends Query>(this: T, data: CreateData<T>): CreateResult<T>;
-    /**
-     * `createMany` will create a batch of records.
-     *
-     * Each column may be set with a specific value, a raw SQL, or a query, the same as in [create](#create).
-     *
-     * In case one of the objects has fewer fields, the `DEFAULT` SQL keyword will be placed in its place in the `VALUES` statement.
+     * `undefined` values are ignored, so you can supply a partial object with conditions:
      *
      * ```ts
-     * const manyRecords = await db.table.createMany([
-     *   { key: 'value', otherKey: 'other value' },
-     *   { key: 'value' }, // default will be used for `otherKey`
-     * ]);
-     * ```
-     *
-     * @param data - data for the record, may have values, raw SQL, queries, relation operations
-     */
-    createMany<T extends Query>(this: T, data: CreateData<T>[]): CreateManyResult<T>;
-    _createMany<T extends Query>(this: T, data: CreateData<T>[]): CreateManyResult<T>;
-    /**
-     * `createRaw` is for creating one record with a raw expression.
-     *
-     * Provided SQL will be wrapped into parens for a single `VALUES` record.
+     * type Params = {
+     *   // allow providing exact age, or lower or greate than
+     *   age?: number | { lt?: number; gt?: number };
+     * };
      *
-     * If the table has a column with runtime defaults (defined with callbacks), the value will be appended to your SQL.
+     * const loadRecords = async (params: Params) => {
+     *   // this will load all records if params is an empty object
+     *   const records = await db.table.where(params);
+     * };
+     * ```
      *
-     * `columns` are type-checked to contain all required columns.
+     * It supports a sub-query that is selecting a single value to compare it with a column:
      *
      * ```ts
-     * const oneRecord = await db.table.createRaw({
-     *   columns: ['name', 'amount'],
-     *   values: db.table.sql`'name', random()`,
+     * db.table.where({
+     *   // compare `someColumn` in one table with the `column` value returned from another query.
+     *   someColumn: db.otherTable.where(...conditions).get('column'),
      * });
      * ```
      *
-     * @param args - object with columns list and raw SQL for values
-     */
-    createRaw<T extends Query, Arg extends CreateRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateResult<T>;
-    _createRaw<T extends Query, Arg extends CreateRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateResult<T>;
-    /**
-     * `createRaw` is for creating many record with raw expressions.
-     *
-     * Takes array of SQL expressions, each of them will be wrapped into parens for `VALUES` records.
-     *
-     * If the table has a column with runtime defaults (defined with callbacks), function will be called for each SQL and the value will be appended.
-     *
-     * `columns` are type-checked to contain all required columns.
+     * `where` can accept other queries and merge their conditions:
      *
      * ```ts
-     * const manyRecords = await db.table.createManyRaw({
-     *   columns: ['name', 'amount'],
-     *   values: [db.table.sql`'one', 2`, db.table.sql`'three', 4`],
-     * });
+     * const otherQuery = db.table.where({ name: 'John' });
+     *
+     * db.table.where({ id: 1 }, otherQuery);
+     * // this will produce WHERE "table"."id" = 1 AND "table"."name' = 'John'
      * ```
      *
-     * @param args - object with columns list and array of raw SQL for values
-     */
-    createManyRaw<T extends Query, Arg extends CreateManyRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateManyResult<T>;
-    _createManyRaw<T extends Query, Arg extends CreateManyRawData<T>>(this: T, ...args: CreateRawArgs<T, Arg>): CreateManyResult<T>;
-    /**
-     * This method is for creating a single record, for batch creating see `createManyFrom`.
+     * `where` supports raw SQL:
      *
-     * `createFrom` is to perform the `INSERT ... SELECT ...` SQL statement, it does select and insert in a single query.
+     * ```ts
+     * db.table.where`a = b`;
      *
-     * The first argument is a query for a **single** record, it should have `find`, `take`, or similar.
+     * // or
+     * db.table.where(db.table.sql`a = b`);
      *
-     * The second optional argument is a data which will be merged with columns returned from the select query.
+     * // or
+     * import { raw } from 'orchid-orm';
      *
-     * The data for the second argument is the same as in [create](#create) and [createMany](#createMany).
+     * db.table.where(raw`a = b`);
+     * ```
      *
-     * Columns with runtime defaults (defined with a callback) are supported here.
-     * The value for such a column will be injected unless selected from a related table or provided in a data object.
+     * `where` can accept a callback with a specific query builder containing all "where" methods such as `where`, `or`, `whereNot`, `whereIn`, `whereExists`:
      *
      * ```ts
-     * const oneRecord = await db.table.createFrom(
-     *   // In the select, key is a related table column, value is a column to insert as
-     *   RelatedTable.select({ relatedId: 'id' }).findBy({ key: 'value' }),
-     *   // optional argument:
-     *   {
-     *     key: 'value',
-     *   },
+     * db.table.where((q) =>
+     *   q
+     *     .where({ name: 'Name' })
+     *     .or({ id: 1 }, { id: 2 })
+     *     .whereIn('letter', ['a', 'b', 'c'])
+     *     .whereExists(Message, 'authorId', 'id'),
      * );
      * ```
      *
-     * The query above will produce such SQL:
-     *
-     * ```sql
-     * INSERT INTO "table"("relatedId", "key")
-     * SELECT "relatedTable"."id" AS "relatedId", 'value'
-     * FROM "relatedTable"
-     * WHERE "relatedTable"."key" = 'value'
-     * LIMIT 1
-     * RETURNING *
-     * ```
-     *
-     * @param query - query to create new records from
-     * @param data - additionally you can set some columns
-     */
-    createFrom<T extends Query, Q extends Query & {
-        returnType: 'one' | 'oneOrThrow';
-    }>(this: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>): CreateResult<T>;
-    _createFrom<T extends Query, Q extends Query & {
-        returnType: 'one' | 'oneOrThrow';
-    }>(this: T, query: Q, data?: Omit<CreateData<T>, keyof Q['result']>): CreateResult<T>;
-    /**
-     * Similar to `createFrom`, but intended to create many records.
-     *
-     * Unlike `createFrom`, it doesn't accept second argument with data, and runtime defaults cannot work with it.
+     * `where` can accept multiple arguments, conditions are joined with `AND`:
      *
      * ```ts
-     * const manyRecords = await db.table.createManyFrom(
-     *   RelatedTable.select({ relatedId: 'id' }).where({ key: 'value' }),
+     * db.table.where(
+     *   { id: 1 },
+     *   db.table.where({ name: 'John' }),
+     *   db.table.sql`a = b`,
      * );
      * ```
      *
-     * @param query - query to create new records from
-     */
-    createManyFrom<T extends Query, Q extends Query>(this: T, query: Q): CreateManyResult<T>;
-    _createManyFrom<T extends Query, Q extends Query>(this: T, query: Q): CreateManyResult<T>;
-    /**
-     * `defaults` allows setting values that will be used later in `create`.
+     * ## where sub query
      *
-     * Columns provided in `defaults` are marked as optional in the following `create`.
+     * `where` handles a special callback where you can query a relation to get some value and filter by that value.
      *
-     * Default data is the same as in [create](#create) and [createMany](#createMany),
-     * so you can provide a raw SQL, or a query with a query.
+     * It is useful for a faceted search. For instance, posts have tags, and we want to find all posts that have all the given tags.
      *
      * ```ts
-     * // Will use firstName from defaults and lastName from create argument:
-     * db.table
-     *   .defaults({
-     *     firstName: 'first name',
-     *     lastName: 'last name',
-     *   })
-     *   .create({
-     *     lastName: 'override the last name',
-     *   });
-     * ```
+     * const givenTags = ['typescript', 'node.js'];
      *
-     * @param data - default values for `create` and `createMany` which will follow `defaults`
-     */
-    defaults<T extends Query, Data extends Partial<CreateData<T>>>(this: T, data: Data): T & {
-        meta: {
-            defaults: Record<keyof Data, true>;
-        };
-    };
-    _defaults<T extends Query, Data extends Partial<CreateData<T>>>(this: T, data: Data): T & {
-        meta: {
-            defaults: Record<keyof Data, true>;
-        };
-    };
-    /**
-     * A modifier for creating queries that specify alternative behavior in the case of a conflict.
-     * A conflict occurs when a table has a `PRIMARY KEY` or a `UNIQUE` index on a column
-     * (or a composite index on a set of columns) and a row being created has the same value as a row
-     * that already exists in the table in this column(s).
-     * The default behavior in case of conflict is to raise an error and abort the query.
-     * Using this method you can change this behavior to either silently ignore the error by using .onConflict().ignore()
-     * or to update the existing row with new data (perform an "UPSERT") by using .onConflict().merge().
+     * const posts = await db.post.where(
+     *   (post) =>
+     *     post.tags // query tags of the post
+     *       .whereIn('tagName', givenTags) // where name of the tag is inside array
+     *       .count() // count how many such tags were found
+     *       .equals(wantedTags.length), // the count must be exactly the length of array
+     *   // if the post has ony `typescript` tag but not the `node.js` it will be omitted
+     * );
+     * ```
      *
-     * ```ts
-     * // leave without argument to ignore or merge on any conflict
-     * Target.create(data).onConflict().ignore();
+     * This will produce an efficient SQL query:
      *
-     * // single column:
-     * db.table.create(data).onConfict('email');
+     * ```sql
+     * SELECT * FROM "post"
+     * WHERE (
+     *   SELECT count(*) = 3
+     *   FROM "tag" AS "tags"
+     *   WHERE "tag"."tagName" IN ('typescript', 'node.js')
+     *     -- join tags to the post via "postTag" table
+     *     AND EXISTS (
+     *       SELECT 1 FROM "postTag"
+     *       WHERE "postTag"."postId" = "post"."id"
+     *         AND "postTag"."tagId" = "tag"."id"
+     *     )
+     * )
+     * ```
      *
-     * // array of columns:
-     * db.table.create(data).onConfict(['email', 'name']);
+     * In the example above we use `count()`, you can also use any other aggregate method instead, such as `min`, `max`, `avg`.
      *
-     * // raw expression:
-     * db.table.create(data).onConfict(db.table.sql`(email) where condition`);
-     * ```
+     * The `count()` is chained with `equals` to check for a strict equality, any other operation is also allowed, such as `not`, `lt`, `gt`.
      *
-     * ::: info
-     * The column(s) specified by this method must either be the table's PRIMARY KEY or have a UNIQUE index on them, or the query will fail to execute.
-     * When specifying multiple columns, they must be a composite PRIMARY KEY or have a composite UNIQUE index.
+     * ## where special keys
      *
-     * You can use the db.table.sql function in onConflict.
-     * It can be useful to specify a condition when you have a partial index:
+     * The object passed to `where` can contain special keys, each of the keys corresponds to its own method and takes the same value as the type of argument of the method.
+     *
+     * For example:
      *
      * ```ts
-     * db.table
-     *   .create({
-     *     email: 'ignore@example.com',
-     *     name: 'John Doe',
-     *     active: true,
-     *   })
-     *   // ignore only on email conflict and active is true.
-     *   .onConflict(db.table.sql`(email) where active`)
-     *   .ignore();
+     * db.table.where({
+     *   NOT: { key: 'value' },
+     *   OR: [{ name: 'a' }, { name: 'b' }],
+     *   IN: {
+     *     columns: ['id', 'name'],
+     *     values: [
+     *       [1, 'a'],
+     *       [2, 'b'],
+     *     ],
+     *   },
+     * });
      * ```
      *
-     * :::
+     * Using methods `whereNot`, `or`, `whereIn` instead of this is a shorter and cleaner way, but in some cases, such object keys way may be more convenient.
      *
-     * See the documentation on the .ignore() and .merge() methods for more details.
+     * ```ts
+     * db.table.where({
+     *   // see .whereNot
+     *   NOT: { id: 1 },
+     *   // can be an array:
+     *   NOT: [{ id: 1 }, { id: 2 }],
      *
-     * @param arg - optionally provide an array of columns
-     */
-    onConflict<T extends Query, Arg extends OnConflictArg<T>>(this: T, arg?: Arg): OnConflictQueryBuilder<T, Arg>;
-    _onConflict<T extends Query, Arg extends OnConflictArg<T> | undefined = undefined>(this: T, arg?: Arg): OnConflictQueryBuilder<T, Arg>;
-}
-declare class OnConflictQueryBuilder<T extends Query, Arg extends OnConflictArg<T> | undefined> {
-    private query;
-    private onConflict;
-    constructor(query: T, onConflict: Arg);
-    /**
-     * Available only after `onConflict`.
+     *   // see .or
+     *   OR: [{ name: 'a' }, { name: 'b' }],
+     *   // can be an array:
+     *   // this will give id = 1 AND id = 2 OR id = 3 AND id = 4
+     *   OR: [
+     *     [{ id: 1 }, { id: 2 }],
+     *     [{ id: 3 }, { id: 4 }],
+     *   ],
      *
-     * Modifies a create query, and causes it to be silently dropped without an error if a conflict occurs.
+     *   // see .in, the key syntax requires an object with columns and values
+     *   IN: {
+     *     columns: ['id', 'name'],
+     *     values: [
+     *       [1, 'a'],
+     *       [2, 'b'],
+     *     ],
+     *   },
+     *   // can be an array:
+     *   IN: [
+     *     {
+     *       columns: ['id', 'name'],
+     *       values: [
+     *         [1, 'a'],
+     *         [2, 'b'],
+     *       ],
+     *     },
+     *     { columns: ['someColumn'], values: [['foo', 'bar']] },
+     *   ],
+     * });
+     * ```
      *
-     * Adds the `ON CONFLICT (columns) DO NOTHING` clause to the insert statement.
+     * ## column operators
      *
-     * It produces `ON CONFLICT DO NOTHING` when no `onConflict` argument provided.
+     * `where` argument can take an object where the key is the name of the operator and the value is its argument.
+     *
+     * Different types of columns support different sets of operators.
+     *
+     * All column operators can take a value of the same type as the column, a sub-query, or a raw SQL expression:
      *
      * ```ts
-     * db.table
-     *   .create({
-     *     email: 'ignore@example.com',
-     *     name: 'John Doe',
-     *   })
-     *   .onConflict('email')
-     *   .ignore();
-     * ```
-     */
-    ignore(): T;
-    /**
-     * Available only after `onConflict`.
+     * import { sql } from 'orchid-orm';
      *
-     * Modifies a create query, to turn it into an 'upsert' operation.
+     * db.table.where({
+     *   numericColumn: {
+     *     // lower than 5
+     *     lt: 5,
      *
-     * Adds an `ON CONFLICT (columns) DO UPDATE` clause to the insert statement.
+     *     // lower than the value returned by sub-query
+     *     lt: OtherTable.select('someNumber').take(),
      *
-     * When no `onConflict` argument provided,
-     * it will automatically collect all table columns that have unique index and use them as a conflict target.
+     *     // raw SQL expression produces WHERE "numericColumn" < "otherColumn" + 10
+     *     lt: sql`"otherColumn" + 10`,
+     *   },
+     * });
+     * ```
+     *
+     * ### Any type of column operators
+     *
+     * `equals` is a simple `=` operator, it may be useful for comparing column value with JSON object:
      *
      * ```ts
-     * db.table
-     *   .create({
-     *     email: 'ignore@example.com',
-     *     name: 'John Doe',
-     *   })
-     *   .onConflict('email')
-     *   .merge();
+     * db.table.where({
+     *  // when searching for an exact same JSON value, this won't work:
+     *   jsonColumn: someObject,
+     *
+     *   // use `{ equals: ... }` instead:
+     *   jsonColumn: { equals: someObject },
+     * });
      * ```
      *
-     * This also works with batch creates:
+     * `not` is `!=` (aka `<>`) not equal operator:
      *
      * ```ts
-     * db.table
-     *   .createMany([
-     *     { email: 'john@example.com', name: 'John Doe' },
-     *     { email: 'jane@example.com', name: 'Jane Doe' },
-     *     { email: 'alex@example.com', name: 'Alex Doe' },
-     *   ])
-     *   .onConflict('email')
-     *   .merge();
+     * db.table.where({
+     *   anyColumn: { not: value },
+     * });
      * ```
      *
-     * It is also possible to specify a subset of the columns to merge when a conflict occurs.
-     * For example, you may want to set a `createdAt` column when creating but would prefer not to update it if the row already exists:
+     * `in` is for the `IN` operator to check if the column value is included in a list of values.
+     *
+     * Takes an array of the same type as a column, a sub-query that returns a list of values, or a raw SQL expression that returns a list.
      *
      * ```ts
-     * const timestamp = Date.now();
+     * db.table.where({
+     *   column: {
+     *     in: ['a', 'b', 'c'],
      *
-     * db.table
-     *   .create({
-     *     email: 'ignore@example.com',
-     *     name: 'John Doe',
-     *     createdAt: timestamp,
-     *     updatedAt: timestamp,
-     *   })
-     *   .onConflict('email')
-     *   // string argument for a single column:
-     *   .merge('email')
-     *   // array of strings for multiple columns:
-     *   .merge(['email', 'name', 'updatedAt']);
+     *     // WHERE "column" IN (SELECT "column" FROM "otherTable")
+     *     in: OtherTable.select('column'),
+     *
+     *     in: db.table.sql`('a', 'b')`,
+     *   },
+     * });
      * ```
      *
-     * It is also possible to specify data to update separately from the data to create.
-     * This is useful if you want to make an update with different data than in creating.
-     * For example, you may want to change a value if the row already exists:
+     * `notIn` is for the `NOT IN` operator, and takes the same arguments as `in`
      *
-     * ```ts
-     * const timestamp = Date.now();
+     * ### Numeric, Date, and Time column operators
      *
-     * db.table
-     *   .create({
-     *     email: 'ignore@example.com',
-     *     name: 'John Doe',
-     *     createdAt: timestamp,
-     *     updatedAt: timestamp,
-     *   })
-     *   .onConflict('email')
-     *   .merge({
-     *     name: 'John Doe The Second',
-     *   });
-     * ```
+     * To compare numbers, dates, and times.
      *
-     * It is also possible to add a WHERE clause to conditionally update only the matching rows:
+     * `lt` is for `<` (lower than)
+     *
+     * `lte` is for `<=` (lower than or equal)
+     *
+     * `gt` is for `>` (greater than)
+     *
+     * `gte` is for `>=` (greater than or equal)
      *
      * ```ts
-     * const timestamp = Date.now();
+     * db.table.where({
+     *   numericColumn: {
+     *     gt: 5,
+     *     lt: 10,
+     *   },
      *
-     * db.table
-     *   .create({
-     *     email: 'ignore@example.com',
-     *     name: 'John Doe',
-     *     createdAt: timestamp,
-     *     updatedAt: timestamp,
-     *   })
-     *   .onConflict('email')
-     *   .merge({
-     *     name: 'John Doe',
-     *     updatedAt: timestamp,
-     *   })
-     *   .where({ updatedAt: { lt: timestamp } });
+     *   date: {
+     *     lte: new Date(),
+     *   },
+     *
+     *   time: {
+     *     gte: new Date(),
+     *   },
+     * });
      * ```
      *
-     * `merge` also accepts raw expression:
+     * `between` also works with numeric, dates, and time columns, it takes an array of two elements.
      *
-     * ```ts
-     * db.table
-     *   .create(data)
-     *   .onConflict()
-     *   .merge(db.table.sql`raw SQL expression`);
-     * ```
+     * Both elements can be of the same type as a column, a sub-query, or a raw SQL expression.
      *
-     * @param update - column, or array of columns, or object for new column values, or raw SQL
-     */
-    merge(update?: keyof T['shape'] | (keyof T['shape'])[] | Partial<T['inputType']> | Expression): T;
-}
-
-type DeleteMethodsNames = 'del' | '_del' | 'delete' | '_delete';
-type DeleteArgs<T extends Query> = T['meta']['hasWhere'] extends true ? [] : [never];
-type DeleteResult<T extends Query> = T['meta']['hasSelect'] extends true ? SetQueryKind<T, 'delete'> : SetQueryReturnsRowCount<SetQueryKind<T, 'delete'>>;
-declare class Delete {
-    /**
-     * Alias for `delete` method
-     */
-    del<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
-    _del<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
-    /**
-     * It is aliased to `del` because `delete` is a reserved word in JavaScript.
+     * ```ts
+     * db.table.where({
+     *   column: {
+     *     // simple values
+     *     between: [1, 10],
      *
-     * This method deletes one or more rows, based on other conditions specified in the query.
+     *     // sub-query and raw SQL expression
+     *     between: [OtherTable.select('column').take(), db.table.sql`2 + 2`],
+     *   },
+     * });
+     * ```
      *
-     * By default, `delete` will return a count of deleted records.
+     * ### Text column operators
      *
-     * Place `select`, `selectAll`, or `get` before `delete` to specify returning columns.
+     * For `text`, `char`, `varchar`, and `json` columns.
      *
-     * Need to provide `where`, `findBy`, or `find` conditions before calling `delete`.
-     * To prevent accidental deletion of all records, deleting without where will result in TypeScript and a runtime error.
+     * `json` is stored as text, so it has text operators. Use the `jsonb` type for JSON operators.
      *
-     * Use `all()` to delete ALL records without conditions:
+     * Takes a string, or sub-query returning string, or raw SQL expression as well as other operators.
      *
      * ```ts
-     * await db.table.all().delete();
+     * db.table.where({
+     *   textColumn: {
+     *     // WHERE "textColumn" LIKE '%string%'
+     *     contains: 'string',
+     *     // WHERE "textColumn" ILIKE '%string%'
+     *     containsInsensitive: 'string',
+     *     // WHERE "textColumn" LIKE 'string%'
+     *     startsWith: 'string',
+     *     // WHERE "textColumn" ILIKE 'string%'
+     *     startsWithInsensitive: 'string',
+     *     // WHERE "textColumn" LIKE '%string'
+     *     endsWith: 'string',
+     *     // WHERE "textColumn" ILIKE '%string'
+     *     endsWithInsensitive: 'string',
+     *   },
+     * });
      * ```
      *
-     * ```ts
-     * // deletedCount is the number of deleted records
-     * const deletedCount = await db.table.where(...conditions).delete();
-     *
-     * // returns a single value, throws if not found
-     * const id: number | undefined = await db.table
-     *   .findBy(...conditions)
-     *   .get('id')
-     *   .delete();
+     * ### JSONB column operators
      *
-     * // returns an array of records with specified columns
-     * const deletedRecord = await db.table
-     *   .select('id', 'name', 'age')
-     *   .where(...conditions)
-     *   .delete();
+     * For the `jsonb` column, note that the `json` type has text operators instead.
      *
-     * // returns an array of fully deleted records
-     * const deletedUsersFull = await db.table
-     *   .selectAll()
-     *   .where(...conditions)
-     *   .delete();
-     * ```
+     * `jsonPath` operator: compare a column value under a given JSON path with the provided value.
      *
-     * `delete` supports joining, under the hood the join is transformed to `USING` and `WHERE` statements:
+     * Value can be of any type to compare with JSON value, or it can be a sub-query or a raw SQL expression.
      *
      * ```ts
-     * // delete all users who have corresponding profile records:
-     * db.table.join(Profile, 'profile.userId', 'user.id').all().delete();
+     * db.table.where({
+     *   jsonbColumn: {
+     *     jsonPath: [
+     *       '$.name', // first element is JSON path
+     *       '=', // second argument is comparison operator
+     *       'value', // third argument is a value to compare with
+     *     ],
+     *   },
+     * });
      * ```
-     */
-    delete<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
-    _delete<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
-}
-
-type ForQueryBuilder<Q extends Query> = Q & {
-    noWait<T extends ForQueryBuilder<Q>>(this: T): T;
-    _noWait<T extends ForQueryBuilder<Q>>(this: T): T;
-    skipLocked<T extends ForQueryBuilder<Q>>(this: T): T;
-    _skipLocked<T extends ForQueryBuilder<Q>>(this: T): T;
-};
-declare class For {
-    forUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
-    _forUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
-    forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
-    _forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
-    forShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
-    _forShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
-    forKeyShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
-    _forKeyShare<T extends Query>(this: T, tableNames?: string[] | Expression): ForQueryBuilder<T>;
-}
-
-type FromArgs<T extends Query> = [
-    first: Query | Expression | Exclude<keyof T['withData'], symbol | number>,
-    second?: {
-        only?: boolean;
-    }
-] | TemplateLiteralArgs;
-type FromResult<T extends Query, Args extends FromArgs<T>> = Args extends TemplateStringsArray ? T : Args[0] extends string ? T['withData'] extends Record<string, WithDataItem> ? Args[0] extends keyof T['withData'] ? Omit<T, 'meta' | 'selectable'> & {
-    meta: Omit<T['meta'], 'as'> & {
-        as?: string;
-    };
-    selectable: SelectableFromShape<T['withData'][Args[0]]['shape'], Args[0]>;
-} : SetQueryTableAlias<T, Args[0]> : SetQueryTableAlias<T, Args[0]> : Args[0] extends Query ? FromQueryResult<T, Args[0]> : T;
-type FromQueryResult<T extends Query, Q extends Query, Selectable extends SelectableBase = {
-    [K in keyof Q['result']]: K extends string ? {
-        as: K;
-        column: Q['result'][K];
-    } : never;
-}, Data = GetQueryResult<T['returnType'], Q['result']>> = {
-    [K in keyof T]: K extends 'meta' ? Omit<T['meta'], 'hasSelect' | 'as'> & {
-        as: AliasOrTable<Q>;
-    } : K extends 'selectable' ? Selectable : K extends 'result' | 'shape' ? Q['result'] : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : T[K];
-};
-declare class From {
-    /**
-     * Set the `FROM` value, by default the table name is used.
      *
-     * ```ts
-     * // accepts sub-query:
-     * db.table.from(Otherdb.table.select('foo', 'bar'));
+     * `jsonSupersetOf`: check if the column value is a superset of provided value.
      *
-     * // accepts raw sql by template literal:
-     * const value = 123;
-     * db.table.from`value = ${value}`;
+     * For instance, it is true if the column has JSON `{ "a": 1, "b": 2 }` and provided value is `{ "a": 1 }`.
      *
-     * // accepts raw sql:
-     * db.table.from(db.table.sql`value = ${value}`);
+     * Takes the value of any type, or sub query which returns a single value, or a raw SQL expression.
      *
-     * // accepts alias of `WITH` expression:
-     * q.with('foo', Otherdb.table.select('id', 'name')).from('foo');
+     * ```ts
+     * db.table.where({
+     *   jsonbColumn: {
+     *     jsonSupersetOf: { a: 1 },
+     *   },
+     * });
      * ```
      *
-     * Optionally takes a second argument of type `{ only?: boolean }`, (see `FROM ONLY` in Postgres docs, this is related to table inheritance).
+     * `jsonSubsetOf`: check if the column value is a subset of provided value.
+     *
+     * For instance, it is true if the column has JSON `{ "a": 1 }` and provided value is `{ "a": 1, "b": 2 }`.
+     *
+     * Takes the value of any type, or sub query which returns a single value, or a raw SQL expression.
      *
      * ```ts
-     * db.table.from(Otherdb.table.select('foo', 'bar'), {
-     *   only: true,
+     * db.table.where({
+     *   jsonbColumn: {
+     *     jsonSupersetOf: { a: 1 },
+     *   },
      * });
      * ```
      *
-     * @param args - query, raw SQL, name of CTE table, or a template string
+     * @param args - {@link WhereArgs}
      */
-    from<T extends Query, Args extends FromArgs<T>>(this: T, ...args: Args): FromResult<T, Args>;
-    _from<T extends Query, Args extends FromArgs<T>>(this: T, ...args: Args): FromResult<T, Args>;
-}
-
-type GetArg<T extends QueryBase> = GetStringArg<T> | Expression;
-type GetStringArg<T extends QueryBase> = StringKey<keyof T['selectable']>;
-type GetResult<T extends Query, Arg extends GetArg<T>> = Arg extends GetStringArg<T> ? SetQueryReturnsValue<T, Arg> : Arg extends Expression ? SetQueryReturnsColumn<T, Arg['_type']> : never;
-type GetResultOptional<T extends Query, Arg extends GetArg<T>> = Arg extends GetStringArg<T> ? SetQueryReturnsValueOptional<T, Arg> : Arg extends Expression ? SetQueryReturnsColumnOptional<T, Arg['_type']> : never;
-declare class QueryGet {
+    where<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    _where<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     /**
-     * `.get` returns a single value, it will add `LIMIT 1` to the query, and accepts a column name or a raw expression.
-     * It will throw `NotFoundError` when not found.
+     * `whereNot` takes the same arguments as `where` and prepends them with `NOT` in SQL
      *
      * ```ts
-     * import { NumberColumn } from 'pqb';
-     *
-     * const firstName: string = await db.table.get('name');
-     *
-     * const rawResult: number = await db.table.get(
-     *   db.table.sql((t) => t.integer())`1 + 1`,
-     * );
+     * // find records of different colors than red
+     * db.table.whereNot({ color: 'red' });
      * ```
      *
-     * @param arg - string for a column to get, or a raw SQL
+     * @param args - {@link WhereArgs}
      */
-    get<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResult<T, Arg>;
-    _get<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResult<T, Arg>;
+    whereNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    _whereNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     /**
-     * `.getOptional` returns a single value or undefined when not found:
+     * `and` is an alias for {@link where} to make it look closer to SQL:
      *
      * ```ts
-     * const firstName: string | undefined = await db.table.getOptional('name');
+     * db.table.where({ id: 1 }).and({ name: 'John' });
      * ```
      *
-     * @param arg - string for a column to get, or a raw SQL
+     * @param args - {@link WhereArgs}
      */
-    getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResultOptional<T, Arg>;
-    _getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResultOptional<T, Arg>;
-}
-
-type HavingArgs<T extends Query> = TemplateLiteralArgs | HavingArgFn<T>[];
-type HavingArgFn<T extends Query> = (q: SelectAggMethods<T>) => Expression<ColumnTypeBase<boolean | null>>;
-declare class Having {
+    and<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    _and<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
     /**
-     * Build a `HAVING` clause to the query to filter records by results of [aggregate functions](#aggregate-functions).
+     * `andNot` is an alias for `whereNot`.
      *
-     * The argument of `having` is a function where you call the aggregate function and compare it with some value by using [column operators](/guide/where.html#column-operators).
+     * @param args - {@link WhereArgs}
+     */
+    andNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    _andNot<T extends WhereQueryBase>(this: T, ...args: WhereArgs<T>): WhereResult<T>;
+    /**
+     * `or` is accepting the same arguments as {@link where}, joining arguments with `OR`.
+     *
+     * Columns in single arguments are still joined with `AND`.
+     *
+     * The database is processing `AND` before `OR`, so this should be intuitively clear.
      *
      * ```ts
-     * db.table.having((q) => q.count().gte(10));
-     * // HAVING count(*) >= 10
+     * db.table.or({ id: 1, color: 'red' }, { id: 2, color: 'blue' });
      * ```
      *
-     * Alternatively, it accepts a raw SQL template:
+     * This query will produce such SQL (simplified):
+     *
+     * ```sql
+     * SELECT * FROM "table"
+     * WHERE id = 1 AND color = 'red'
+     *    OR id = 2 AND color = 'blue'
+     * ```
+     *
+     * @param args - {@link WhereArgs} will be joined with `OR`
+     */
+    or<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _or<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    /**
+     * `orNot` takes the same arguments as {@link or}, and prepends each condition with `NOT` just as {@link whereNot} does.
+     *
+     * @param args - {@link WhereArgs} will be prefixed with `NOT` and joined with `OR`
+     */
+    orNot<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _orNot<T extends WhereQueryBase>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    /**
+     * `whereIn` and related methods are for the `IN` operator to check for inclusion in a list of values.
+     *
+     * When used with a single column it works equivalent to the `in` column operator:
      *
      * ```ts
-     * db.table.having`count(*) >= ${10}`;
+     * db.table.whereIn('column', [1, 2, 3]);
+     * // the same as:
+     * db.table.where({ column: [1, 2, 3] });
      * ```
      *
-     * Multiple having conditions will be combined with `AND`:
+     * `whereIn` can support a tuple of columns, that's what the `in` operator cannot support:
      *
      * ```ts
-     * db.table.having(
-     *   (q) => q.sum('column').gt(5),
-     *   (q) => q.avg('column').lt(10),
+     * db.table.whereIn(
+     *   ['id', 'name'],
+     *   [
+     *     [1, 'Alice'],
+     *     [2, 'Bob'],
+     *   ],
      * );
-     * // HAVING sum(column) > 5 AND avg(column) < 10
      * ```
      *
-     * After applying a comparison, `or` and `and` methods become available:
+     * It supports sub query which should return records with columns of the same type:
      *
      * ```ts
-     * db.table.having((q) =>
-     *   q.sum('column').equals(5).or(q.min('column').gt(1), q.max('column').lt(10)),
-     * );
-     * // HAVING (sum(column) = 5) OR (min(column) > 1 AND max(column) < 10)
+     * db.table.whereIn(['id', 'name'], OtherTable.select('id', 'name'));
      * ```
      *
-     * Aggregate functions are exactly the same functions described in [aggregate functions](#aggregate-functions), they can accept aggregation options:
+     * It supports raw SQL expression:
      *
      * ```ts
-     * db.table.having((q) =>
-     *   q
-     *     .count('id', {
-     *       distinct: true,
-     *       order: { createdAt: 'DESC', filter: { someColumn: { not: null } } },
-     *     })
-     *     .gte(10),
-     * );
+     * db.table.whereIn(['id', 'name'], db.table.sql`((1, 'one'), (2, 'two'))`);
      * ```
      *
-     * Arguments of the aggregate function and of the comparison can be raw SQL:
+     * @param column - one column name, or array of column names
+     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
+     */
+    whereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    /**
+     * See {@link whereIn}.
+     *
+     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
+     */
+    whereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _whereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _whereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    /**
+     * Takes the same arguments as {@link whereIn}.
+     * Add a `WHERE IN` condition prefixed with `OR` to the query:
      *
      * ```ts
-     * db.table.having((q) => q.count(q.sql('coalesce(one, two)')).gte(q.sql`2 + 2`));
+     * db.table.whereIn('a', [1, 2, 3]).orWhereIn('b', ['one', 'two']);
      * ```
      *
-     * @param args - raw SQL template string or one or multiple callbacks returning a boolean expression
+     * @param column - one column name, or array of column names
+     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
      */
-    having<T extends Query>(this: T, ...args: HavingArgs<T>): T;
-    _having<T extends Query>(this: T, ...args: HavingArgs<T>): T;
-}
-
-type AfterHook<Select extends PropertyKey[], Shape extends ColumnsShapeBase, Selected extends ColumnsShapeBase = Pick<Shape, StringKey<Select[number]>>, Item = {
-    [K in keyof Selected]: Selected[K]['outputType'];
-}> = QueryAfterHook<Item[]>;
-type HookSelect<T extends QueryBase> = (keyof T['shape'])[];
-type HookAction = 'Create' | 'Update' | 'Delete';
-declare abstract class QueryHooks extends QueryBase {
+    orWhereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     /**
-     * Run the function before any kind of query.
+     * See {@link orWhereIn}.
      *
-     * @param cb - function to call, first argument is a query object
+     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
      */
-    beforeQuery<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
-    _beforeQuery<T extends QueryBase>(this: T, cb: QueryBeforeHook): T;
+    orWhereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _orWhereIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _orWhereIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     /**
-     * Run the function after any kind of query.
-     * Enforces wrapping the query into a transaction.
-     * The function will run after the query is succeeded, but before the transaction commit.
+     * Acts as `whereIn`, but negates the condition with `NOT`:
      *
-     * @param cb - function to call, first argument is the query result of type `unknown`, second argument is a query object
+     * ```ts
+     * db.table.whereNotIn('color', ['red', 'green', 'blue']);
+     * ```
+     *
+     * @param column - one column name, or array of column names
+     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
      */
-    afterQuery<T extends QueryHooks>(this: T, cb: QueryAfterHook): T;
-    _afterQuery<T extends QueryBase>(this: T, cb: QueryAfterHook): T;
+    whereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     /**
-     * Run the function before a `create` kind of query.
+     * See {@link whereNotIn}.
      *
-     * @param cb - function to call, first argument is a query object
+     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
      */
-    beforeCreate<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
-    _beforeCreate<T extends QueryBase>(this: T, cb: QueryBeforeHook): T;
+    whereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _whereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _whereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     /**
-     * Run the function after a `create` kind of query.
-     * Enforces wrapping the query into a transaction.
-     * The function will run after the query is succeeded, but before the transaction commit.
-     * Queries inside the function will run in the same transaction as the target query.
+     * Acts as `whereIn`, but prepends `OR` to the condition and negates it with `NOT`:
      *
-     * @param select - list of columns to select for the hook
-     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+     * ```ts
+     * db.table.whereNotIn('a', [1, 2, 3]).orWhereNoIn('b', ['one', 'two']);
+     * ```
+     *
+     * @param column - one column name, or array of column names
+     * @param values - array of values, or a query to load values, or a raw SQL. Tuple of such values in case of multiple columns.
      */
-    afterCreate<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
-    _afterCreate<T extends QueryBase, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    orWhereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     /**
-     * Run the function after transaction for a `create` kind of query will be committed.
-     * If the query wasn't wrapped in a transaction, will run after the query.
+     * See {@link orWhereNotIn}.
      *
-     * @param select - list of columns to select for the hook
-     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+     * @param arg - object where keys are column names, and values are an array of column values, or a query returning column values, or a raw SQL.
      */
-    afterCreateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
-    _afterCreateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    orWhereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _orWhereNotIn<T extends WhereQueryBase, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _orWhereNotIn<T extends WhereQueryBase>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     /**
-     * Run the function before an `update` kind of query.
+     * `whereExists` is for support of the `WHERE EXISTS (query)` clause.
      *
-     * @param cb - function to call, first argument is a query object
+     * This method is accepting the same arguments as `join`, see the {@link Join.join} section for more details.
+     *
+     * ```ts
+     * // find users who have accounts
+     * // find by a relation name if it's defined
+     * db.user.whereExists('account');
+     *
+     * // find using a table and a join conditions
+     * db.user.whereExists(db.account, 'account.id', 'user.id');
+     *
+     * // find using a query builder in a callback:
+     * db.user.whereExists(db.account, (q) => q.on('account.id', '=', 'user.id'));
+     * ```
+     *
+     * @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.
      */
-    beforeUpdate<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
-    _beforeUpdate<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
+    whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
     /**
-     * Run the function after an `update` kind of query.
-     * Enforces wrapping the query into a transaction.
-     * The function will run after the query is succeeded, but before the transaction commit.
-     * Queries inside the function will run in the same transaction as the target query.
-     * If no records were updated, the hook *won't* run.
+     * See {@link whereExists}.
      *
-     * @param select - list of columns to select for the hook
-     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param cb - callback with a query builder to join the table.
      */
-    afterUpdate<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
-    _afterUpdate<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
+    _whereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     /**
-     * Run the function after transaction for an `update` kind of query will be committed.
-     * If the query wasn't wrapped in a transaction, will run after the query.
-     * If no records were updated, the hook *won't* run.
+     * Acts as `whereExists`, but prepends the condition with `OR`:
      *
-     * @param select - list of columns to select for the hook
-     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+     * ```ts
+     * // find users who have an account or a profile,
+     * // imagine that the user has both `account` and `profile` relations defined.
+     * db.user.whereExist('account').orWhereExists('profile');
+     * ```
+     *
+     * @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.
      */
-    afterUpdateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
-    _afterUpdateCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
     /**
-     * Run the function before a `create` or an `update` kind of query.
+     * See {@link orWhereExists}.
      *
-     * @param cb - function to call, first argument is a query object
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param cb - callback with a query builder to join the table.
      */
-    beforeSave<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
-    _beforeSave<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
+    orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    _orWhereExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     /**
-     * Run the function after a `create` or an `update` kind of query.
-     * Enforces wrapping the query into a transaction.
-     * The function will run after the query is succeeded, but before the transaction commit.
-     * Queries inside the function will run in the same transaction as the target query.
-     * For the `update` query, if no records were updated, the hook *won't* run.
+     * Acts as `whereExists`, but negates the condition with `NOT`:
      *
-     * @param select - list of columns to select for the hook
-     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+     * ```ts
+     * // find users who don't have an account,
+     * // image that the user `belongsTo` or `hasOne` account.
+     * db.user.whereNotExist('account');
+     * ```
+     *
+     * @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.
      */
-    afterSave<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
-    _afterSave<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
     /**
-     * Run the function after transaction for a `create` or an `update` kind of query will be committed.
-     * If the query wasn't wrapped in a transaction, will run after the query.
-     * For the `update` query, if no records were updated, the hook *won't* run.
+     * See {@link whereNotExists}.
      *
-     * @param select - list of columns to select for the hook
-     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param cb - callback with a query builder to join the table.
      */
-    afterSaveCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
-    _afterSaveCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    _whereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     /**
-     * Run the function before a `delete` kind of query.
+     * Acts as `whereExists`, but prepends the condition with `OR` and negates it with `NOT`:
      *
-     * @param cb - function to call, first argument is a query object
+     * ```ts
+     * // find users who don't have an account OR who don't have a profile
+     * // imagine that the user has both `account` and `profile` relations defined.
+     * db.user.whereNotExists('account').orWhereNotExists('profile');
+     * ```
+     *
+     * @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.
      */
-    beforeDelete<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
-    _beforeDelete<T extends QueryHooks>(this: T, cb: QueryBeforeHook): T;
+    orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
     /**
-     * Run the function after a `delete` kind of query.
-     * Enforces wrapping the query into a transaction.
-     * The function will run after the query is succeeded, but before the transaction commit.
-     * Queries inside the function will run in the same transaction as the target query.
-     * If no records were deleted, the hook *won't* run.
+     * See {@link orWhereNotExists}.
      *
-     * @param select - list of columns to select for the hook
-     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
-     */
-    afterDelete<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
-    _afterDelete<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+     * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+     * @param cb - callback with a query builder to join the table.
+     */
+    orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    _orWhereNotExists<T extends WhereQueryBase, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+}
+interface WhereQueryBase extends Where, QueryBase {
+}
+declare abstract class WhereQueryBase extends QueryBase {
+}
+
+type WithSelectable<T extends QueryBase, W extends keyof T['withData']> = T['withData'][W] extends WithDataItem ? StringKey<keyof T['withData'][W]['shape']> | `${T['withData'][W]['table']}.${StringKey<keyof T['withData'][W]['shape']>}` : never;
+/**
+ * The first argument of all `join` and `joinLateral` methods.
+ * See argument of {@link Join.join}.
+ */
+type JoinFirstArg<T extends QueryBase> = Query | keyof T['relations'] | keyof T['withData'] | ((q: T['relations']) => Query);
+/**
+ * Arguments of `join` methods (not `joinLateral`).
+ * See {@link Join.join}
+ */
+type JoinArgs<T extends QueryBase, Arg extends JoinFirstArg<T>> = Arg extends Query ? JoinQueryArgs<T, Arg> : Arg extends keyof T['relations'] ? EmptyTuple : Arg extends keyof T['withData'] ? JoinWithArgs<T, Arg> : never;
+/**
+ * Column names of the joined table that can be used to join.
+ * Derived from 'result', not from 'shape',
+ * because if the joined table has a specific selection, it will be wrapped like:
+ * ```sql
+ * JOIN (SELECT something FROM joined) joined ON joined.something = ...
+ * ```
+ * And the selection becomes available to use in the `ON` and to select from the joined table.
+ */
+type JoinSelectable<Q extends Query> = keyof Q['result'] | `${AliasOrTable<Q>}.${StringKey<keyof Q['result']>}`;
+type JoinQueryArgs<T extends QueryBase, Q extends Query> = [
+    conditions: Record<JoinSelectable<Q>, Selectable<T> | Expression> | Expression | true
+] | [
+    leftColumn: JoinSelectable<Q> | Expression,
+    rightColumn: Selectable<T> | Expression
+] | [
+    leftColumn: JoinSelectable<Q> | Expression,
+    op: string,
+    rightColumn: Selectable<T> | Expression
+];
+type JoinWithArgs<T extends QueryBase, W extends keyof T['withData']> = [
+    conditions: Record<WithSelectable<T, W>, Selectable<T> | Expression> | Expression
+] | [
+    leftColumn: WithSelectable<T, W> | Expression,
+    rightColumn: Selectable<T> | Expression
+] | [
+    leftColumn: WithSelectable<T, W> | Expression,
+    op: string,
+    rightColumn: Selectable<T> | Expression
+];
+/**
+ * Result of all `join` methods, not `joinLateral`.
+ * 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
+ * @param RequireMain - when false, main table shape will be mapped to make all columns optional (for right and full join)
+ */
+type JoinResult<T extends Query, Arg extends JoinFirstArg<T>, RequireJoined extends boolean, RequireMain extends boolean, Cb extends (q: never) => {
+    meta: QueryMetaBase;
+} = () => {
+    meta: QueryMetaBase;
+}, J extends Pick<Query, 'result' | 'table' | 'meta'> = Arg extends Query ? Arg : Arg extends keyof T['relations'] ? T['relations'][Arg]['relationConfig']['table'] : Arg extends (q: never) => Query ? ReturnType<Arg> : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
+    table: T['withData'][Arg]['table'];
+    result: T['withData'][Arg]['shape'];
+    meta: QueryBase['meta'];
+} : never : never, Selectable extends SelectableBase = JoinResultSelectable<J, RequireJoined, ReturnType<Cb>>> = RequireMain extends true ? JoinAddSelectable<T, Selectable> : JoinOptionalMain<T, Selectable>;
+/**
+ * Result of all `joinLateral` methods.
+ * 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 Query, R extends QueryBase, RequireJoined extends boolean, Selectable extends SelectableBase = JoinResultSelectable<R, RequireJoined, {
+    meta: QueryMetaBase;
+}>> = JoinAddSelectable<T, Selectable>;
+/**
+ * Build `selectable` type for joined table.
+ *
+ * When `RequireJoined` parameter is false,
+ * the result type of the joined table will be mapped to make all columns optional.
+ *
+ * Callback may override the joined table alias.
+ *
+ * The resulting selectable receives all joined table columns prefixed with the table name or alias,
+ * and a star prefixed with the table name or alias to select all joined columns.
+ */
+type JoinResultSelectable<J extends Pick<Query, 'result' | 'table' | 'meta'>, RequireJoined extends boolean, CbResult extends {
+    meta: QueryMetaBase;
+}, Result extends ColumnsShapeBase = RequireJoined extends true ? J['result'] : {
+    [K in keyof J['result']]: NullableColumn<J['result'][K]>;
+}, As extends string = CbResult extends {
+    meta: QueryMetaBase & {
+        as: string;
+    };
+} ? CbResult['meta']['as'] : AliasOrTable<J>> = {
+    [K in keyof Result as `${As}.${StringKey<K>}`]: {
+        as: K;
+        column: Result[K];
+    };
+} & {
+    [K in As as `${As}.*`]: {
+        as: K;
+        column: RequireJoined extends true ? ColumnsObject<J['result']> : NullableColumn<ColumnsObject<J['result']>>;
+    };
+};
+type JoinAddSelectable<T extends Query, Selectable extends SelectableBase> = {
+    [K in keyof T]: K extends 'selectable' ? T['selectable'] & Selectable : T[K];
+};
+type JoinOptionalMain<T extends Query, Selectable extends SelectableBase, Result extends ColumnsShapeBase = {
+    [K in keyof T['result']]: NullableColumn<T['result'][K]>;
+}, Data = GetQueryResult<T['returnType'], Result>> = {
+    [K in keyof T]: K extends 'selectable' ? {
+        [K in keyof T['selectable']]: {
+            as: T['selectable'][K]['as'];
+            column: NullableColumn<T['selectable'][K]['column']>;
+        };
+    } & Selectable : K extends 'result' ? Result : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : T[K];
+};
+/**
+ * Map the `with` table first argument of `join` or `joinLateral` to a query type.
+ * Constructs `selectable` based on `with` table shape, and adds generic types to conform the `QueryBase` type.
+ */
+type JoinWithArgToQuery<With extends WithDataItem, Selectable extends SelectableBase = {
+    [K in keyof With['shape']]: {
+        as: StringKey<K>;
+        column: With['shape'][K];
+    };
+}> = {
+    q: QueryData;
+    table: With['table'];
+    clone<T extends QueryBase>(this: T): T;
+    selectable: Selectable & {
+        [K in keyof Selectable as `${With['table']}.${StringKey<K>}`]: Selectable[K];
+    };
+    shape: With['shape'];
+    result: With['shape'];
+    baseQuery: Query;
+    relations: RelationsBase;
+    withData: WithDataBase;
+    meta: QueryBase['meta'];
+    internal: QueryInternal;
+    returnType: QueryReturnType;
+};
+/**
+ * Map the first argument of `join` or `joinLateral` to a query type.
+ *
+ * `with` table arg is mapped into `QueryBase`,
+ * query arg is returned as is,
+ * relation name is replaced with a relation table.
+ */
+type JoinArgToQuery<T extends QueryBase, Arg extends JoinFirstArg<T>> = Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? JoinWithArgToQuery<T['withData'][Arg]> : never : Arg extends Query ? Arg : Arg extends keyof T['relations'] ? T['relations'][Arg]['relationConfig']['table'] : never;
+/**
+ * Type of the `join` callback (not `joinLateral`).
+ *
+ * Receives a query builder that can access columns of both the main and the joined table.
+ *
+ * The query builder is limited to `or` and `where` methods only.
+ *
+ * Callback must return a query builder.
+ */
+type JoinCallback<T extends QueryBase, Arg extends JoinFirstArg<T>> = (q: OnQueryBuilder<T, JoinArgToQuery<T, Arg>>) => OnQueryBuilder;
+/**
+ * Type of the `joinLateral`.
+ *
+ * Receives a query builder that can access columns of both the main and the joined table.
+ *
+ * Query builder inside callback is the query derived from the `joinLateral` first argument,
+ * all query methods are allowed, `on` methods are available.
+ *
+ * The callback must return a query object. Its resulting type will become a type of the joined table.
+ */
+type JoinLateralCallback<T extends QueryBase, Arg extends JoinFirstArg<T>, R extends QueryBase, Q extends QueryBase = JoinArgToQuery<T, Arg>> = (q: Q & OnQueryBuilder<T, Q>) => R;
+declare class Join {
     /**
-     * Run the function after transaction for a `delete` kind of query will be committed.
-     * If the query wasn't wrapped in a transaction, will run after the query.
-     * If no records were deleted, the hook *won't* run.
+     * TODO: write docs
      *
-     * @param select - list of columns to select for the hook
-     * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+     * @param arg - can be a query object, a name of a relation, a name of `with` table, or a callback to join a relation
+     * @param args - arguments depend on the first argument, it can be object with columns, list of columns, `true` literal.
      */
-    afterDeleteCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
-    _afterDeleteCommit<T extends QueryHooks, S extends HookSelect<T>>(this: T, select: S, cb: AfterHook<S, T['shape']>): T;
+    join<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, true, true>;
+    join<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, true, true, Cb>;
+    _join<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, true, true>;
+    _join<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, true, true, Cb>;
+    leftJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, false, true>;
+    leftJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, false, true, Cb>;
+    _leftJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, false, true>;
+    _leftJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, false, true, Cb>;
+    rightJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, true, false>;
+    rightJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, true, false, Cb>;
+    _rightJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, true, false>;
+    _rightJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, true, false, Cb>;
+    fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, false, false>;
+    fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, false, false, Cb>;
+    _fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): JoinResult<T, Arg, false, false>;
+    _fullJoin<T extends Query, Arg extends JoinFirstArg<T>, Cb extends JoinCallback<T, Arg>>(this: T, arg: Arg, cb: Cb): JoinResult<T, Arg, false, false, Cb>;
+    joinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, true>;
+    _joinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, true>;
+    leftJoinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, false>;
+    _leftJoinLateral<T extends Query, Arg extends JoinFirstArg<T>, R extends QueryBase>(this: T, arg: Arg, cb: JoinLateralCallback<T, Arg, R>): JoinLateralResult<T, R, false>;
+}
+type OnArgs<Q extends {
+    selectable: SelectableBase;
+}> = [leftColumn: keyof Q['selectable'], rightColumn: keyof Q['selectable']] | [
+    leftColumn: keyof Q['selectable'],
+    op: string,
+    rightColumn: keyof Q['selectable']
+];
+declare const pushQueryOn: <T extends QueryBase>(q: T, joinFrom: QueryBase, joinTo: QueryBase, ...on: OnArgs<QueryBase>) => T;
+declare const pushQueryOrOn: typeof pushQueryOn;
+declare const addQueryOn: <T extends QueryBase>(q: T, joinFrom: QueryBase, joinTo: QueryBase, ...args: OnArgs<QueryBase>) => T;
+declare const addQueryOrOn: typeof pushQueryOrOn;
+type OnJsonPathEqualsArgs<T extends QueryBase> = [
+    leftColumn: keyof T['selectable'],
+    leftPath: string,
+    rightColumn: keyof T['selectable'],
+    rightPath: string
+];
+declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBase = QueryBase> extends WhereQueryBase {
+    selectable: J['selectable'] & Omit<S['selectable'], keyof S['shape']>;
+    relations: J['relations'];
+    result: J['result'];
+    shape: J['shape'];
+    baseQuery: Query;
+    withData: {};
+    internal: QueryInternal;
+    constructor(q: QueryBase, { shape, joinedShapes }: Pick<QueryData, 'shape' | 'joinedShapes'>, joinTo: QueryBase);
+    on<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
+    _on<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
+    orOn<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
+    _orOn<T extends OnQueryBuilder>(this: T, ...args: OnArgs<T>): T;
+    onJsonPathEquals<T extends OnQueryBuilder>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
+    _onJsonPathEquals<T extends OnQueryBuilder>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
 }
 
 type JsonColumnName<T extends QueryBase> = StringKey<{
@@ -3436,9 +3342,11 @@ type SelectAsResult<T extends Query, Arg, Result extends SelectObjectResultTuple
     Result[1] & AddSelectable
 ] : Result;
 type SelectAsValueResult<T extends Query, Arg extends SelectAsValue<T>> = Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends Expression ? Arg['_type'] : Arg extends (q: SelectQueryBuilder<T>) => infer R ? R extends QueryBase ? SelectSubQueryResult<R> : R extends Expression ? R['_type'] : R extends QueryBase | Expression ? SelectSubQueryResult<Exclude<R, Expression>> | Exclude<R, QueryBase>['_type'] : never : never;
-type SelectSubQueryResult<Arg extends QueryBase & {
-    [isRequiredRelationKey]?: boolean;
-}> = QueryReturnsAll<Arg['returnType']> extends true ? ArrayOfColumnsObjects<Arg['result']> : Arg['returnType'] extends 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? PluckResultColumnType<Arg['result']['pluck']> : Arg[isRequiredRelationKey] extends true ? ColumnsObject<Arg['result']> : NullableColumn<ColumnsObject<Arg['result']>>;
+type SelectSubQueryResult<Arg extends QueryBase> = QueryReturnsAll<Arg['returnType']> extends true ? ArrayOfColumnsObjects<Arg['result']> : Arg['returnType'] extends 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? PluckResultColumnType<Arg['result']['pluck']> : Arg extends {
+    relationConfig: {
+        required: true;
+    };
+} ? ColumnsObject<Arg['result']> : NullableColumn<ColumnsObject<Arg['result']>>;
 declare const addParserForRawExpression: (q: Query, key: string | getValueKey, raw: Expression) => void;
 declare const addParserForSelectItem: <T extends Query>(q: T, as: string | getValueKey | undefined, key: string, arg: Query | SelectableOrExpression<T>) => string | Expression | Query;
 declare const processSelectArg: <T extends Query>(q: T, as: string | undefined, arg: SelectArg<T>, columnAs?: string | getValueKey) => SelectItem;
@@ -3672,75 +3580,19 @@ declare class Union {
 
 type UpdateData<T extends Query> = {
     [K in keyof T['inputType']]?: UpdateColumn<T, K>;
-} & (T['relations'] extends Record<string, Relation> ? {
-    [K in keyof T['relations']]?: T['relations'][K] extends BelongsToRelation ? UpdateBelongsToData<T, T['relations'][K]> : T['relations'][K] extends HasOneRelation ? UpdateHasOneData<T, T['relations'][K]> : T['relations'][K] extends HasManyRelation ? UpdateHasManyData<T, T['relations'][K]> : T['relations'][K] extends HasAndBelongsToManyRelation ? UpdateHasAndBelongsToManyData<T['relations'][K]> : never;
-} : EmptyObject) & {
-    __raw?: never;
+} & {
+    [K in keyof T['relations']]?: UpdateRelationData<T, T['relations'][K]['relationConfig']>;
 };
 type UpdateColumn<T extends Query, Key extends keyof T['inputType']> = T['inputType'][Key] | Expression | {
     [K in keyof Query]: K extends 'then' ? QueryThen<T['inputType'][Key]> : Query[K];
 } | ((q: {
     [K in keyof JsonModifiers]: K extends 'selectable' ? T['selectable'] : T[K];
-} & {
-    [K in keyof T['relations']]: T[K];
-}) => JsonItem | (RelationQueryBase & {
+} & T['relations']) => JsonItem | (RelationQueryBase & {
     meta: {
         kind: 'select';
     };
 }));
-type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> = {
-    disconnect: boolean;
-} | {
-    set: WhereArg<Rel['table']>;
-} | {
-    delete: boolean;
-} | {
-    update: UpdateData<Rel['table']>;
-} | {
-    create: CreateData<Rel['nestedCreateQuery']>;
-} | (QueryReturnsAll<T['returnType']> extends true ? never : {
-    upsert: {
-        update: UpdateData<Rel['table']>;
-        create: CreateData<Rel['nestedCreateQuery']> | (() => CreateData<Rel['nestedCreateQuery']>);
-    };
-});
-type UpdateHasOneData<T extends Query, Rel extends HasOneRelation> = {
-    disconnect: boolean;
-} | {
-    delete: boolean;
-} | {
-    update: UpdateData<Rel['table']>;
-} | (QueryReturnsAll<T['returnType']> extends true ? never : {
-    set: WhereArg<Rel['table']>;
-} | {
-    upsert: {
-        update: UpdateData<Rel['table']>;
-        create: CreateData<Rel['nestedCreateQuery']> | (() => CreateData<Rel['nestedCreateQuery']>);
-    };
-} | {
-    create: CreateData<Rel['nestedCreateQuery']>;
-});
-type UpdateHasManyData<T extends Query, Rel extends HasManyRelation> = {
-    disconnect?: MaybeArray<WhereArg<Rel['table']>>;
-    delete?: MaybeArray<WhereArg<Rel['table']>>;
-    update?: {
-        where: MaybeArray<WhereArg<Rel['table']>>;
-        data: UpdateData<Rel['table']>;
-    };
-} & (QueryReturnsAll<T['returnType']> extends true ? EmptyObject : {
-    set?: MaybeArray<WhereArg<Rel['table']>>;
-    create?: CreateData<Rel['nestedCreateQuery']>[];
-});
-type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
-    disconnect?: MaybeArray<WhereArg<Rel['table']>>;
-    set?: MaybeArray<WhereArg<Rel['table']>>;
-    delete?: MaybeArray<WhereArg<Rel['table']>>;
-    update?: {
-        where: MaybeArray<WhereArg<Rel['table']>>;
-        data: UpdateData<Rel['table']>;
-    };
-    create?: CreateData<Rel['nestedCreateQuery']>[];
-};
+type UpdateRelationData<T extends Query, Rel extends RelationConfigBase> = Rel['one'] extends true ? Rel['dataForUpdate'] | (QueryReturnsAll<T['returnType']> extends true ? never : Rel['dataForUpdateOne']) : Rel['dataForUpdate'] & (QueryReturnsAll<T['returnType']> extends true ? EmptyObject : Rel['dataForUpdateOne']);
 type UpdateArg<T extends Query> = T['meta']['hasWhere'] extends true ? UpdateData<T> : never;
 type UpdateRawArgs<T extends Query> = T['meta']['hasWhere'] extends true ? [sql: Expression] | TemplateLiteralArgs : never;
 type UpdateResult<T extends Query> = T['meta']['hasSelect'] extends true ? SetQueryKind<T, 'update'> : SetQueryReturnsRowCount<SetQueryKind<T, 'update'>>;
@@ -5206,7 +5058,6 @@ type Query = QueryBase & QueryMethods<ColumnTypesBase> & {
     windows: EmptyObject;
     defaultSelectColumns: string[];
     relations: RelationsBase;
-    relationsQueries: Record<string, Query>;
     withData: WithDataBase;
     error: new (message: string, length: number, name: QueryErrorName) => QueryError;
     isSubQuery: boolean;
@@ -5260,7 +5111,7 @@ type SetQueryReturnsPluck<T extends Query, S extends keyof T['selectable'] | Exp
     catch: QueryCatch<C['outputType'][]>;
 };
 type SetQueryReturnsValueOptional<T extends Query, Arg extends GetStringArg<T>> = SetQueryReturnsValue<T, Arg, 'value'>;
-type SetQueryReturnsValue<T extends Query, Arg extends GetStringArg<T>, ReturnType extends 'value' | 'valueOrThrow' = 'valueOrThrow'> = SetQueryReturnsColumn<T, Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends RelationQueryBase ? Arg['result']['value'] : never, ReturnType>;
+type SetQueryReturnsValue<T extends Query, Arg extends GetStringArg<T>, ReturnType extends 'value' | 'valueOrThrow' = 'valueOrThrow'> = SetQueryReturnsColumn<T, Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends Query ? Arg['result']['value'] : never, ReturnType>;
 type SetQueryReturnsColumnOptional<T extends QueryBase, Column extends ColumnTypeBase> = SetQueryReturnsColumn<T, Column, 'value'>;
 type SetQueryReturnsColumn<T extends QueryBase, Column extends ColumnTypeBase, ReturnType extends 'value' | 'valueOrThrow' = 'valueOrThrow', Data = ReturnType extends 'value' ? Column['outputType'] | undefined : Column['outputType']> = {
     [K in keyof T]: K extends 'meta' ? T['meta'] & {
@@ -6657,4 +6508,4 @@ declare const testTransaction: {
     close(arg: Arg): Promise<void>;
 };
 
-export { Adapter, AdapterConfig, AdapterOptions, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AsMethods, BaseOperators, BaseRelation, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanNullable, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnOperators, ColumnType, ColumnTypes, ColumnsObject, ColumnsShape, CommonQueryData, CopyMethods, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DomainColumn, DoublePrecisionColumn, DropMode, EnumColumn, ExpressionOutput, FnExpression, FnExpressionArg, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArgs, FromResult, GetArg, GetQueryResult, GetStringArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBeforeHook, QueryData, QueryError, QueryErrorName, QueryGet, QueryHookSelect, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationSubQueries, RelationsBase, SearchArg, SearchMethods, SearchWeight, Select, SelectAggMethods, SelectArg, SelectItem, SelectQueryBuilder, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumn, SetQueryReturnsColumnInfo, SetQueryReturnsColumnOptional, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn, SubQueryBuilder, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimeInterval, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertCreateArg, UpsertData, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBase, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, anyShape, checkIfASimpleQuery, cloneQueryArrays, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, columnsByType, columnsShapeToCode, constraintPropsToCode, constraintToCode, createDb, createOperator, foreignKeyArgumentToCode, getClonedQueryData, getColumnTypes, getConstraintKind, getQueryAs, getShapeFromSelect, getSubQueryBuilder, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnFn, makeColumnFnClass, makeRegexToFindInSql, makeSQL, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, raw, referencesArgsToCode, relationQueryKey, resetTableData, resolveSubQueryCallback, saveSearchAlias, setQueryObjectValue, simplifyColumnDefault, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };
+export { Adapter, AdapterConfig, AdapterOptions, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AsMethods, BaseOperators, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanNullable, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnOperators, ColumnType, ColumnTypes, ColumnsObject, ColumnsShape, CommonQueryData, CopyMethods, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DomainColumn, DoublePrecisionColumn, DropMode, EnumColumn, ExpressionOutput, FnExpression, FnExpressionArg, For, ForeignKey, ForeignKeyAction, ForeignKeyMatch, ForeignKeyOptions, From, FromArgs, FromResult, GetArg, GetQueryResult, GetStringArg, Having, HavingItem, HookAction, HookSelect, IdentityColumn, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBeforeHook, QueryData, QueryError, QueryErrorName, QueryGet, QueryHookSelect, QueryHooks, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, RelationConfigBase, RelationQuery, RelationQueryBase, RelationSubQueries, RelationsBase, SearchArg, SearchMethods, SearchWeight, Select, SelectAggMethods, SelectArg, SelectItem, SelectQueryBuilder, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumn, SetQueryReturnsColumnInfo, SetQueryReturnsColumnOptional, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWith, SimpleJoinItem, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, StringColumn, SubQueryBuilder, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimeInterval, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownColumn, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertCreateArg, UpsertData, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBase, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, anyShape, checkIfASimpleQuery, cloneQueryArrays, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, columnsByType, columnsShapeToCode, constraintPropsToCode, constraintToCode, createDb, createOperator, foreignKeyArgumentToCode, getClonedQueryData, getColumnTypes, getConstraintKind, getQueryAs, getShapeFromSelect, getSubQueryBuilder, getTableData, handleResult, identityToCode, indexToCode, instantiateColumn, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnFn, makeColumnFnClass, makeRegexToFindInSql, makeSQL, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, raw, referencesArgsToCode, resetTableData, resolveSubQueryCallback, saveSearchAlias, setQueryObjectValue, simplifyColumnDefault, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };