pqb 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,3630 @@
+import { PoolConfig, Pool, PoolClient } from 'pg';
+
+declare type AliasOrTable<T extends Pick<Query, 'tableAlias' | 'table'>> = T['tableAlias'] extends string ? T['tableAlias'] : T['table'] extends string ? T['table'] : never;
+declare type StringKey<K extends PropertyKey> = Exclude<K, symbol | number>;
+declare type RawExpression<C extends ColumnType = ColumnType> = {
+    __raw: string;
+    __values: unknown[];
+    __column: C;
+};
+declare type Expression<T extends Query = Query, C extends ColumnType = ColumnType> = keyof T['selectable'] | RawExpression<C>;
+declare type ExpressionOfType<T extends Query, C extends ColumnType, Type> = {
+    [K in keyof T['selectable']]: ColumnOutput<T['selectable'][K]['column']> extends Type | null ? K : never;
+}[Selectable<T>] | RawExpression<C>;
+declare type NumberExpression<T extends Query, C extends ColumnType = ColumnType> = ExpressionOfType<T, C, number>;
+declare type StringExpression<T extends Query, C extends ColumnType = ColumnType> = ExpressionOfType<T, C, string>;
+declare type BooleanExpression<T extends Query, C extends ColumnType = ColumnType> = ExpressionOfType<T, C, boolean>;
+declare type ExpressionOutput<T extends Query, Expr extends Expression<T>> = Expr extends keyof T['selectable'] ? T['selectable'][Expr]['column'] : Expr extends RawExpression<infer ColumnType> ? ColumnType : never;
+declare const raw: <C extends ColumnType<unknown, Operators, unknown>>(sql: string, ...values: unknown[]) => RawExpression<C>;
+declare const rawColumn: <C extends ColumnType<unknown, Operators, unknown>>(column: C, sql: string, ...values: unknown[]) => RawExpression<C>;
+declare const isRaw: (obj: object) => obj is RawExpression<ColumnType<unknown, Operators, unknown>>;
+declare const getRaw: (raw: RawExpression, values: unknown[]) => string;
+declare const EMPTY_OBJECT: {};
+declare const getQueryParsers: (q: Query) => ColumnsParsers | undefined;
+
+declare type WithSelectable<T extends QueryBase, W extends keyof T['withData']> = T['withData'][W] extends WithDataItem ? StringKey<keyof T['withData'][W]['shape']> | `${T['withData'][W]['table']}.${StringKey<keyof T['withData'][W]['shape']>}` : never;
+declare type JoinArgs<T extends QueryBase, Q extends Query = Query, R extends keyof T['relations'] = keyof T['relations'], W extends keyof T['withData'] = keyof T['withData']> = [relation: R] | [
+    query: Q,
+    conditions: Record<Selectable<Q>, Selectable<T> | RawExpression> | RawExpression
+] | [
+    withAlias: W,
+    conditions: Record<WithSelectable<T, W>, Selectable<T> | RawExpression> | RawExpression
+] | [
+    query: Q,
+    leftColumn: Selectable<Q> | RawExpression,
+    rightColumn: Selectable<T> | RawExpression
+] | [
+    withAlias: W,
+    leftColumn: WithSelectable<T, W> | RawExpression,
+    rightColumn: Selectable<T> | RawExpression
+] | [
+    query: Q,
+    leftColumn: Selectable<Q> | RawExpression,
+    op: string,
+    rightColumn: Selectable<T> | RawExpression
+] | [
+    withAlias: W,
+    leftColumn: WithSelectable<T, W> | RawExpression,
+    op: string,
+    rightColumn: Selectable<T> | RawExpression
+];
+declare type JoinResult<T extends Query, Args extends JoinArgs<T>, A extends Query | keyof T['relations'] = Args[0]> = AddQueryJoinedTable<T, A extends Query ? A : T['relations'] extends Record<string, Relation> ? A extends keyof T['relations'] ? T['relations'][A]['model'] : A extends keyof T['withData'] ? T['withData'][A] extends WithDataItem ? {
+    table: T['withData'][A]['table'];
+    tableAlias: undefined;
+    result: T['withData'][A]['shape'];
+} : never : never : never>;
+declare type JoinCallbackArg<T extends QueryBase> = Query | keyof T['withData'] | keyof T['relations'];
+declare type JoinCallback<T extends QueryBase, Arg extends JoinCallbackArg<T>> = (q: OnQueryBuilder<T, Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
+    table: T['withData'][Arg]['table'];
+    tableAlias: undefined;
+    shape: T['withData'][Arg]['shape'];
+    selectable: {
+        [K in keyof T['withData'][Arg]['shape'] as `${T['withData'][Arg]['table']}.${StringKey<K>}`]: {
+            as: StringKey<K>;
+            column: T['withData'][Arg]['shape'][K];
+        };
+    };
+} : never : Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['model'] : never : never>) => OnQueryBuilder;
+declare type JoinCallbackResult<T extends Query, Arg extends JoinCallbackArg<T>> = AddQueryJoinedTable<T, Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['model'] : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
+    table: T['withData'][Arg]['table'];
+    tableAlias: undefined;
+    result: T['withData'][Arg]['shape'];
+} : never : never : never>;
+declare class Join {
+    join<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    join<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _join<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _join<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    innerJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    innerJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _innerJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _innerJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    leftJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    leftJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _leftJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _leftJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    leftOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    leftOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _leftOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _leftOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    rightJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    rightJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _rightJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _rightJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    rightOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    rightOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _rightOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _rightOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    fullOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    fullOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+    _fullOuterJoin<T extends Query, Args extends JoinArgs<T>>(this: T, ...args: Args): JoinResult<T, Args>;
+    _fullOuterJoin<T extends Query, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): JoinCallbackResult<T, Arg>;
+}
+declare type PickQueryForSelect<T extends QueryBase = QueryBase> = Pick<T, 'table' | 'tableAlias' | 'selectable'>;
+declare type OnArgs<Q extends {
+    selectable: SelectableBase;
+}> = [leftColumn: keyof Q['selectable'], rightColumn: keyof Q['selectable']] | [
+    leftColumn: keyof Q['selectable'],
+    op: string,
+    rightColumn: keyof Q['selectable']
+];
+declare const pushQueryOn: <T extends QueryBase>(q: T, joinFrom: QueryBase | string, joinTo: QueryBase | string, ...on: OnArgs<QueryBase>) => T;
+declare const pushQueryOrOn: typeof pushQueryOn;
+declare const addQueryOn: typeof pushQueryOrOn;
+declare const addQueryOrOn: typeof pushQueryOrOn;
+declare type OnJsonPathEqualsArgs<T extends QueryBase> = [
+    leftColumn: keyof T['selectable'],
+    leftPath: string,
+    rightColumn: keyof T['selectable'],
+    rightPath: string
+];
+declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends PickQueryForSelect = PickQueryForSelect> extends WhereQueryBuilder<Omit<S, 'selectable'> & {
+    selectable: S['selectable'] & J['selectable'];
+}> implements QueryBase {
+    joinTo: QueryBase | string;
+    constructor(q: {
+        table?: string;
+        query: {
+            as?: string;
+        };
+    }, joinTo: QueryBase | string);
+    on<T extends this>(this: T, ...args: OnArgs<T>): T;
+    _on<T extends this>(this: T, ...args: OnArgs<T>): T;
+    orOn<T extends this>(this: T, ...args: OnArgs<T>): T;
+    _orOn<T extends this>(this: T, ...args: OnArgs<T>): T;
+    onJsonPathEquals<T extends this>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
+    _onJsonPathEquals<T extends this>(this: T, ...args: OnJsonPathEqualsArgs<T>): T;
+}
+
+declare type WhereArg<T extends QueryBase> = (Omit<{
+    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'] | null | ColumnOperators<T['selectable'], K> | RawExpression;
+}, 'NOT' | 'OR' | 'IN' | 'EXISTS'> & {
+    NOT?: MaybeArray<WhereArg<T>>;
+    OR?: MaybeArray<WhereArg<T>>[];
+    IN?: MaybeArray<{
+        columns: (keyof T['selectable'])[];
+        values: unknown[][] | Query | RawExpression;
+    }>;
+    EXISTS?: MaybeArray<JoinArgs<T> | JoinCallbackArg<T>>;
+}) | QueryBase | RawExpression | ((q: WhereQueryBuilder<T>) => WhereQueryBuilder);
+declare type WhereInColumn<T extends QueryBase> = keyof T['selectable'] | [keyof T['selectable'], ...(keyof T['selectable'])[]];
+declare type WhereInValues<T extends QueryBase, Column extends WhereInColumn<T>> = Column extends keyof T['selectable'] ? T['selectable'][Column]['column']['type'][] | Query | RawExpression : ({
+    [I in keyof Column]: Column[I] extends keyof T['selectable'] ? T['selectable'][Column[I]]['column']['type'] : never;
+} & {
+    length: Column extends {
+        length: number;
+    } ? Column['length'] : never;
+})[] | Query | RawExpression;
+declare type WhereResult<T extends QueryBase> = Omit<T, 'hasWhere'> & {
+    hasWhere: true;
+};
+declare type WhereInArg<T extends Pick<Query, 'selectable'>> = {
+    [K in keyof T['selectable']]?: T['selectable'][K]['column']['type'][] | Query | RawExpression;
+};
+declare abstract class Where implements QueryBase {
+    abstract clone<T extends this>(this: T): T;
+    abstract selectable: SelectableBase;
+    abstract relations: RelationsBase;
+    abstract withData: WithDataBase;
+    abstract __model: Query;
+    query: QueryData;
+    table?: string;
+    tableAlias?: string;
+    where<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _where<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    whereNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _whereNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    and<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _and<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    andNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _andNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    _orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
+    whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): T;
+    whereIn<T extends Where>(this: T, arg: WhereInArg<T>): T;
+    _whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _whereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    orWhereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _orWhereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    whereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    whereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _whereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _whereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    _orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    _orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
+    whereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    whereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _whereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    _whereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    orWhereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    orWhereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _orWhereExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    _orWhereExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    whereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    whereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _whereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    _whereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    orWhereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    orWhereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+    _orWhereNotExists<T extends Where, Args extends JoinArgs<T>>(this: T, ...args: Args): WhereResult<T>;
+    _orWhereNotExists<T extends Where, Arg extends JoinCallbackArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
+}
+declare class WhereQueryBuilder<Q extends QueryBase = QueryBase> extends Where implements QueryBase {
+    table: Q['table'];
+    tableAlias: Q['tableAlias'];
+    query: QueryData;
+    selectable: Q['selectable'];
+    __model: Query;
+    relations: {};
+    withData: {};
+    constructor(table: Q['table'], tableAlias: Q['tableAlias']);
+    clone<T extends this>(this: T): T;
+}
+
+declare type OptionalKeys<T extends Query> = {
+    [K in keyof T['shape']]: T['shape'][K]['isPrimaryKey'] extends true ? K : T['shape'][K]['isNullable'] extends true ? K : never;
+}[keyof T['shape']];
+declare type InsertData<T extends Query, DefaultKeys extends string = T[defaultsKey] extends string ? T[defaultsKey] : never, Data = SetOptional<SetOptional<T['inputType'], OptionalKeys<T>>, DefaultKeys>> = [keyof T['relations']] extends [never] ? Data : Omit<Data, {
+    [K in keyof T['relations']]: T['relations'][K] extends BelongsToRelation ? T['relations'][K]['options']['foreignKey'] : never;
+}[keyof T['relations']]> & {
+    [Key in keyof T['relations']]: T['relations'][Key] extends BelongsToRelation ? SetOptional<{
+        [K in T['relations'][Key]['options']['foreignKey']]: T['relations'][Key]['options']['foreignKey'] extends keyof T['inputType'] ? T['inputType'][T['relations'][Key]['options']['foreignKey']] : never;
+    }, DefaultKeys> | {
+        [K in Key]: {
+            create?: InsertData<T['relations'][Key]['nestedCreateQuery']>;
+            connect?: WhereArg<T['relations'][Key]['model']>;
+        };
+    } : T['relations'][Key] extends HasOneRelation ? 'through' extends T['relations'][Key]['options'] ? {} : {
+        [K in Key]?: {
+            create?: InsertData<T['relations'][Key]['nestedCreateQuery']>;
+            connect?: WhereArg<T['relations'][Key]['model']>;
+        };
+    } : T['relations'][Key] extends Relation ? 'through' extends T['relations'][Key]['options'] ? {} : {
+        [K in Key]?: {
+            create?: InsertData<T['relations'][Key]['nestedCreateQuery']>[];
+            connect?: WhereArg<T['relations'][Key]['model']>[];
+            connectOrCreate?: {
+                where: WhereArg<T['relations'][Key]['model']>;
+                create: InsertData<T['relations'][Key]['nestedCreateQuery']>;
+            }[];
+        };
+    } : {};
+}[keyof T['relations']];
+declare type InsertOneResult<T extends Query> = T['hasSelect'] extends false ? SetQueryReturnsRowCount<T> : T['returnType'] extends 'all' ? SetQueryReturnsOne<T> : T['returnType'] extends 'one' ? SetQueryReturnsOne<T> : T;
+declare type InsertManyResult<T extends Query> = T['hasSelect'] extends false ? SetQueryReturnsRowCount<T> : T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAll<T> : T;
+declare type OnConflictArg<T extends Query> = keyof T['shape'] | (keyof T['shape'])[] | RawExpression;
+declare class Insert {
+    insert<T extends Query>(this: T, data: InsertData<T>): InsertOneResult<T>;
+    insert<T extends Query>(this: T, data: InsertData<T>[] | {
+        columns: string[];
+        values: RawExpression;
+    }): InsertManyResult<T>;
+    _insert<T extends Query>(this: T, data: InsertData<T>): InsertOneResult<T>;
+    _insert<T extends Query>(this: T, data: InsertData<T>[] | {
+        columns: string[];
+        values: RawExpression;
+    }): InsertManyResult<T>;
+    create<T extends Query>(this: T, data: InsertData<T>): SetQueryReturnsOne<T>;
+    create<T extends Query>(this: T, data: InsertData<T>[] | {
+        columns: string[];
+        values: RawExpression;
+    }): SetQueryReturnsAll<T>;
+    _create<T extends Query>(this: T, data: InsertData<T>): SetQueryReturnsOne<T>;
+    _create<T extends Query>(this: T, data: InsertData<T>[] | {
+        columns: string[];
+        values: RawExpression;
+    }): SetQueryReturnsAll<T>;
+    defaults<T extends Query, Data extends Partial<InsertData<T>>>(this: T, data: Data): T & {
+        [defaultsKey]: keyof Data;
+    };
+    _defaults<T extends Query, Data extends Partial<InsertData<T>>>(this: T, data: Data): T & {
+        [defaultsKey]: keyof Data;
+    };
+    onConflict<T extends Query, Arg extends OnConflictArg<T>>(this: T, arg?: Arg): OnConflictQueryBuilder<T, Arg>;
+    _onConflict<T extends Query, Arg extends OnConflictArg<T> | undefined = undefined>(this: T, arg?: Arg): OnConflictQueryBuilder<T, Arg>;
+}
+declare class OnConflictQueryBuilder<T extends Query, Arg extends OnConflictArg<T> | undefined> {
+    private query;
+    private onConflict;
+    constructor(query: T, onConflict: Arg);
+    ignore(): T;
+    merge(update?: keyof T['shape'] | (keyof T['shape'])[] | Partial<T['inputType']> | RawExpression): T;
+}
+
+declare type UpdateData<T extends Query> = {
+    [K in keyof T['type']]?: T['type'][K] | RawExpression;
+} & (T['relations'] extends Record<string, Relation> ? {
+    [K in keyof T['relations']]?: T['relations'][K]['type'] extends 'belongsTo' ? {
+        disconnect: boolean;
+    } | {
+        set: WhereArg<T['relations'][K]['model']>;
+    } | {
+        delete: boolean;
+    } | {
+        update: UpdateData<T['relations'][K]['model']>;
+    } | (T['returnType'] extends 'one' | 'oneOrThrow' ? {
+        create: InsertData<T['relations'][K]['nestedCreateQuery']>;
+    } | {
+        upsert: {
+            update: UpdateData<T['relations'][K]['model']>;
+            create: InsertData<T['relations'][K]['nestedCreateQuery']>;
+        };
+    } : never) : T['relations'][K]['type'] extends 'hasOne' ? {
+        disconnect: boolean;
+    } | {
+        delete: boolean;
+    } | {
+        update: UpdateData<T['relations'][K]['model']>;
+    } | (T['returnType'] extends 'one' | 'oneOrThrow' ? {
+        set: WhereArg<T['relations'][K]['model']>;
+    } | {
+        upsert: {
+            update: UpdateData<T['relations'][K]['model']>;
+            create: InsertData<T['relations'][K]['nestedCreateQuery']>;
+        };
+    } | {
+        create: InsertData<T['relations'][K]['nestedCreateQuery']>;
+    } : never) : T['relations'][K]['type'] extends 'hasMany' ? {
+        disconnect: MaybeArray<WhereArg<T['relations'][K]['model']>>;
+    } | {
+        delete: MaybeArray<WhereArg<T['relations'][K]['model']>>;
+    } | {
+        update: {
+            where: MaybeArray<WhereArg<T['relations'][K]['model']>>;
+            data: UpdateData<T['relations'][K]['model']>;
+        };
+    } | (T['returnType'] extends 'one' | 'oneOrThrow' ? {
+        set: MaybeArray<WhereArg<T['relations'][K]['model']>>;
+    } | {
+        create: InsertData<T['relations'][K]['nestedCreateQuery']>[];
+    } : never) : T['relations'][K]['type'] extends 'hasAndBelongsToMany' ? {
+        disconnect: MaybeArray<WhereArg<T['relations'][K]['model']>>;
+    } | {
+        set: MaybeArray<WhereArg<T['relations'][K]['model']>>;
+    } | {
+        delete: MaybeArray<WhereArg<T['relations'][K]['model']>>;
+    } | {
+        update: {
+            where: MaybeArray<WhereArg<T['relations'][K]['model']>>;
+            data: UpdateData<T['relations'][K]['model']>;
+        };
+    } | {
+        create: InsertData<T['relations'][K]['nestedCreateQuery']>[];
+    } : never;
+} : {});
+declare type UpdateArgs<T extends Query, ForceAll extends boolean> = (T['hasWhere'] extends true ? true : ForceAll) extends true ? [update: RawExpression | UpdateData<T>, forceAll?: ForceAll] : [update: RawExpression | UpdateData<T>, forceAll: true];
+declare type UpdateResult<T extends Query> = T['hasSelect'] extends false ? SetQueryReturnsRowCount<T> : T;
+declare type ChangeCountArg<T extends Query> = keyof T['shape'] | Partial<Record<keyof T['shape'], number>>;
+declare class Update {
+    update<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
+    _update<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
+    updateOrThrow<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
+    _updateOrThrow<T extends Query, ForceAll extends boolean = false>(this: T, ...args: UpdateArgs<T, ForceAll>): UpdateResult<T>;
+    increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+    _increment<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+    decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+    _decrement<T extends Query>(this: T, data: ChangeCountArg<T>): UpdateResult<T>;
+}
+
+declare type NestedInsertOneItem = {
+    create?: Record<string, unknown>;
+    connect?: WhereArg<QueryBase>;
+};
+declare type NestedInsertManyItems = {
+    create?: Record<string, unknown>[];
+    connect?: WhereArg<QueryBase>[];
+    connectOrCreate?: {
+        where: WhereArg<QueryBase>;
+        create: Record<string, unknown>;
+    }[];
+};
+declare type NestedInsertItem = NestedInsertOneItem | NestedInsertManyItems;
+declare type BelongsToNestedInsert = (query: Query, relationData: NestedInsertOneItem[]) => Promise<Record<string, unknown>[]>;
+declare type HasOneNestedInsert = (query: Query, data: [
+    selfData: Record<string, unknown>,
+    relationData: NestedInsertOneItem
+][]) => Promise<void>;
+declare type HasManyNestedInsert = (query: Query, data: [
+    selfData: Record<string, unknown>,
+    relationData: NestedInsertManyItems
+][]) => Promise<void>;
+declare type NestedUpdateOneItem = {
+    disconnect?: boolean;
+    set?: WhereArg<QueryBase>;
+    delete?: boolean;
+    update?: UpdateData<Query>;
+    upsert?: {
+        update: UpdateData<Query>;
+        create: Record<string, unknown>;
+    };
+    create: Record<string, unknown>;
+};
+declare type NestedUpdateManyItems = {
+    disconnect?: MaybeArray<WhereArg<QueryBase>>;
+    set?: MaybeArray<WhereArg<QueryBase>>;
+    delete?: MaybeArray<WhereArg<QueryBase>>;
+    update?: {
+        where: MaybeArray<WhereArg<QueryBase>>;
+        data: UpdateData<Query>;
+    };
+    create: Record<string, unknown>[];
+};
+declare type 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;
+    joinQuery: Query;
+    nestedCreateQuery: Query;
+    nestedInsert?: BelongsToNestedInsert | HasOneNestedInsert | HasManyNestedInsert;
+    nestedUpdate?: BelongsToNestedUpdate | HasOneNestedUpdate | HasManyNestedUpdate;
+    primaryKey: string;
+    options: {
+        scope?(q: QueryWithTable): QueryWithTable;
+        required?: boolean;
+    };
+};
+interface BelongsToRelation extends BaseRelation {
+    type: 'belongsTo';
+    returns: 'one';
+    options: BaseRelation['options'] & {
+        primaryKey: string;
+        foreignKey: string;
+    };
+}
+interface HasOneRelation extends BaseRelation {
+    type: 'hasOne';
+    returns: 'one';
+    options: BaseRelation['options'] & ({
+        primaryKey: string;
+        foreignKey: string;
+    } | {
+        through: string;
+        source: string;
+    });
+}
+interface HasManyRelation extends BaseRelation {
+    type: 'hasMany';
+    returns: 'many';
+    options: BaseRelation['options'] & ({
+        primaryKey: string;
+        foreignKey: string;
+    } | {
+        through: string;
+        source: string;
+    });
+}
+interface HasAndBelongsToManyRelation extends BaseRelation {
+    type: 'hasAndBelongsToMany';
+    returns: 'many';
+    options: BaseRelation['options'] & {
+        primaryKey: string;
+        foreignKey: string;
+        associationPrimaryKey: string;
+        associationForeignKey: string;
+        joinTable: string;
+    };
+}
+declare type Relation = BelongsToRelation | HasOneRelation | HasManyRelation | HasAndBelongsToManyRelation;
+declare type RelationsBase = Record<never, Relation>;
+declare type relationQueryKey = typeof relationQueryKey;
+declare const relationQueryKey: unique symbol;
+declare type isRequiredRelationKey = typeof isRequiredRelationKey;
+declare const isRequiredRelationKey: unique symbol;
+declare type RelationQueryBase = Query & {
+    [relationQueryKey]: string;
+    [isRequiredRelationKey]: boolean;
+};
+declare type RelationQuery<RelationName extends PropertyKey = string, Params extends Record<string, unknown> = never, Populate extends string = never, T extends Query = Query, Required extends boolean = boolean, Q extends RelationQueryBase = Omit<T, 'tableAlias'> & {
+    tableAlias: RelationName extends string ? RelationName : never;
+    [isRequiredRelationKey]: Required;
+    [relationQueryKey]: string;
+}> = ((params: Params) => Q & {
+    [defaultsKey]: Pick<T['type'], Populate>;
+}) & Q;
+
+interface QueryResultRow {
+    [column: string]: any;
+}
+declare type TypeParsers = Record<number, (input: string) => unknown>;
+declare type Query$1 = 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: Query$1, types?: TypeParsers): Promise<QueryResult<T>>;
+    arrays<R extends any[] = any[]>(query: Query$1, types?: TypeParsers): Promise<QueryArraysResult<R>>;
+    transaction<Result>(cb: (adapter: Adapter) => 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: Query$1, types?: TypeParsers): Promise<QueryResult<T>>;
+    arrays<R extends any[] = any[]>(query: Query$1, types?: TypeParsers): Promise<QueryArraysResult<R>>;
+    transaction<Result>(cb: (adapter: Adapter) => Promise<Result>): Promise<Result>;
+    destroy(): Promise<void>;
+}
+
+declare type QueryLogObject = {
+    colors: boolean;
+    beforeQuery(q: Query, sql: Sql): unknown;
+    afterQuery(q: Query, sql: Sql, logData: unknown): void;
+    onError(error: Error, q: Query, 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 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[];
+};
+declare const queryKeysOfNotSimpleQuery: (keyof SelectQueryData)[];
+declare type CommonQueryData = {
+    adapter: Adapter;
+    handleResult(q: Query, result: QueryResult): Promise<unknown>;
+    returnType: QueryReturnType;
+    [relationQueryKey]?: string;
+    inTransaction?: boolean;
+    wrapInTransaction?: boolean;
+    throwOnNotFound?: boolean;
+    take?: boolean;
+    with?: WithItem[];
+    withShapes?: Record<string, ColumnsShape>;
+    schema?: string;
+    select?: SelectItem[];
+    as?: string;
+    from?: string | Query | RawExpression;
+    and?: WhereItem[];
+    or?: WhereItem[][];
+    parsers?: ColumnsParsers;
+    defaults?: Record<string, unknown>;
+    beforeQuery?: BeforeCallback<Query>[];
+    afterQuery?: AfterCallback<Query>[];
+    log?: QueryLogObject;
+    logger: QueryLogger;
+};
+declare type SelectQueryData = CommonQueryData & {
+    type: undefined;
+    distinct?: Expression[];
+    fromOnly?: boolean;
+    join?: JoinItem[];
+    joinedParsers?: Record<string, ColumnsParsers>;
+    group?: (string | RawExpression)[];
+    having?: HavingItem[];
+    havingOr?: HavingItem[][];
+    window?: WindowItem[];
+    union?: {
+        arg: UnionItem;
+        kind: UnionKind;
+        wrap?: boolean;
+    }[];
+    order?: OrderItem[];
+    limit?: number;
+    offset?: number;
+    for?: {
+        type: 'UPDATE' | 'NO KEY UPDATE' | 'SHARE' | 'KEY SHARE';
+        tableNames?: string[] | RawExpression;
+        mode?: 'NO WAIT' | 'SKIP LOCKED';
+    };
+};
+declare type InsertQueryData = CommonQueryData & {
+    type: 'insert';
+    columns: string[];
+    values: unknown[][] | RawExpression;
+    using?: JoinItem[];
+    join?: JoinItem[];
+    joinedParsers?: Record<string, ColumnsParsers>;
+    onConflict?: {
+        type: 'ignore';
+        expr?: OnConflictItem;
+    } | {
+        type: 'merge';
+        expr?: OnConflictItem;
+        update?: OnConflictMergeUpdate;
+    };
+    beforeInsert?: BeforeCallback<Query>[];
+    afterInsert?: AfterCallback<Query>[];
+};
+declare type UpdateQueryData = CommonQueryData & {
+    type: 'update';
+    data: (Record<string, RawExpression | {
+        op: string;
+        arg: unknown;
+    } | unknown> | RawExpression)[];
+    beforeUpdate?: BeforeCallback<Query>[];
+    afterUpdate?: AfterCallback<Query>[];
+};
+declare type DeleteQueryData = CommonQueryData & {
+    type: 'delete';
+    join?: JoinItem[];
+    joinedParsers?: Record<string, ColumnsParsers>;
+};
+declare type TruncateQueryData = CommonQueryData & {
+    type: 'truncate';
+    restartIdentity?: boolean;
+    cascade?: boolean;
+};
+declare type ColumnInfoQueryData = CommonQueryData & {
+    type: 'columnInfo';
+    column?: string;
+};
+declare type QueryData = SelectQueryData | InsertQueryData | UpdateQueryData | DeleteQueryData | TruncateQueryData | ColumnInfoQueryData;
+declare type WithItem = [
+    as: string,
+    options: WithOptions,
+    query: Query | RawExpression
+];
+declare type WithOptions = {
+    columns?: string[];
+    recursive?: true;
+    materialized?: true;
+    notMaterialized?: true;
+};
+declare type JsonItem<As extends string = string, Type extends ColumnType = ColumnType> = {
+    __json: [
+        kind: 'set',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>,
+        value: unknown,
+        options?: {
+            createIfMissing?: boolean;
+        }
+    ] | [
+        kind: 'insert',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>,
+        value: unknown,
+        options?: {
+            insertAfter?: boolean;
+        }
+    ] | [
+        kind: 'remove',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>
+    ] | [
+        kind: 'pathQuery',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: string,
+        options?: {
+            vars?: string;
+            silent?: boolean;
+        }
+    ];
+};
+declare type SelectItem = string | RelationQuery | AggregateItem | {
+    selectAs: Record<string, string | Query | RawExpression>;
+} | SelectFunctionItem | JsonItem | RawExpression;
+declare type SelectFunctionItem = {
+    function: string;
+    arguments: SelectItem[];
+    as?: string;
+};
+declare type JoinItem = {
+    type: string;
+    args: [relation: string] | [
+        arg: string | QueryWithTable,
+        conditions: Record<string, string | RawExpression> | RawExpression | ((q: unknown) => QueryBase)
+    ] | [
+        arg: string | QueryWithTable,
+        leftColumn: string | RawExpression,
+        rightColumn: string | RawExpression
+    ] | [
+        arg: string | QueryWithTable,
+        leftColumn: string | RawExpression,
+        op: string,
+        rightColumn: string | RawExpression
+    ];
+};
+declare type WhereItem = (Omit<Record<string, unknown | Record<string, unknown | Query | RawExpression> | RawExpression>, 'NOT' | 'AND' | 'OR' | 'IN' | 'EXISTS' | 'ON' | 'ON_JSON_PATH_EQUALS'> & {
+    NOT?: MaybeArray<WhereItem>;
+    AND?: MaybeArray<WhereItem>;
+    OR?: MaybeArray<WhereItem>[];
+    IN?: MaybeArray<WhereInItem>;
+    EXISTS?: MaybeArray<JoinItem['args']>;
+    ON?: WhereOnItem | WhereJsonPathEqualsItem;
+}) | ((q: unknown) => QueryBase) | Query | RawExpression;
+declare type WhereInItem = {
+    columns: string[];
+    values: unknown[][] | Query | RawExpression;
+};
+declare type WhereJsonPathEqualsItem = [
+    leftColumn: string,
+    leftPath: string,
+    rightColumn: string,
+    rightPath: string
+];
+declare type WhereOnItem = {
+    joinFrom: {
+        table?: string;
+        query: {
+            as?: string;
+        };
+    } | string;
+    joinTo: {
+        table?: string;
+        query: {
+            as?: string;
+        };
+    } | string;
+    on: [leftFullColumn: string, rightFullColumn: string] | [leftFullColumn: string, op: string, rightFullColumn: string];
+};
+declare type AggregateItemOptions = {
+    as?: string;
+    distinct?: boolean;
+    order?: OrderItem[];
+    filter?: WhereItem;
+    filterOr?: WhereItem[];
+    withinGroup?: boolean;
+    over?: string;
+    window?: WindowItem;
+};
+declare type SortDir = 'ASC' | 'DESC';
+declare type OrderItem = string | Record<string, SortDir | {
+    dir: SortDir;
+    nulls: 'FIRST' | 'LAST';
+}> | RawExpression;
+declare type AggregateItemArg = Expression | Record<string, Expression> | [Expression, string];
+declare type AggregateItem = {
+    function: string;
+    arg?: AggregateItemArg;
+    options: AggregateItemOptions;
+};
+declare type ColumnOperators<S extends SelectableBase, Column extends keyof S> = {
+    [O in keyof S[Column]['column']['operators']]?: S[Column]['column']['operators'][O]['type'];
+};
+declare type HavingItemObject = Record<string, unknown>;
+declare type HavingItem = Record<string, HavingItemObject> | {
+    count?: number | HavingItemObject;
+} | Query | RawExpression;
+declare type WindowItem = Record<string, WindowDeclaration | RawExpression>;
+declare type WindowDeclaration = {
+    partitionBy?: Expression | Expression[];
+    order?: OrderItem;
+};
+declare type UnionItem = Query | RawExpression;
+declare type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT' | 'EXCEPT ALL';
+declare type OnConflictItem = string | string[] | RawExpression;
+declare type OnConflictMergeUpdate = string | string[] | Record<string, unknown> | RawExpression;
+
+declare const toSql: (model: Query, values?: unknown[]) => Sql;
+
+declare type MaybeArray<T> = T | T[];
+declare type SetOptional<T, K extends PropertyKey> = Omit<T, K> & {
+    [P in K]?: P extends keyof T ? T[P] : never;
+};
+declare type GetTypesOrRaw<T extends [...unknown[]]> = T extends [
+    infer Head,
+    ...infer Tail
+] ? [GetTypeOrRaw<Head>, ...GetTypesOrRaw<Tail>] : [];
+declare type GetTypeOrRaw<T> = T | RawExpression;
+declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
+declare type PopPropertyKeyUnion<U> = UnionToOvlds<U> extends (a: infer A extends PropertyKey) => void ? A : never;
+declare type IsUnion$1<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+declare type PropertyKeyUnionToArray<T, A extends PropertyKey[] = []> = IsUnion$1<T> extends true ? PropertyKeyUnionToArray<Exclude<T, PopPropertyKeyUnion<T>>, [
+    PopPropertyKeyUnion<T>,
+    ...A
+]> : [T, ...A];
+declare type OptionalPropertyNames<T> = {
+    [K in keyof T]-?: {} extends {
+        [P in K]: T[K];
+    } ? K : never;
+}[keyof T];
+declare type SpreadProperties<L, R, K extends keyof L & keyof R> = {
+    [P in K]: L[P] | Exclude<R[P], undefined>;
+};
+declare type Id<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;
+declare type SpreadTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>>;
+declare type Spread<A extends readonly [...any]> = A extends [
+    infer L,
+    ...infer R
+] ? SpreadTwo<L, Spread<R>> : unknown;
+declare type SimpleSpread<A extends readonly [...any]> = A extends [
+    infer L,
+    ...infer R
+] ? L & SimpleSpread<R> : {};
+declare type FilterTuple<T extends readonly any[], E> = T extends [
+    infer F,
+    ...infer R
+] ? [F] extends [E] ? [F, ...FilterTuple<R, E>] : FilterTuple<R, E> : [];
+declare type CoalesceString<Left extends string | undefined, Right extends string> = Left extends undefined ? Right : Left;
+declare function applyMixins(derivedCtor: any, constructors: any[]): void;
+declare const joinTruthy: (...strings: (string | false | undefined)[]) => string;
+declare const getClonedQueryData: (query: QueryData) => QueryData;
+declare const getQueryAs: (q: {
+    table?: string;
+    query: {
+        as?: string;
+    };
+}) => string;
+declare const toArray: <T>(item: T) => T extends unknown[] ? T : [T];
+declare const noop: () => void;
+
+declare type ThenResult<Res> = <T extends Query>(this: T, 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 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 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 SelectArg<T extends QueryBase> = keyof T['selectable'] | (T['relations'] extends Record<string, Relation> ? keyof T['relations'] : never) | RelationQueryBase | SelectAsArg<T>;
+declare type SelectAsArg<T extends QueryBase> = Record<string, keyof T['selectable'] | Query | RawExpression>;
+declare type SelectResult<T extends Query, Args extends SelectArg<T>[], SelectAsArgs = SimpleSpread<FilterTuple<Args, SelectAsArg<QueryBase>>>> = AddQuerySelect<T, {
+    [Arg in Args[number] as Arg extends keyof T['selectable'] ? T['selectable'][Arg]['as'] : Arg extends keyof T['relations'] ? Arg : Arg extends RelationQueryBase ? Arg['tableAlias'] extends string ? Arg['tableAlias'] : never : never]: Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends RelationQueryBase ? Arg['returnType'] extends 'all' ? ArrayOfColumnsObjects<Arg['result']> : Arg['returnType'] extends 'valueOrThrow' ? Arg['result']['value'] : Arg[isRequiredRelationKey] extends true ? ColumnsObject<Arg['result']> : NullableColumn<ColumnsObject<Arg['result']>> : 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 Query ? SelectAsArgs[K]['returnType'] extends 'all' ? ArrayOfColumnsObjects<SelectAsArgs[K]['result']> : ColumnsObject<SelectAsArgs[K]['result']> : never;
+}>;
+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 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 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: false;
+    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]: Query[defaultsKey];
+}
+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 Record<string, AnyColumnTypeCreator>> = 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 Record<string, AnyColumnTypeCreator> = ColumnTypes> = ({
+    adapter: Adapter;
+} | Omit<AdapterOptions, 'log'>) & QueryLogOptions & {
+    columnTypes?: CT;
+};
+declare const createDb: <CT extends Record<string, AnyColumnTypeCreator>>({ 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 UnionArg<T extends Query> = (Omit<Query, 'result'> & {
+    result: T['result'];
+}) | RawExpression;
+declare class Union {
+    union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    unionAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _unionAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    intersect<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _intersect<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    intersectAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _intersectAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    except<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _except<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    exceptAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+    _exceptAll<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
+}
+
+declare type JsonColumnName<T extends Pick<Query, 'selectable'>> = StringKey<{
+    [K in keyof T['selectable']]: T['selectable'][K]['column']['dataType'] extends 'jsonb' ? K : never;
+}[keyof T['selectable']]>;
+declare type ColumnOrJsonMethod<T extends Query> = JsonColumnName<T> | JsonItem;
+declare type JsonSetResult<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string, Type extends ColumnType = Column extends keyof T['shape'] ? T['shape'][Column] : Column extends JsonItem ? Column['__json'][2] : ColumnType> = JsonItem<As, Type> & (Type extends ColumnType ? AddQuerySelect<T, Record<As, Type>> : T);
+declare type JsonPathQueryResult<T extends Query, As extends string, Type extends ColumnType> = JsonItem & AddQuerySelect<T, {
+    [K in As]: Type;
+}>;
+declare class Json {
+    json<T extends Query>(this: T): SetQueryReturnsValueOptional<T, StringColumn>;
+    _json<T extends Query>(this: T): SetQueryReturnsValueOptional<T, StringColumn>;
+    jsonSet<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, value: unknown, options?: {
+        as?: As;
+        createIfMissing?: boolean;
+    }): JsonSetResult<T, Column, As>;
+    _jsonSet<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, column: Column, path: Array<string | number>, value: unknown, options?: {
+        as?: As;
+        createIfMissing?: boolean;
+    }): JsonSetResult<T, Column, As>;
+    jsonInsert<T extends Query, Column extends ColumnOrJsonMethod<T>, As extends string = Column extends JsonItem ? Column['__json'][1] : Column>(this: T, ...args: [
+        column: Column,
+        path: Array<string | number>,
+        value: unknown,
+        options?: {
+            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 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 class Transaction {
+    transaction<T extends Query, Result>(this: T, cb: (query: T) => Promise<Result>): Promise<Result>;
+    transacting<T extends Query>(this: T, query: Query): T;
+    _transacting<T extends Query>(this: T, query: Query): T;
+}
+
+declare type ForQueryBuilder<Q extends Query> = Q & {
+    noWait<T extends ForQueryBuilder<Q>>(this: T): T;
+    _noWait<T extends ForQueryBuilder<Q>>(this: T): T;
+    skipLocked<T extends ForQueryBuilder<Q>>(this: T): T;
+    _skipLocked<T extends ForQueryBuilder<Q>>(this: T): T;
+};
+declare 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 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 ClearStatement = 'with' | 'select' | 'where' | 'union' | 'using' | 'join' | 'group' | 'order' | 'having' | 'limit' | 'offset' | 'counters';
+declare class Clear {
+    clear<T extends Query>(this: T, ...clears: ClearStatement[]): T;
+    _clear<T extends Query>(this: T, ...clears: ClearStatement[]): T;
+}
+
+declare type HavingArgObject<T extends Query, Agg extends keyof Aggregate1ArgumentTypes<T>> = {
+    [Column in Exclude<Aggregate1ArgumentTypes<T>[Agg], RawExpression>]?: T['selectable'][Column]['column']['type'] | (ColumnOperators<T['selectable'], Column> & AggregateOptions<T>);
+};
+declare type HavingArg<T extends Query = Query> = ({
+    [Agg in keyof Aggregate1ArgumentTypes<T>]?: HavingArgObject<T, Agg>;
+} & {
+    count?: number | HavingArgObject<T, 'count'>;
+}) | Query | RawExpression;
+declare class Having {
+    having<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
+    _having<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
+    havingOr<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
+    _havingOr<T extends Query>(this: T, ...args: HavingArg<T>[]): T;
+}
+
+declare class Window {
+    selectRowNumber<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'row_number', As, IntegerColumn>;
+    _selectRowNumber<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'row_number', As, IntegerColumn>;
+    selectRank<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'rank', As, IntegerColumn>;
+    _selectRank<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'rank', As, IntegerColumn>;
+    selectDenseRank<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'dense_rank', As, IntegerColumn>;
+    _selectDenseRank<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'dense_rank', As, IntegerColumn>;
+    selectPercentRank<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'percent_rank', As, IntegerColumn>;
+    _selectPercentRank<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'percent_rank', As, IntegerColumn>;
+    selectCumeDist<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'cume_dist', As, IntegerColumn>;
+    _selectCumeDist<T extends Query, As extends string | undefined = undefined>(this: T, options: WindowFunctionOptions<T, As>): SelectAgg<T, 'cume_dist', As, IntegerColumn>;
+}
+
+declare type UpsertData<T extends Query> = {
+    update: UpdateData<T>;
+    create: InsertData<T>;
+};
+declare type UpsertResult<T extends Query> = T['hasSelect'] extends true ? SetQueryReturnsOne<T> : SetQueryReturnsVoid<T>;
+declare type UpsertThis = WhereResult<Query> & {
+    returnType: 'one' | 'oneOrThrow';
+};
+declare class QueryUpsert {
+    upsert<T extends UpsertThis>(this: T, data: UpsertData<T>): UpsertResult<T>;
+    _upsert<T extends UpsertThis>(this: T, data: UpsertData<T>): UpsertResult<T>;
+}
+
+declare type GetArg<T extends QueryBase> = keyof T['selectable'] | (RelationQueryBase & {
+    returnType: 'value' | 'valueOrThrow';
+}) | 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 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 WindowArg<T extends Query> = Record<string, WindowArgDeclaration<T> | RawExpression>;
+declare type WindowArgDeclaration<T extends Query = Query> = {
+    partitionBy?: Expression<T> | Expression<T>[];
+    order?: OrderArg<T>;
+};
+declare type WindowResult<T extends Query, W extends WindowArg<T>> = SetQueryWindows<T, PropertyKeyUnionToArray<keyof W>>;
+declare type OrderArg<T extends Query> = keyof T['selectable'] | {
+    [K in Selectable<T>]?: SortDir | {
+        dir: SortDir;
+        nulls: 'FIRST' | 'LAST';
+    };
+} | RawExpression;
+interface QueryMethods extends Aggregate, Select, From, Join, With, Union, Json, Insert, Update, Delete, Transaction, For, ColumnInfoMethods, Where, Clear, Having, Window, Then, QueryLog, QueryCallbacks, QueryUpsert, QueryGet {
+}
+declare class QueryMethods {
+    windows: PropertyKey[];
+    __model: Query;
+    all<T extends Query>(this: T): SetQueryReturnsAll<T>;
+    _all<T extends Query>(this: T): SetQueryReturnsAll<T>;
+    take<T extends Query>(this: T): SetQueryReturnsOne<T>;
+    _take<T extends Query>(this: T): SetQueryReturnsOne<T>;
+    takeOptional<T extends Query>(this: T): SetQueryReturnsOneOptional<T>;
+    _takeOptional<T extends Query>(this: T): SetQueryReturnsOneOptional<T>;
+    rows<T extends Query>(this: T): SetQueryReturnsRows<T>;
+    _rows<T extends Query>(this: T): SetQueryReturnsRows<T>;
+    pluck<T extends Query, S extends Expression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
+    _pluck<T extends Query, S extends Expression<T>>(this: T, select: S): SetQueryReturnsPluck<T, S>;
+    exec<T extends Query>(this: T): SetQueryReturnsVoid<T>;
+    _exec<T extends Query>(this: T): SetQueryReturnsVoid<T>;
+    clone<T extends QueryBase>(this: T): T;
+    toSql(this: Query, values?: unknown[]): Sql;
+    distinct<T extends Query>(this: T, ...columns: Expression<T>[]): T;
+    _distinct<T extends Query>(this: T, ...columns: Expression<T>[]): T;
+    find<T extends Query>(this: T, ...args: GetTypesOrRaw<T['schema']['primaryTypes']>): SetQueryReturnsOne<WhereResult<T>>;
+    _find<T extends Query>(this: T, ...args: GetTypesOrRaw<T['schema']['primaryTypes']>): SetQueryReturnsOne<WhereResult<T>>;
+    findOptional<T extends Query>(this: T, ...args: GetTypesOrRaw<T['schema']['primaryTypes']>): SetQueryReturnsOneOptional<WhereResult<T>>;
+    _findOptional<T extends Query>(this: T, ...args: GetTypesOrRaw<T['schema']['primaryTypes']>): SetQueryReturnsOneOptional<WhereResult<T>>;
+    findBy<T extends Query>(this: T, ...args: WhereArg<T>[]): SetQueryReturnsOne<WhereResult<T>>;
+    _findBy<T extends Query>(this: T, ...args: WhereArg<T>[]): SetQueryReturnsOne<WhereResult<T>>;
+    findByOptional<T extends Query>(this: T, ...args: WhereArg<T>[]): SetQueryReturnsOneOptional<WhereResult<T>>;
+    _findByOptional<T extends Query>(this: T, ...args: WhereArg<T>[]): SetQueryReturnsOneOptional<WhereResult<T>>;
+    as<T extends Query, TableAlias extends string>(this: T, tableAlias: TableAlias): SetQueryTableAlias<T, TableAlias>;
+    _as<T extends Query, TableAlias extends string>(this: T, tableAlias: TableAlias): SetQueryTableAlias<T, TableAlias>;
+    withSchema<T extends Query>(this: T, schema: string): T;
+    _withSchema<T extends Query>(this: T, schema: string): T;
+    group<T extends Query>(this: T, ...columns: Expression<T>[]): T;
+    _group<T extends Query>(this: T, ...columns: Expression<T>[]): T;
+    window<T extends Query, W extends WindowArg<T>>(this: T, arg: W): WindowResult<T, W>;
+    _window<T extends Query, W extends WindowArg<T>>(this: T, arg: W): WindowResult<T, W>;
+    wrap<T extends Query, Q extends Query, As extends string = 't'>(this: T, query: Q, as?: As): SetQueryTableAlias<Q, As>;
+    _wrap<T extends Query, Q extends Query, As extends string = 't'>(this: T, query: Q, as?: As): SetQueryTableAlias<Q, As>;
+    order<T extends Query>(this: T, ...args: OrderArg<T>[]): T;
+    _order<T extends Query>(this: T, ...args: OrderArg<T>[]): T;
+    limit<T extends Query>(this: T, arg: number): T;
+    _limit<T extends Query>(this: T, arg: number): T;
+    offset<T extends Query>(this: T, arg: number): T;
+    _offset<T extends Query>(this: T, arg: number): T;
+    exists<T extends Query>(this: T): SetQueryReturnsValueOptional<T, NumberColumn>;
+    _exists<T extends Query>(this: T): SetQueryReturnsValueOptional<T, NumberColumn>;
+    truncate<T extends Query>(this: T, options?: {
+        restartIdentity?: boolean;
+        cascade?: boolean;
+    }): SetQueryReturnsVoid<T>;
+    _truncate<T extends Query>(this: T, options?: {
+        restartIdentity?: boolean;
+        cascade?: boolean;
+    }): SetQueryReturnsVoid<T>;
+}
+
+declare type ColumnParser = (input: unknown) => unknown;
+declare type ColumnsParsers = Record<string, ColumnParser>;
+declare type SelectableBase = Record<PropertyKey, {
+    as: string;
+    column: ColumnType;
+}>;
+declare type WithDataItem = {
+    table: string;
+    shape: ColumnsShape;
+};
+declare type WithDataBase = Record<never, WithDataItem>;
+declare type QueryBase = {
+    query: QueryData;
+    table?: string;
+    tableAlias?: string;
+    clone(): QueryBase;
+    selectable: SelectableBase;
+    __model: Query;
+    relations: RelationsBase;
+    withData: WithDataBase;
+};
+declare type defaultsKey = typeof defaultsKey;
+declare const defaultsKey: unique symbol;
+declare type Query = QueryMethods & {
+    queryBuilder: Db;
+    whereQueryBuilder: typeof WhereQueryBuilder;
+    onQueryBuilder: typeof OnQueryBuilder;
+    table?: string;
+    shape: ColumnsShape;
+    schema: Omit<TableSchema<ColumnsShape>, 'primaryKeys' | 'primaryTypes'> & {
+        primaryKeys: any[];
+        primaryTypes: any[];
+    };
+    type: Record<string, unknown>;
+    inputType: Record<string, unknown>;
+    query: QueryData;
+    result: ColumnsShape;
+    hasSelect: boolean;
+    hasWhere: boolean;
+    selectable: SelectableBase;
+    returnType: QueryReturnType;
+    then: ThenResult<unknown>;
+    tableAlias: string | undefined;
+    joinedTables: Record<string, Pick<Query, 'result' | 'tableAlias' | 'table'>>;
+    windows: PropertyKey[];
+    defaultSelectColumns: string[];
+    columnsParsers?: ColumnsParsers;
+    relations: RelationsBase;
+    withData: WithDataBase;
+    [defaultsKey]?: string;
+};
+declare type Selectable<T extends QueryBase> = StringKey<keyof T['selectable']>;
+declare type QueryWithTable = Query & {
+    table: string;
+};
+declare type DefaultSelectColumns<S extends ColumnsShape> = {
+    [K in keyof S]: S[K]['isHidden'] extends true ? never : K;
+}[StringKey<keyof S>][];
+declare type QueryReturnType = 'all' | 'one' | 'oneOrThrow' | 'rows' | 'pluck' | 'value' | 'valueOrThrow' | 'rowCount' | 'void';
+declare type JoinedTablesBase = Record<string, Pick<Query, 'result' | 'tableAlias' | 'table'>>;
+declare type QueryThen<ReturnType extends QueryReturnType, Result extends ColumnsShape> = ReturnType extends 'all' ? ThenResult<ColumnShapeOutput<Result>[]> : ReturnType extends 'one' ? ThenResult<ColumnShapeOutput<Result> | undefined> : ReturnType extends 'oneOrThrow' ? ThenResult<ColumnShapeOutput<Result>> : ReturnType extends 'value' ? Result extends {
+    value: ColumnType;
+} ? ThenResult<Result['value']['type'] | undefined> : never : ReturnType extends 'valueOrThrow' ? Result extends {
+    value: ColumnType;
+} ? ThenResult<Result['value']['type']> : never : ReturnType extends 'rows' ? ThenResult<ColumnShapeOutput<Result>[keyof Result][][]> : ReturnType extends 'pluck' ? Result extends {
+    pluck: ColumnType;
+} ? ThenResult<Result['pluck']['type'][]> : never : ReturnType extends 'rowCount' ? ThenResult<number> : ReturnType extends 'void' ? ThenResult<void> : never;
+declare type AddQuerySelect<T extends Pick<Query, 'hasSelect' | 'result' | 'then' | 'returnType'>, Result extends ColumnsShape> = T['hasSelect'] extends false ? Omit<T, 'hasSelect' | 'result' | 'then'> & {
+    hasSelect: true;
+    result: Result;
+    then: QueryThen<T['returnType'], Result>;
+} : Omit<T, 'result' | 'then'> & {
+    result: Spread<[T['result'], Result]>;
+    then: QueryThen<T['returnType'], Spread<[T['result'], Result]>>;
+};
+declare type QuerySelectAll<T extends Query> = Omit<T, 'hasSelect' | 'result' | 'then'> & {
+    hasSelect: true;
+    result: T['shape'];
+    then: QueryThen<T['returnType'], T['shape']>;
+};
+declare type SetQueryReturns<T extends Query, R extends QueryReturnType> = Omit<T, 'returnType' | 'then'> & {
+    returnType: R;
+    then: QueryThen<R, T['result']>;
+};
+declare type SetQueryReturnsAll<T extends Query> = SetQueryReturns<T, 'all'>;
+declare type SetQueryReturnsOneOptional<T extends Query> = SetQueryReturns<T, 'one'>;
+declare type SetQueryReturnsOne<T extends Query> = SetQueryReturns<T, 'oneOrThrow'>;
+declare type SetQueryReturnsRows<T extends Query> = SetQueryReturns<T, 'rows'>;
+declare type SetQueryReturnsPluck<T extends Query, S extends keyof T['selectable'] | RawExpression, C extends ColumnType = S extends keyof T['selectable'] ? T['selectable'][S]['column'] : S extends RawExpression ? S['__column'] : never> = Omit<T, 'hasSelect' | 'result' | 'returnType' | 'then'> & {
+    hasSelect: true;
+    result: {
+        pluck: C;
+    };
+    returnType: 'pluck';
+    then: ThenResult<C['type'][]>;
+};
+declare type SetQueryReturnsValueOptional<T extends Query, Arg extends Exclude<GetArg<T>, RawExpression> | ColumnType, Column extends ColumnType = Arg extends ColumnType ? Arg : Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends RelationQueryBase ? Arg['result']['value'] : never> = Omit<T, 'hasSelect' | 'result' | 'returnType' | 'then'> & {
+    hasSelect: true;
+    result: {
+        value: Column;
+    };
+    returnType: 'value';
+    then: ThenResult<Column['type'] | undefined>;
+};
+declare type SetQueryReturnsValue<T extends Query, Arg extends Exclude<GetArg<T>, RawExpression> | ColumnType, Column extends ColumnType = Arg extends ColumnType ? Arg : Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends RelationQueryBase ? Arg['result']['value'] : never> = Omit<T, 'hasSelect' | 'result' | 'returnType' | 'then'> & {
+    hasSelect: true;
+    result: {
+        value: Column;
+    };
+    returnType: 'valueOrThrow';
+    then: ThenResult<Column['type']>;
+};
+declare type SetQueryReturnsRowCount<T extends Query> = SetQueryReturns<T, 'rowCount'>;
+declare type SetQueryReturnsVoid<T extends Query> = SetQueryReturns<T, 'void'>;
+declare type SetQueryReturnsColumnInfo<T extends Query, Column extends keyof T['shape'] | undefined, Result = Column extends keyof T['shape'] ? ColumnInfo : Record<keyof T['shape'], ColumnInfo>> = Omit<T, 'result' | 'returnType' | 'then'> & {
+    result: {
+        value: ColumnType<Result>;
+    };
+    returnType: 'value';
+    then: ThenResult<Result>;
+};
+declare type SetQueryTableAlias<T extends Query, TableAlias extends string> = Omit<T, 'tableAlias' | 'selectable'> & {
+    tableAlias: TableAlias;
+    selectable: Omit<T['selectable'], `${AliasOrTable<T>}.${StringKey<keyof T['shape']>}`> & {
+        [K in keyof T['shape'] as `${TableAlias}.${StringKey<keyof T['shape']>}`]: {
+            as: K;
+            column: T['shape'][K];
+        };
+    };
+};
+declare type SetQueryJoinedTables<T extends Query, Selectable extends Record<string, {
+    as: string;
+    column: ColumnType;
+}>, JoinedTables extends JoinedTablesBase> = Omit<T, 'selectable' | 'joinedTables'> & {
+    selectable: Selectable;
+    joinedTables: JoinedTables;
+};
+declare type AddQueryJoinedTable<T extends Query, J extends Pick<Query, 'result' | 'tableAlias' | 'table'>> = SetQueryJoinedTables<T, T['selectable'] & {
+    [K in keyof J['result'] as `${AliasOrTable<J>}.${StringKey<K>}`]: {
+        as: K;
+        column: J['result'][K];
+    };
+}, string extends keyof T['joinedTables'] ? Record<AliasOrTable<J>, J> : Spread<[T['joinedTables'], Record<AliasOrTable<J>, J>]>>;
+declare type SetQueryWith<T extends Query, WithData extends Record<string, WithDataItem>> = Omit<T, 'withData'> & {
+    withData: WithData;
+};
+declare type AddQueryWith<T extends Query, With extends WithDataItem> = SetQueryWith<T, Spread<[T['withData'], {
+    [K in With['table']]: With;
+}]>>;
+declare type SetQueryWindows<T extends Query, W extends PropertyKey[]> = Omit<T, 'windows'> & {
+    windows: W;
+};
+
+declare type Fn<T> = (key: string, value: T, values: unknown[]) => string;
+declare type Operator<T> = Fn<T> & {
+    type: T;
+};
+declare const createOperator: <T>(fn: Fn<T>) => Fn<T> & {
+    type: T;
+};
+declare type Operators = Record<string, Operator<any>>;
+declare const Operators: {
+    any: {
+        equals: Fn<any> & {
+            type: any;
+        };
+        not: Fn<any> & {
+            type: any;
+        };
+        in: Fn<any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: Fn<any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+    boolean: {
+        equals: Fn<boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: Fn<boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[]> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[];
+        };
+        notIn: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[]> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[];
+        };
+    };
+    number: {
+        lt: Fn<number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        lte: Fn<number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        gt: Fn<number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        gte: Fn<number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        between: Fn<[number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>]> & {
+            type: [number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>];
+        };
+        equals: Fn<number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: Fn<number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[]> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[];
+        };
+        notIn: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[]> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[];
+        };
+    };
+    date: {
+        lt: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        lte: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        gt: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        gte: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        between: Fn<[Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date]> & {
+            type: [Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date];
+        };
+        equals: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        not: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        in: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[]> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[];
+        };
+        notIn: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[]> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[];
+        };
+    };
+    time: {
+        lt: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        lte: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        gt: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        gte: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        between: Fn<[Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date]> & {
+            type: [Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date];
+        };
+        equals: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        not: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        in: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[]> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[];
+        };
+        notIn: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[]> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[];
+        };
+    };
+    text: {
+        contains: Fn<string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: Fn<string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: Fn<string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: Fn<string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: Fn<string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: Fn<string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: Fn<string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: Fn<string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[]> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: Fn<Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[]> & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+    json: {
+        jsonPath: Fn<[path: string, op: string, value: unknown]> & {
+            type: [path: string, op: string, value: unknown];
+        };
+        jsonSupersetOf: Fn<unknown> & {
+            type: unknown;
+        };
+        jsonSubsetOf: Fn<unknown> & {
+            type: unknown;
+        };
+        equals: Fn<unknown> & {
+            type: unknown;
+        };
+        not: Fn<unknown> & {
+            type: unknown;
+        };
+        in: Fn<Query | unknown[] | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: Query | unknown[] | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: Fn<Query | unknown[] | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: Query | unknown[] | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+    array: {
+        equals: Fn<any> & {
+            type: any;
+        };
+        not: Fn<any> & {
+            type: any;
+        };
+        in: Fn<any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: Fn<any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>> & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+};
+
+declare type EmptyObject = Record<never, never>;
+declare const cloneInstance: <T>(instance: T) => T;
+declare const assignMethodsToClass: <Methods extends Record<string, unknown>>(klass: {
+    prototype: unknown;
+}, methods: Methods) => void;
+
+type utils_EmptyObject = EmptyObject;
+declare const utils_cloneInstance: typeof cloneInstance;
+declare const utils_assignMethodsToClass: typeof assignMethodsToClass;
+declare namespace utils {
+  export {
+    utils_EmptyObject as EmptyObject,
+    utils_cloneInstance as cloneInstance,
+    utils_assignMethodsToClass as assignMethodsToClass,
+  };
+}
+
+declare type ColumnOutput<T extends ColumnType> = T['type'];
+declare type ColumnInput<T extends ColumnType> = T['inputType'];
+declare type NullableColumn<T extends ColumnType> = Omit<T, 'type' | 'operators'> & {
+    type: T['type'] | null;
+    isNullable: true;
+    operators: Omit<T['operators'], 'equals' | 'not'> & {
+        equals: Operator<T['type'] | null>;
+        not: Operator<T['type'] | null>;
+    };
+};
+declare type AnyColumnType = ColumnType<any, Record<string, Operator<any>>>;
+declare type AnyColumnTypeCreator = (...args: any[]) => AnyColumnType;
+declare abstract class ColumnType<Type = unknown, Ops extends Operators = Operators, InputType = Type> {
+    abstract dataType: string;
+    abstract operators: Ops;
+    type: Type;
+    inputType: InputType;
+    data: EmptyObject;
+    isPrimaryKey: boolean;
+    isHidden: boolean;
+    isNullable: boolean;
+    encodeFn?: (input: any) => unknown;
+    parseFn?: (input: unknown) => unknown;
+    primaryKey<T extends ColumnType>(this: T): T & {
+        isPrimaryKey: true;
+    };
+    hidden<T extends ColumnType>(this: T): T & {
+        isHidden: true;
+    };
+    nullable<T extends ColumnType>(this: T): NullableColumn<T>;
+    encode<T extends ColumnType, Input>(this: T, fn: (input: Input) => unknown): Omit<T, 'inputType'> & {
+        inputType: Input;
+    };
+    parse<T extends ColumnType, Output>(this: T, fn: (input: T['type']) => Output): Omit<T, 'type'> & {
+        type: Output;
+    };
+    toSQL(): string;
+}
+
+interface BaseNumberData {
+    lt?: number;
+    lte?: number;
+    gt?: number;
+    gte?: number;
+    multipleOf?: number;
+}
+declare type NumberColumn = ColumnType<number>;
+declare type NumberColumnData = BaseNumberData;
+declare type NumberMethods = typeof numberMethods$1;
+declare const numberMethods$1: {
+    lt<T extends ColumnType<unknown, Operators, unknown>, Value extends number>(this: T, value: Value): T & {
+        data: Omit<T["data"], "lt"> & {
+            lt: Value;
+        };
+    };
+    lte<T_1 extends ColumnType<unknown, Operators, unknown>, Value_1 extends number>(this: T_1, value: Value_1): T_1 & {
+        data: Omit<T_1["data"], "lte"> & {
+            lte: Value_1;
+        };
+    };
+    max<T_2 extends ColumnType<unknown, Operators, unknown>, Value_2 extends number>(this: T_2, value: Value_2): T_2 & {
+        data: Omit<T_2["data"], "lte"> & {
+            lte: Value_2;
+        };
+    };
+    gt<T_3 extends ColumnType<unknown, Operators, unknown>, Value_3 extends number>(this: T_3, value: Value_3): T_3 & {
+        data: Omit<T_3["data"], "gt"> & {
+            gt: Value_3;
+        };
+    };
+    gte<T_4 extends ColumnType<unknown, Operators, unknown>, Value_4 extends number>(this: T_4, value: Value_4): T_4 & {
+        data: Omit<T_4["data"], "gte"> & {
+            gte: Value_4;
+        };
+    };
+    min<T_5 extends ColumnType<unknown, Operators, unknown>, Value_5 extends number>(this: T_5, value: Value_5): T_5 & {
+        data: Omit<T_5["data"], "gte"> & {
+            gte: Value_5;
+        };
+    };
+    positive<T_6 extends ColumnType<unknown, Operators, unknown>>(this: T_6): T_6 & {
+        data: Omit<T_6["data"], "gt"> & {
+            gt: 0;
+        };
+    };
+    nonNegative<T_7 extends ColumnType<unknown, Operators, unknown>>(this: T_7): T_7 & {
+        data: Omit<T_7["data"], "gte"> & {
+            gte: 0;
+        };
+    };
+    negative<T_8 extends ColumnType<unknown, Operators, unknown>>(this: T_8): T_8 & {
+        data: Omit<T_8["data"], "lt"> & {
+            lt: 0;
+        };
+    };
+    nonPositive<T_9 extends ColumnType<unknown, Operators, unknown>>(this: T_9): T_9 & {
+        data: Omit<T_9["data"], "lte"> & {
+            lte: 0;
+        };
+    };
+    multipleOf<T_10 extends ColumnType<unknown, Operators, unknown>, Value_6 extends number>(this: T_10, value: Value_6): T_10 & {
+        data: Omit<T_10["data"], "multipleOf"> & {
+            multipleOf: Value_6;
+        };
+    };
+    step<T_11 extends ColumnType<unknown, Operators, unknown>, Value_7 extends number>(this: T_11, value: Value_7): T_11 & {
+        data: Omit<T_11["data"], "multipleOf"> & {
+            multipleOf: Value_7;
+        };
+    };
+};
+interface NumberBaseColumn<Type> extends ColumnType<Type, typeof Operators.number>, NumberMethods {
+}
+declare abstract class NumberBaseColumn<Type> extends ColumnType<Type, typeof Operators.number> {
+    data: BaseNumberData;
+    operators: {
+        lt: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        lte: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        gt: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        gte: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        between: ((key: string, value: [number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>], values: unknown[]) => string) & {
+            type: [number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>];
+        };
+        equals: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[];
+        };
+    };
+}
+interface DecimalColumnData extends NumberColumnData {
+    precision?: number;
+    scale?: number;
+}
+declare class DecimalBaseColumn<Type extends number | bigint, Precision extends number | undefined = undefined, Scale extends number | undefined = undefined> extends NumberBaseColumn<Type> {
+    data: DecimalColumnData & {
+        precision: Precision;
+        scale: Scale;
+    };
+    dataType: "decimal";
+    constructor(precision?: Precision, scale?: Scale);
+    toSQL(): string;
+}
+declare class SmallIntColumn extends NumberBaseColumn<number> {
+    dataType: "smallint";
+}
+declare class IntegerColumn extends NumberBaseColumn<number> {
+    dataType: "integer";
+}
+declare class BigIntColumn extends NumberBaseColumn<bigint> {
+    dataType: "bigint";
+}
+declare class DecimalColumn<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined> extends DecimalBaseColumn<number, Precision, Scale> {
+}
+declare class DecimalBigIntColumn<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined> extends DecimalBaseColumn<bigint, Precision, Scale> {
+}
+declare class RealColumn extends NumberBaseColumn<number> {
+    dataType: "real";
+}
+declare class DoublePrecisionColumn extends NumberBaseColumn<bigint> {
+    dataType: "double precision";
+}
+declare class SmallSerialColumn extends NumberBaseColumn<number> {
+    dataType: "smallserial";
+}
+declare class SerialColumn extends NumberBaseColumn<number> {
+    dataType: "serial";
+}
+declare class BigSerialColumn extends NumberBaseColumn<bigint> {
+    dataType: "bigserial";
+}
+
+interface BaseStringData {
+    min?: number;
+    max?: number;
+    length?: number;
+    email?: boolean;
+    url?: boolean;
+    uuid?: boolean;
+    cuid?: boolean;
+    regex?: RegExp;
+    trim?: boolean;
+}
+declare type StringColumn = ColumnType<string>;
+declare type TextColumnData = BaseStringData;
+declare type TextMethods = typeof textMethods;
+declare const textMethods: {
+    email<T extends ColumnType<string, Operators, string>>(this: T): T & {
+        data: Omit<T["data"], "email"> & {
+            email: true;
+        };
+    };
+    url<T_1 extends ColumnType<string, Operators, string>>(this: T_1): T_1 & {
+        data: Omit<T_1["data"], "url"> & {
+            url: true;
+        };
+    };
+    uuid<T_2 extends ColumnType<string, Operators, string>>(this: T_2): T_2 & {
+        data: Omit<T_2["data"], "uuid"> & {
+            uuid: true;
+        };
+    };
+    cuid<T_3 extends ColumnType<string, Operators, string>>(this: T_3): T_3 & {
+        data: Omit<T_3["data"], "cuid"> & {
+            cuid: true;
+        };
+    };
+    regex<T_4 extends ColumnType<string, Operators, string>, Value extends RegExp>(this: T_4, value: Value): T_4 & {
+        data: Omit<T_4["data"], "regex"> & {
+            regex: Value;
+        };
+    };
+    trim<T_5 extends ColumnType<string, Operators, string>>(this: T_5): T_5 & {
+        data: Omit<T_5["data"], "cuid"> & {
+            trim: true;
+        };
+    };
+    min<T_6 extends {
+        data: {
+            min?: number | undefined;
+        };
+    }, Value_1 extends number>(this: T_6, value: Value_1): T_6 & {
+        data: Omit<T_6["data"], "min"> & {
+            min: Value_1;
+        };
+    };
+    max<T_7 extends {
+        data: {
+            max?: number | undefined;
+        };
+    }, Value_2 extends number>(this: T_7, value: Value_2): T_7 & {
+        data: Omit<T_7["data"], "max"> & {
+            max: Value_2;
+        };
+    };
+    length<T_8 extends {
+        data: {
+            length?: number | undefined;
+        };
+    }, Value_3 extends number>(this: T_8, value: Value_3): T_8 & {
+        data: Omit<T_8["data"], "length"> & {
+            length: Value_3;
+        };
+    };
+};
+interface TextBaseColumn extends ColumnType<string, typeof Operators.text>, TextMethods {
+}
+declare abstract class TextBaseColumn extends ColumnType<string, typeof Operators.text> {
+    data: BaseStringData;
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare abstract class LimitedTextBaseColumn<Limit extends number | undefined = undefined> extends TextBaseColumn {
+    data: TextColumnData & {
+        max: Limit;
+    };
+    constructor(limit?: Limit);
+    toSQL(): string;
+}
+declare class VarCharColumn<Limit extends number | undefined = undefined> extends LimitedTextBaseColumn<Limit> {
+    dataType: "varchar";
+}
+declare class CharColumn<Limit extends number | undefined = undefined> extends LimitedTextBaseColumn<Limit> {
+    dataType: "char";
+}
+declare class TextColumn extends ColumnType<string> {
+    dataType: "text";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class ByteaColumn extends NumberBaseColumn<string> {
+    dataType: "bytea";
+}
+declare class PointColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "point";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class LineColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "point";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class LsegColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "point";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class BoxColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "point";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class PathColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "point";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class PolygonColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "point";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class CircleColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "point";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class MoneyColumn extends NumberBaseColumn<string> {
+    dataType: "money";
+}
+declare class CidrColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "cidr";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class InetColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "inet";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class MacAddrColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "macaddr";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class MacAddr8Column extends ColumnType<string, typeof Operators.text> {
+    dataType: "macaddr8";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class BitColumn<Length extends number | undefined = undefined> extends ColumnType<string, typeof Operators.text> {
+    dataType: "bit";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+    data: {
+        length: Length;
+    };
+    constructor(length?: Length);
+    toSQL(): string;
+}
+declare class BitVaryingColumn<Length extends number | undefined = undefined> extends ColumnType<string, typeof Operators.text> {
+    dataType: "bit varying";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+    data: {
+        length: Length;
+    };
+    constructor(length?: Length);
+    toSQL(): string;
+}
+declare class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "tsvector";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class TsQueryColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "tsquery";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class UUIDColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "uuid";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+declare class XMLColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "uuid";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+
+declare class DateColumn extends ColumnType<string, typeof Operators.date> {
+    dataType: "date";
+    operators: {
+        lt: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        lte: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        gt: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        gte: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        between: ((key: string, value: [Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date], values: unknown[]) => string) & {
+            type: [Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date];
+        };
+        equals: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        not: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[];
+        };
+    };
+}
+interface DateTimeColumnData {
+    precision?: number;
+}
+declare abstract class DateTimeBaseClass<Precision extends number | undefined = undefined> extends ColumnType<string, typeof Operators.date, string | number | Date> {
+    data: DateTimeColumnData & {
+        precision: Precision;
+    };
+    operators: {
+        lt: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        lte: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        gt: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        gte: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        between: ((key: string, value: [Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date], values: unknown[]) => string) & {
+            type: [Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date];
+        };
+        equals: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        not: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[];
+        };
+    };
+    constructor(precision?: Precision);
+    toSQL(): string;
+}
+declare abstract class DateTimeWithTimeZoneBaseClass<Precision extends number | undefined = undefined> extends DateTimeBaseClass<Precision> {
+    abstract baseDataType: string;
+    toSQL(): string;
+}
+declare class TimestampColumn<Precision extends number | undefined = undefined> extends DateTimeBaseClass<Precision> {
+    dataType: "timestamp";
+}
+declare class TimestampWithTimeZoneColumn<Precision extends number | undefined = undefined> extends DateTimeWithTimeZoneBaseClass<Precision> {
+    dataType: "timestamp with time zone";
+    baseDataType: "timestamp";
+}
+declare class TimeColumn<Precision extends number | undefined = undefined> extends DateTimeBaseClass<Precision> {
+    dataType: "time";
+}
+declare class TimeWithTimeZoneColumn<Precision extends number | undefined = undefined> extends DateTimeWithTimeZoneBaseClass<Precision> {
+    dataType: "time with time zone";
+    baseDataType: "time";
+}
+declare class IntervalColumn<Fields extends string | undefined = undefined, Precision extends number | undefined = undefined> extends ColumnType<string, typeof Operators.date> {
+    dataType: "interval";
+    data: DateTimeColumnData & {
+        fields: Fields;
+        precision: Precision;
+    };
+    operators: {
+        lt: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        lte: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        gt: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        gte: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        between: ((key: string, value: [Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date], values: unknown[]) => string) & {
+            type: [Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date];
+        };
+        equals: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        not: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date, values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | Date[];
+        };
+    };
+    constructor(fields?: Fields, precision?: Precision);
+    toSQL(): string;
+}
+
+declare class BooleanColumn extends ColumnType<boolean, typeof Operators.boolean> {
+    dataType: "boolean";
+    operators: {
+        equals: ((key: string, value: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[];
+        };
+    };
+}
+
+declare class EnumColumn<DataType extends string, Type> extends ColumnType<Type, typeof Operators.any> {
+    dataType: DataType;
+    operators: {
+        equals: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        not: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        in: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+    constructor(dataType: DataType);
+}
+
+declare type JSONNullable<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+    type: T['type'] | null;
+    data: T['data'] & {
+        nullable: true;
+    };
+};
+declare type JSONNotNullable<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+    type: Exclude<T['type'], null>;
+    data: Omit<T['data'], 'nullable'>;
+};
+
+declare type JSONNullish<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+    type: T['type'] | undefined | null;
+    data: T['data'] & {
+        nullable: true;
+    };
+};
+declare type JSONNotNullish<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+    type: Exclude<T['type'], undefined | null>;
+    data: Omit<T['data'], 'nullable'>;
+};
+
+declare type JSONIntersection<Left extends JSONTypeAny, Right extends JSONTypeAny> = JSONType<Left['type'] & Right['type'], 'intersection'> & {
+    left: Left;
+    right: Right;
+};
+
+declare type ArrayMethods = typeof arrayMethods;
+declare const arrayMethods: {
+    min<T extends {
+        data: {
+            min?: number;
+        };
+    }, Value extends number>(this: T, value: Value): T & {
+        data: Omit<T["data"], "min"> & {
+            min: Value;
+        };
+    };
+    max<T_1 extends {
+        data: {
+            max?: number;
+        };
+    }, Value_1 extends number>(this: T_1, value: Value_1): T_1 & {
+        data: Omit<T_1["data"], "max"> & {
+            max: Value_1;
+        };
+    };
+    length<T_2 extends {
+        data: {
+            length?: number;
+        };
+    }, Value_2 extends number>(this: T_2, value: Value_2): T_2 & {
+        data: Omit<T_2["data"], "length"> & {
+            length: Value_2;
+        };
+    };
+};
+
+declare type ArrayCardinality = 'many' | 'atLeastOne';
+declare type arrayOutputType<T extends JSONTypeAny, Cardinality extends ArrayCardinality = 'many'> = Cardinality extends 'atLeastOne' ? [T['type'], ...T['type'][]] : T['type'][];
+interface JSONArray<Type extends JSONTypeAny, Cardinality extends ArrayCardinality = 'many'> extends JSONType<arrayOutputType<Type, Cardinality>, 'array'>, ArrayMethods {
+    data: JSONTypeData & {
+        min?: number;
+        max?: number;
+        length?: number;
+    };
+    element: Type;
+    deepPartial(): JSONArray<DeepPartial<Type>, Cardinality>;
+    nonEmpty(this: JSONArray<Type>): JSONArray<Type, 'atLeastOne'> & {
+        data: {
+            min: 1;
+        };
+    };
+}
+
+declare type JSONTypeAny = JSONType<any, string>;
+declare type DeepPartial<T extends JSONTypeAny> = ReturnType<JSONTypeAny['deepPartial']> extends ReturnType<T['deepPartial']> ? T : ReturnType<T['deepPartial']>;
+declare type JSONTypeData = {
+    optional?: true;
+    nullable?: true;
+};
+declare type Primitive = string | number | bigint | boolean | null | undefined;
+declare type JSONType<Type, DataType> = {
+    type: Type;
+    data: JSONTypeData;
+    dataType: DataType;
+    chain: (['transform', (input: unknown) => unknown] | ['to', (input: unknown) => JSONTypeAny | undefined, JSONTypeAny] | ['refine', (input: unknown) => unknown] | ['superRefine', (input: unknown) => unknown])[];
+    optional<T extends JSONTypeAny>(this: T): JSONOptional<T>;
+    required<T extends JSONTypeAny>(this: T): JSONRequired<T>;
+    nullable<T extends JSONTypeAny>(this: T): JSONNullable<T>;
+    notNullable<T extends JSONTypeAny>(this: T): JSONNotNullable<T>;
+    nullish<T extends JSONTypeAny>(this: T): JSONNullish<T>;
+    notNullish<T extends JSONTypeAny>(this: T): JSONNotNullish<T>;
+    deepPartial(): JSONTypeAny;
+    transform<T extends JSONTypeAny, Transformed>(this: T, fn: (input: T['type']) => Transformed): JSONType<Transformed extends PromiseLike<unknown> ? Awaited<Transformed> : Transformed, T['dataType']>;
+    to<T extends JSONTypeAny, ToType extends JSONTypeAny>(this: T, fn: (input: T['type']) => ToType['type'] | undefined, type: ToType): ToType;
+    refine<T extends JSONTypeAny, RefinedOutput extends T['type']>(this: T, check: (arg: T['type']) => unknown): T & {
+        type: RefinedOutput;
+    };
+    superRefine<T extends JSONTypeAny, RefinedOutput extends T['type']>(this: T, check: (arg: T['type']) => unknown): T & {
+        type: RefinedOutput;
+    };
+    and<A extends JSONTypeAny, B extends JSONTypeAny>(this: A, type: B): JSONIntersection<A, B>;
+    or<T extends JSONTypeAny, U extends [JSONTypeAny, ...JSONTypeAny[]]>(this: T, ...types: U): T | U[number];
+    default<T extends JSONTypeAny>(this: T, value: T['type'] | (() => T['type'])): JSONNotNullish<T>;
+    array<T extends JSONTypeAny>(this: T): JSONArray<T>;
+};
+
+declare type JSONOptional<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+    type: T['type'] | undefined;
+    data: T['data'] & {
+        optional: true;
+    };
+};
+declare type JSONRequired<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+    type: Exclude<T['type'], undefined>;
+    data: Omit<T['data'], 'optional'>;
+};
+
+interface JSONNativeEnum<T extends EnumLike> extends JSONType<T[keyof T], 'nativeEnum'> {
+    dataType: 'nativeEnum';
+    enum: T;
+    options: (number | string)[];
+}
+declare type EnumLike = {
+    [k: string]: string | number;
+    [nu: number]: string;
+};
+
+interface JSONMap<Key extends JSONTypeAny, Value extends JSONTypeAny> extends JSONType<Map<Key['type'], Value['type']>, 'map'> {
+    keyType: Key;
+    valueType: Value;
+    deepPartial(): JSONMap<ReturnType<Key['deepPartial']>, ReturnType<Value['deepPartial']>>;
+}
+
+interface JSONInstanceOf<T extends Class> extends JSONType<T, 'instanceOf'> {
+    class: T;
+}
+declare type Class = new (...args: any[]) => any;
+
+interface JSONEnum<T extends EnumValues> extends JSONType<T[number], 'enum'> {
+    enum: {
+        [k in T[number]]: k;
+    };
+    options: T;
+}
+declare type EnumValues = readonly [string, ...string[]];
+
+declare type JSONObjectShape = Record<string, JSONTypeAny>;
+declare type UnknownKeysParam = 'passthrough' | 'strict' | 'strip';
+declare type FullyPartial<T extends JSONObjectShape> = {
+    [K in keyof T]: JSONOptional<T[K]>;
+};
+declare type PartiallyPartial<T extends JSONObjectShape, P extends keyof T> = {
+    [K in keyof T]: K extends P ? JSONOptional<T[K]> : T[K];
+};
+declare type identity<T> = T;
+declare type flatten<T extends object> = identity<{
+    [k in keyof T]: T[k];
+}>;
+declare type optionalKeys<T extends object> = {
+    [k in keyof T]: undefined extends T[k] ? k : never;
+}[keyof T];
+declare type requiredKeys<T extends object> = {
+    [k in keyof T]: undefined extends T[k] ? never : k;
+}[keyof T];
+declare type addQuestionMarks<T extends object> = Partial<Pick<T, optionalKeys<T>>> & Pick<T, requiredKeys<T>>;
+declare type baseObjectOutputType<Shape extends JSONObjectShape> = flatten<addQuestionMarks<{
+    [k in keyof Shape]: Shape[k]['type'];
+}>>;
+declare type objectOutputType<Shape extends JSONObjectShape, Catchall extends JSONTypeAny> = JSONTypeAny extends Catchall ? baseObjectOutputType<Shape> : flatten<baseObjectOutputType<Shape> & {
+    [k: string]: Catchall['type'];
+}>;
+declare type IsEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
+declare type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : KeyType extends ExcludeType ? never : KeyType;
+declare type Except<ObjectType, KeysType extends keyof ObjectType> = {
+    [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+};
+declare type Merge<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
+interface JSONObject<T extends JSONObjectShape, UnknownKeys extends UnknownKeysParam = 'strip', Catchall extends JSONTypeAny = JSONTypeAny, Output = objectOutputType<T, Catchall>> extends JSONType<Output, 'object'> {
+    shape: T;
+    unknownKeys: UnknownKeys;
+    catchAllType: Catchall;
+    extend<S extends JSONObjectShape>(shape: S): JSONObject<Merge<T, S>, UnknownKeys, Catchall>;
+    merge<S extends JSONObjectShape, U extends UnknownKeysParam, C extends JSONTypeAny>(obj: JSONObject<S, U, C>): JSONObject<Merge<T, S>, U, C>;
+    pick<K extends keyof T>(...arr: K[]): JSONObject<Pick<T, K>, UnknownKeys, Catchall>;
+    omit<K extends keyof T>(...arr: K[]): JSONObject<Omit<T, K>, UnknownKeys, Catchall>;
+    partial(): JSONObject<FullyPartial<T>, UnknownKeys, Catchall>;
+    partial<P extends keyof T>(...arr: P[]): JSONObject<PartiallyPartial<T, P>, UnknownKeys, Catchall>;
+    deepPartial(): JSONObject<{
+        [k in keyof T]: JSONOptional<DeepPartial<T[k]>>;
+    }, UnknownKeys, Catchall>;
+    passthrough(): JSONObject<T, 'passthrough', Catchall>;
+    strict(): JSONObject<T, 'strict', Catchall>;
+    strip(): JSONObject<T, 'strip', Catchall>;
+    catchAll<C extends JSONTypeAny>(type: C): JSONObject<T, UnknownKeys, C>;
+}
+
+interface JSONLiteral<T extends Primitive> extends JSONType<T, 'literal'> {
+    value: Primitive;
+}
+
+interface JSONDiscriminatedUnion<Discriminator extends string, Options extends DiscriminatedOptions<Discriminator>> extends JSONType<Options[number]['type'], 'discriminatedUnion'> {
+    discriminator: Discriminator;
+    options: OptionsMap<Discriminator, Options>;
+}
+declare type JSONDiscriminatedObject<Discriminator extends string> = JSONObject<Record<Discriminator, JSONLiteral<Primitive>>>;
+declare type DiscriminatedOptions<Discriminator extends string> = readonly [
+    JSONDiscriminatedObject<Discriminator>,
+    JSONDiscriminatedObject<Discriminator>,
+    ...JSONDiscriminatedObject<Discriminator>[]
+];
+declare type OptionsMap<Discriminator extends string, Options extends DiscriminatedOptions<Discriminator>> = Map<Options[number]['shape'][Discriminator]['value'], Options[number]>;
+
+declare type JSONAny = JSONTypeAny & {
+    dataType: 'any';
+};
+declare type JSONBigInt = JSONType<bigint, 'bigint'> & {
+    data: BaseNumberData;
+} & typeof bigIntMethods;
+declare const bigIntMethods: {
+    lt<T extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }, Value extends number>(this: T, value: Value): T & {
+        data: Omit<T["data"], "lt"> & {
+            lt: Value;
+        };
+    };
+    lte<T_1 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }, Value_1 extends number>(this: T_1, value: Value_1): T_1 & {
+        data: Omit<T_1["data"], "lte"> & {
+            lte: Value_1;
+        };
+    };
+    max<T_2 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }, Value_2 extends number>(this: T_2, value: Value_2): T_2 & {
+        data: Omit<T_2["data"], "lte"> & {
+            lte: Value_2;
+        };
+    };
+    gt<T_3 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }, Value_3 extends number>(this: T_3, value: Value_3): T_3 & {
+        data: Omit<T_3["data"], "gt"> & {
+            gt: Value_3;
+        };
+    };
+    gte<T_4 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }, Value_4 extends number>(this: T_4, value: Value_4): T_4 & {
+        data: Omit<T_4["data"], "gte"> & {
+            gte: Value_4;
+        };
+    };
+    min<T_5 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }, Value_5 extends number>(this: T_5, value: Value_5): T_5 & {
+        data: Omit<T_5["data"], "gte"> & {
+            gte: Value_5;
+        };
+    };
+    positive<T_6 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }>(this: T_6): T_6 & {
+        data: Omit<T_6["data"], "gt"> & {
+            gt: 0;
+        };
+    };
+    nonNegative<T_7 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }>(this: T_7): T_7 & {
+        data: Omit<T_7["data"], "gte"> & {
+            gte: 0;
+        };
+    };
+    negative<T_8 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }>(this: T_8): T_8 & {
+        data: Omit<T_8["data"], "lt"> & {
+            lt: 0;
+        };
+    };
+    nonPositive<T_9 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }>(this: T_9): T_9 & {
+        data: Omit<T_9["data"], "lte"> & {
+            lte: 0;
+        };
+    };
+    multipleOf<T_10 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }, Value_6 extends number>(this: T_10, value: Value_6): T_10 & {
+        data: Omit<T_10["data"], "multipleOf"> & {
+            multipleOf: Value_6;
+        };
+    };
+    step<T_11 extends JSONType<bigint, "bigint"> & {
+        data: BaseNumberData;
+    }, Value_7 extends number>(this: T_11, value: Value_7): T_11 & {
+        data: Omit<T_11["data"], "multipleOf"> & {
+            multipleOf: Value_7;
+        };
+    };
+    dataType: "bigint";
+};
+declare type JSONBoolean = JSONType<boolean, 'boolean'>;
+declare type JSONNaN = JSONType<number, 'nan'>;
+declare type JSONNever = JSONType<unknown, 'never'>;
+declare type JSONNull = JSONType<null, 'null'>;
+declare type JSONNumber = JSONType<number, 'number'> & {
+    data: BaseNumberData;
+} & typeof numberMethods;
+declare const numberMethods: {
+    dataType: "number";
+    lt<T extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }, Value extends number>(this: T, value: Value): T & {
+        data: Omit<T["data"], "lt"> & {
+            lt: Value;
+        };
+    };
+    lte<T_1 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }, Value_1 extends number>(this: T_1, value: Value_1): T_1 & {
+        data: Omit<T_1["data"], "lte"> & {
+            lte: Value_1;
+        };
+    };
+    max<T_2 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }, Value_2 extends number>(this: T_2, value: Value_2): T_2 & {
+        data: Omit<T_2["data"], "lte"> & {
+            lte: Value_2;
+        };
+    };
+    gt<T_3 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }, Value_3 extends number>(this: T_3, value: Value_3): T_3 & {
+        data: Omit<T_3["data"], "gt"> & {
+            gt: Value_3;
+        };
+    };
+    gte<T_4 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }, Value_4 extends number>(this: T_4, value: Value_4): T_4 & {
+        data: Omit<T_4["data"], "gte"> & {
+            gte: Value_4;
+        };
+    };
+    min<T_5 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }, Value_5 extends number>(this: T_5, value: Value_5): T_5 & {
+        data: Omit<T_5["data"], "gte"> & {
+            gte: Value_5;
+        };
+    };
+    positive<T_6 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }>(this: T_6): T_6 & {
+        data: Omit<T_6["data"], "gt"> & {
+            gt: 0;
+        };
+    };
+    nonNegative<T_7 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }>(this: T_7): T_7 & {
+        data: Omit<T_7["data"], "gte"> & {
+            gte: 0;
+        };
+    };
+    negative<T_8 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }>(this: T_8): T_8 & {
+        data: Omit<T_8["data"], "lt"> & {
+            lt: 0;
+        };
+    };
+    nonPositive<T_9 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }>(this: T_9): T_9 & {
+        data: Omit<T_9["data"], "lte"> & {
+            lte: 0;
+        };
+    };
+    multipleOf<T_10 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }, Value_6 extends number>(this: T_10, value: Value_6): T_10 & {
+        data: Omit<T_10["data"], "multipleOf"> & {
+            multipleOf: Value_6;
+        };
+    };
+    step<T_11 extends JSONType<number, "number"> & {
+        data: BaseNumberData;
+    }, Value_7 extends number>(this: T_11, value: Value_7): T_11 & {
+        data: Omit<T_11["data"], "multipleOf"> & {
+            multipleOf: Value_7;
+        };
+    };
+};
+declare type JSONDate = JSONType<Date, 'date'>;
+declare type JSONString = JSONType<string, 'string'> & {
+    data: BaseStringData;
+} & typeof stringMethods;
+declare const stringMethods: {
+    dataType: "string";
+    email<T extends JSONType<number, "string"> & {
+        data: BaseStringData;
+    }>(this: T): T & {
+        data: Omit<T["data"], "email"> & {
+            email: true;
+        };
+    };
+    url<T_1 extends JSONType<number, "string"> & {
+        data: BaseStringData;
+    }>(this: T_1): T_1 & {
+        data: Omit<T_1["data"], "url"> & {
+            url: true;
+        };
+    };
+    uuid<T_2 extends JSONType<number, "string"> & {
+        data: BaseStringData;
+    }>(this: T_2): T_2 & {
+        data: Omit<T_2["data"], "uuid"> & {
+            uuid: true;
+        };
+    };
+    cuid<T_3 extends JSONType<number, "string"> & {
+        data: BaseStringData;
+    }>(this: T_3): T_3 & {
+        data: Omit<T_3["data"], "cuid"> & {
+            cuid: true;
+        };
+    };
+    regex<T_4 extends JSONType<number, "string"> & {
+        data: BaseStringData;
+    }, Value extends RegExp>(this: T_4, value: Value): T_4 & {
+        data: Omit<T_4["data"], "regex"> & {
+            regex: Value;
+        };
+    };
+    trim<T_5 extends JSONType<number, "string"> & {
+        data: BaseStringData;
+    }>(this: T_5): T_5 & {
+        data: Omit<T_5["data"], "cuid"> & {
+            trim: true;
+        };
+    };
+    min<T_6 extends {
+        data: {
+            min?: number | undefined;
+        };
+    }, Value_1 extends number>(this: T_6, value: Value_1): T_6 & {
+        data: Omit<T_6["data"], "min"> & {
+            min: Value_1;
+        };
+    };
+    max<T_7 extends {
+        data: {
+            max?: number | undefined;
+        };
+    }, Value_2 extends number>(this: T_7, value: Value_2): T_7 & {
+        data: Omit<T_7["data"], "max"> & {
+            max: Value_2;
+        };
+    };
+    length<T_8 extends {
+        data: {
+            length?: number | undefined;
+        };
+    }, Value_3 extends number>(this: T_8, value: Value_3): T_8 & {
+        data: Omit<T_8["data"], "length"> & {
+            length: Value_3;
+        };
+    };
+};
+declare type JSONUndefined = JSONType<undefined, 'undefined'>;
+declare type JSONUnknown = JSONType<unknown, 'unknown'>;
+declare type JSONVoid = JSONType<void, 'void'>;
+
+interface JSONTuple<T extends JSONTupleItems | [] = JSONTupleItems, Rest extends JSONTypeAny | null = null> extends JSONType<OutputTypeOfTupleWithRest<T, Rest>, 'tuple'> {
+    items: T;
+    deepPartial(): {
+        [k in keyof T]: T[k] extends JSONTypeAny ? DeepPartial<T[k]> : never;
+    } extends infer PI ? PI extends JSONTupleItems ? JSONTuple<PI> : never : never;
+}
+declare type JSONTupleItems = [JSONTypeAny, ...JSONTypeAny[]];
+declare type AssertArray<T> = T extends unknown[] ? T : never;
+declare type OutputTypeOfTuple<T extends JSONTupleItems | []> = AssertArray<{
+    [k in keyof T]: T[k] extends JSONTypeAny ? T[k]['type'] : never;
+}>;
+declare type OutputTypeOfTupleWithRest<T extends JSONTupleItems | [], Rest extends JSONTypeAny | null = null> = Rest extends JSONTypeAny ? [...OutputTypeOfTuple<T>, ...Rest['type'][]] : OutputTypeOfTuple<T>;
+
+interface JSONSet<Value extends JSONTypeAny> extends JSONType<Set<Value['type']>, 'set'>, ArrayMethods {
+    data: JSONTypeData & {
+        min?: number;
+        max?: number;
+        length?: number;
+    };
+    valueType: Value;
+    deepPartial(): JSONSet<ReturnType<Value['deepPartial']>>;
+    nonEmpty(this: JSONSet<Value>): JSONSet<Value> & {
+        data: {
+            min: 1;
+        };
+    };
+}
+
+interface JSONRecord<Key extends KeyType, Value extends JSONTypeAny> extends JSONType<Record<Key['type'], Value['type']>, 'record'> {
+    keyType: Key;
+    valueType: Value;
+    deepPartial(): JSONRecord<Key, ReturnType<Value['deepPartial']>>;
+}
+declare type KeyType = JSONType<string | number, 'string' | 'number'>;
+declare type Args<Key extends KeyType, Value extends JSONTypeAny> = Args2<Key, Value> | Args1<Key>;
+declare type Args2<Key extends KeyType, Value extends JSONTypeAny> = [
+    key: Key,
+    value: Value
+];
+declare type Args1<Value extends JSONTypeAny> = [value: Value];
+declare function record(...args: Args<JSONString | JSONNumber, JSONTypeAny>): JSONRecord<JSONString | JSONNumber, JSONTypeAny>;
+
+declare type JSONTypes = typeof jsonTypes;
+declare const jsonTypes: {
+    set: <Value extends JSONTypeAny>(valueType: Value) => JSONSet<Value>;
+    tuple: <T extends [] | JSONTupleItems>(items: T) => JSONTuple<T, null>;
+    union: <T_1 extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]>(types: T_1) => T_1[number];
+    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 extends JSONTypeAny>(element: Type) => JSONArray<Type, "many">;
+    discriminatedUnion: <Discriminator extends string, Options extends readonly [JSONObject<Record<Discriminator, JSONLiteral<Primitive>>, "strip", JSONTypeAny, addQuestionMarks<Record<Discriminator, JSONLiteral<Primitive>> extends infer T_3 ? { [k_1 in keyof T_3]: Record<Discriminator, JSONLiteral<Primitive>>[k_1]["type"]; } : never> extends infer T_2 ? { [k in keyof T_2]: addQuestionMarks<Record<Discriminator, JSONLiteral<Primitive>> extends infer T_3 ? { [k_1 in keyof T_3]: Record<Discriminator, JSONLiteral<Primitive>>[k_1]["type"]; } : never>[k]; } : never>, JSONObject<Record<Discriminator, JSONLiteral<Primitive>>, "strip", JSONTypeAny, addQuestionMarks<Record<Discriminator, JSONLiteral<Primitive>> extends infer T_3 ? { [k_1 in keyof T_3]: Record<Discriminator, JSONLiteral<Primitive>>[k_1]["type"]; } : never> extends infer T_2 ? { [k in keyof T_2]: addQuestionMarks<Record<Discriminator, JSONLiteral<Primitive>> extends infer T_3 ? { [k_1 in keyof T_3]: Record<Discriminator, JSONLiteral<Primitive>>[k_1]["type"]; } : never>[k]; } : never>, ...JSONObject<Record<Discriminator, JSONLiteral<Primitive>>, "strip", JSONTypeAny, addQuestionMarks<Record<Discriminator, JSONLiteral<Primitive>> extends infer T_3 ? { [k_1 in keyof T_3]: Record<Discriminator, JSONLiteral<Primitive>>[k_1]["type"]; } : never> extends infer T_2 ? { [k in keyof T_2]: addQuestionMarks<Record<Discriminator, JSONLiteral<Primitive>> extends infer T_3 ? { [k_1 in keyof T_3]: Record<Discriminator, JSONLiteral<Primitive>>[k_1]["type"]; } : never>[k]; } : never>[]]>(discriminator: Discriminator, options: Options) => JSONDiscriminatedUnion<Discriminator, Options>;
+    enum: <T_4 extends readonly [string, ...string[]]>(options: T_4) => JSONEnum<T_4>;
+    instanceOf: <T_5 extends new (...args: any[]) => any>(cls: T_5) => JSONInstanceOf<T_5>;
+    intersection: <Left extends JSONTypeAny, Right extends JSONTypeAny>(left: Left, right: Right) => JSONIntersection<Left, Right>;
+    lazy: <T_6 extends JSONTypeAny>(fn: () => T_6) => void;
+    literal: <T_7 extends Primitive>(value: T_7) => JSONLiteral<T_7>;
+    map: <Key extends JSONTypeAny, Value_1 extends JSONTypeAny>(keyType: Key, valueType: Value_1) => JSONMap<Key, Value_1>;
+    nativeEnum: <T_8 extends {
+        [k: string]: string | number;
+        [nu: number]: string;
+    }>(givenEnum: T_8) => JSONNativeEnum<T_8>;
+    nullable: <T_9 extends JSONTypeAny>(type: T_9) => JSONNullable<T_9>;
+    nullish: <T_10 extends JSONTypeAny>(type: T_10) => JSONNullish<T_10>;
+    object: <T_11 extends JSONObjectShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends JSONTypeAny = JSONTypeAny>(shape: T_11) => JSONObject<T_11, UnknownKeys, Catchall, JSONTypeAny extends Catchall ? addQuestionMarks<{ [k_3 in keyof T_11]: T_11[k_3]["type"]; }> extends infer T_12 ? { [k_2 in keyof T_12]: addQuestionMarks<{ [k_3 in keyof T_11]: T_11[k_3]["type"]; }>[k_2]; } : never : (addQuestionMarks<{ [k_3 in keyof T_11]: T_11[k_3]["type"]; }> extends infer T_12 ? { [k_2 in keyof T_12]: addQuestionMarks<{ [k_3 in keyof T_11]: T_11[k_3]["type"]; }>[k_2]; } : never) & {
+        [k: string]: Catchall["type"];
+    } extends infer T_13 ? { [k_4 in keyof T_13]: ((addQuestionMarks<{ [k_3 in keyof T_11]: T_11[k_3]["type"]; }> extends infer T_12 ? { [k_2 in keyof T_12]: addQuestionMarks<{ [k_3 in keyof T_11]: T_11[k_3]["type"]; }>[k_2]; } : never) & {
+        [k: string]: Catchall["type"];
+    })[k_4]; } : never>;
+    optional: <T_14 extends JSONTypeAny>(type: T_14) => JSONOptional<T_14>;
+    record: typeof record;
+};
+declare class JSONColumn<Type extends JSONTypeAny = JSONTypeAny> extends ColumnType<Type['type'], typeof Operators.json> {
+    dataType: "jsonb";
+    operators: {
+        jsonPath: ((key: string, value: [path: string, op: string, value: unknown], values: unknown[]) => string) & {
+            type: [path: string, op: string, value: unknown];
+        };
+        jsonSupersetOf: ((key: string, value: unknown, values: unknown[]) => string) & {
+            type: unknown;
+        };
+        jsonSubsetOf: ((key: string, value: unknown, values: unknown[]) => string) & {
+            type: unknown;
+        };
+        equals: ((key: string, value: unknown, values: unknown[]) => string) & {
+            type: unknown;
+        };
+        not: ((key: string, value: unknown, values: unknown[]) => string) & {
+            type: unknown;
+        };
+        in: ((key: string, value: Query | unknown[] | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: Query | unknown[] | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: ((key: string, value: Query | unknown[] | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: Query | unknown[] | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+    data: {
+        schema: Type;
+    };
+    constructor(schemaOrFn: Type | ((j: JSONTypes) => Type));
+}
+declare class JSONTextColumn extends ColumnType<string, typeof Operators.text> {
+    dataType: "json";
+    operators: {
+        contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        containsInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        startsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWith: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        endsWithInsensitive: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        equals: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
+        };
+    };
+}
+
+declare class ArrayColumn<Item extends ColumnType> extends ColumnType<Item['type'][], typeof Operators.array> {
+    dataType: "array";
+    operators: {
+        equals: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        not: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        in: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+    data: {
+        item: Item;
+    };
+    constructor(item: Item);
+    toSQL(): string;
+}
+
+declare type ColumnTypes = typeof columnTypes;
+declare const columnTypes: {
+    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>;
+    numericBigInt: <Precision_1 extends number | undefined = undefined, Scale_1 extends number | undefined = undefined>(precision?: Precision_1 | undefined, scale?: Scale_1 | undefined) => DecimalBigIntColumn<Precision_1, Scale_1>;
+    decimal: <Precision_2 extends number | undefined = undefined, Scale_2 extends number | undefined = undefined>(precision?: Precision_2 | undefined, scale?: Scale_2 | undefined) => DecimalColumn<Precision_2, Scale_2>;
+    decimalBigInt: <Precision_3 extends number | undefined = undefined, Scale_3 extends number | undefined = undefined>(precision?: Precision_3 | undefined, scale?: Scale_3 | undefined) => DecimalBigIntColumn<Precision_3, Scale_3>;
+    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;
+    bytea: () => ByteaColumn;
+    date: () => DateColumn;
+    timestamp: <Precision_4 extends number | undefined = undefined>(precision?: Precision_4 | undefined) => TimestampColumn<Precision_4>;
+    timestampWithTimeZone: <Precision_5 extends number | undefined = undefined>(precision?: Precision_5 | undefined) => TimestampWithTimeZoneColumn<Precision_5>;
+    time: <Precision_6 extends number | undefined = undefined>(precision?: Precision_6 | undefined) => TimeColumn<Precision_6>;
+    timeWithTimeZone: <Precision_7 extends number | undefined = undefined>(precision?: Precision_7 | undefined) => TimeWithTimeZoneColumn<Precision_7>;
+    interval: <Fields extends string | undefined = undefined, Precision_8 extends number | undefined = undefined>(fields?: Fields | undefined, precision?: Precision_8 | undefined) => IntervalColumn<Fields, Precision_8>;
+    boolean: () => BooleanColumn;
+    enum: <DataType extends string, Type>(dataType: DataType) => EnumColumn<DataType, Type>;
+    point: () => PointColumn;
+    line: () => LineColumn;
+    lseg: () => LsegColumn;
+    box: () => BoxColumn;
+    path: () => PathColumn;
+    polygon: () => PolygonColumn;
+    circle: () => CircleColumn;
+    cidr(): CidrColumn;
+    inet: () => InetColumn;
+    macaddr: () => MacAddrColumn;
+    macaddr8: () => MacAddr8Column;
+    bit: () => BitColumn<undefined>;
+    bitVarying: () => BitVaryingColumn<undefined>;
+    tsvector: () => TsVectorColumn;
+    tsquery: () => TsQueryColumn;
+    uuid: () => UUIDColumn;
+    xml: () => XMLColumn;
+    json: <Type_1 extends JSONTypeAny>(schemaOrFn: Type_1 | ((j: JSONTypes) => Type_1)) => JSONColumn<Type_1>;
+    jsonText: () => JSONTextColumn;
+    array: <Item extends ColumnType<unknown, Operators, unknown>>(item: Item) => ArrayColumn<Item>;
+};
+
+declare type ColumnsShape = Record<string, ColumnType>;
+declare type ColumnShapeOutput<Shape extends ColumnsShape> = {
+    [K in keyof Shape]: ColumnOutput<Shape[K]>;
+};
+declare type ColumnShapeInput<Shape extends ColumnsShape> = {
+    [K in keyof Shape]: ColumnInput<Shape[K]>;
+};
+declare class ColumnsObject<Shape extends ColumnsShape> extends ColumnType<{
+    [K in keyof Shape]: Shape[K]['type'];
+}, typeof Operators.any> {
+    shape: Shape;
+    dataType: string;
+    operators: {
+        equals: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        not: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        in: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+    constructor(shape: Shape);
+}
+declare class ArrayOfColumnsObjects<Shape extends ColumnsShape> extends ColumnType<{
+    [K in keyof Shape]: Shape[K]['type'];
+}[], typeof Operators.any> {
+    shape: Shape;
+    dataType: string;
+    operators: {
+        equals: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        not: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        in: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+    constructor(shape: Shape);
+}
+declare type UnionKeyofToOvlds<S, U> = UnionToIntersection<U extends keyof S ? (f: U) => void : never>;
+declare type PopKeyofColumnShapeUnion<S extends ColumnsShape, U extends keyof S> = UnionKeyofToOvlds<S, U> extends (a: infer A extends keyof S) => void ? A : never;
+declare type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+declare type UnionToArray<S extends ColumnsShape, T extends keyof S, A extends [...(keyof S)[]] = []> = IsUnion<T> extends true ? UnionToArray<S, Exclude<T, PopKeyofColumnShapeUnion<S, T>>, [
+    PopKeyofColumnShapeUnion<S, T>,
+    ...A
+]> : [T, ...A];
+declare type GetPrimaryKeys<S extends ColumnsShape> = UnionToArray<S, {
+    [K in keyof S]: S[K] extends {
+        isPrimaryKey: true;
+    } ? K : never;
+}[keyof S]>;
+declare type GetPrimaryTypes<S extends ColumnsShape, Keys extends [...(keyof S | string)[]] = GetPrimaryKeys<S>> = GetTypesFromKeys<S, Keys>;
+declare type GetTypesFromKeys<S extends ColumnsShape, T extends [...(keyof S)[]]> = T extends [
+    infer Head extends keyof S,
+    ...infer Tail extends [...(keyof S)[]]
+] ? [GetTypeFromKey<S, Head>, ...GetTypesFromKeys<S, Tail>] : [];
+declare type GetTypeFromKey<S extends ColumnsShape, T extends keyof S> = S[T]['type'];
+declare class TableSchema<Shape extends ColumnsShape> {
+    shape: Shape;
+    primaryKeys: string extends keyof Shape ? string[] : GetPrimaryKeys<Shape>;
+    primaryTypes: GetPrimaryTypes<Shape>;
+    constructor(shape: Shape);
+}
+
+declare type Value = any;
+declare const quote: (value: Value) => string;
+
+declare const removeFromQuery: <T extends Query>(q: T, key: string) => T;
+declare const pushQueryArray: <T extends {
+    query: QueryData;
+}>(q: T, key: string, value: unknown) => T;
+declare const pushQueryValue: <T extends {
+    query: QueryData;
+}>(q: T, key: string, value: unknown) => T;
+declare const setQueryObjectValue: <T extends {
+    query: QueryData;
+}>(q: T, object: string, key: string, value: unknown) => T;
+
+declare class NotFoundError extends Error {
+    constructor(message?: string);
+}
+declare class MoreThanOneRowError extends Error {
+}
+
+export { Adapter, AdapterOptions, AddQueryJoinedTable, AddQuerySelect, AddQueryWith, AggregateItem, AggregateItemArg, AggregateItemOptions, AliasOrTable, AnyColumnType, AnyColumnTypeCreator, ArrayColumn, ArrayOfColumnsObjects, BaseNumberData, BaseRelation, BaseStringData, BelongsToNestedInsert, BelongsToNestedUpdate, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CoalesceString, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnInput, ColumnOperators, ColumnOutput, ColumnParser, ColumnShapeInput, ColumnShapeOutput, ColumnType, ColumnTypes, ColumnsObject, ColumnsParsers, ColumnsShape, CommonQueryData, DateColumn, DateTimeBaseClass, DateTimeColumnData, DateTimeWithTimeZoneBaseClass, Db, DbOptions, DbTableOptions, DecimalBaseColumn, DecimalBigIntColumn, DecimalColumn, DecimalColumnData, DefaultSelectColumns, DeleteQueryData, DoublePrecisionColumn, EMPTY_OBJECT, EnumColumn, Expression, ExpressionOfType, ExpressionOutput, FilterTuple, GetTypeOrRaw, GetTypesOrRaw, HasAndBelongsToManyRelation, HasManyNestedInsert, HasManyNestedUpdate, HasManyRelation, HasOneNestedInsert, HasOneNestedUpdate, HasOneRelation, HavingItem, InetColumn, Insert, InsertData, InsertQueryData, IntegerColumn, IntervalColumn, JSONColumn, JSONTextColumn, JSONTypes, Join, JoinArgs, JoinCallback, JoinCallbackArg, JoinItem, JoinedTablesBase, JsonItem, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MaybeArray, MoneyColumn, MoreThanOneRowError, NestedInsertItem, NestedInsertManyItems, NestedInsertOneItem, NestedUpdateItem, NestedUpdateManyItems, NestedUpdateOneItem, NotFoundError, NullableColumn, NumberBaseColumn, NumberColumn, NumberColumnData, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OptionalKeys, OrderArg, OrderItem, PathColumn, PointColumn, PolygonColumn, PropertyKeyUnionToArray, Query, QueryArraysResult, QueryBase, QueryData, QueryMethods, QueryResult, QueryResultRow, QueryReturnType, QuerySelectAll, QueryWithTable, RawExpression, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationsBase, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SerialColumn, SetOptional, SetQueryJoinedTables, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumnInfo, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWindows, SetQueryWith, SimpleSpread, SmallIntColumn, SmallSerialColumn, SortDir, Spread, Sql, StringColumn, StringExpression, StringKey, TableSchema, TextBaseColumn, TextColumn, TextColumnData, Then, ThenResult, TimeColumn, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, Transaction, TransactionAdapter, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnionItem, UnionToArray, UnionToIntersection, UnionToOvlds, UpdateQueryData, VarCharColumn, WhereInItem, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addQueryOn, addQueryOrOn, applyMixins, columnTypes, utils as columnUtils, createDb, createOperator, defaultsKey, getClonedQueryData, getQueryAs, getQueryParsers, getRaw, handleResult, isRaw, isRequiredRelationKey, joinTruthy, noop, parseRecord, parseResult, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryKeysOfNotSimpleQuery, queryMethodByReturnType, quote, raw, rawColumn, relationQueryKey, removeFromQuery, setQueryObjectValue, toArray, toSql };