pqb 0.2.3 → 0.2.4

package/dist/index.d.ts

@@ -230,6 +230,239 @@ declare class WhereQueryBuilder<Q extends QueryBase = QueryBase> extends Where i
     clone<T extends this>(this: T): T;
 }
 
+declare type AggregateArg<T extends Query> = Expression<T> | Record<string, Expression<T>> | [Expression<T>, string];
+declare type AggregateOptions<T extends Query = Query, As extends string | undefined = any> = {
+    as?: As;
+    distinct?: boolean;
+    order?: OrderArg<T> | OrderArg<T>[];
+    filter?: WhereArg<T>;
+    filterOr?: WhereArg<T>[];
+    withinGroup?: boolean;
+    over?: 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;
@@ -241,14 +474,38 @@ declare type InsertBelongsToData<T extends Query, Key extends keyof T['relations
     [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?: WhereArg<Rel['model']>;
+        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?: WhereArg<Rel['model']>;
+        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'] ? {} : {
@@ -298,21 +555,202 @@ 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;
-    } | {
-        set: WhereArg<T['relations'][K]['model']>;
-    } | {
-        delete: boolean;
-    } | {
-        update: UpdateData<T['relations'][K]['model']>;
-    } | {
-        create: InsertData<T['relations'][K]['nestedCreateQuery']>;
-    } | (T['returnType'] extends 'one' | 'oneOrThrow' ? {
-        upsert: {
+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']>;
+    } | {
+        delete: boolean;
+    } | {
+        update: UpdateData<T['relations'][K]['model']>;
+    } | {
+        create: InsertData<T['relations'][K]['nestedCreateQuery']>;
+    } | (T['returnType'] extends 'one' | 'oneOrThrow' ? {
+        upsert: {
             update: UpdateData<T['relations'][K]['model']>;
             create: InsertData<T['relations'][K]['nestedCreateQuery']>;
         };
@@ -373,62 +811,255 @@ 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 UpsertData<T extends Query> = {
+    update: UpdateData<T>;
+    create: InsertData<T>;
 };
-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 UpsertResult<T extends Query> = T['hasSelect'] extends true ? SetQueryReturnsOne<T> : SetQueryReturnsVoid<T>;
+declare type UpsertThis = WhereResult<Query> & {
+    returnType: 'one' | 'oneOrThrow';
 };
-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;
+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;
@@ -497,95 +1128,9 @@ 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 | {
+declare type Sql = {
     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[];
+    values: unknown[];
 };
 declare const queryKeysOfNotSimpleQuery: (keyof SelectQueryData)[];
 declare type CommonQueryData = {
@@ -821,523 +1366,6 @@ declare type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT 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>;
-};
-declare type UpsertResult<T extends Query> = T['hasSelect'] extends true ? SetQueryReturnsOne<T> : SetQueryReturnsVoid<T>;
-declare type UpsertThis = WhereResult<Query> & {
-    returnType: 'one' | 'oneOrThrow';
-};
-declare class QueryUpsert {
-    upsert<T extends UpsertThis>(this: T, data: UpsertData<T>): UpsertResult<T>;
-    _upsert<T extends UpsertThis>(this: T, data: UpsertData<T>): UpsertResult<T>;
-}
-
-declare type 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 ToSqlCtx = {
     whereQueryBuilder: typeof WhereQueryBuilder;
     onQueryBuilder: typeof OnQueryBuilder;