pqb 0.2.2 → 0.2.4

package/dist/index.d.ts

@@ -230,59 +230,314 @@ declare class WhereQueryBuilder<Q extends QueryBase = QueryBase> extends Where i
     clone<T extends this>(this: T): T;
 }
 
-declare type OptionalKeys<T extends Query> = {
-    [K in keyof T['shape']]: T['shape'][K]['isPrimaryKey'] extends true ? K : T['shape'][K]['isNullable'] extends true ? K : never;
-}[keyof T['shape']];
-declare type InsertData<T extends Query, DefaultKeys extends PropertyKey = keyof T[defaultsKey], Data = SetOptional<SetOptional<T['inputType'], OptionalKeys<T>>, DefaultKeys>> = [keyof T['relations']] extends [never] ? Data : Omit<Data, {
-    [K in keyof T['relations']]: T['relations'][K] extends BelongsToRelation ? T['relations'][K]['options']['foreignKey'] : never;
-}[keyof T['relations']]> & {
-    [Key in keyof T['relations']]: T['relations'][Key] extends BelongsToRelation ? SetOptional<{
-        [K in T['relations'][Key]['options']['foreignKey']]: T['relations'][Key]['options']['foreignKey'] extends keyof T['inputType'] ? T['inputType'][T['relations'][Key]['options']['foreignKey']] : never;
-    }, DefaultKeys> | {
-        [K in Key]: {
-            create?: InsertData<T['relations'][Key]['nestedCreateQuery']>;
-            connect?: WhereArg<T['relations'][Key]['model']>;
-        };
-    } : T['relations'][Key] extends HasOneRelation ? 'through' extends T['relations'][Key]['options'] ? {} : {
-        [K in Key]?: {
-            create?: InsertData<T['relations'][Key]['nestedCreateQuery']>;
-            connect?: WhereArg<T['relations'][Key]['model']>;
-        };
-    } : T['relations'][Key] extends Relation ? 'through' extends T['relations'][Key]['options'] ? {} : {
-        [K in Key]?: {
-            create?: InsertData<T['relations'][Key]['nestedCreateQuery']>[];
-            connect?: WhereArg<T['relations'][Key]['model']>[];
-            connectOrCreate?: {
-                where: WhereArg<T['relations'][Key]['model']>;
-                create: InsertData<T['relations'][Key]['nestedCreateQuery']>;
-            }[];
-        };
-    } : {};
+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 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 BeforeCallback<T extends Query> = (query: T) => void | Promise<void>;
+declare type AfterCallback<T extends Query> = (query: T, data: unknown) => void | Promise<void>;
+declare class QueryCallbacks {
+    beforeQuery<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    _beforeQuery<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    afterQuery<T extends Query>(this: T, cb: AfterCallback<T>): T;
+    _afterQuery<T extends Query>(this: T, cb: AfterCallback<T>): T;
+    beforeInsert<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    _beforeInsert<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    afterInsert<T extends Query>(this: T, cb: AfterCallback<T>): T;
+    _afterInsert<T extends Query>(this: T, cb: AfterCallback<T>): T;
+    beforeUpdate<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    _beforeUpdate<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    afterUpdate<T extends Query>(this: T, cb: AfterCallback<T>): T;
+    _afterUpdate<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;
+    type: string;
+    maxLength: number | null;
+    nullable: boolean;
+};
+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 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 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 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> = {
+    [Key in keyof T['relations']]: T['relations'][Key] extends BelongsToRelation ? InsertBelongsToData<T, Key, T['relations'][Key]> : T['relations'][Key] extends HasOneRelation ? InsertHasOneData<T, Key, T['relations'][Key]> : T['relations'][Key] extends HasManyRelation | HasAndBelongsToManyRelation ? InsertHasManyData<T, Key, T['relations'][Key]> : {};
 }[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 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 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 InsertRawData = {
+    columns: string[];
+    values: RawExpression;
+};
 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>[] | {
-        columns: string[];
-        values: RawExpression;
-    }): InsertManyResult<T>;
     _insert<T extends Query>(this: T, data: InsertData<T>): InsertOneResult<T>;
-    _insert<T extends Query>(this: T, data: InsertData<T>[] | {
-        columns: string[];
-        values: RawExpression;
-    }): InsertManyResult<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>[] | {
-        columns: string[];
-        values: RawExpression;
-    }): SetQueryReturnsAll<T>;
     _create<T extends Query>(this: T, data: InsertData<T>): SetQueryReturnsOne<T>;
-    _create<T extends Query>(this: T, data: InsertData<T>[] | {
-        columns: string[];
-        values: RawExpression;
-    }): SetQueryReturnsAll<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>;
     };
@@ -300,11 +555,192 @@ declare class OnConflictQueryBuilder<T extends Query, Arg extends OnConflictArg<
     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]['type'] extends 'belongsTo' ? {
-        disconnect: boolean;
+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 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 SelectArg<T extends QueryBase> = StringKey<keyof T['selectable']> | (T['relations'] extends Record<string, Relation> ? StringKey<keyof T['relations']> : never) | SelectAsArg<T>;
+declare type SelectAsArg<T extends QueryBase> = Record<string, StringKey<keyof T['selectable']> | RawExpression | ((q: T) => Query)>;
+declare type SelectResult<T extends Query, Args extends SelectArg<T>[], SelectAsArgs = SimpleSpread<FilterTuple<Args, SelectAsArg<T>>>> = AddQuerySelect<T, {
+    [Arg in Args[number] as Arg extends keyof T['selectable'] ? T['selectable'][Arg]['as'] : Arg extends keyof T['relations'] ? Arg : never]: Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['returns'] extends 'many' ? ArrayOfColumnsObjects<T['relations'][Arg]['model']['result']> : T['relations'][Arg]['options']['required'] extends true ? ColumnsObject<T['relations'][Arg]['model']['result']> : NullableColumn<ColumnsObject<T['relations'][Arg]['model']['result']>> : never : never;
+} & {
+    [K in keyof SelectAsArgs]: SelectAsArgs[K] extends keyof T['selectable'] ? T['selectable'][SelectAsArgs[K]]['column'] : SelectAsArgs[K] extends RawExpression ? SelectAsArgs[K]['__column'] : SelectAsArgs[K] extends (q: T) => Query ? SelectSubQueryResult<ReturnType<SelectAsArgs[K]>> : never;
+}>;
+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']>>;
+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;
+declare const processSelectArg: <T extends Query>(q: T, as: string | undefined, arg: SelectArg<T>, columnAs?: string | getValueKey) => SelectItem;
+declare class Select {
+    select<T extends Query, K extends SelectArg<T>[]>(this: T, ...args: K): SelectResult<T, K>;
+    _select<T extends Query, K extends SelectArg<T>[]>(this: T, ...args: K): SelectResult<T, K>;
+    selectAll<T extends Query>(this: T): QuerySelectAll<T>;
+    _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>;
+    destroy(): 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>;
+    destroy(): 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]['type'] extends 'belongsTo' ? {
+        disconnect: boolean;
     } | {
         set: WhereArg<T['relations'][K]['model']>;
     } | {
@@ -375,72 +811,265 @@ declare class Update {
     _decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
 }
 
-declare type NestedInsertOneItem = {
-    create?: Record<string, unknown>;
-    connect?: WhereArg<QueryBase>;
-};
-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 UpsertData<T extends Query> = {
+    update: UpdateData<T>;
+    create: InsertData<T>;
 };
-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;
-    };
+declare type UpsertResult<T extends Query> = T['hasSelect'] extends true ? SetQueryReturnsOne<T> : SetQueryReturnsVoid<T>;
+declare type UpsertThis = WhereResult<Query> & {
+    returnType: 'one' | 'oneOrThrow';
 };
-interface BelongsToRelation extends BaseRelation {
+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 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;
+    queryBuilder: Db;
+    whereQueryBuilder: Query['whereQueryBuilder'];
+    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;
+    hasWhere: boolean;
+    selectable: {
+        [K in keyof Shape]: {
+            as: K;
+            column: Shape[K];
+        };
+    } & {
+        [K in keyof Shape as `${Table}.${StringKey<K>}`]: {
+            as: K;
+            column: Shape[K];
+        };
+    };
+    tableAlias: undefined;
+    windows: PropertyKey[];
+    withData: Query['withData'];
+    joinedTables: Query['joinedTables'];
+    relations: Relations;
+    [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;
+    destroy: Adapter['destroy'];
+};
+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<T_14 extends ColumnType<unknown, Operators, unknown>>(this: {
+        timestamp(): T_14;
+    }): {
+        createdAt: T_14 & {
+            hasDefault: true;
+        };
+        updatedAt: T_14 & {
+            hasDefault: true;
+        };
+    };
+    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'] & {
@@ -499,92 +1128,6 @@ declare type RelationQuery<RelationName extends PropertyKey = string, Params ext
     [defaultsKey]: Record<Populate, true>;
 }) & Q;
 
-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>;
-    destroy(): 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>;
-    destroy(): Promise<void>;
-}
-
-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 BeforeCallback<T extends Query> = (query: T) => void | Promise<void>;
-declare type AfterCallback<T extends Query> = (query: T, data: unknown) => void | Promise<void>;
-declare class QueryCallbacks {
-    beforeQuery<T extends Query>(this: T, cb: BeforeCallback<T>): T;
-    _beforeQuery<T extends Query>(this: T, cb: BeforeCallback<T>): T;
-    afterQuery<T extends Query>(this: T, cb: AfterCallback<T>): T;
-    _afterQuery<T extends Query>(this: T, cb: AfterCallback<T>): T;
-    beforeInsert<T extends Query>(this: T, cb: BeforeCallback<T>): T;
-    _beforeInsert<T extends Query>(this: T, cb: BeforeCallback<T>): T;
-    afterInsert<T extends Query>(this: T, cb: AfterCallback<T>): T;
-    _afterInsert<T extends Query>(this: T, cb: AfterCallback<T>): T;
-    beforeUpdate<T extends Query>(this: T, cb: BeforeCallback<T>): T;
-    _beforeUpdate<T extends Query>(this: T, cb: BeforeCallback<T>): T;
-    afterUpdate<T extends Query>(this: T, cb: AfterCallback<T>): T;
-    _afterUpdate<T extends Query>(this: T, cb: AfterCallback<T>): T;
-}
-
 declare type Sql = {
     text: string;
     values: unknown[];
@@ -742,603 +1285,86 @@ declare type SelectFunctionItem = {
 };
 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 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 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];
-};
-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 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'];
-};
-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 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 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 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;
-    type: string;
-    maxLength: number | null;
-    nullable: boolean;
-};
-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 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 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 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 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 SelectArg<T extends QueryBase> = StringKey<keyof T['selectable']> | (T['relations'] extends Record<string, Relation> ? StringKey<keyof T['relations']> : never) | SelectAsArg<T>;
-declare type SelectAsArg<T extends QueryBase> = Record<string, StringKey<keyof T['selectable']> | RawExpression | ((q: T) => Query)>;
-declare type SelectResult<T extends Query, Args extends SelectArg<T>[], SelectAsArgs = SimpleSpread<FilterTuple<Args, SelectAsArg<T>>>> = AddQuerySelect<T, {
-    [Arg in Args[number] as Arg extends keyof T['selectable'] ? T['selectable'][Arg]['as'] : Arg extends keyof T['relations'] ? Arg : never]: Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['returns'] extends 'many' ? ArrayOfColumnsObjects<T['relations'][Arg]['model']['result']> : T['relations'][Arg]['options']['required'] extends true ? ColumnsObject<T['relations'][Arg]['model']['result']> : NullableColumn<ColumnsObject<T['relations'][Arg]['model']['result']>> : never : never;
-} & {
-    [K in keyof SelectAsArgs]: SelectAsArgs[K] extends keyof T['selectable'] ? T['selectable'][SelectAsArgs[K]]['column'] : SelectAsArgs[K] extends RawExpression ? SelectAsArgs[K]['__column'] : SelectAsArgs[K] extends (q: T) => Query ? SelectSubQueryResult<ReturnType<SelectAsArgs[K]>> : never;
-}>;
-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']>>;
-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;
-declare const processSelectArg: <T extends Query>(q: T, as: string | undefined, arg: SelectArg<T>, columnAs?: string | getValueKey) => SelectItem;
-declare class Select {
-    select<T extends Query, K extends SelectArg<T>[]>(this: T, ...args: K): SelectResult<T, K>;
-    _select<T extends Query, K extends SelectArg<T>[]>(this: T, ...args: K): SelectResult<T, K>;
-    selectAll<T extends Query>(this: T): QuerySelectAll<T>;
-    _selectAll<T extends Query>(this: T): QuerySelectAll<T>;
-}
-
-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 UpsertData<T extends Query> = {
-    update: UpdateData<T>;
-    create: InsertData<T>;
+    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 UpsertResult<T extends Query> = T['hasSelect'] extends true ? SetQueryReturnsOne<T> : SetQueryReturnsVoid<T>;
-declare type UpsertThis = WhereResult<Query> & {
-    returnType: 'one' | 'oneOrThrow';
+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 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 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;
-    queryBuilder: Db;
-    whereQueryBuilder: Query['whereQueryBuilder'];
-    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;
-    hasWhere: boolean;
-    selectable: {
-        [K in keyof Shape]: {
-            as: K;
-            column: Shape[K];
-        };
-    } & {
-        [K in keyof Shape as `${Table}.${StringKey<K>}`]: {
-            as: K;
-            column: Shape[K];
-        };
+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];
+};
+declare type WhereOnJoinItem = {
+    table?: string;
+    query: {
+        as?: string;
     };
-    tableAlias: undefined;
-    windows: PropertyKey[];
-    withData: Query['withData'];
-    joinedTables: Query['joinedTables'];
-    relations: Relations;
-    [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;
-    destroy: Adapter['destroy'];
+} | string;
+declare type AggregateItemOptions = {
+    as?: string;
+    distinct?: boolean;
+    order?: OrderItem[];
+    filter?: WhereItem;
+    filterOr?: WhereItem[];
+    withinGroup?: boolean;
+    over?: string;
+    window?: WindowItem;
 };
-declare type DbOptions<CT extends ColumnTypesBase = ColumnTypes> = ({
-    adapter: Adapter;
-} | Omit<AdapterOptions, 'log'>) & QueryLogOptions & {
-    columnTypes?: CT;
+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 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<T_14 extends ColumnType<unknown, Operators, unknown>>(this: {
-        timestamp(): T_14;
-    }): {
-        createdAt: T_14 & {
-            hasDefault: true;
-        };
-        updatedAt: T_14 & {
-            hasDefault: true;
-        };
-    };
-    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 ColumnOperators<S extends SelectableBase, Column extends keyof S> = {
+    [O in keyof S[Column]['column']['operators']]?: S[Column]['column']['operators'][O]['type'];
 };
-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 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;
@@ -1348,6 +1374,10 @@ declare type ToSqlCtx = {
 };
 declare const toSql: (model: Query, values?: unknown[]) => 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;
@@ -2140,9 +2170,15 @@ declare type ColumnsShape = Record<string, ColumnType>;
 declare type ColumnShapeOutput<Shape extends ColumnsShape> = {
     [K in keyof Shape]: ColumnOutput<Shape[K]>;
 };
-declare type ColumnShapeInput<Shape extends ColumnsShape> = {
+declare type OptionalColumnsForInput<Shape extends ColumnsShape> = {
+    [K in keyof Shape]: SomeIsTrue<[
+        Shape[K]['isNullable'],
+        Shape[K]['hasDefault']
+    ]> extends true ? K : never;
+}[keyof Shape];
+declare type ColumnShapeInput<Shape extends ColumnsShape> = SetOptional<{
     [K in keyof Shape]: ColumnInput<Shape[K]>;
-};
+}, OptionalColumnsForInput<Shape>>;
 declare class ColumnsObject<Shape extends ColumnsShape> extends ColumnType<{
     [K in keyof Shape]: Shape[K]['type'];
 }, typeof Operators.any> {
@@ -2483,13 +2519,16 @@ declare class DoublePrecisionColumn extends NumberAsStringBaseColumn {
 declare class SmallSerialColumn extends IntegerBaseColumn {
     dataType: "smallserial";
     parseItem: typeof parseInt;
+    hasDefault: true;
 }
 declare class SerialColumn extends IntegerBaseColumn {
     dataType: "serial";
     parseItem: typeof parseInt;
+    hasDefault: true;
 }
 declare class BigSerialColumn extends NumberAsStringBaseColumn {
     dataType: "bigserial";
+    hasDefault: true;
 }
 
 declare type BaseStringData = ColumnData & {
@@ -4315,4 +4354,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, OptionalKeys, 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, SortDir, Spread, Sql, StringColumn, StringExpression, StringKey, TableData, TableSchema, TextBaseColumn, TextColumn, TextColumnData, Then, ThenResult, TimeColumn, TimeInterval, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, ToSqlCtx, Transaction, TransactionAdapter, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionToArray, UnionToIntersection, UnionToOvlds, UnknownKeysParam, Update, UpdateData, UpdateQueryData, 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, getTableData, getValidEnumValues, getValueKey, handleResult, identity, instanceOf, intersection, isRaw, isRequiredRelationKey, joinTruthy, jsonTypes, lazy, literal, logColors, logParamToLogObject, map, nativeEnum, newTableData, noop, notNullable, notNullish, nullable, nullish, object, optional, parseRecord, parseResult, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryKeysOfNotSimpleQuery, queryMethodByReturnType, quote, raw, record, relationQueryKey, removeFromQuery, required, resetTableData, scalarTypes, set, setQueryObjectValue, toArray, toSql, 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, 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, Transaction, TransactionAdapter, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionToArray, UnionToIntersection, UnionToOvlds, UnknownKeysParam, Update, UpdateData, UpdateQueryData, 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, getTableData, getValidEnumValues, getValueKey, handleResult, identity, instanceOf, intersection, isRaw, isRequiredRelationKey, joinTruthy, jsonTypes, lazy, literal, logColors, logParamToLogObject, map, nativeEnum, newTableData, noop, notNullable, notNullish, nullable, nullish, object, optional, parseRecord, parseResult, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryKeysOfNotSimpleQuery, queryMethodByReturnType, quote, raw, record, relationQueryKey, removeFromQuery, required, resetTableData, scalarTypes, set, setQueryObjectValue, toArray, toSql, tuple, union };