pqb 0.3.2 → 0.3.3

package/dist/index.d.ts

@@ -22,343 +22,201 @@ declare const getRawSql: (raw: RawExpression) => string;
 declare const EMPTY_OBJECT: {};
 declare const getQueryParsers: (q: Query) => ColumnsParsers | undefined;
 
-declare 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;
-declare type JoinArgs<T extends QueryBase, Q extends Query = Query, R extends keyof T['relations'] = keyof T['relations'], W extends keyof T['withData'] = keyof T['withData']> = [relation: R] | [
-    query: Q,
-    conditions: Record<Selectable<Q>, Selectable<T> | RawExpression> | RawExpression
-] | [
-    withAlias: W,
-    conditions: Record<WithSelectable<T, W>, Selectable<T> | RawExpression> | RawExpression
-] | [
-    query: Q,
-    leftColumn: Selectable<Q> | RawExpression,
-    rightColumn: Selectable<T> | RawExpression
-] | [
-    withAlias: W,
-    leftColumn: WithSelectable<T, W> | RawExpression,
-    rightColumn: Selectable<T> | RawExpression
-] | [
-    query: Q,
-    leftColumn: Selectable<Q> | RawExpression,
-    op: string,
-    rightColumn: Selectable<T> | RawExpression
-] | [
-    withAlias: W,
-    leftColumn: WithSelectable<T, W> | RawExpression,
-    op: string,
-    rightColumn: Selectable<T> | RawExpression
-];
-declare type JoinResult<T extends Query, Args extends JoinArgs<T>, A extends Query | keyof T['relations'] = Args[0]> = AddQueryJoinedTable<T, A extends Query ? A : T['relations'] extends Record<string, Relation> ? A extends keyof T['relations'] ? T['relations'][A]['model'] : A extends keyof T['withData'] ? T['withData'][A] extends WithDataItem ? {
-    table: T['withData'][A]['table'];
-    tableAlias: undefined;
-    result: T['withData'][A]['shape'];
-} : never : never : never>;
-declare type JoinCallbackArg<T extends QueryBase> = Query | keyof T['withData'] | keyof T['relations'];
-declare type JoinCallback<T extends QueryBase, Arg extends JoinCallbackArg<T>> = (q: OnQueryBuilder<T, Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
-    query: QueryData;
-    table: T['withData'][Arg]['table'];
-    tableAlias: undefined;
-    clone(): QueryBase;
-    selectable: {
-        [K in keyof T['withData'][Arg]['shape'] as `${T['withData'][Arg]['table']}.${StringKey<K>}`]: {
-            as: StringKey<K>;
-            column: T['withData'][Arg]['shape'][K];
-        };
+declare type NestedInsertOneItem = {
+    create?: Record<string, unknown>;
+    connect?: WhereArg<QueryBase>;
+    connectOrCreate?: {
+        where: WhereArg<QueryBase>;
+        create: Record<string, unknown>;
+    };
+};
+declare type NestedInsertManyItems = {
+    create?: Record<string, unknown>[];
+    connect?: WhereArg<QueryBase>[];
+    connectOrCreate?: {
+        where: WhereArg<QueryBase>;
+        create: Record<string, unknown>;
+    }[];
+};
+declare type NestedInsertItem = NestedInsertOneItem | NestedInsertManyItems;
+declare type BelongsToNestedInsert = (query: Query, relationData: NestedInsertOneItem[]) => Promise<Record<string, unknown>[]>;
+declare type HasOneNestedInsert = (query: Query, data: [
+    selfData: Record<string, unknown>,
+    relationData: NestedInsertOneItem
+][]) => Promise<void>;
+declare type HasManyNestedInsert = (query: Query, data: [
+    selfData: Record<string, unknown>,
+    relationData: NestedInsertManyItems
+][]) => Promise<void>;
+declare type NestedUpdateOneItem = {
+    disconnect?: boolean;
+    set?: WhereArg<QueryBase>;
+    delete?: boolean;
+    update?: UpdateData<Query>;
+    upsert?: {
+        update: UpdateData<Query>;
+        create: Record<string, unknown>;
+    };
+    create: Record<string, unknown>;
+};
+declare type NestedUpdateManyItems = {
+    disconnect?: MaybeArray<WhereArg<QueryBase>>;
+    set?: MaybeArray<WhereArg<QueryBase>>;
+    delete?: MaybeArray<WhereArg<QueryBase>>;
+    update?: {
+        where: MaybeArray<WhereArg<QueryBase>>;
+        data: UpdateData<Query>;
+    };
+    create: Record<string, unknown>[];
+};
+declare type NestedUpdateItem = NestedUpdateOneItem | NestedUpdateManyItems;
+declare type BelongsToNestedUpdate = (q: Query, update: Record<string, unknown>, params: NestedUpdateOneItem, state: {
+    updateLater?: Record<string, unknown>;
+    updateLaterPromises?: Promise<void>[];
+}) => boolean;
+declare type HasOneNestedUpdate = (query: Query, data: Record<string, unknown>[], relationData: NestedUpdateOneItem) => Promise<void>;
+declare type HasManyNestedUpdate = (query: Query, data: Record<string, unknown>[], relationData: NestedUpdateManyItems) => Promise<void>;
+declare type BaseRelation = {
+    type: string;
+    key: string;
+    model: QueryWithTable;
+    query: QueryWithTable;
+    joinQuery(fromQuery: QueryBase, toQuery: Query): Query;
+    nestedCreateQuery: Query;
+    nestedInsert?: BelongsToNestedInsert | HasOneNestedInsert | HasManyNestedInsert;
+    nestedUpdate?: BelongsToNestedUpdate | HasOneNestedUpdate | HasManyNestedUpdate;
+    primaryKey: string;
+    options: {
+        scope?(q: QueryWithTable): QueryWithTable;
+        required?: boolean;
+    };
+};
+interface BelongsToRelation extends BaseRelation {
+    type: 'belongsTo';
+    returns: 'one';
+    options: BaseRelation['options'] & {
+        primaryKey: string;
+        foreignKey: string;
     };
-    shape: T['withData'][Arg]['shape'];
-    __model: Query;
-    relations: RelationsBase;
-    withData: WithDataBase;
-} : never : Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['model'] : never : never>) => OnQueryBuilder;
-declare type JoinCallbackResult<T extends Query, Arg extends JoinCallbackArg<T>> = AddQueryJoinedTable<T, Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['model'] : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
-    table: T['withData'][Arg]['table'];
-    tableAlias: undefined;
-    result: T['withData'][Arg]['shape'];
-} : never : never : never>;
-declare class Join {
-    join<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    join<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    _join<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    _join<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    innerJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    innerJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    _innerJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    _innerJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    leftJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    leftJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    _leftJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    _leftJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    leftOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    leftOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    _leftOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    _leftOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    rightJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    rightJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    _rightJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    _rightJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    rightOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    rightOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    _rightOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    _rightOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    fullOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    fullOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
-    _fullOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
-    _fullOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
 }
-declare 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 | string, joinTo: QueryBase | string, ...on: OnArgs<QueryBase>) => T;
-declare const pushQueryOrOn: typeof pushQueryOn;
-declare const addQueryOn: typeof pushQueryOrOn;
-declare const addQueryOrOn: typeof pushQueryOrOn;
-declare 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 WhereQueryBuilder<Omit<J, 'selectable'> & {
-    selectable: Omit<S['selectable'], keyof S['shape']> & J['selectable'];
-}> implements QueryBase {
-    joinTo: QueryBase;
-    constructor(q: QueryBase | string, shape: ColumnsShape, joinTo: QueryBase);
-    on<T extends this>(this: T, ...args: OnArgs<T>): T;
-    _on<T extends this>(this: T, ...args: OnArgs<T>): T;
-    orOn<T extends this>(this: T, ...args: OnArgs<T>): T;
-    _orOn<T extends this>(this: T, ...args: OnArgs<T>): T;
-    onJsonPathEquals<T extends this>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
-    _onJsonPathEquals<T extends this>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
+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;
+    };
+}
+declare type Relation = BelongsToRelation | HasOneRelation | HasManyRelation | HasAndBelongsToManyRelation;
+declare type RelationsBase = Record<never, Relation>;
+declare type relationQueryKey = typeof relationQueryKey;
+declare const relationQueryKey: unique symbol;
+declare type isRequiredRelationKey = typeof isRequiredRelationKey;
+declare const isRequiredRelationKey: unique symbol;
+declare type RelationQueryBase = Query & {
+    [relationQueryKey]: string;
+    [isRequiredRelationKey]: boolean;
+};
+declare type RelationQuery<RelationName extends PropertyKey = string, Params extends Record<string, unknown> = never, Populate extends string = never, T extends Query = Query, Required extends boolean = boolean, Q extends RelationQueryBase = Omit<T, 'tableAlias'> & {
+    tableAlias: RelationName extends string ? RelationName : never;
+    [isRequiredRelationKey]: Required;
+    [relationQueryKey]: string;
+}> = ((params: Params) => Q & {
+    [defaultsKey]: Record<Populate, true>;
+}) & Q;
 
-declare type WhereArg<T extends QueryBase> = (Omit<{
-    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'] | null | ColumnOperators<T['selectable'], K> | RawExpression;
-}, 'NOT' | 'OR' | 'IN' | 'EXISTS'> & {
-    NOT?: MaybeArray<WhereArg<T>>;
-    OR?: MaybeArray<WhereArg<T>>[];
-    IN?: MaybeArray<{
-        columns: (keyof T['selectable'])[];
-        values: unknown[][] | Query | RawExpression;
-    }>;
-    EXISTS?: MaybeArray<JoinArgs<T> | JoinCallbackArg<T>>;
-}) | QueryBase | RawExpression | ((q: WhereQueryBuilder<T>) => WhereQueryBuilder);
-declare type WhereInColumn<T extends QueryBase> = keyof T['selectable'] | [keyof T['selectable'], ...(keyof T['selectable'])[]];
-declare type WhereInValues<T extends QueryBase, Column extends WhereInColumn<T>> = Column extends keyof T['selectable'] ? T['selectable'][Column]['column']['type'][] | Query | RawExpression : ({
-    [I in keyof Column]: Column[I] extends keyof T['selectable'] ? T['selectable'][Column[I]]['column']['type'] : never;
-} & {
-    length: Column extends {
-        length: number;
-    } ? Column['length'] : never;
-})[] | Query | RawExpression;
-declare type WhereResult<T extends QueryBase> = T & {
-    hasWhere: true;
+interface QueryResultRow {
+    [column: string]: any;
+}
+declare type TypeParsers = Record<number, (input: string) => unknown>;
+declare type QueryInput = string | {
+    text: string;
+    values?: unknown[];
 };
-declare type WhereInArg<T extends Pick<Query, 'selectable'>> = {
-    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'][] | Query | RawExpression;
+declare type QueryResult<T extends QueryResultRow = any> = {
+    rowCount: number;
+    rows: T[];
 };
-declare const addWhere: <T extends Where>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
-declare const addWhereNot: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
-declare const addOr: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
-declare const addOrNot: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
-declare const addWhereIn: <T extends QueryBase>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | RawExpression | undefined, not?: boolean) => WhereResult<T>;
-declare abstract class Where implements QueryBase {
-    abstract clone<T extends this>(this: T): T;
-    abstract selectable: SelectableBase;
-    abstract shape: ColumnsShape;
-    abstract relations: RelationsBase;
-    abstract withData: WithDataBase;
-    abstract __model: Query;
-    query: QueryData;
-    table?: string;
-    tableAlias?: string;
-    where<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    _where<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    whereNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    _whereNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    and<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    _and<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    andNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    _andNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    _or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    _orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): T;
-    whereIn<T extends Where>(this: T, arg: WhereInArg<T>): T;
-    _whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _whereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    orWhereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _orWhereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    whereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    whereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _whereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _whereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    _orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
-    _orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    whereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
-    whereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _whereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
-    _whereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    orWhereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
-    orWhereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _orWhereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
-    _orWhereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    whereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
-    whereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _whereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
-    _whereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    orWhereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
-    orWhereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _orWhereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
-    _orWhereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+declare type QueryArraysResult<R extends any[] = any[]> = {
+    rowCount: number;
+    rows: R[];
+    fields: {
+        name: string;
+    }[];
+};
+declare type AdapterOptions = Omit<PoolConfig, 'types'> & {
+    types?: TypeParsers;
+};
+declare class Adapter {
+    types: TypeParsers;
+    pool: Pool;
+    constructor({ types, ...config }: AdapterOptions);
+    query<T extends QueryResultRow = any>(query: QueryInput, types?: TypeParsers): Promise<QueryResult<T>>;
+    arrays<R extends any[] = any[]>(query: QueryInput, types?: TypeParsers): Promise<QueryArraysResult<R>>;
+    transaction<Result>(cb: (adapter: TransactionAdapter) => Promise<Result>): Promise<Result>;
+    close(): Promise<void>;
 }
-declare class WhereQueryBuilder<Q extends QueryBase = QueryBase> extends Where implements QueryBase {
-    query: QueryData;
-    selectable: Q['selectable'];
-    shape: Q['shape'];
-    relations: Q['relations'];
-    __model: Query;
-    withData: {};
-    constructor(q: QueryBase | string, shape: ColumnsShape);
-    clone<T extends this>(this: T): T;
+declare class TransactionAdapter implements Adapter {
+    pool: Pool;
+    client: PoolClient;
+    types: TypeParsers;
+    constructor(pool: Pool, client: PoolClient, types: TypeParsers);
+    query<T extends QueryResultRow = any>(query: QueryInput, types?: TypeParsers): Promise<QueryResult<T>>;
+    arrays<R extends any[] = any[]>(query: QueryInput, types?: TypeParsers): Promise<QueryArraysResult<R>>;
+    transaction<Result>(cb: (adapter: TransactionAdapter) => Promise<Result>): Promise<Result>;
+    close(): Promise<void>;
 }
 
-declare type AggregateArg<T extends Query> = Expression<T> | Record<string, Expression<T>> | [Expression<T>, string];
-declare type AggregateOptions<T extends Query = Query, As extends string | undefined = any> = {
-    as?: As;
-    distinct?: boolean;
-    order?: OrderArg<T> | OrderArg<T>[];
-    filter?: WhereArg<T>;
-    filterOr?: WhereArg<T>[];
-    withinGroup?: boolean;
-    over?: T['windows'][number] | WindowArgDeclaration<T>;
+declare type QueryLogObject = {
+    colors: boolean;
+    beforeQuery(sql: Sql): unknown;
+    afterQuery(sql: Sql, logData: unknown): void;
+    onError(error: Error, sql: Sql, logData: unknown): void;
+};
+declare type QueryLogger = {
+    log(message: string): void;
+    error(message: string): void;
 };
-declare type Aggregate1ArgumentTypes<T extends Query = Query, C extends ColumnType = ColumnType> = {
-    count: Expression<T, C>;
-    avg: NumberExpression<T, C>;
-    min: Expression<T, C>;
-    max: Expression<T, C>;
-    sum: NumberExpression<T, C>;
-    bitAnd: NumberExpression<T, C>;
-    bitOr: NumberExpression<T, C>;
-    boolAnd: BooleanExpression<T, C>;
-    boolOr: BooleanExpression<T, C>;
-    every: BooleanExpression<T, C>;
-    jsonAgg: Expression<T, C>;
-    jsonbAgg: Expression<T, C>;
-    xmlAgg: Expression<T, C>;
+declare type QueryLogOptions = {
+    log?: boolean | Partial<QueryLogObject>;
+    logger?: QueryLogger;
 };
-declare const aggregate1FunctionNames: {
-    readonly count: "count";
-    readonly avg: "avg";
-    readonly min: "min";
-    readonly max: "max";
-    readonly sum: "sum";
-    readonly bitAnd: "bit_and";
-    readonly bitOr: "bit_or";
-    readonly boolAnd: "bool_and";
-    readonly boolOr: "bool_or";
-    readonly every: "every";
-    readonly jsonAgg: "json_agg";
-    readonly jsonbAgg: "jsonb_agg";
-    readonly xmlAgg: "xmlagg";
+declare const logColors: {
+    boldCyanBright: (message: string) => string;
+    boldBlue: (message: string) => string;
+    boldYellow: (message: string) => string;
+    boldMagenta: (message: string) => string;
+    boldRed: (message: string) => string;
 };
-declare type SelectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnType> = AddQuerySelect<T, Record<CoalesceString<As, Func>, Value>>;
-declare type AT1<T extends Query> = Aggregate1ArgumentTypes<T>;
-declare type WindowFunctionOptions<T extends Query = Query, As extends string | undefined = any> = {
-    as?: As;
-} & WindowArgDeclaration<T>;
-declare class Aggregate {
-    selectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnType>(this: T, functionName: Func, arg: AggregateArg<T>, options?: AggregateOptions<T, As>): SelectAgg<T, Func, As, Value>;
-    _selectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnType>(this: T, functionName: Func, arg: AggregateArg<T>, options?: AggregateOptions<T, As>, columnType?: ColumnType): SelectAgg<T, Func, As, Value>;
-    count<T extends Query>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T>): SetQueryReturnsValue<T, NumberColumn>;
-    _count<T extends Query>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T>): SetQueryReturnsValue<T, NumberColumn>;
-    selectCount<T extends Query, As extends string | undefined = undefined>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T, As>): SelectAgg<T, 'count', As, NumberColumn>;
-    _selectCount<T extends Query, As extends string | undefined = undefined>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T, As>): SelectAgg<T, 'count', As, NumberColumn>;
-    avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
-    _selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
-    min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
-    _selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
-    max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
-    _selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
-    sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
-    _selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
-    bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
-    _selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
-    bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    _bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
-    selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
-    _selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
-    boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
-    _boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
-    selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
-    _selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
-    boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
-    _boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
-    selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
-    _selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
-    every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
-    _every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
-    selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
-    _selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
-    jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    _jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    selectJsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    _selectJsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    jsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    _jsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    selectJsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    _selectJsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
-    xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
-    _xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
-    selectXmlAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Aggregate1ArgumentTypes<T>['xmlAgg'], options?: AggregateOptions<T, As>): SelectAgg<T, 'xmlagg', As, NullableColumn<StringColumn>>;
-    _selectXmlAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Aggregate1ArgumentTypes<T>['xmlAgg'], options?: AggregateOptions<T, As>): SelectAgg<T, 'xmlagg', As, NullableColumn<StringColumn>>;
-    jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
-        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
-    }>>>;
-    _jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
-        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
-    }>>>;
-    selectJsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
-        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
-    }>>>;
-    _selectJsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
-        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
-    }>>>;
-    jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
-        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
-    }>>>;
-    _jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
-        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
-    }>>>;
-    selectJsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
-        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
-    }>>>;
-    _selectJsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
-        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
-    }>>>;
-    stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
-    _stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
-    selectStringAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T, As>): SelectAgg<T, 'string_agg', As, NullableColumn<StringColumn>>;
-    _selectStringAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T, As>): SelectAgg<T, 'string_agg', As, NullableColumn<StringColumn>>;
+declare const logParamToLogObject: (logger: QueryLogger, log: QueryLogOptions['log']) => QueryLogObject | undefined;
+declare class QueryLog {
+    log<T extends Query>(this: T, log?: boolean): T;
+    _log<T extends Query>(this: T, log?: boolean): T;
 }
 
 declare type BeforeCallback<T extends Query = Query> = (query: T) => void | Promise<void>;
@@ -382,267 +240,340 @@ declare class QueryCallbacks {
     _afterDelete<T extends Query>(this: T, cb: AfterCallback<T>): T;
 }
 
-declare type ClearStatement = 'with' | 'select' | 'where' | 'union' | 'using' | 'join' | 'group' | 'order' | 'having' | 'limit' | 'offset' | 'counters';
-declare class Clear {
-    clear<T extends Query>(this: T, ...clears: ClearStatement[]): T;
-    _clear<T extends Query>(this: T, ...clears: ClearStatement[]): T;
-}
-
-declare type ColumnInfo = {
-    defaultValue: unknown;
+declare type Sql = {
+    text: string;
+    values: unknown[];
+};
+declare const checkIfASimpleQuery: (q: QueryData) => boolean;
+declare type CommonQueryData = {
+    adapter: Adapter;
+    handleResult(q: Query, result: QueryResult): Promise<unknown>;
+    returnType: QueryReturnType;
+    [relationQueryKey]?: string;
+    inTransaction?: boolean;
+    wrapInTransaction?: boolean;
+    throwOnNotFound?: boolean;
+    with?: WithItem[];
+    withShapes?: Record<string, ColumnsShape>;
+    schema?: string;
+    select?: SelectItem[];
+    as?: string;
+    from?: string | Query | RawExpression;
+    and?: WhereItem[];
+    or?: WhereItem[][];
+    coalesceValue?: unknown | RawExpression;
+    parsers?: ColumnsParsers;
+    notFoundDefault?: unknown;
+    defaults?: Record<string, unknown>;
+    beforeQuery?: BeforeCallback[];
+    afterQuery?: AfterCallback[];
+    log?: QueryLogObject;
+    logger: QueryLogger;
+    [toSqlCacheKey]?: Sql;
+};
+declare type SelectQueryData = CommonQueryData & {
+    type: undefined;
+    distinct?: Expression[];
+    fromOnly?: boolean;
+    join?: JoinItem[];
+    joinedParsers?: Record<string, ColumnsParsers>;
+    group?: (string | RawExpression)[];
+    having?: HavingItem[];
+    havingOr?: HavingItem[][];
+    window?: WindowItem[];
+    union?: {
+        arg: UnionItem;
+        kind: UnionKind;
+        wrap?: boolean;
+    }[];
+    order?: OrderItem[];
+    limit?: number;
+    offset?: number;
+    for?: {
+        type: 'UPDATE' | 'NO KEY UPDATE' | 'SHARE' | 'KEY SHARE';
+        tableNames?: string[] | RawExpression;
+        mode?: 'NO WAIT' | 'SKIP LOCKED';
+    };
+};
+declare type InsertQueryData = CommonQueryData & {
+    type: 'insert';
+    columns: string[];
+    values: unknown[][] | RawExpression;
+    using?: JoinItem[];
+    join?: JoinItem[];
+    joinedParsers?: Record<string, ColumnsParsers>;
+    onConflict?: {
+        type: 'ignore';
+        expr?: OnConflictItem;
+    } | {
+        type: 'merge';
+        expr?: OnConflictItem;
+        update?: OnConflictMergeUpdate;
+    };
+    beforeInsert?: BeforeCallback[];
+    afterInsert?: AfterCallback[];
+};
+declare type UpdateQueryDataObject = Record<string, RawExpression | {
+    op: string;
+    arg: unknown;
+} | unknown>;
+declare type UpdatedAtDataInjector = (data: UpdateQueryDataItem[]) => UpdateQueryDataItem | void;
+declare type UpdateQueryDataItem = UpdateQueryDataObject | RawExpression | UpdatedAtDataInjector;
+declare type UpdateQueryData = CommonQueryData & {
+    type: 'update';
+    updateData: UpdateQueryDataItem[];
+    beforeUpdate?: BeforeCallback[];
+    afterUpdate?: AfterCallback[];
+};
+declare type DeleteQueryData = CommonQueryData & {
+    type: 'delete';
+    join?: JoinItem[];
+    joinedParsers?: Record<string, ColumnsParsers>;
+    beforeDelete?: BeforeCallback[];
+    afterDelete?: AfterCallback[];
+};
+declare type TruncateQueryData = CommonQueryData & {
+    type: 'truncate';
+    restartIdentity?: boolean;
+    cascade?: boolean;
+};
+declare type ColumnInfoQueryData = CommonQueryData & {
+    type: 'columnInfo';
+    column?: string;
+};
+declare type QueryData = SelectQueryData | InsertQueryData | UpdateQueryData | DeleteQueryData | TruncateQueryData | ColumnInfoQueryData;
+declare type WithItem = [
+    as: string,
+    options: WithOptions,
+    query: Query | RawExpression
+];
+declare type WithOptions = {
+    columns?: string[];
+    recursive?: true;
+    materialized?: true;
+    notMaterialized?: true;
+};
+declare type JsonItem<As extends string = string, Type extends ColumnType = ColumnType> = {
+    __json: [
+        kind: 'set',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>,
+        value: unknown,
+        options?: {
+            createIfMissing?: boolean;
+        }
+    ] | [
+        kind: 'insert',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>,
+        value: unknown,
+        options?: {
+            insertAfter?: boolean;
+        }
+    ] | [
+        kind: 'remove',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>
+    ] | [
+        kind: 'pathQuery',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: string,
+        options?: {
+            vars?: string;
+            silent?: boolean;
+        }
+    ];
+};
+declare type SelectItem = string | RelationQuery | AggregateItem | {
+    selectAs: Record<string, string | Query | RawExpression>;
+} | SelectFunctionItem | JsonItem | RawExpression;
+declare type SelectFunctionItem = {
+    function: string;
+    arguments: SelectItem[];
+    as?: string;
+};
+declare type JoinItem = {
     type: string;
-    maxLength: number | null;
-    nullable: boolean;
+    args: [relation: string] | [
+        arg: string | QueryWithTable,
+        conditions: Record<string, string | RawExpression> | RawExpression | ((q: unknown) => QueryBase)
+    ] | [
+        arg: string | QueryWithTable,
+        leftColumn: string | RawExpression,
+        rightColumn: string | RawExpression
+    ] | [
+        arg: string | QueryWithTable,
+        leftColumn: string | RawExpression,
+        op: string,
+        rightColumn: string | RawExpression
+    ];
 };
-declare class ColumnInfoMethods {
-    columnInfo<T extends Query, Column extends keyof T['shape'] | undefined = undefined>(this: T, column?: Column): SetQueryReturnsColumnInfo<T, Column>;
-    _columnInfo<T extends Query, Column extends keyof T['shape'] | undefined = undefined>(this: T, column?: Column): SetQueryReturnsColumnInfo<T, Column>;
-}
-
-declare type DeleteArgs<T extends Query> = T['hasWhere'] extends true ? [forceAll?: boolean] : [true];
-declare type DeleteResult<T extends Query> = T['hasSelect'] extends false ? SetQueryReturnsRowCount<T> : T;
-declare class Delete {
-    del<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T>;
-    _del<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T>;
-    delete<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T>;
-    _delete<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T>;
-}
-
-declare 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 type WhereItem = (Omit<Record<string, unknown | Record<string, unknown | Query | RawExpression> | RawExpression>, 'NOT' | 'AND' | 'OR' | 'IN' | 'EXISTS' | 'ON' | 'ON_JSON_PATH_EQUALS'> & {
+    NOT?: MaybeArray<WhereItem>;
+    AND?: MaybeArray<WhereItem>;
+    OR?: MaybeArray<WhereItem>[];
+    IN?: MaybeArray<WhereInItem>;
+    EXISTS?: MaybeArray<JoinItem['args']>;
+    ON?: WhereOnItem | WhereJsonPathEqualsItem;
+}) | ((q: unknown) => QueryBase) | Query | RawExpression;
+declare type WhereInItem = {
+    columns: string[];
+    values: unknown[][] | Query | RawExpression;
 };
-declare class For {
-    forUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    _forUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    _forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    forShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    _forShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    forKeyShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-    _forKeyShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
-}
-
-declare type FromArgs<T extends Query> = [
-    first: string | Query | RawExpression | Exclude<keyof T['withData'], symbol | number>,
-    second?: string | {
-        as?: string;
-        only?: boolean;
-    }
+declare type WhereJsonPathEqualsItem = [
+    leftColumn: string,
+    leftPath: string,
+    rightColumn: string,
+    rightPath: string
 ];
-declare type FromResult<T extends Query, Args extends FromArgs<T>> = Args[1] extends string ? SetQueryTableAlias<T, Args[1]> : Args[1] extends {
-    as: string;
-} ? SetQueryTableAlias<T, Args[1]['as']> : Args[0] extends string ? SetQueryTableAlias<T, Args[0]> : Args[0] extends Query ? SetQueryTableAlias<T, AliasOrTable<Args[0]>> : T;
-declare class From {
-    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>;
-}
-
-declare type GetArg<T extends QueryBase> = StringKey<keyof T['selectable']> | RawExpression;
-declare type UnwrapRaw<T extends Query, Arg extends GetArg<T>> = Arg extends RawExpression ? Arg['__column'] : Exclude<Arg, RawExpression>;
-declare type GetResult<T extends Query, Arg extends GetArg<T>> = SetQueryReturnsValue<T, UnwrapRaw<T, Arg>>;
-declare type GetOptionalResult<T extends Query, Arg extends GetArg<T>> = SetQueryReturnsValueOptional<T, UnwrapRaw<T, Arg>>;
-declare type getValueKey = typeof getValueKey;
-declare const getValueKey: unique symbol;
-declare class QueryGet {
-    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>;
-    getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetOptionalResult<T, Arg>;
-    _getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetOptionalResult<T, Arg>;
-}
-
-declare type HavingArgObject<T extends Query, Agg extends keyof Aggregate1ArgumentTypes<T>> = {
-    [Column in Exclude<Aggregate1ArgumentTypes<T>[Agg], RawExpression>]?: T['selectable'][Column]['column']['type'] | (ColumnOperators<T['selectable'], Column> & AggregateOptions<T>);
+declare type WhereOnItem = {
+    joinFrom: WhereOnJoinItem;
+    joinTo: WhereOnJoinItem;
+    on: [leftFullColumn: string, rightFullColumn: string] | [leftFullColumn: string, op: string, rightFullColumn: string];
 };
-declare type HavingArg<T extends Query = Query> = ({
-    [Agg in keyof Aggregate1ArgumentTypes<T>]?: HavingArgObject<T, Agg>;
-} & {
-    count?: number | HavingArgObject<T, 'count'>;
-}) | Query | RawExpression;
-declare class Having {
-    having<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
-    _having<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
-    havingOr<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
-    _havingOr<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
-}
-
-declare type InsertData<T extends Query, DefaultKeys extends PropertyKey = keyof T[defaultsKey], Data = SetOptional<T['inputType'], DefaultKeys>> = [keyof T['relations']] extends [never] ? Data : OmitBelongsToForeignKeys<T['relations'], Data> & InsertRelationData<T>;
-declare type OmitBelongsToForeignKeys<R extends RelationsBase, Data> = Omit<Data, {
-    [K in keyof R]: R[K] extends BelongsToRelation ? R[K]['options']['foreignKey'] : never;
-}[keyof R]>;
-declare type InsertRelationData<T extends Query> = {
-    [K in keyof T['relations']]: T['relations'][K] extends BelongsToRelation ? InsertBelongsToData<T, K, T['relations'][K]> : T['relations'][K] extends HasOneRelation ? InsertHasOneData<T, K, T['relations'][K]> : T['relations'][K] extends HasManyRelation | HasAndBelongsToManyRelation ? InsertHasManyData<T, K, T['relations'][K]> : EmptyObject;
-}[keyof T['relations']];
-declare type InsertBelongsToData<T extends Query, Key extends keyof T['relations'], Rel extends BelongsToRelation> = SetOptional<{
-    [K in Rel['options']['foreignKey']]: Rel['options']['foreignKey'] extends keyof T['inputType'] ? T['inputType'][Rel['options']['foreignKey']] : never;
-}, keyof T[defaultsKey]> | {
-    [K in Key]: {
-        create: InsertData<Rel['nestedCreateQuery']>;
-        connect?: never;
-        connectOrCreate?: never;
-    } | {
-        create?: never;
-        connect: WhereArg<Rel['model']>;
-        connectOrCreate?: never;
-    } | {
-        create?: never;
-        connect?: never;
-        connectOrCreate: {
-            where: WhereArg<Rel['model']>;
-            create: InsertData<Rel['nestedCreateQuery']>;
-        };
+declare type WhereOnJoinItem = {
+    table?: string;
+    query: {
+        as?: string;
     };
+} | string;
+declare type AggregateItemOptions = {
+    as?: string;
+    distinct?: boolean;
+    order?: OrderItem[];
+    filter?: WhereItem;
+    filterOr?: WhereItem[];
+    withinGroup?: boolean;
+    over?: string;
+    window?: WindowItem;
 };
-declare type InsertHasOneData<T extends Query, Key extends keyof T['relations'], Rel extends HasOneRelation> = 'through' extends Rel['options'] ? {} : {
-    [K in Key]?: {
-        create: InsertData<Rel['nestedCreateQuery']>;
-        connect?: never;
-        connectOrCreate?: never;
-    } | {
-        create?: never;
-        connect: WhereArg<Rel['model']>;
-        connectOrCreate?: never;
-    } | {
-        create?: never;
-        connect?: never;
-        connectOrCreate: {
-            where?: WhereArg<Rel['model']>;
-            create?: InsertData<Rel['nestedCreateQuery']>;
-        };
-    };
+declare type SortDir = 'ASC' | 'DESC';
+declare type OrderItem = string | Record<string, SortDir | {
+    dir: SortDir;
+    nulls: 'FIRST' | 'LAST';
+}> | RawExpression;
+declare type AggregateItemArg = Expression | Record<string, Expression> | [Expression, string];
+declare type AggregateItem = {
+    function: string;
+    arg?: AggregateItemArg;
+    options: AggregateItemOptions;
 };
-declare type InsertHasManyData<T extends Query, Key extends keyof T['relations'], Rel extends HasManyRelation | HasAndBelongsToManyRelation> = 'through' extends Rel['options'] ? {} : {
-    [K in Key]?: {
-        create?: InsertData<Rel['nestedCreateQuery']>[];
-        connect?: WhereArg<Rel['model']>[];
-        connectOrCreate?: {
-            where: WhereArg<Rel['model']>;
-            create: InsertData<Rel['nestedCreateQuery']>;
-        }[];
-    };
+declare type ColumnOperators<S extends SelectableBase, Column extends keyof S> = {
+    [O in keyof S[Column]['column']['operators']]?: S[Column]['column']['operators'][O]['type'];
+};
+declare type HavingItemObject = Record<string, unknown>;
+declare type HavingItem = Record<string, HavingItemObject> | {
+    count?: number | HavingItemObject;
+} | Query | RawExpression;
+declare type WindowItem = Record<string, WindowDeclaration | RawExpression>;
+declare type WindowDeclaration = {
+    partitionBy?: Expression | Expression[];
+    order?: OrderItem;
+};
+declare type UnionItem = Query | RawExpression;
+declare type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT' | 'EXCEPT ALL';
+declare type OnConflictItem = string | string[] | RawExpression;
+declare type OnConflictMergeUpdate = string | string[] | Record<string, unknown> | RawExpression;
+
+declare type ToSqlCtx = {
+    whereQueryBuilder: typeof WhereQueryBuilder;
+    onQueryBuilder: typeof OnQueryBuilder;
+    sql: string[];
+    values: unknown[];
+};
+declare type toSqlCacheKey = typeof toSqlCacheKey;
+declare const toSqlCacheKey: unique symbol;
+declare type ToSqlOptions = {
+    clearCache?: boolean;
+    values?: unknown[];
+};
+declare const toSql: (model: Query, options?: ToSqlOptions) => Sql;
+
+declare type SomeIsTrue<T extends unknown[]> = T extends [
+    infer Head,
+    ...infer Tail
+] ? Head extends true ? true : SomeIsTrue<Tail> : false;
+declare type MaybeArray<T> = T | T[];
+declare type SetOptional<T, K extends PropertyKey> = Omit<T, K> & {
+    [P in K]?: P extends keyof T ? T[P] : never;
 };
-declare type InsertRawData = {
-    columns: string[];
-    values: RawExpression;
+declare type GetTypesOrRaw<T extends [...unknown[]]> = T extends [
+    infer Head,
+    ...infer Tail
+] ? [GetTypeOrRaw<Head>, ...GetTypesOrRaw<Tail>] : [];
+declare type GetTypeOrRaw<T> = T | RawExpression;
+declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
+declare type OptionalPropertyNames<T> = {
+    [K in keyof T]-?: {} extends {
+        [P in K]: T[K];
+    } ? K : never;
+}[keyof T];
+declare type SpreadProperties<L, R, K extends keyof L & keyof R> = {
+    [P in K]: L[P] | Exclude<R[P], undefined>;
 };
-declare type InsertOneResult<T extends Query> = T['hasSelect'] extends false ? SetQueryReturnsRowCount<T> : T['returnType'] extends 'all' ? SetQueryReturnsOne<T> : T['returnType'] extends 'one' ? SetQueryReturnsOne<T> : T;
-declare type InsertManyResult<T extends Query> = T['hasSelect'] extends false ? SetQueryReturnsRowCount<T> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAll<T> : T;
-declare type OnConflictArg<T extends Query> = keyof T['shape'] | (keyof T['shape'])[] | RawExpression;
-declare class Insert {
-    insert<T extends Query>(this: T, data: InsertData<T>): InsertOneResult<T>;
-    _insert<T extends Query>(this: T, data: InsertData<T>): InsertOneResult<T>;
-    insertMany<T extends Query>(this: T, data: InsertData<T>[]): InsertManyResult<T>;
-    _insertMany<T extends Query>(this: T, data: InsertData<T>[]): InsertManyResult<T>;
-    insertRaw<T extends Query>(this: T, data: InsertRawData): InsertManyResult<T>;
-    _insertRaw<T extends Query>(this: T, data: InsertRawData): InsertManyResult<T>;
-    create<T extends Query>(this: T, data: InsertData<T>): SetQueryReturnsOne<T>;
-    _create<T extends Query>(this: T, data: InsertData<T>): SetQueryReturnsOne<T>;
-    createMany<T extends Query>(this: T, data: InsertData<T>[]): SetQueryReturnsAll<T>;
-    _createMany<T extends Query>(this: T, data: InsertData<T>[]): SetQueryReturnsAll<T>;
-    createRaw<T extends Query>(this: T, data: InsertRawData): SetQueryReturnsAll<T>;
-    _createRaw<T extends Query>(this: T, data: InsertRawData): SetQueryReturnsAll<T>;
-    defaults<T extends Query, Data extends Partial<InsertData<T>>>(this: T, data: Data): T & {
-        [defaultsKey]: Record<keyof Data, true>;
-    };
-    _defaults<T extends Query, Data extends Partial<InsertData<T>>>(this: T, data: Data): T & {
-        [defaultsKey]: Record<keyof Data, true>;
+declare type Id<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;
+declare type SpreadTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>>;
+declare type Spread<A extends readonly [...any]> = A extends [
+    infer L,
+    ...infer R
+] ? SpreadTwo<L, Spread<R>> : unknown;
+declare type SimpleSpread<A extends readonly [...any]> = A extends [
+    infer L,
+    ...infer R
+] ? L & SimpleSpread<R> : {};
+declare type FilterTuple<T extends readonly any[], E> = T extends [
+    infer F,
+    ...infer R
+] ? [F] extends [E] ? [F, ...FilterTuple<R, E>] : FilterTuple<R, E> : [];
+declare type CoalesceString<Left extends string | undefined, Right extends string> = Left extends undefined ? Right : Left;
+declare function applyMixins(derivedCtor: any, constructors: any[]): void;
+declare const joinTruthy: (...strings: (string | false | undefined)[]) => string;
+declare const getClonedQueryData: (query: QueryData) => QueryData;
+declare const getQueryAs: (q: {
+    table?: string;
+    query: {
+        as?: string;
     };
-    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);
-    ignore(): T;
-    merge(update?: keyof T['shape'] | (keyof T['shape'])[] | Partial<T['inputType']> | RawExpression): T;
-}
+}) => string;
+declare const toArray: <T>(item: T) => T extends unknown[] ? T : [T];
+declare const noop: () => void;
+declare type EmptyObject = typeof emptyObject;
+declare const emptyObject: {};
+declare const makeRegexToFindInSql: (value: string) => RegExp;
+declare const pushOrNewArrayToObject: <Obj extends {}, Key extends keyof Obj>(obj: Obj, key: Key, value: Exclude<Obj[Key], undefined> extends unknown[] ? Exclude<Obj[Key], undefined>[number] : never) => void;
+declare const pushOrNewArray: <Arr extends unknown[]>(arr: Arr | undefined, value: Arr[number]) => Arr;
 
-declare type JsonColumnName<T extends Pick<Query, 'selectable'>> = StringKey<{
-    [K in keyof T['selectable']]: T['selectable'][K]['column']['dataType'] extends 'jsonb' ? K : never;
-}[keyof T['selectable']]>;
-declare type ColumnOrJsonMethod<T extends Query> = JsonColumnName<T> | JsonItem;
-declare type JsonSetResult<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string, Type extends ColumnType = Column extends keyof T['shape'] ? T['shape'][Column] : Column extends JsonItem ? Column['__json'][2] : ColumnType> = JsonItem<As, Type> & (Type extends ColumnType ? AddQuerySelect<T, Record<As, Type>> : T);
-declare type JsonPathQueryResult<T extends Query, As extends string, Type extends ColumnType> = JsonItem & AddQuerySelect<T, {
-    [K in As]: Type;
-}>;
-declare class Json {
-    json<T extends Query>(this: T): SetQueryReturnsValueOptional<T, StringColumn>;
-    _json<T extends Query>(this: T): SetQueryReturnsValueOptional<T, StringColumn>;
-    jsonSet<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, value: unknown, options?: {
-        as?: As;
-        createIfMissing?: boolean;
-    }): JsonSetResult<T, Column, As>;
-    _jsonSet<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, value: unknown, options?: {
-        as?: As;
-        createIfMissing?: boolean;
-    }): JsonSetResult<T, Column, As>;
-    jsonInsert<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, ...args: [
-        column: Column,
-        path: Array<string | number>,
-        value: unknown,
-        options?: {
-            as?: As;
-            insertAfter?: boolean;
-        }
-    ]): JsonSetResult<T, Column, As>;
-    _jsonInsert<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, value: unknown, options?: {
-        as?: As;
-        insertAfter?: boolean;
-    }): JsonSetResult<T, Column, As>;
-    jsonRemove<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, ...args: [
-        column: Column,
-        path: Array<string | number>,
-        options?: {
-            as?: As;
-        }
-    ]): JsonSetResult<T, Column, As>;
-    _jsonRemove<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, options?: {
-        as?: As;
-    }): JsonSetResult<T, Column, As>;
-    jsonPathQuery<T extends Query, As extends string, Type extends ColumnType>(this: T, ...args: [
-        type: Type,
-        column: ColumnOrJsonMethod<T>,
-        path: string,
-        as: As,
-        options?: {
-            vars?: string;
-            silent?: boolean;
-        }
-    ]): JsonPathQueryResult<T, As, Type>;
-    _jsonPathQuery<T extends Query, As extends string, Type extends ColumnType>(this: T, type: Type, column: ColumnOrJsonMethod<T>, path: string, as: As, options?: {
-        vars?: string;
-        silent?: boolean;
-    }): JsonPathQueryResult<T, As, Type>;
+declare type ThenResult<Res> = (resolve?: (value: Res) => any, reject?: (error: any) => any) => Promise<Res | never>;
+declare const queryMethodByReturnType: Record<QueryReturnType, 'query' | 'arrays'>;
+declare class Then {
+    then(this: Query, resolve?: (result: any) => any, reject?: (error: any) => any): Promise<any>;
 }
+declare const handleResult: CommonQueryData['handleResult'];
+declare const parseResult: (q: Query, returnType: QueryReturnType | undefined, result: QueryResult) => unknown;
+declare const parseRecord: (parsers: ColumnsParsers, row: any) => any;
 
-declare type QueryLogObject = {
-    colors: boolean;
-    beforeQuery(sql: Sql): unknown;
-    afterQuery(sql: Sql, logData: unknown): void;
-    onError(error: Error, sql: Sql, logData: unknown): void;
-};
-declare type QueryLogger = {
-    log(message: string): void;
-    error(message: string): void;
-};
-declare type QueryLogOptions = {
-    log?: boolean | Partial<QueryLogObject>;
-    logger?: QueryLogger;
-};
-declare const logColors: {
-    boldCyanBright: (message: string) => string;
-    boldBlue: (message: string) => string;
-    boldYellow: (message: string) => string;
-    boldMagenta: (message: string) => string;
-    boldRed: (message: string) => string;
-};
-declare const logParamToLogObject: (logger: QueryLogger, log: QueryLogOptions['log']) => QueryLogObject | undefined;
-declare class QueryLog {
-    log<T extends Query>(this: T, log?: boolean): T;
-    _log<T extends Query>(this: T, log?: boolean): T;
+declare type GetArg<T extends QueryBase> = StringKey<keyof T['selectable']> | RawExpression;
+declare type UnwrapRaw<T extends Query, Arg extends GetArg<T>> = Arg extends RawExpression ? Arg['__column'] : Exclude<Arg, RawExpression>;
+declare type GetResult<T extends Query, Arg extends GetArg<T>> = SetQueryReturnsValue<T, UnwrapRaw<T, Arg>>;
+declare type GetOptionalResult<T extends Query, Arg extends GetArg<T>> = SetQueryReturnsValueOptional<T, UnwrapRaw<T, Arg>>;
+declare type getValueKey = typeof getValueKey;
+declare const getValueKey: unique symbol;
+declare class QueryGet {
+    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>;
+    getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetOptionalResult<T, Arg>;
+    _getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetOptionalResult<T, Arg>;
 }
 
 declare type SelectArg<T extends QueryBase> = StringKey<keyof T['selectable']> | (T['relations'] extends Record<string, Relation> ? StringKey<keyof T['relations']> : never) | SelectAsArg<T>;
@@ -654,7 +585,7 @@ declare type SelectResult<T extends Query, Args extends SelectArg<T>[], SelectAs
 }>;
 declare type SelectSubQueryResult<Arg extends Query & {
     [isRequiredRelationKey]?: boolean;
-}> = Arg['returnType'] extends 'all' ? 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']>>;
+}> = 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']>>;
 declare const addParserForRawExpression: (q: Query, key: string | getValueKey, raw: RawExpression) => void;
 declare const addParserForSelectItem: <T extends Query>(q: T, as: string | getValueKey | undefined, key: string, arg: RawExpression<ColumnType<unknown, Operators, unknown>> | Exclude<keyof T["selectable"], number | symbol> | ((q: T) => Query)) => string | RawExpression | Query;
 declare const addParserToQuery: (query: QueryData, key: string | getValueKey, parser: ColumnParser) => void;
@@ -666,203 +597,248 @@ declare class Select {
     _selectAll<T extends Query>(this: T): QuerySelectAll<T>;
 }
 
-interface QueryResultRow {
-    [column: string]: any;
-}
-declare type TypeParsers = Record<number, (input: string) => unknown>;
-declare type QueryInput = string | {
-    text: string;
-    values?: unknown[];
-};
-declare type QueryResult<T extends QueryResultRow = any> = {
-    rowCount: number;
-    rows: T[];
-};
-declare type QueryArraysResult<R extends any[] = any[]> = {
-    rowCount: number;
-    rows: R[];
-    fields: {
-        name: string;
-    }[];
-};
-declare type AdapterOptions = Omit<PoolConfig, 'types'> & {
-    types?: TypeParsers;
-};
-declare class Adapter {
-    types: TypeParsers;
-    pool: Pool;
-    constructor({ types, ...config }: AdapterOptions);
-    query<T extends QueryResultRow = any>(query: QueryInput, types?: TypeParsers): Promise<QueryResult<T>>;
-    arrays<R extends any[] = any[]>(query: QueryInput, types?: TypeParsers): Promise<QueryArraysResult<R>>;
-    transaction<Result>(cb: (adapter: TransactionAdapter) => Promise<Result>): Promise<Result>;
-    close(): Promise<void>;
-}
-declare class TransactionAdapter implements Adapter {
-    pool: Pool;
-    client: PoolClient;
-    types: TypeParsers;
-    constructor(pool: Pool, client: PoolClient, types: TypeParsers);
-    query<T extends QueryResultRow = any>(query: QueryInput, types?: TypeParsers): Promise<QueryResult<T>>;
-    arrays<R extends any[] = any[]>(query: QueryInput, types?: TypeParsers): Promise<QueryArraysResult<R>>;
-    transaction<Result>(cb: (adapter: TransactionAdapter) => Promise<Result>): Promise<Result>;
-    close(): Promise<void>;
-}
-
-declare type ThenResult<Res> = (resolve?: (value: Res) => any, reject?: (error: any) => any) => Promise<Res | never>;
-declare const queryMethodByReturnType: Record<QueryReturnType, 'query' | 'arrays'>;
-declare class Then {
-    then(this: Query, resolve?: (result: any) => any, reject?: (error: any) => any): Promise<any>;
-}
-declare const handleResult: CommonQueryData['handleResult'];
-declare const parseResult: (q: Query, returnType: QueryReturnType, result: QueryResult) => unknown;
-declare const parseRecord: (parsers: ColumnsParsers, row: any) => any;
-
-declare class Transaction {
-    transaction<T extends Query, Result>(this: T, cb: (query: T) => Promise<Result>): Promise<Result>;
-    transacting<T extends Query>(this: T, query: Query): T;
-    _transacting<T extends Query>(this: T, query: Query): T;
-}
-
-declare type UnionArg<T extends Query> = (Omit<Query, 'result'> & {
-    result: T['result'];
-}) | RawExpression;
-declare class Union {
-    union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    unionAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _unionAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    intersect<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _intersect<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    intersectAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _intersectAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    except<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _except<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    exceptAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-    _exceptAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
-}
-
-declare type UpdateData<T extends Query> = {
-    [K in keyof T['type']]?: T['type'][K] | RawExpression;
-} & (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;
+declare type FromArgs<T extends Query> = [
+    first: string | Query | RawExpression | Exclude<keyof T['withData'], symbol | number>,
+    second?: string | {
+        as?: string;
+        only?: boolean;
+    }
+];
+declare type FromResult<T extends Query, Args extends FromArgs<T>> = Args[1] extends string ? SetQueryTableAlias<T, Args[1]> : Args[1] extends {
+    as: string;
+} ? SetQueryTableAlias<T, Args[1]['as']> : Args[0] extends string ? SetQueryTableAlias<T, Args[0]> : Args[0] extends Query ? SetQueryTableAlias<T, AliasOrTable<Args[0]>> : T;
+declare class From {
+    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>;
+}
+
+declare type WhereArg<T extends QueryBase> = (Omit<{
+    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'] | null | ColumnOperators<T['selectable'], K> | RawExpression;
+}, 'NOT' | 'OR' | 'IN' | 'EXISTS'> & {
+    NOT?: MaybeArray<WhereArg<T>>;
+    OR?: MaybeArray<WhereArg<T>>[];
+    IN?: MaybeArray<{
+        columns: (keyof T['selectable'])[];
+        values: unknown[][] | Query | RawExpression;
+    }>;
+    EXISTS?: MaybeArray<JoinArgs<T> | JoinCallbackArg<T>>;
+}) | QueryBase | RawExpression | ((q: WhereQueryBuilder<T>) => WhereQueryBuilder);
+declare type WhereInColumn<T extends QueryBase> = keyof T['selectable'] | [keyof T['selectable'], ...(keyof T['selectable'])[]];
+declare type WhereInValues<T extends QueryBase, Column extends WhereInColumn<T>> = Column extends keyof T['selectable'] ? T['selectable'][Column]['column']['type'][] | Query | RawExpression : ({
+    [I in keyof Column]: Column[I] extends keyof T['selectable'] ? T['selectable'][Column[I]]['column']['type'] : never;
+} & {
+    length: Column extends {
+        length: number;
+    } ? Column['length'] : never;
+})[] | Query | RawExpression;
+declare type WhereResult<T extends QueryBase> = T & {
+    hasWhere: true;
 };
-declare type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> = {
-    disconnect: boolean;
-} | {
-    set: WhereArg<Rel['model']>;
-} | {
-    delete: boolean;
-} | {
-    update: UpdateData<Rel['model']>;
-} | {
-    create: InsertData<Rel['nestedCreateQuery']>;
-} | (T['returnType'] extends 'all' ? never : {
-    upsert: {
-        update: UpdateData<Rel['model']>;
-        create: InsertData<Rel['nestedCreateQuery']>;
-    };
-});
-declare type UpdateHasOneData<T extends Query, Rel extends HasOneRelation> = {
-    disconnect: boolean;
-} | {
-    delete: boolean;
-} | {
-    update: UpdateData<Rel['model']>;
-} | (T['returnType'] extends 'all' ? never : {
-    set: WhereArg<Rel['model']>;
-} | {
-    upsert: {
-        update: UpdateData<Rel['model']>;
-        create: InsertData<Rel['nestedCreateQuery']>;
-    };
-} | {
-    create: InsertData<Rel['nestedCreateQuery']>;
-});
-declare type UpdateHasManyData<T extends Query, Rel extends HasManyRelation> = {
-    disconnect?: MaybeArray<WhereArg<Rel['model']>>;
-    delete?: MaybeArray<WhereArg<Rel['model']>>;
-    update?: {
-        where: MaybeArray<WhereArg<Rel['model']>>;
-        data: UpdateData<Rel['model']>;
-    };
-} & (T['returnType'] extends 'all' ? EmptyObject : {
-    set?: MaybeArray<WhereArg<Rel['model']>>;
-    create?: InsertData<Rel['nestedCreateQuery']>[];
-});
-declare type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
-    disconnect?: MaybeArray<WhereArg<Rel['model']>>;
-    set?: MaybeArray<WhereArg<Rel['model']>>;
-    delete?: MaybeArray<WhereArg<Rel['model']>>;
-    update?: {
-        where: MaybeArray<WhereArg<Rel['model']>>;
-        data: UpdateData<Rel['model']>;
-    };
-    create?: InsertData<Rel['nestedCreateQuery']>[];
+declare type WhereInArg<T extends Pick<Query, 'selectable'>> = {
+    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'][] | Query | RawExpression;
 };
-declare type UpdateArgs<T extends Query, ForceAll extends boolean> = (T['hasWhere'] extends true ? true : ForceAll) extends true ? [update: UpdateData<T>] : [update: UpdateData<T>, forceAll: true];
-declare type UpdateRawArgs<T extends Query, ForceAll extends boolean> = (T['hasWhere'] extends true ? true : ForceAll) extends true ? [update: RawExpression] : [update: RawExpression, forceAll: true];
-declare type UpdateResult<T extends Query> = T['hasSelect'] extends false ? SetQueryReturnsRowCount<T> : T;
-declare type ChangeCountArg<T extends Query> = keyof T['shape'] | Partial<Record<keyof T['shape'], number>>;
-declare class Update {
-    update<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
-    _update<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
-    updateRaw<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateRawArgs<T, ForceAll>): UpdateResult<T>;
-    _updateRaw<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateRawArgs<T, ForceAll>): UpdateResult<T>;
-    updateOrThrow<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
-    _updateOrThrow<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
-    increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
-    _increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
-    decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
-    _decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+declare const addWhere: <T extends Where>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const addWhereNot: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const addOr: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const addOrNot: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const addWhereIn: <T extends QueryBase>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | RawExpression | undefined, not?: boolean) => WhereResult<T>;
+declare abstract class Where implements QueryBase {
+    abstract clone<T extends this>(this: T): T;
+    abstract selectable: SelectableBase;
+    abstract shape: ColumnsShape;
+    abstract relations: RelationsBase;
+    abstract withData: WithDataBase;
+    abstract __model: Query;
+    query: QueryData;
+    table?: string;
+    tableAlias?: string;
+    where<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _where<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    whereNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _whereNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    and<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _and<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    andNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _andNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): T;
+    whereIn<T extends Where>(this: T, arg: WhereInArg<T>): T;
+    _whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _whereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    orWhereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _orWhereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    whereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    whereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _whereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _whereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    whereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    whereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _whereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    _whereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    orWhereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    orWhereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _orWhereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    _orWhereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    whereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    whereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _whereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    _whereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    orWhereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    orWhereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _orWhereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    _orWhereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+}
+declare class WhereQueryBuilder<Q extends QueryBase = QueryBase> extends Where implements QueryBase {
+    query: QueryData;
+    selectable: Q['selectable'];
+    shape: Q['shape'];
+    relations: Q['relations'];
+    __model: Query;
+    withData: {};
+    constructor(q: QueryBase | string, shape: ColumnsShape);
+    clone<T extends this>(this: T): T;
+}
+
+declare 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;
+declare type JoinArgs<T extends QueryBase, Q extends Query = Query, R extends keyof T['relations'] = keyof T['relations'], W extends keyof T['withData'] = keyof T['withData']> = [relation: R] | [
+    query: Q,
+    conditions: Record<Selectable<Q>, Selectable<T> | RawExpression> | RawExpression
+] | [
+    withAlias: W,
+    conditions: Record<WithSelectable<T, W>, Selectable<T> | RawExpression> | RawExpression
+] | [
+    query: Q,
+    leftColumn: Selectable<Q> | RawExpression,
+    rightColumn: Selectable<T> | RawExpression
+] | [
+    withAlias: W,
+    leftColumn: WithSelectable<T, W> | RawExpression,
+    rightColumn: Selectable<T> | RawExpression
+] | [
+    query: Q,
+    leftColumn: Selectable<Q> | RawExpression,
+    op: string,
+    rightColumn: Selectable<T> | RawExpression
+] | [
+    withAlias: W,
+    leftColumn: WithSelectable<T, W> | RawExpression,
+    op: string,
+    rightColumn: Selectable<T> | RawExpression
+];
+declare type JoinResult<T extends Query, Args extends JoinArgs<T>, A extends Query | keyof T['relations'] = Args[0]> = AddQueryJoinedTable<T, A extends Query ? A : T['relations'] extends Record<string, Relation> ? A extends keyof T['relations'] ? T['relations'][A]['model'] : A extends keyof T['withData'] ? T['withData'][A] extends WithDataItem ? {
+    table: T['withData'][A]['table'];
+    tableAlias: undefined;
+    result: T['withData'][A]['shape'];
+} : never : never : never>;
+declare type JoinCallbackArg<T extends QueryBase> = Query | keyof T['withData'] | keyof T['relations'];
+declare type JoinCallback<T extends QueryBase, Arg extends JoinCallbackArg<T>> = (q: OnQueryBuilder<T, Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
+    query: QueryData;
+    table: T['withData'][Arg]['table'];
+    tableAlias: undefined;
+    clone(): QueryBase;
+    selectable: {
+        [K in keyof T['withData'][Arg]['shape'] as `${T['withData'][Arg]['table']}.${StringKey<K>}`]: {
+            as: StringKey<K>;
+            column: T['withData'][Arg]['shape'][K];
+        };
+    };
+    shape: T['withData'][Arg]['shape'];
+    __model: Query;
+    relations: RelationsBase;
+    withData: WithDataBase;
+} : never : Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['model'] : never : never>) => OnQueryBuilder;
+declare type JoinCallbackResult<T extends Query, Arg extends JoinCallbackArg<T>> = AddQueryJoinedTable<T, Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['model'] : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
+    table: T['withData'][Arg]['table'];
+    tableAlias: undefined;
+    result: T['withData'][Arg]['shape'];
+} : never : never : never>;
+declare class Join {
+    join<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    join<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _join<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _join<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    innerJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    innerJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _innerJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _innerJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    leftJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    leftJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _leftJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _leftJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    leftOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    leftOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _leftOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _leftOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    rightJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    rightJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _rightJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _rightJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    rightOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    rightOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _rightOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _rightOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    fullOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    fullOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _fullOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _fullOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
 }
-
-declare type UpsertData<T extends Query> = {
-    update: UpdateData<T>;
-    create: InsertData<T>;
-};
-declare type UpsertResult<T extends Query> = T['hasSelect'] extends true ? SetQueryReturnsOne<T> : SetQueryReturnsVoid<T>;
-declare type UpsertThis = WhereResult<Query> & {
-    returnType: 'one' | 'oneOrThrow';
-};
-declare class QueryUpsert {
-    upsert<T extends UpsertThis>(this: T, data: UpsertData<T>): UpsertResult<T>;
-    _upsert<T extends UpsertThis>(this: T, data: UpsertData<T>): UpsertResult<T>;
+declare 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 | string, joinTo: QueryBase | string, ...on: OnArgs<QueryBase>) => T;
+declare const pushQueryOrOn: typeof pushQueryOn;
+declare const addQueryOn: typeof pushQueryOrOn;
+declare const addQueryOrOn: typeof pushQueryOrOn;
+declare 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 WhereQueryBuilder<Omit<J, 'selectable'> & {
+    selectable: Omit<S['selectable'], keyof S['shape']> & J['selectable'];
+}> implements QueryBase {
+    joinTo: QueryBase;
+    constructor(q: QueryBase | string, shape: ColumnsShape, joinTo: QueryBase);
+    on<T extends this>(this: T, ...args: OnArgs<T>): T;
+    _on<T extends this>(this: T, ...args: OnArgs<T>): T;
+    orOn<T extends this>(this: T, ...args: OnArgs<T>): T;
+    _orOn<T extends this>(this: T, ...args: OnArgs<T>): T;
+    onJsonPathEquals<T extends this>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
+    _onJsonPathEquals<T extends this>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
 }
 
-declare function timestamps<T extends ColumnType>(this: {
-    timestamp(): T;
-}): {
-    createdAt: T & {
-        hasDefault: true;
-    };
-    updatedAt: T & {
-        hasDefault: true;
-    };
-};
-
 declare type DbTableOptions = {
     schema?: string;
 } & QueryLogOptions;
 interface Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends Query['relations'] = Query['relations']> extends QueryMethods {
     new (adapter: Adapter, queryBuilder: Db, table?: Table, shape?: Shape, options?: DbTableOptions): this;
     adapter: Adapter;
+    columns: (keyof ColumnShapeOutput<Shape>)[];
     queryBuilder: Db;
     whereQueryBuilder: Query['whereQueryBuilder'];
+    onQueryBuilder: Query['onQueryBuilder'];
     table: Table;
     shape: Shape;
     schema: TableSchema<Shape>;
     type: ColumnShapeOutput<Shape>;
     inputType: ColumnShapeInput<Shape>;
-    returnType: 'all';
-    then: ThenResult<Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]>;
     query: QueryData;
-    columns: (keyof ColumnShapeOutput<Shape>)[];
-    defaultSelectColumns: DefaultSelectColumns<Shape>;
-    columnsParsers?: ColumnsParsers;
     result: Pick<Shape, DefaultSelectColumns<Shape>[number]>;
-    hasSelect: false;
+    hasSelect: Query['hasSelect'];
     hasWhere: boolean;
     selectable: {
         [K in keyof Shape]: {
@@ -875,588 +851,363 @@ interface Db<Table extends string | undefined = undefined, Shape extends Columns
             column: Shape[K];
         };
     };
+    returnType: Query['returnType'];
+    then: ThenResult<Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]>;
     tableAlias: undefined;
-    windows: PropertyKey[];
-    withData: Query['withData'];
     joinedTables: Query['joinedTables'];
+    windows: Query['windows'];
+    defaultSelectColumns: DefaultSelectColumns<Shape>;
+    columnsParsers?: ColumnsParsers;
     relations: Relations;
+    withData: Query['withData'];
     [defaultsKey]: Record<{
         [K in keyof Shape]: Shape[K]['hasDefault'] extends true ? K : never;
     }[keyof Shape], true>;
 }
-declare class Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends Query['relations'] = Query['relations']> implements Query {
-    adapter: Adapter;
-    queryBuilder: Db;
-    table: Table;
-    shape: Shape;
-    whereQueryBuilder: typeof WhereQueryBuilder;
-    onQueryBuilder: typeof OnQueryBuilder;
-    constructor(adapter: Adapter, queryBuilder: Db, table: Table, shape: Shape, options: DbTableOptions);
-}
-declare type DbResult<CT extends ColumnTypesBase> = Db & {
-    <Table extends string, Shape extends ColumnsShape = ColumnsShape>(table: Table, shape?: ((t: CT) => Shape) | Shape, options?: DbTableOptions): Db<Table, Shape>;
-    adapter: Adapter;
-    close: Adapter['close'];
-};
-declare type DbOptions<CT extends ColumnTypesBase = ColumnTypes> = ({
-    adapter: Adapter;
-} | Omit<AdapterOptions, 'log'>) & QueryLogOptions & {
-    columnTypes?: CT;
-};
-declare const createDb: <CT extends ColumnTypesBase = {
-    smallint: () => SmallIntColumn;
-    integer: () => IntegerColumn;
-    bigint: () => BigIntColumn;
-    numeric: <Precision extends number | undefined = undefined, Scale extends number | undefined = undefined>(precision?: Precision | undefined, scale?: Scale | undefined) => DecimalColumn<Precision, Scale>;
-    decimal: <Precision_1 extends number | undefined = undefined, Scale_1 extends number | undefined = undefined>(precision?: Precision_1 | undefined, scale?: Scale_1 | undefined) => DecimalColumn<Precision_1, Scale_1>;
-    real: () => RealColumn;
-    doublePrecision: () => DoublePrecisionColumn;
-    smallSerial: () => SmallSerialColumn;
-    serial: () => SerialColumn;
-    bigSerial: () => BigSerialColumn;
-    money: () => MoneyColumn;
-    varchar: <Limit extends number | undefined = undefined>(limit?: Limit | undefined) => VarCharColumn<Limit>;
-    char: <Limit_1 extends number | undefined = undefined>(limit?: Limit_1 | undefined) => CharColumn<Limit_1>;
-    text: () => TextColumn;
-    string: () => TextColumn;
-    bytea: () => ByteaColumn;
-    date: () => DateColumn;
-    timestamp: <Precision_2 extends number | undefined = undefined>(precision?: Precision_2 | undefined) => TimestampColumn<Precision_2>;
-    timestampWithTimeZone: <Precision_3 extends number | undefined = undefined>(precision?: Precision_3 | undefined) => TimestampWithTimeZoneColumn<Precision_3>;
-    time: <Precision_4 extends number | undefined = undefined>(precision?: Precision_4 | undefined) => TimeColumn<Precision_4>;
-    timeWithTimeZone: <Precision_5 extends number | undefined = undefined>(precision?: Precision_5 | undefined) => TimeWithTimeZoneColumn<Precision_5>;
-    interval: <Fields extends string | undefined = undefined, Precision_6 extends number | undefined = undefined>(fields?: Fields | undefined, precision?: Precision_6 | undefined) => IntervalColumn<Fields, Precision_6>;
-    boolean: () => BooleanColumn;
-    enum: <U extends string, T extends [U, ...U[]]>(dataType: string, type: T) => EnumColumn<U, T>;
-    point: () => PointColumn;
-    line: () => LineColumn;
-    lseg: () => LsegColumn;
-    box: () => BoxColumn;
-    path: () => PathColumn;
-    polygon: () => PolygonColumn;
-    circle: () => CircleColumn;
-    cidr: () => CidrColumn;
-    inet: () => InetColumn;
-    macaddr: () => MacAddrColumn;
-    macaddr8: () => MacAddr8Column;
-    bit: <Length extends number>(length: Length) => BitColumn<Length>;
-    bitVarying: <Length_1 extends number | undefined = undefined>(length?: Length_1 | undefined) => BitVaryingColumn<Length_1 | undefined>;
-    tsvector: () => TsVectorColumn;
-    tsquery: () => TsQueryColumn;
-    uuid: () => UUIDColumn;
-    xml: () => XMLColumn;
-    json: <Type extends JSONTypeAny>(schemaOrFn: Type | ((j: {
-        set: <Value extends JSONTypeAny>(valueType: Value) => JSONSet<Value>;
-        tuple: <T_1 extends [] | JSONTupleItems, Rest extends JSONTypeAny | null = null>(items: T_1, rest?: Rest) => JSONTuple<T_1, Rest>;
-        union: <T_2 extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]>(types: T_2) => JSONUnion<T_2>;
-        any: () => JSONAny;
-        bigint: () => JSONBigInt;
-        boolean: () => JSONBoolean;
-        date: () => JSONDate;
-        nan: () => JSONNaN;
-        never: () => JSONNever;
-        null: () => JSONNull;
-        number: () => JSONNumber;
-        string: () => JSONString;
-        undefined: () => JSONUndefined;
-        unknown: () => JSONUnknown;
-        void: () => JSONVoid;
-        array: <Type_1 extends JSONTypeAny>(element: Type_1) => JSONArray<Type_1, "many">;
-        discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends Primitive, Types extends [JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]>;
-        enum: <U_1 extends string, T_3 extends [U_1, ...U_1[]]>(options: T_3) => JSONEnum<U_1, T_3>;
-        instanceOf: <T_4 extends new (...args: any[]) => any>(cls: T_4) => JSONInstanceOf<T_4>;
-        intersection: <Left extends JSONTypeAny, Right extends JSONTypeAny>(left: Left, right: Right) => JSONIntersection<Left, Right>;
-        lazy: <T_5 extends JSONTypeAny>(fn: () => T_5) => JSONLazy<T_5>;
-        literal: <T_6 extends Primitive>(value: T_6) => JSONLiteral<T_6>;
-        map: <Key extends JSONTypeAny, Value_1 extends JSONTypeAny>(keyType: Key, valueType: Value_1) => JSONMap<Key, Value_1>;
-        nativeEnum: <T_7 extends EnumLike>(givenEnum: T_7) => JSONNativeEnum<T_7>;
-        nullable: <T_8 extends JSONTypeAny>(type: T_8) => JSONNullable<T_8>;
-        nullish: <T_9 extends JSONTypeAny>(type: T_9) => JSONNullish<T_9>;
-        object: <T_10 extends JSONObjectShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends JSONTypeAny = JSONTypeAny>(shape: T_10) => JSONObject<T_10, UnknownKeys, Catchall, JSONTypeAny extends Catchall ? addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }> extends infer T_11 ? { [k in keyof T_11]: addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }>[k]; } : never : (addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }> extends infer T_11 ? { [k in keyof T_11]: addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }>[k]; } : never) & {
-            [k: string]: Catchall["type"];
-        } extends infer T_12 ? { [k_2 in keyof T_12]: ((addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }> extends infer T_11 ? { [k in keyof T_11]: addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }>[k]; } : never) & {
-            [k: string]: Catchall["type"];
-        })[k_2]; } : never>;
-        optional: <T_13 extends JSONTypeAny>(type: T_13) => JSONOptional<T_13>;
-        record: typeof record;
-    }) => Type)) => JSONColumn<Type>;
-    jsonText: () => JSONTextColumn;
-    array: <Item extends ColumnType<unknown, Operators, unknown>>(item: Item) => ArrayColumn<Item>;
-    timestamps: typeof timestamps;
-    primaryKey(columns: string[], options?: {
-        name?: string | undefined;
-    } | undefined): {};
-    index(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
-    unique(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
-    foreignKey: {
-        <Model extends ForeignKeyModelWithColumns, Columns extends [Exclude<keyof InstanceType<Model>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<Model>["columns"]["shape"], number | symbol>[]]>(columns: string[], fn: () => Model, foreignColumns: Columns, options?: ForeignKeyOptions | undefined): {};
-        <Table extends string, Columns_1 extends [string, ...string[]]>(columns: string[], table: Table, foreignColumns: Columns_1, options?: ForeignKeyOptions | undefined): {};
-    };
-}>({ log, logger, columnTypes: ct, ...options }: DbOptions<CT>) => DbResult<CT>;
-
-declare type WithArgsOptions = Omit<WithOptions, 'columns'> & {
-    columns?: boolean | string[];
-};
-declare type WithArgs = [string, ColumnsShape, RawExpression] | [string, WithArgsOptions, ColumnsShape, RawExpression] | [string, Query | ((qb: Db) => Query)] | [string, WithArgsOptions, Query | ((qb: Db) => Query)];
-declare type WithShape<Args extends WithArgs> = Args[1] extends Query ? Args[1]['result'] : Args[1] extends (qb: Db) => Query ? ReturnType<Args[1]>['result'] : Args[2] extends Query ? Args[2]['result'] : Args[2] extends (qb: Db) => Query ? ReturnType<Args[2]>['result'] : Args[1] extends ColumnsShape ? Args[1] : Args[2] extends ColumnsShape ? Args[2] : Args[2] extends (t: ColumnTypes) => ColumnsShape ? ReturnType<Args[2]> : never;
-declare type WithResult<T extends Query, Args extends WithArgs, Shape extends ColumnsShape> = AddQueryWith<T, {
-    table: Args[0];
-    shape: Shape;
-    type: ColumnShapeOutput<Shape>;
-}>;
-declare class With {
-    with<T extends Query, Args extends WithArgs, Shape extends ColumnsShape = WithShape<Args>>(this: T, ...args: Args): WithResult<T, Args, Shape>;
-    _with<T extends Query, Args extends WithArgs, Shape extends ColumnsShape = WithShape<Args>>(this: T, ...args: Args): WithResult<T, Args, Shape>;
-}
-
-declare type NestedInsertOneItem = {
-    create?: Record<string, unknown>;
-    connect?: WhereArg<QueryBase>;
-    connectOrCreate?: {
-        where: WhereArg<QueryBase>;
-        create: Record<string, unknown>;
-    };
-};
-declare type NestedInsertManyItems = {
-    create?: Record<string, unknown>[];
-    connect?: WhereArg<QueryBase>[];
-    connectOrCreate?: {
-        where: WhereArg<QueryBase>;
-        create: Record<string, unknown>;
-    }[];
-};
-declare type NestedInsertItem = NestedInsertOneItem | NestedInsertManyItems;
-declare type BelongsToNestedInsert = (query: Query, relationData: NestedInsertOneItem[]) => Promise<Record<string, unknown>[]>;
-declare type HasOneNestedInsert = (query: Query, data: [
-    selfData: Record<string, unknown>,
-    relationData: NestedInsertOneItem
-][]) => Promise<void>;
-declare type HasManyNestedInsert = (query: Query, data: [
-    selfData: Record<string, unknown>,
-    relationData: NestedInsertManyItems
-][]) => Promise<void>;
-declare type NestedUpdateOneItem = {
-    disconnect?: boolean;
-    set?: WhereArg<QueryBase>;
-    delete?: boolean;
-    update?: UpdateData<Query>;
-    upsert?: {
-        update: UpdateData<Query>;
-        create: Record<string, unknown>;
-    };
-    create: Record<string, unknown>;
-};
-declare type NestedUpdateManyItems = {
-    disconnect?: MaybeArray<WhereArg<QueryBase>>;
-    set?: MaybeArray<WhereArg<QueryBase>>;
-    delete?: MaybeArray<WhereArg<QueryBase>>;
-    update?: {
-        where: MaybeArray<WhereArg<QueryBase>>;
-        data: UpdateData<Query>;
-    };
-    create: Record<string, unknown>[];
-};
-declare type NestedUpdateItem = NestedUpdateOneItem | NestedUpdateManyItems;
-declare type BelongsToNestedUpdate = (q: Query, update: Record<string, unknown>, params: NestedUpdateOneItem, state: {
-    updateLater?: Record<string, unknown>;
-    updateLaterPromises?: Promise<void>[];
-}) => boolean;
-declare type HasOneNestedUpdate = (query: Query, data: Record<string, unknown>[], relationData: NestedUpdateOneItem) => Promise<void>;
-declare type HasManyNestedUpdate = (query: Query, data: Record<string, unknown>[], relationData: NestedUpdateManyItems) => Promise<void>;
-declare type BaseRelation = {
-    type: string;
-    key: string;
-    model: QueryWithTable;
-    query: QueryWithTable;
-    joinQuery(fromQuery: QueryBase, toQuery: Query): Query;
-    nestedCreateQuery: Query;
-    nestedInsert?: BelongsToNestedInsert | HasOneNestedInsert | HasManyNestedInsert;
-    nestedUpdate?: BelongsToNestedUpdate | HasOneNestedUpdate | HasManyNestedUpdate;
-    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;
-    };
-}
-declare type Relation = BelongsToRelation | HasOneRelation | HasManyRelation | HasAndBelongsToManyRelation;
-declare type RelationsBase = Record<never, Relation>;
-declare type relationQueryKey = typeof relationQueryKey;
-declare const relationQueryKey: unique symbol;
-declare type isRequiredRelationKey = typeof isRequiredRelationKey;
-declare const isRequiredRelationKey: unique symbol;
-declare type RelationQueryBase = Query & {
-    [relationQueryKey]: string;
-    [isRequiredRelationKey]: boolean;
-};
-declare type RelationQuery<RelationName extends PropertyKey = string, Params extends Record<string, unknown> = never, Populate extends string = never, T extends Query = Query, Required extends boolean = boolean, Q extends RelationQueryBase = Omit<T, 'tableAlias'> & {
-    tableAlias: RelationName extends string ? RelationName : never;
-    [isRequiredRelationKey]: Required;
-    [relationQueryKey]: string;
-}> = ((params: Params) => Q & {
-    [defaultsKey]: Record<Populate, true>;
-}) & Q;
-
-declare type Sql = {
-    text: string;
-    values: unknown[];
-};
-declare const queryKeysOfNotSimpleQuery: (keyof SelectQueryData)[];
-declare type CommonQueryData = {
+declare class Db<Table extends string | undefined = undefined, Shape extends ColumnsShape = Record<string, never>, Relations extends Query['relations'] = Query['relations']> implements Query {
     adapter: Adapter;
-    handleResult(q: Query, result: QueryResult): Promise<unknown>;
-    returnType: QueryReturnType;
-    [relationQueryKey]?: string;
-    inTransaction?: boolean;
-    wrapInTransaction?: boolean;
-    throwOnNotFound?: boolean;
-    take?: boolean;
-    with?: WithItem[];
-    withShapes?: Record<string, ColumnsShape>;
-    schema?: string;
-    select?: SelectItem[];
-    as?: string;
-    from?: string | Query | RawExpression;
-    and?: WhereItem[];
-    or?: WhereItem[][];
-    coalesceValue?: unknown | RawExpression;
-    parsers?: ColumnsParsers;
-    notFoundDefault?: unknown;
-    defaults?: Record<string, unknown>;
-    beforeQuery?: BeforeCallback[];
-    afterQuery?: AfterCallback[];
-    log?: QueryLogObject;
-    logger: QueryLogger;
-    [toSqlCacheKey]?: Sql;
-};
-declare type SelectQueryData = CommonQueryData & {
-    type: undefined;
-    distinct?: Expression[];
-    fromOnly?: boolean;
-    join?: JoinItem[];
-    joinedParsers?: Record<string, ColumnsParsers>;
-    group?: (string | RawExpression)[];
-    having?: HavingItem[];
-    havingOr?: HavingItem[][];
-    window?: WindowItem[];
-    union?: {
-        arg: UnionItem;
-        kind: UnionKind;
-        wrap?: boolean;
-    }[];
-    order?: OrderItem[];
-    limit?: number;
-    offset?: number;
-    for?: {
-        type: 'UPDATE' | 'NO KEY UPDATE' | 'SHARE' | 'KEY SHARE';
-        tableNames?: string[] | RawExpression;
-        mode?: 'NO WAIT' | 'SKIP LOCKED';
-    };
-};
-declare type InsertQueryData = CommonQueryData & {
-    type: 'insert';
-    columns: string[];
-    values: unknown[][] | RawExpression;
-    using?: JoinItem[];
-    join?: JoinItem[];
-    joinedParsers?: Record<string, ColumnsParsers>;
-    onConflict?: {
-        type: 'ignore';
-        expr?: OnConflictItem;
-    } | {
-        type: 'merge';
-        expr?: OnConflictItem;
-        update?: OnConflictMergeUpdate;
-    };
-    beforeInsert?: BeforeCallback[];
-    afterInsert?: AfterCallback[];
-};
-declare type UpdateQueryDataObject = Record<string, RawExpression | {
-    op: string;
-    arg: unknown;
-} | unknown>;
-declare type UpdatedAtDataInjector = (data: UpdateQueryDataItem[]) => UpdateQueryDataItem | void;
-declare type UpdateQueryDataItem = UpdateQueryDataObject | RawExpression | UpdatedAtDataInjector;
-declare type UpdateQueryData = CommonQueryData & {
-    type: 'update';
-    updateData: UpdateQueryDataItem[];
-    beforeUpdate?: BeforeCallback[];
-    afterUpdate?: AfterCallback[];
-};
-declare type DeleteQueryData = CommonQueryData & {
-    type: 'delete';
-    join?: JoinItem[];
-    joinedParsers?: Record<string, ColumnsParsers>;
-    beforeDelete?: BeforeCallback[];
-    afterDelete?: AfterCallback[];
-};
-declare type TruncateQueryData = CommonQueryData & {
-    type: 'truncate';
-    restartIdentity?: boolean;
-    cascade?: boolean;
+    queryBuilder: Db;
+    table: Table;
+    shape: Shape;
+    whereQueryBuilder: typeof WhereQueryBuilder;
+    onQueryBuilder: typeof OnQueryBuilder;
+    constructor(adapter: Adapter, queryBuilder: Db, table: Table, shape: Shape, options: DbTableOptions);
+}
+declare type DbResult<CT extends ColumnTypesBase> = Db & {
+    <Table extends string, Shape extends ColumnsShape = ColumnsShape>(table: Table, shape?: ((t: CT) => Shape) | Shape, options?: DbTableOptions): Db<Table, Shape>;
+    adapter: Adapter;
+    close: Adapter['close'];
 };
-declare type ColumnInfoQueryData = CommonQueryData & {
-    type: 'columnInfo';
-    column?: string;
+declare type DbOptions<CT extends ColumnTypesBase> = ({
+    adapter: Adapter;
+} | Omit<AdapterOptions, 'log'>) & QueryLogOptions & {
+    columnTypes: CT;
 };
-declare type QueryData = SelectQueryData | InsertQueryData | UpdateQueryData | DeleteQueryData | TruncateQueryData | ColumnInfoQueryData;
-declare type WithItem = [
-    as: string,
-    options: WithOptions,
-    query: Query | RawExpression
-];
-declare type WithOptions = {
-    columns?: string[];
-    recursive?: true;
-    materialized?: true;
-    notMaterialized?: true;
+declare const createDb: <CT extends ColumnTypesBase>({ log, logger, columnTypes: ct, ...options }: DbOptions<CT>) => DbResult<CT>;
+
+declare type WithArgsOptions = Omit<WithOptions, 'columns'> & {
+    columns?: boolean | string[];
 };
-declare type JsonItem<As extends string = string, Type extends ColumnType = ColumnType> = {
-    __json: [
-        kind: 'set',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
+declare type WithArgs = [string, ColumnsShape, RawExpression] | [string, WithArgsOptions, ColumnsShape, RawExpression] | [string, Query | ((qb: Db) => Query)] | [string, WithArgsOptions, Query | ((qb: Db) => Query)];
+declare type WithShape<Args extends WithArgs> = Args[1] extends Query ? Args[1]['result'] : Args[1] extends (qb: Db) => Query ? ReturnType<Args[1]>['result'] : Args[2] extends Query ? Args[2]['result'] : Args[2] extends (qb: Db) => Query ? ReturnType<Args[2]>['result'] : Args[1] extends ColumnsShape ? Args[1] : Args[2] extends ColumnsShape ? Args[2] : Args[2] extends (t: ColumnTypes) => ColumnsShape ? ReturnType<Args[2]> : never;
+declare type WithResult<T extends Query, Args extends WithArgs, Shape extends ColumnsShape> = AddQueryWith<T, {
+    table: Args[0];
+    shape: Shape;
+    type: ColumnShapeOutput<Shape>;
+}>;
+declare class With {
+    with<T extends Query, Args extends WithArgs, Shape extends ColumnsShape = WithShape<Args>>(this: T, ...args: Args): WithResult<T, Args, Shape>;
+    _with<T extends Query, Args extends WithArgs, Shape extends ColumnsShape = WithShape<Args>>(this: T, ...args: Args): WithResult<T, Args, Shape>;
+}
+
+declare type UnionArg<T extends Query> = (Omit<Query, 'result'> & {
+    result: T['result'];
+}) | RawExpression;
+declare class Union {
+    union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    unionAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _unionAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    intersect<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _intersect<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    intersectAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _intersectAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    except<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _except<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    exceptAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _exceptAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+}
+
+declare type JsonColumnName<T extends Pick<Query, 'selectable'>> = StringKey<{
+    [K in keyof T['selectable']]: T['selectable'][K]['column']['dataType'] extends 'jsonb' ? K : never;
+}[keyof T['selectable']]>;
+declare type ColumnOrJsonMethod<T extends Query> = JsonColumnName<T> | JsonItem;
+declare type JsonSetResult<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string, Type extends ColumnType = Column extends keyof T['shape'] ? T['shape'][Column] : Column extends JsonItem ? Column['__json'][2] : ColumnType> = JsonItem<As, Type> & (Type extends ColumnType ? AddQuerySelect<T, Record<As, Type>> : T);
+declare type JsonPathQueryResult<T extends Query, As extends string, Type extends ColumnType> = JsonItem & AddQuerySelect<T, {
+    [K in As]: Type;
+}>;
+declare class Json {
+    json<T extends Query>(this: T): SetQueryReturnsValueOptional<T, StringColumn>;
+    _json<T extends Query>(this: T): SetQueryReturnsValueOptional<T, StringColumn>;
+    jsonSet<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, value: unknown, options?: {
+        as?: As;
+        createIfMissing?: boolean;
+    }): JsonSetResult<T, Column, As>;
+    _jsonSet<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, value: unknown, options?: {
+        as?: As;
+        createIfMissing?: boolean;
+    }): JsonSetResult<T, Column, As>;
+    jsonInsert<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, ...args: [
+        column: Column,
         path: Array<string | number>,
         value: unknown,
         options?: {
-            createIfMissing?: boolean;
+            as?: As;
+            insertAfter?: boolean;
         }
-    ] | [
-        kind: 'insert',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
+    ]): JsonSetResult<T, Column, As>;
+    _jsonInsert<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, value: unknown, options?: {
+        as?: As;
+        insertAfter?: boolean;
+    }): JsonSetResult<T, Column, As>;
+    jsonRemove<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, ...args: [
+        column: Column,
         path: Array<string | number>,
-        value: unknown,
         options?: {
-            insertAfter?: boolean;
+            as?: As;
         }
-    ] | [
-        kind: 'remove',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
-        path: Array<string | number>
-    ] | [
-        kind: 'pathQuery',
-        as: As,
+    ]): JsonSetResult<T, Column, As>;
+    _jsonRemove<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, options?: {
+        as?: As;
+    }): JsonSetResult<T, Column, As>;
+    jsonPathQuery<T extends Query, As extends string, Type extends ColumnType>(this: T, ...args: [
         type: Type,
-        column: string | JsonItem,
+        column: ColumnOrJsonMethod<T>,
         path: string,
+        as: As,
         options?: {
             vars?: string;
             silent?: boolean;
         }
-    ];
+    ]): JsonPathQueryResult<T, As, Type>;
+    _jsonPathQuery<T extends Query, As extends string, Type extends ColumnType>(this: T, type: Type, column: ColumnOrJsonMethod<T>, path: string, as: As, options?: {
+        vars?: string;
+        silent?: boolean;
+    }): JsonPathQueryResult<T, As, Type>;
+}
+
+declare type InsertData<T extends Query, DefaultKeys extends PropertyKey = keyof T[defaultsKey], Data = SetOptional<T['inputType'], DefaultKeys>> = [keyof T['relations']] extends [never] ? Data : OmitBelongsToForeignKeys<T['relations'], Data> & InsertRelationData<T>;
+declare type OmitBelongsToForeignKeys<R extends RelationsBase, Data> = Omit<Data, {
+    [K in keyof R]: R[K] extends BelongsToRelation ? R[K]['options']['foreignKey'] : never;
+}[keyof R]>;
+declare type InsertRelationData<T extends Query> = {
+    [K in keyof T['relations']]: T['relations'][K] extends BelongsToRelation ? InsertBelongsToData<T, K, T['relations'][K]> : T['relations'][K] extends HasOneRelation ? InsertHasOneData<T, K, T['relations'][K]> : T['relations'][K] extends HasManyRelation | HasAndBelongsToManyRelation ? InsertHasManyData<T, K, T['relations'][K]> : EmptyObject;
+}[keyof T['relations']];
+declare type InsertBelongsToData<T extends Query, Key extends keyof T['relations'], Rel extends BelongsToRelation> = SetOptional<{
+    [K in Rel['options']['foreignKey']]: Rel['options']['foreignKey'] extends keyof T['inputType'] ? T['inputType'][Rel['options']['foreignKey']] : never;
+}, keyof T[defaultsKey]> | {
+    [K in Key]: {
+        create: InsertData<Rel['nestedCreateQuery']>;
+        connect?: never;
+        connectOrCreate?: never;
+    } | {
+        create?: never;
+        connect: WhereArg<Rel['model']>;
+        connectOrCreate?: never;
+    } | {
+        create?: never;
+        connect?: never;
+        connectOrCreate: {
+            where: WhereArg<Rel['model']>;
+            create: InsertData<Rel['nestedCreateQuery']>;
+        };
+    };
 };
-declare type SelectItem = string | RelationQuery | AggregateItem | {
-    selectAs: Record<string, string | Query | RawExpression>;
-} | SelectFunctionItem | JsonItem | RawExpression;
-declare type SelectFunctionItem = {
-    function: string;
-    arguments: SelectItem[];
-    as?: string;
+declare type InsertHasOneData<T extends Query, Key extends keyof T['relations'], Rel extends HasOneRelation> = 'through' extends Rel['options'] ? {} : {
+    [K in Key]?: {
+        create: InsertData<Rel['nestedCreateQuery']>;
+        connect?: never;
+        connectOrCreate?: never;
+    } | {
+        create?: never;
+        connect: WhereArg<Rel['model']>;
+        connectOrCreate?: never;
+    } | {
+        create?: never;
+        connect?: never;
+        connectOrCreate: {
+            where?: WhereArg<Rel['model']>;
+            create?: InsertData<Rel['nestedCreateQuery']>;
+        };
+    };
 };
-declare type JoinItem = {
-    type: string;
-    args: [relation: string] | [
-        arg: string | QueryWithTable,
-        conditions: Record<string, string | RawExpression> | RawExpression | ((q: unknown) => QueryBase)
-    ] | [
-        arg: string | QueryWithTable,
-        leftColumn: string | RawExpression,
-        rightColumn: string | RawExpression
-    ] | [
-        arg: string | QueryWithTable,
-        leftColumn: string | RawExpression,
-        op: string,
-        rightColumn: string | RawExpression
-    ];
+declare type InsertHasManyData<T extends Query, Key extends keyof T['relations'], Rel extends HasManyRelation | HasAndBelongsToManyRelation> = 'through' extends Rel['options'] ? {} : {
+    [K in Key]?: {
+        create?: InsertData<Rel['nestedCreateQuery']>[];
+        connect?: WhereArg<Rel['model']>[];
+        connectOrCreate?: {
+            where: WhereArg<Rel['model']>;
+            create: InsertData<Rel['nestedCreateQuery']>;
+        }[];
+    };
 };
-declare type WhereItem = (Omit<Record<string, unknown | Record<string, unknown | Query | RawExpression> | RawExpression>, 'NOT' | 'AND' | 'OR' | 'IN' | 'EXISTS' | 'ON' | 'ON_JSON_PATH_EQUALS'> & {
-    NOT?: MaybeArray<WhereItem>;
-    AND?: MaybeArray<WhereItem>;
-    OR?: MaybeArray<WhereItem>[];
-    IN?: MaybeArray<WhereInItem>;
-    EXISTS?: MaybeArray<JoinItem['args']>;
-    ON?: WhereOnItem | WhereJsonPathEqualsItem;
-}) | ((q: unknown) => QueryBase) | Query | RawExpression;
-declare type WhereInItem = {
+declare type InsertRawData = {
     columns: string[];
-    values: unknown[][] | Query | RawExpression;
-};
-declare type WhereJsonPathEqualsItem = [
-    leftColumn: string,
-    leftPath: string,
-    rightColumn: string,
-    rightPath: string
-];
-declare type WhereOnItem = {
-    joinFrom: WhereOnJoinItem;
-    joinTo: WhereOnJoinItem;
-    on: [leftFullColumn: string, rightFullColumn: string] | [leftFullColumn: string, op: string, rightFullColumn: string];
+    values: RawExpression;
 };
-declare type WhereOnJoinItem = {
-    table?: string;
-    query: {
-        as?: string;
+declare type InsertOneResult<T extends Query> = T['hasSelect'] extends true ? QueryReturnsAll<T['returnType']> extends true ? SetQueryReturnsOne<T> : T['returnType'] extends 'one' ? SetQueryReturnsOne<T> : T : SetQueryReturnsRowCount<T>;
+declare type InsertManyResult<T extends Query> = T['hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAll<T> : T : SetQueryReturnsRowCount<T>;
+declare type OnConflictArg<T extends Query> = keyof T['shape'] | (keyof T['shape'])[] | RawExpression;
+declare class Insert {
+    insert<T extends Query>(this: T, data: InsertData<T>): InsertOneResult<T>;
+    _insert<T extends Query>(this: T, data: InsertData<T>): InsertOneResult<T>;
+    insertMany<T extends Query>(this: T, data: InsertData<T>[]): InsertManyResult<T>;
+    _insertMany<T extends Query>(this: T, data: InsertData<T>[]): InsertManyResult<T>;
+    insertRaw<T extends Query>(this: T, data: InsertRawData): InsertManyResult<T>;
+    _insertRaw<T extends Query>(this: T, data: InsertRawData): InsertManyResult<T>;
+    create<T extends Query>(this: T, data: InsertData<T>): SetQueryReturnsOne<T>;
+    _create<T extends Query>(this: T, data: InsertData<T>): SetQueryReturnsOne<T>;
+    createMany<T extends Query>(this: T, data: InsertData<T>[]): SetQueryReturnsAll<T>;
+    _createMany<T extends Query>(this: T, data: InsertData<T>[]): SetQueryReturnsAll<T>;
+    createRaw<T extends Query>(this: T, data: InsertRawData): SetQueryReturnsAll<T>;
+    _createRaw<T extends Query>(this: T, data: InsertRawData): SetQueryReturnsAll<T>;
+    defaults<T extends Query, Data extends Partial<InsertData<T>>>(this: T, data: Data): T & {
+        [defaultsKey]: Record<keyof Data, true>;
     };
-} | string;
-declare type AggregateItemOptions = {
-    as?: string;
-    distinct?: boolean;
-    order?: OrderItem[];
-    filter?: WhereItem;
-    filterOr?: WhereItem[];
-    withinGroup?: boolean;
-    over?: string;
-    window?: WindowItem;
-};
-declare type SortDir = 'ASC' | 'DESC';
-declare type OrderItem = string | Record<string, SortDir | {
-    dir: SortDir;
-    nulls: 'FIRST' | 'LAST';
-}> | RawExpression;
-declare type AggregateItemArg = Expression | Record<string, Expression> | [Expression, string];
-declare type AggregateItem = {
-    function: string;
-    arg?: AggregateItemArg;
-    options: AggregateItemOptions;
-};
-declare type ColumnOperators<S extends SelectableBase, Column extends keyof S> = {
-    [O in keyof S[Column]['column']['operators']]?: S[Column]['column']['operators'][O]['type'];
+    _defaults<T extends Query, Data extends Partial<InsertData<T>>>(this: T, data: Data): T & {
+        [defaultsKey]: Record<keyof Data, true>;
+    };
+    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);
+    ignore(): T;
+    merge(update?: keyof T['shape'] | (keyof T['shape'])[] | Partial<T['inputType']> | RawExpression): T;
+}
+
+declare type UpdateData<T extends Query> = {
+    [K in keyof T['type']]?: T['type'][K] | RawExpression;
+} & (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;
 };
-declare type HavingItemObject = Record<string, unknown>;
-declare type HavingItem = Record<string, HavingItemObject> | {
-    count?: number | HavingItemObject;
-} | Query | RawExpression;
-declare type WindowItem = Record<string, WindowDeclaration | RawExpression>;
-declare type WindowDeclaration = {
-    partitionBy?: Expression | Expression[];
-    order?: OrderItem;
+declare type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> = {
+    disconnect: boolean;
+} | {
+    set: WhereArg<Rel['model']>;
+} | {
+    delete: boolean;
+} | {
+    update: UpdateData<Rel['model']>;
+} | {
+    create: InsertData<Rel['nestedCreateQuery']>;
+} | (QueryReturnsAll<T['returnType']> extends true ? never : {
+    upsert: {
+        update: UpdateData<Rel['model']>;
+        create: InsertData<Rel['nestedCreateQuery']>;
+    };
+});
+declare type UpdateHasOneData<T extends Query, Rel extends HasOneRelation> = {
+    disconnect: boolean;
+} | {
+    delete: boolean;
+} | {
+    update: UpdateData<Rel['model']>;
+} | (QueryReturnsAll<T['returnType']> extends true ? never : {
+    set: WhereArg<Rel['model']>;
+} | {
+    upsert: {
+        update: UpdateData<Rel['model']>;
+        create: InsertData<Rel['nestedCreateQuery']>;
+    };
+} | {
+    create: InsertData<Rel['nestedCreateQuery']>;
+});
+declare type UpdateHasManyData<T extends Query, Rel extends HasManyRelation> = {
+    disconnect?: MaybeArray<WhereArg<Rel['model']>>;
+    delete?: MaybeArray<WhereArg<Rel['model']>>;
+    update?: {
+        where: MaybeArray<WhereArg<Rel['model']>>;
+        data: UpdateData<Rel['model']>;
+    };
+} & (QueryReturnsAll<T['returnType']> extends true ? EmptyObject : {
+    set?: MaybeArray<WhereArg<Rel['model']>>;
+    create?: InsertData<Rel['nestedCreateQuery']>[];
+});
+declare type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
+    disconnect?: MaybeArray<WhereArg<Rel['model']>>;
+    set?: MaybeArray<WhereArg<Rel['model']>>;
+    delete?: MaybeArray<WhereArg<Rel['model']>>;
+    update?: {
+        where: MaybeArray<WhereArg<Rel['model']>>;
+        data: UpdateData<Rel['model']>;
+    };
+    create?: InsertData<Rel['nestedCreateQuery']>[];
 };
-declare type UnionItem = Query | RawExpression;
-declare type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT' | 'EXCEPT ALL';
-declare type OnConflictItem = string | string[] | RawExpression;
-declare type OnConflictMergeUpdate = string | string[] | Record<string, unknown> | RawExpression;
+declare type UpdateArgs<T extends Query, ForceAll extends boolean> = (T['hasWhere'] extends true ? true : ForceAll) extends true ? [update: UpdateData<T>] : [update: UpdateData<T>, forceAll: true];
+declare type UpdateRawArgs<T extends Query, ForceAll extends boolean> = (T['hasWhere'] extends true ? true : ForceAll) extends true ? [update: RawExpression] : [update: RawExpression, forceAll: true];
+declare type UpdateResult<T extends Query> = T['hasSelect'] extends true ? T : SetQueryReturnsRowCount<T>;
+declare type ChangeCountArg<T extends Query> = keyof T['shape'] | Partial<Record<keyof T['shape'], number>>;
+declare class Update {
+    update<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
+    _update<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
+    updateRaw<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateRawArgs<T, ForceAll>): UpdateResult<T>;
+    _updateRaw<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateRawArgs<T, ForceAll>): UpdateResult<T>;
+    updateOrThrow<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
+    _updateOrThrow<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
+    increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+    _increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+    decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+    _decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+}
 
-declare type ToSqlCtx = {
-    whereQueryBuilder: typeof WhereQueryBuilder;
-    onQueryBuilder: typeof OnQueryBuilder;
-    sql: string[];
-    values: unknown[];
-};
-declare type toSqlCacheKey = typeof toSqlCacheKey;
-declare const toSqlCacheKey: unique symbol;
-declare type ToSqlOptions = {
-    clearCache?: boolean;
-    values?: unknown[];
+declare type DeleteArgs<T extends Query> = T['hasWhere'] extends true ? [forceAll?: boolean] : [true];
+declare type DeleteResult<T extends Query> = T['hasSelect'] extends true ? T : SetQueryReturnsRowCount<T>;
+declare class Delete {
+    del<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T>;
+    _del<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T>;
+    delete<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T>;
+    _delete<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T>;
+}
+
+declare class Transaction {
+    transaction<T extends Query, Result>(this: T, cb: (query: T) => Promise<Result>): Promise<Result>;
+    transacting<T extends Query>(this: T, query: Query): T;
+    _transacting<T extends Query>(this: T, query: Query): T;
+}
+
+declare 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 const toSql: (model: Query, options?: ToSqlOptions) => Sql;
+declare class For {
+    forUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
+    _forUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
+    forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
+    _forNoKeyUpdate<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
+    forShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
+    _forShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
+    forKeyShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
+    _forKeyShare<T extends Query>(this: T, tableNames?: string[] | RawExpression): ForQueryBuilder<T>;
+}
 
-declare type SomeIsTrue<T extends unknown[]> = T extends [
-    infer Head,
-    ...infer Tail
-] ? Head extends true ? true : SomeIsTrue<Tail> : false;
-declare type MaybeArray<T> = T | T[];
-declare type SetOptional<T, K extends PropertyKey> = Omit<T, K> & {
-    [P in K]?: P extends keyof T ? T[P] : never;
+declare type ColumnInfo = {
+    defaultValue: unknown;
+    type: string;
+    maxLength: number | null;
+    nullable: boolean;
 };
-declare type GetTypesOrRaw<T extends [...unknown[]]> = T extends [
-    infer Head,
-    ...infer Tail
-] ? [GetTypeOrRaw<Head>, ...GetTypesOrRaw<Tail>] : [];
-declare type GetTypeOrRaw<T> = T | RawExpression;
-declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-declare type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
-declare type PopPropertyKeyUnion<U> = UnionToOvlds<U> extends (a: infer A extends PropertyKey) => void ? A : never;
-declare type IsUnion$1<T> = [T] extends [UnionToIntersection<T>] ? false : true;
-declare type PropertyKeyUnionToArray<T, A extends PropertyKey[] = []> = IsUnion$1<T> extends true ? PropertyKeyUnionToArray<Exclude<T, PopPropertyKeyUnion<T>>, [
-    PopPropertyKeyUnion<T>,
-    ...A
-]> : [T, ...A];
-declare type OptionalPropertyNames<T> = {
-    [K in keyof T]-?: {} extends {
-        [P in K]: T[K];
-    } ? K : never;
-}[keyof T];
-declare type SpreadProperties<L, R, K extends keyof L & keyof R> = {
-    [P in K]: L[P] | Exclude<R[P], undefined>;
+declare class ColumnInfoMethods {
+    columnInfo<T extends Query, Column extends keyof T['shape'] | undefined = undefined>(this: T, column?: Column): SetQueryReturnsColumnInfo<T, Column>;
+    _columnInfo<T extends Query, Column extends keyof T['shape'] | undefined = undefined>(this: T, column?: Column): SetQueryReturnsColumnInfo<T, Column>;
+}
+
+declare type ClearStatement = 'with' | 'select' | 'where' | 'union' | 'using' | 'join' | 'group' | 'order' | 'having' | 'limit' | 'offset' | 'counters';
+declare class Clear {
+    clear<T extends Query>(this: T, ...clears: ClearStatement[]): T;
+    _clear<T extends Query>(this: T, ...clears: ClearStatement[]): T;
+}
+
+declare type HavingArgObject<T extends Query, Agg extends keyof Aggregate1ArgumentTypes<T>> = {
+    [Column in Exclude<Aggregate1ArgumentTypes<T>[Agg], RawExpression>]?: T['selectable'][Column]['column']['type'] | (ColumnOperators<T['selectable'], Column> & AggregateOptions<T>);
 };
-declare type Id<T> = T extends infer U ? {
-    [K in keyof U]: U[K];
-} : never;
-declare type SpreadTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>>;
-declare type Spread<A extends readonly [...any]> = A extends [
-    infer L,
-    ...infer R
-] ? SpreadTwo<L, Spread<R>> : unknown;
-declare type SimpleSpread<A extends readonly [...any]> = A extends [
-    infer L,
-    ...infer R
-] ? L & SimpleSpread<R> : {};
-declare type FilterTuple<T extends readonly any[], E> = T extends [
-    infer F,
-    ...infer R
-] ? [F] extends [E] ? [F, ...FilterTuple<R, E>] : FilterTuple<R, E> : [];
-declare type CoalesceString<Left extends string | undefined, Right extends string> = Left extends undefined ? Right : Left;
-declare function applyMixins(derivedCtor: any, constructors: any[]): void;
-declare const joinTruthy: (...strings: (string | false | undefined)[]) => string;
-declare const getClonedQueryData: (query: QueryData) => QueryData;
-declare const getQueryAs: (q: {
-    table?: string;
-    query: {
-        as?: string;
-    };
-}) => string;
-declare const toArray: <T>(item: T) => T extends unknown[] ? T : [T];
-declare const noop: () => void;
-declare type EmptyObject = typeof emptyObject;
-declare const emptyObject: {};
-declare const makeRegexToFindInSql: (value: string) => RegExp;
-declare const pushOrNewArrayToObject: <Obj extends {}, Key extends keyof Obj>(obj: Obj, key: Key, value: Exclude<Obj[Key], undefined> extends unknown[] ? Exclude<Obj[Key], undefined>[number] : never) => void;
-declare const pushOrNewArray: <Arr extends unknown[]>(arr: Arr | undefined, value: Arr[number]) => Arr;
+declare type HavingArg<T extends Query = Query> = ({
+    [Agg in keyof Aggregate1ArgumentTypes<T>]?: HavingArgObject<T, Agg>;
+} & {
+    count?: number | HavingArgObject<T, 'count'>;
+}) | Query | RawExpression;
+declare class Having {
+    having<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
+    _having<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
+    havingOr<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
+    _havingOr<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
+}
 
 declare class Window {
     selectRowNumber<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'row_number', As, IntegerColumn>;
@@ -1471,22 +1222,51 @@ declare class Window {
     _selectCumeDist<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'cume_dist', As, IntegerColumn>;
 }
 
+declare type UpsertData<T extends Query> = {
+    update: UpdateData<T>;
+    create: InsertData<T>;
+};
+declare type UpsertResult<T extends Query> = T['hasSelect'] extends true ? SetQueryReturnsOne<T> : SetQueryReturnsVoid<T>;
+declare type UpsertThis = WhereResult<Query> & {
+    returnType: 'one' | 'oneOrThrow';
+};
+declare class QueryUpsert {
+    upsert<T extends UpsertThis>(this: T, data: UpsertData<T>): UpsertResult<T>;
+    _upsert<T extends UpsertThis>(this: T, data: UpsertData<T>): UpsertResult<T>;
+}
+
+declare type MergeQuery<T extends Query, Q extends Query, ReturnType extends QueryReturnType = QueryReturnType extends Q['returnType'] ? T['returnType'] : Q['returnType']> = Omit<T, 'result' | 'returnType' | 'then'> & {
+    hasSelect: Q['hasSelect'] extends true ? true : T['hasSelect'];
+    hasWhere: Q['hasWhere'] extends true ? true : T['hasWhere'];
+    result: T['hasSelect'] extends true ? Spread<[T['result'], Q['result']]> : Q['result'];
+    returnType: ReturnType;
+    then: T['hasSelect'] extends true ? QueryThen<ReturnType, Spread<[T['result'], Q['result']]>> : QueryThen<ReturnType, Q['result']>;
+    selectable: T['selectable'] & Q['selectable'];
+    joinedTables: T['joinedTables'] & Q['joinedTables'];
+    windows: T['windows'] & Q['windows'];
+    withData: T['withData'] & Q['withData'];
+};
+declare class MergeQueryMethods {
+    merge<T extends Query, Q extends Query>(this: T, q: Q): MergeQuery<T, Q>;
+    _merge<T extends Query, Q extends Query>(this: T, q: Q): MergeQuery<T, Q>;
+}
+
 declare type WindowArg<T extends Query> = Record<string, WindowArgDeclaration<T> | RawExpression>;
 declare type WindowArgDeclaration<T extends Query = Query> = {
     partitionBy?: Expression<T> | Expression<T>[];
     order?: OrderArg<T>;
 };
-declare type WindowResult<T extends Query, W extends WindowArg<T>> = SetQueryWindows<T, PropertyKeyUnionToArray<keyof W>>;
+declare type WindowResult<T extends Query, W extends WindowArg<T>> = SetQueryWindows<T, Record<keyof W, true>>;
 declare type OrderArg<T extends Query> = keyof T['selectable'] | {
     [K in Selectable<T>]?: SortDir | {
         dir: SortDir;
         nulls: 'FIRST' | 'LAST';
     };
 } | RawExpression;
-interface QueryMethods extends Aggregate, Select, From, Join, With, Union, Json, Insert, Update, Delete, Transaction, For, ColumnInfoMethods, Where, Clear, Having, Window, Then, QueryLog, QueryCallbacks, QueryUpsert, QueryGet {
+interface QueryMethods extends Aggregate, Select, From, Join, With, Union, Json, Insert, Update, Delete, Transaction, For, ColumnInfoMethods, Where, Clear, Having, Window, Then, QueryLog, QueryCallbacks, QueryUpsert, QueryGet, MergeQueryMethods {
 }
 declare class QueryMethods {
-    windows: PropertyKey[];
+    windows: EmptyObject;
     __model: Query;
     all<T extends Query>(this: T): SetQueryReturnsAll<T>;
     _all<T extends Query>(this: T): SetQueryReturnsAll<T>;
@@ -1540,6 +1320,136 @@ declare class QueryMethods {
     }): SetQueryReturnsVoid<T>;
 }
 
+declare type AggregateArg<T extends Query> = Expression<T> | Record<string, Expression<T>> | [Expression<T>, string];
+declare type AggregateOptions<T extends Query = Query, As extends string | undefined = any> = {
+    as?: As;
+    distinct?: boolean;
+    order?: OrderArg<T> | OrderArg<T>[];
+    filter?: WhereArg<T>;
+    filterOr?: WhereArg<T>[];
+    withinGroup?: boolean;
+    over?: keyof T['windows'] | WindowArgDeclaration<T>;
+};
+declare type Aggregate1ArgumentTypes<T extends Query = Query, C extends ColumnType = ColumnType> = {
+    count: Expression<T, C>;
+    avg: NumberExpression<T, C>;
+    min: Expression<T, C>;
+    max: Expression<T, C>;
+    sum: NumberExpression<T, C>;
+    bitAnd: NumberExpression<T, C>;
+    bitOr: NumberExpression<T, C>;
+    boolAnd: BooleanExpression<T, C>;
+    boolOr: BooleanExpression<T, C>;
+    every: BooleanExpression<T, C>;
+    jsonAgg: Expression<T, C>;
+    jsonbAgg: Expression<T, C>;
+    xmlAgg: Expression<T, C>;
+};
+declare const aggregate1FunctionNames: {
+    readonly count: "count";
+    readonly avg: "avg";
+    readonly min: "min";
+    readonly max: "max";
+    readonly sum: "sum";
+    readonly bitAnd: "bit_and";
+    readonly bitOr: "bit_or";
+    readonly boolAnd: "bool_and";
+    readonly boolOr: "bool_or";
+    readonly every: "every";
+    readonly jsonAgg: "json_agg";
+    readonly jsonbAgg: "jsonb_agg";
+    readonly xmlAgg: "xmlagg";
+};
+declare type SelectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnType> = AddQuerySelect<T, Record<CoalesceString<As, Func>, Value>>;
+declare type AT1<T extends Query> = Aggregate1ArgumentTypes<T>;
+declare type WindowFunctionOptions<T extends Query = Query, As extends string | undefined = any> = {
+    as?: As;
+} & WindowArgDeclaration<T>;
+declare class Aggregate {
+    selectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnType>(this: T, functionName: Func, arg: AggregateArg<T>, options?: AggregateOptions<T, As>): SelectAgg<T, Func, As, Value>;
+    _selectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnType>(this: T, functionName: Func, arg: AggregateArg<T>, options?: AggregateOptions<T, As>, columnType?: ColumnType): SelectAgg<T, Func, As, Value>;
+    count<T extends Query>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T>): SetQueryReturnsValue<T, NumberColumn>;
+    _count<T extends Query>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T>): SetQueryReturnsValue<T, NumberColumn>;
+    selectCount<T extends Query, As extends string | undefined = undefined>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T, As>): SelectAgg<T, 'count', As, NumberColumn>;
+    _selectCount<T extends Query, As extends string | undefined = undefined>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T, As>): SelectAgg<T, 'count', As, NumberColumn>;
+    avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
+    _selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
+    min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
+    _selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
+    max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
+    _selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
+    sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
+    _selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
+    bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
+    _selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
+    bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
+    _selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
+    boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    _boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
+    _selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
+    boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    _boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
+    _selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
+    every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    _every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
+    _selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
+    jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    _jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    selectJsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    _selectJsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    jsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    _jsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    selectJsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    _selectJsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
+    _xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
+    selectXmlAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Aggregate1ArgumentTypes<T>['xmlAgg'], options?: AggregateOptions<T, As>): SelectAgg<T, 'xmlagg', As, NullableColumn<StringColumn>>;
+    _selectXmlAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Aggregate1ArgumentTypes<T>['xmlAgg'], options?: AggregateOptions<T, As>): SelectAgg<T, 'xmlagg', As, NullableColumn<StringColumn>>;
+    jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    _jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    selectJsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    _selectJsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    _jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    selectJsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    _selectJsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
+    _stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
+    selectStringAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T, As>): SelectAgg<T, 'string_agg', As, NullableColumn<StringColumn>>;
+    _selectStringAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T, As>): SelectAgg<T, 'string_agg', As, NullableColumn<StringColumn>>;
+}
+
 declare type ColumnParser = (input: unknown) => unknown;
 declare type ColumnsParsers = Record<string | getValueKey, ColumnParser>;
 declare type SelectableBase = Record<PropertyKey, {
@@ -1585,7 +1495,7 @@ declare type Query = QueryMethods & {
     then: ThenResult<unknown>;
     tableAlias: string | undefined;
     joinedTables: Record<string, Pick<Query, 'result' | 'tableAlias' | 'table'>>;
-    windows: PropertyKey[];
+    windows: EmptyObject;
     defaultSelectColumns: string[];
     columnsParsers?: ColumnsParsers;
     relations: RelationsBase;
@@ -1600,21 +1510,23 @@ declare type DefaultSelectColumns<S extends ColumnsShape> = {
     [K in keyof S]: S[K]['isHidden'] extends true ? never : K;
 }[StringKey<keyof S>][];
 declare type QueryReturnType = 'all' | 'one' | 'oneOrThrow' | 'rows' | 'pluck' | 'value' | 'valueOrThrow' | 'rowCount' | 'void';
+declare const queryTypeWithLimitOne: Record<QueryReturnType, true | undefined>;
 declare type JoinedTablesBase = Record<string, Pick<Query, 'result' | 'tableAlias' | 'table'>>;
-declare type QueryThen<ReturnType extends QueryReturnType, Result extends ColumnsShape> = ReturnType extends 'all' ? ThenResult<ColumnShapeOutput<Result>[]> : ReturnType extends 'one' ? ThenResult<ColumnShapeOutput<Result> | undefined> : ReturnType extends 'oneOrThrow' ? ThenResult<ColumnShapeOutput<Result>> : ReturnType extends 'value' ? Result extends {
+declare type QueryReturnsAll<T extends QueryReturnType> = (QueryReturnType extends T ? 'all' : T) extends 'all' ? true : false;
+declare type QueryThen<ReturnType extends QueryReturnType, Result extends ColumnsShape> = QueryReturnsAll<ReturnType> extends true ? ThenResult<ColumnShapeOutput<Result>[]> : ReturnType extends 'one' ? ThenResult<ColumnShapeOutput<Result> | undefined> : ReturnType extends 'oneOrThrow' ? ThenResult<ColumnShapeOutput<Result>> : ReturnType extends 'value' ? Result extends {
     value: ColumnType;
 } ? ThenResult<Result['value']['type'] | undefined> : never : ReturnType extends 'valueOrThrow' ? Result extends {
     value: ColumnType;
 } ? ThenResult<Result['value']['type']> : never : ReturnType extends 'rows' ? ThenResult<ColumnShapeOutput<Result>[keyof Result][][]> : ReturnType extends 'pluck' ? Result extends {
     pluck: ColumnType;
 } ? ThenResult<Result['pluck']['type'][]> : never : ReturnType extends 'rowCount' ? ThenResult<number> : ReturnType extends 'void' ? ThenResult<void> : never;
-declare type AddQuerySelect<T extends Pick<Query, 'hasSelect' | 'result' | 'then' | 'returnType'>, Result extends ColumnsShape> = T['hasSelect'] extends false ? Omit<T, 'hasSelect' | 'result' | 'then'> & {
+declare type AddQuerySelect<T extends Pick<Query, 'hasSelect' | 'result' | 'then' | 'returnType'>, Result extends ColumnsShape> = T['hasSelect'] extends true ? Omit<T, 'result' | 'then'> & {
+    result: Spread<[T['result'], Result]>;
+    then: QueryThen<T['returnType'], Spread<[T['result'], Result]>>;
+} : Omit<T, 'result' | 'then'> & {
     hasSelect: true;
     result: Result;
     then: QueryThen<T['returnType'], Result>;
-} : Omit<T, 'result' | 'then'> & {
-    result: Spread<[T['result'], Result]>;
-    then: QueryThen<T['returnType'], Spread<[T['result'], Result]>>;
 };
 declare type QuerySelectAll<T extends Query> = Omit<T, 'hasSelect' | 'result' | 'then'> & {
     hasSelect: true;
@@ -1690,7 +1602,7 @@ declare type SetQueryWith<T extends Query, WithData extends Record<string, WithD
 declare type AddQueryWith<T extends Query, With extends WithDataItem> = SetQueryWith<T, Spread<[T['withData'], {
     [K in With['table']]: With;
 }]>>;
-declare type SetQueryWindows<T extends Query, W extends PropertyKey[]> = Omit<T, 'windows'> & {
+declare type SetQueryWindows<T extends Query, W extends EmptyObject> = T & {
     windows: W;
 };
 
@@ -4251,6 +4163,17 @@ declare class ArrayColumn<Item extends ColumnType> extends ColumnType<Item['type
     parseFn: (input: unknown) => unknown[];
 }
 
+declare function timestamps<T extends ColumnType>(this: {
+    timestamp(): T;
+}): {
+    createdAt: T & {
+        hasDefault: true;
+    };
+    updatedAt: T & {
+        hasDefault: true;
+    };
+};
+
 declare type ColumnTypes = typeof columnTypes;
 declare type TableData = {
     primaryKey?: {
@@ -4347,7 +4270,6 @@ declare namespace utils {
 declare type Value = any;
 declare const quote: (value: Value) => string;
 
-declare const removeFromQuery: <T extends Query>(q: T, key: string) => T;
 declare const pushQueryArray: <T extends {
     query: QueryData;
 }>(q: T, key: string, value: unknown) => T;
@@ -4371,4 +4293,4 @@ declare class UnhandledTypeError extends PormInternalError {
     constructor(value: never);
 }
 
-export { Adapter, AdapterOptions, AddQueryJoinedTable, AddQuerySelect, AddQueryWith, AfterCallback, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, AnyColumnType, AnyColumnTypeCreator, ArrayCardinality, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AssertArray, BaseNumberData, BaseRelation, BaseStringData, BeforeCallback, BelongsToNestedInsert, BelongsToNestedUpdate, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, Clear, ClearStatement, CoalesceString, ColumnData, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnInput, ColumnNameOfModel, ColumnOperators, ColumnOutput, ColumnParser, ColumnShapeInput, ColumnShapeOutput, ColumnType, ColumnTypes, ColumnTypesBase, ColumnsObject, ColumnsParsers, ColumnsShape, CommonQueryData, DateBaseColumn, DateColumn, DateColumnData, DateTimeBaseClass, DateTimeColumnData, DateTimeWithTimeZoneBaseClass, Db, DbOptions, DbTableOptions, DecimalBaseColumn, DecimalColumn, DecimalColumnData, DeepPartial, DefaultSelectColumns, Delete, DeleteQueryData, DoublePrecisionColumn, DropMode, EMPTY_OBJECT, EmptyObject, EnumColumn, EnumLike, Except, Expression, ExpressionOfType, ExpressionOutput, FilterTuple, For, ForeignKey, ForeignKeyModel, ForeignKeyModelWithColumns, ForeignKeyOptions, From, GetArg, GetTypeOrRaw, GetTypesOrRaw, HasAndBelongsToManyRelation, HasManyNestedInsert, HasManyNestedUpdate, HasManyRelation, HasOneNestedInsert, HasOneNestedUpdate, HasOneRelation, Having, HavingArg, HavingItem, IndexColumnOptions, IndexOptions, InetColumn, Insert, InsertData, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsEqual, JSONAny, JSONArray, JSONBigInt, JSONBoolean, JSONColumn, JSONDate, JSONDiscriminatedObject, JSONDiscriminatedUnion, JSONEnum, JSONInstanceOf, JSONIntersection, JSONLazy, JSONLiteral, JSONMap, JSONNaN, JSONNativeEnum, JSONNever, JSONNotNullable, JSONNotNullish, JSONNull, JSONNullable, JSONNullish, JSONNumber, JSONObject, JSONObjectShape, JSONOptional, JSONRecord, JSONRecordKeyType, JSONRequired, JSONSet, JSONString, JSONTextColumn, JSONTuple, JSONTupleItems, JSONType, JSONTypeAny, JSONTypeData, JSONTypes, JSONUndefined, JSONUnion, JSONUnknown, JSONVoid, Join, JoinArgs, JoinCallback, JoinCallbackArg, JoinItem, JoinedTablesBase, Json, JsonItem, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MaybeArray, Merge, MoneyColumn, MoreThanOneRowError, NestedInsertItem, NestedInsertManyItems, NestedInsertOneItem, NestedUpdateItem, NestedUpdateManyItems, NestedUpdateOneItem, NotFoundError, NullableColumn, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OrderArg, OrderItem, OutputTypeOfTuple, OutputTypeOfTupleWithRest, OwnTypeProps, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, PormError, PormInternalError, Primitive, PropertyKeyUnionToArray, Query, QueryArraysResult, QueryBase, QueryCallbacks, QueryData, QueryGet, QueryInput, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryResultRow, QueryReturnType, QuerySelectAll, QueryUpsert, QueryWithTable, RawExpression, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SerialColumn, SetOptional, SetQueryJoinedTables, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumnInfo, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWindows, SetQueryWith, SimpleSpread, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SomeIsTrue, SortDir, Spread, Sql, StringColumn, StringExpression, StringKey, TableData, TableSchema, TextBaseColumn, TextColumn, TextColumnData, Then, ThenResult, TimeColumn, TimeInterval, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionToArray, UnionToIntersection, UnionToOvlds, UnknownKeysParam, Update, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertData, UpsertResult, UpsertThis, ValidationContext, VarCharColumn, Where, WhereArg, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addParserToQuery, addQueryOn, addQueryOrOn, addQuestionMarks, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, applyMixins, array, arrayToEnum, baseObjectOutputType, columnTypes, utils as columnUtils, constructType, createDb, createOperator, defaultsKey, discriminatedUnion, emptyObject, enumType, flatten, getClonedQueryData, getColumnTypes, getQueryAs, getQueryParsers, getRaw, getRawSql, getTableData, getValidEnumValues, getValueKey, handleResult, identity, instanceOf, intersection, isRaw, isRequiredRelationKey, joinTruthy, jsonTypes, lazy, literal, logColors, logParamToLogObject, makeRegexToFindInSql, map, nativeEnum, newTableData, noop, notNullable, notNullish, nullable, nullish, object, optional, parseRecord, parseResult, processSelectArg, pushOrNewArray, pushOrNewArrayToObject, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryKeysOfNotSimpleQuery, queryMethodByReturnType, quote, raw, record, relationQueryKey, removeFromQuery, required, resetTableData, scalarTypes, set, setQueryObjectValue, toArray, toSql, toSqlCacheKey, tuple, union };
+export { Adapter, AdapterOptions, AddQueryJoinedTable, AddQuerySelect, AddQueryWith, AfterCallback, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, AnyColumnType, AnyColumnTypeCreator, ArrayCardinality, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AssertArray, BaseNumberData, BaseRelation, BaseStringData, BeforeCallback, BelongsToNestedInsert, BelongsToNestedUpdate, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, Clear, ClearStatement, CoalesceString, ColumnData, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnInput, ColumnNameOfModel, ColumnOperators, ColumnOutput, ColumnParser, ColumnShapeInput, ColumnShapeOutput, ColumnType, ColumnTypes, ColumnTypesBase, ColumnsObject, ColumnsParsers, ColumnsShape, CommonQueryData, DateBaseColumn, DateColumn, DateColumnData, DateTimeBaseClass, DateTimeColumnData, DateTimeWithTimeZoneBaseClass, Db, DbOptions, DbTableOptions, DecimalBaseColumn, DecimalColumn, DecimalColumnData, DeepPartial, DefaultSelectColumns, Delete, DeleteQueryData, DoublePrecisionColumn, DropMode, EMPTY_OBJECT, EmptyObject, EnumColumn, EnumLike, Except, Expression, ExpressionOfType, ExpressionOutput, FilterTuple, For, ForeignKey, ForeignKeyModel, ForeignKeyModelWithColumns, ForeignKeyOptions, From, GetArg, GetTypeOrRaw, GetTypesOrRaw, HasAndBelongsToManyRelation, HasManyNestedInsert, HasManyNestedUpdate, HasManyRelation, HasOneNestedInsert, HasOneNestedUpdate, HasOneRelation, Having, HavingArg, HavingItem, IndexColumnOptions, IndexOptions, InetColumn, Insert, InsertData, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsEqual, JSONAny, JSONArray, JSONBigInt, JSONBoolean, JSONColumn, JSONDate, JSONDiscriminatedObject, JSONDiscriminatedUnion, JSONEnum, JSONInstanceOf, JSONIntersection, JSONLazy, JSONLiteral, JSONMap, JSONNaN, JSONNativeEnum, JSONNever, JSONNotNullable, JSONNotNullish, JSONNull, JSONNullable, JSONNullish, JSONNumber, JSONObject, JSONObjectShape, JSONOptional, JSONRecord, JSONRecordKeyType, JSONRequired, JSONSet, JSONString, JSONTextColumn, JSONTuple, JSONTupleItems, JSONType, JSONTypeAny, JSONTypeData, JSONTypes, JSONUndefined, JSONUnion, JSONUnknown, JSONVoid, Join, JoinArgs, JoinCallback, JoinCallbackArg, JoinItem, JoinedTablesBase, Json, JsonItem, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MaybeArray, Merge, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NestedInsertItem, NestedInsertManyItems, NestedInsertOneItem, NestedUpdateItem, NestedUpdateManyItems, NestedUpdateOneItem, NotFoundError, NullableColumn, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OrderArg, OrderItem, OutputTypeOfTuple, OutputTypeOfTupleWithRest, OwnTypeProps, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, PormError, PormInternalError, Primitive, Query, QueryArraysResult, QueryBase, QueryCallbacks, QueryData, QueryGet, QueryInput, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryResultRow, QueryReturnType, QueryReturnsAll, QuerySelectAll, QueryThen, QueryUpsert, QueryWithTable, RawExpression, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SerialColumn, SetOptional, SetQueryJoinedTables, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumnInfo, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWindows, SetQueryWith, SimpleSpread, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SomeIsTrue, SortDir, Spread, Sql, StringColumn, StringExpression, StringKey, TableData, TableSchema, TextBaseColumn, TextColumn, TextColumnData, Then, ThenResult, TimeColumn, TimeInterval, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionToArray, UnionToIntersection, UnionToOvlds, UnknownKeysParam, Update, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertData, UpsertResult, UpsertThis, ValidationContext, VarCharColumn, Where, WhereArg, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addParserToQuery, addQueryOn, addQueryOrOn, addQuestionMarks, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, applyMixins, array, arrayToEnum, baseObjectOutputType, checkIfASimpleQuery, columnTypes, utils as columnUtils, constructType, createDb, createOperator, defaultsKey, discriminatedUnion, emptyObject, enumType, flatten, getClonedQueryData, getColumnTypes, getQueryAs, getQueryParsers, getRaw, getRawSql, getTableData, getValidEnumValues, getValueKey, handleResult, identity, instanceOf, intersection, isRaw, isRequiredRelationKey, joinTruthy, jsonTypes, lazy, literal, logColors, logParamToLogObject, makeRegexToFindInSql, map, nativeEnum, newTableData, noop, notNullable, notNullish, nullable, nullish, object, optional, parseRecord, parseResult, processSelectArg, pushOrNewArray, pushOrNewArrayToObject, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, raw, record, relationQueryKey, required, resetTableData, scalarTypes, set, setQueryObjectValue, toArray, toSql, toSqlCacheKey, tuple, union };