pqb 0.0.3 → 0.0.4

package/dist/index.d.ts

@@ -0,0 +1,4154 @@
+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>>(...args: [column: C, sql: string, ...values: unknown[]] | [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 const addWhere: <T extends Where>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const addWhereNot: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const addOr: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const addOrNot: <T extends QueryBase>(q: T, args: WhereArg<T>[]) => WhereResult<T>;
+declare const addWhereIn: <T extends QueryBase>(q: T, and: boolean, arg: unknown, values: unknown[] | unknown[][] | Query | RawExpression | undefined, not?: boolean) => WhereResult<T>;
+declare abstract class Where implements QueryBase {
+    abstract clone<T extends this>(this: T): T;
+    abstract selectable: SelectableBase;
+    abstract 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']>;
+    } | {
+        create: InsertData<T['relations'][K]['nestedCreateQuery']>;
+    } | (T['returnType'] extends 'one' | 'oneOrThrow' ? {
+        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 QueryInput = string | {
+    text: string;
+    values?: unknown[];
+};
+declare type QueryResult<T extends QueryResultRow = any> = {
+    rowCount: number;
+    rows: T[];
+};
+declare type QueryArraysResult<R extends any[] = any[]> = {
+    rowCount: number;
+    rows: R[];
+    fields: {
+        name: string;
+    }[];
+};
+declare type AdapterOptions = Omit<PoolConfig, 'types'> & {
+    types?: TypeParsers;
+};
+declare class Adapter {
+    types: TypeParsers;
+    pool: Pool;
+    constructor({ types, ...config }: AdapterOptions);
+    query<T extends QueryResultRow = any>(query: QueryInput, types?: TypeParsers): Promise<QueryResult<T>>;
+    arrays<R extends any[] = any[]>(query: QueryInput, types?: TypeParsers): Promise<QueryArraysResult<R>>;
+    transaction<Result>(cb: (adapter: TransactionAdapter) => Promise<Result>): Promise<Result>;
+    destroy(): Promise<void>;
+}
+declare class TransactionAdapter implements Adapter {
+    pool: Pool;
+    client: PoolClient;
+    types: TypeParsers;
+    constructor(pool: Pool, client: PoolClient, types: TypeParsers);
+    query<T extends QueryResultRow = any>(query: QueryInput, types?: TypeParsers): Promise<QueryResult<T>>;
+    arrays<R extends any[] = any[]>(query: QueryInput, types?: TypeParsers): Promise<QueryArraysResult<R>>;
+    transaction<Result>(cb: (adapter: TransactionAdapter) => Promise<Result>): Promise<Result>;
+    destroy(): Promise<void>;
+}
+
+declare type QueryLogObject = {
+    colors: boolean;
+    beforeQuery(sql: Sql): unknown;
+    afterQuery(sql: Sql, logData: unknown): void;
+    onError(error: Error, sql: Sql, logData: unknown): void;
+};
+declare type QueryLogger = {
+    log(message: string): void;
+    error(message: string): void;
+};
+declare type QueryLogOptions = {
+    log?: boolean | Partial<QueryLogObject>;
+    logger?: QueryLogger;
+};
+declare const logColors: {
+    boldCyanBright: (message: string) => string;
+    boldBlue: (message: string) => string;
+    boldYellow: (message: string) => string;
+    boldMagenta: (message: string) => string;
+    boldRed: (message: string) => string;
+};
+declare const logParamToLogObject: (logger: QueryLogger, log: QueryLogOptions['log']) => QueryLogObject | undefined;
+declare class QueryLog {
+    log<T extends Query>(this: T, log?: boolean): T;
+    _log<T extends Query>(this: T, log?: boolean): T;
+}
+
+declare type BeforeCallback<T extends Query> = (query: T) => void | Promise<void>;
+declare type AfterCallback<T extends Query> = (query: T, data: unknown) => void | Promise<void>;
+declare class QueryCallbacks {
+    beforeQuery<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    _beforeQuery<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    afterQuery<T extends Query>(this: T, cb: AfterCallback<T>): T;
+    _afterQuery<T extends Query>(this: T, cb: AfterCallback<T>): T;
+    beforeInsert<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    _beforeInsert<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    afterInsert<T extends Query>(this: T, cb: AfterCallback<T>): T;
+    _afterInsert<T extends Query>(this: T, cb: AfterCallback<T>): T;
+    beforeUpdate<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    _beforeUpdate<T extends Query>(this: T, cb: BeforeCallback<T>): T;
+    afterUpdate<T extends Query>(this: T, cb: AfterCallback<T>): T;
+    _afterUpdate<T extends Query>(this: T, cb: AfterCallback<T>): T;
+}
+
+declare type Sql = {
+    text: string;
+    values: unknown[];
+};
+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 EmptyObject = typeof emptyObject;
+declare const emptyObject: {};
+
+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 const aggregate1FunctionNames: {
+    readonly count: "count";
+    readonly avg: "avg";
+    readonly min: "min";
+    readonly max: "max";
+    readonly sum: "sum";
+    readonly bitAnd: "bit_and";
+    readonly bitOr: "bit_or";
+    readonly boolAnd: "bool_and";
+    readonly boolOr: "bool_or";
+    readonly every: "every";
+    readonly jsonAgg: "json_agg";
+    readonly jsonbAgg: "jsonb_agg";
+    readonly xmlAgg: "xmlagg";
+};
+declare type SelectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnType> = AddQuerySelect<T, Record<CoalesceString<As, Func>, Value>>;
+declare type AT1<T extends Query> = Aggregate1ArgumentTypes<T>;
+declare type WindowFunctionOptions<T extends Query = Query, As extends string | undefined = any> = {
+    as?: As;
+} & WindowArgDeclaration<T>;
+declare class Aggregate {
+    selectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnType>(this: T, functionName: Func, arg: AggregateArg<T>, options?: AggregateOptions<T, As>): SelectAgg<T, Func, As, Value>;
+    _selectAgg<T extends Query, Func extends string, As extends string | undefined, Value extends ColumnType>(this: T, functionName: Func, arg: AggregateArg<T>, options?: AggregateOptions<T, As>, columnType?: ColumnType): SelectAgg<T, Func, As, Value>;
+    count<T extends Query>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T>): SetQueryReturnsValue<T, NumberColumn>;
+    _count<T extends Query>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T>): SetQueryReturnsValue<T, NumberColumn>;
+    selectCount<T extends Query, As extends string | undefined = undefined>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T, As>): SelectAgg<T, 'count', As, NumberColumn>;
+    _selectCount<T extends Query, As extends string | undefined = undefined>(this: T, arg?: AT1<T>['count'] | '*', options?: AggregateOptions<T, As>): SelectAgg<T, 'count', As, NumberColumn>;
+    avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _avg<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['avg'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
+    _selectAvg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'avg', As, NullableColumn<NumberColumn>>;
+    min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _min<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['min'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
+    _selectMin<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'min', As, NullableColumn<NumberColumn>>;
+    max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _max<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['max'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
+    _selectMax<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'max', As, NullableColumn<NumberColumn>>;
+    sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _sum<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['sum'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
+    _selectSum<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'sum', As, NullableColumn<NumberColumn>>;
+    bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _bitAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
+    _selectBitAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_and', As, NullableColumn<NumberColumn>>;
+    bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    _bitOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['bitOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<NumberColumn>>;
+    selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
+    _selectBitOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bit_or', As, NullableColumn<NumberColumn>>;
+    boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    _boolAnd<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolAnd'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
+    _selectBoolAnd<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_and', As, NullableColumn<BooleanColumn>>;
+    boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    _boolOr<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['boolOr'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
+    _selectBoolOr<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'bool_or', As, NullableColumn<BooleanColumn>>;
+    every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    _every<T extends Query>(this: T, arg: Aggregate1ArgumentTypes<T>['every'], options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<BooleanColumn>>;
+    selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
+    _selectEvery<T extends Query, As extends string | undefined = undefined>(this: T, arg: Expression<T>, options?: AggregateOptions<T, As>): SelectAgg<T, 'every', As, NullableColumn<BooleanColumn>>;
+    jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    _jsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    selectJsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    _selectJsonAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    jsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    _jsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    selectJsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    _selectJsonbAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['jsonbAgg'], As extends string | undefined = undefined>(this: T, arg: Expr, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_agg', As, NullableColumn<ArrayColumn<ExpressionOutput<T, Expr>>>>;
+    xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
+    _xmlAgg<T extends Query, Expr extends Aggregate1ArgumentTypes<T>['xmlAgg']>(this: T, arg: Expr, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
+    selectXmlAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Aggregate1ArgumentTypes<T>['xmlAgg'], options?: AggregateOptions<T, As>): SelectAgg<T, 'xmlagg', As, NullableColumn<StringColumn>>;
+    _selectXmlAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: Aggregate1ArgumentTypes<T>['xmlAgg'], options?: AggregateOptions<T, As>): SelectAgg<T, 'xmlagg', As, NullableColumn<StringColumn>>;
+    jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    _jsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    selectJsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    _selectJsonObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'json_object_agg', As, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    _jsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>>(this: T, obj: Obj, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    selectJsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    _selectJsonbObjectAgg<T extends Query, Obj extends Record<string, Expression<T>>, As extends string | undefined = undefined>(this: T, obj: Obj, options?: AggregateOptions<T, As>): SelectAgg<T, 'jsonb_object_agg', As, NullableColumn<ColumnType<{
+        [K in keyof Obj]: ExpressionOutput<T, Obj[K]>['type'];
+    }>>>;
+    stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
+    _stringAgg<T extends Query>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T>): SetQueryReturnsValue<T, NullableColumn<StringColumn>>;
+    selectStringAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T, As>): SelectAgg<T, 'string_agg', As, NullableColumn<StringColumn>>;
+    _selectStringAgg<T extends Query, As extends string | undefined = undefined>(this: T, arg: StringExpression<T>, delimiter: string, options?: AggregateOptions<T, As>): SelectAgg<T, 'string_agg', As, NullableColumn<StringColumn>>;
+}
+
+declare type 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 type getValueKey = typeof getValueKey;
+declare const getValueKey: unique symbol;
+declare class QueryGet {
+    get<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResult<T, Arg>;
+    _get<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetResult<T, Arg>;
+    getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetOptionalResult<T, Arg>;
+    _getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetOptionalResult<T, Arg>;
+}
+
+declare type SelectArg<T extends QueryBase> = 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 const addParserForRawExpression: (q: Query, key: string | getValueKey, raw: RawExpression) => void;
+declare const addParserForSelectItem: <T extends Query>(q: T, as: string | getValueKey | undefined, key: string, item: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | keyof T["selectable"]) => void;
+declare const addParserToQuery: (query: QueryData, key: string | getValueKey, parser: ColumnParser) => void;
+declare const processSelectArg: <T extends Query>(q: T, as: string | undefined, item: SelectArg<T>, columnAs?: string | getValueKey) => SelectItem;
+declare class Select {
+    select<T extends Query, K extends SelectArg<T>[]>(this: T, ...args: K): SelectResult<T, K>;
+    _select<T extends Query, K extends SelectArg<T>[]>(this: T, ...args: K): SelectResult<T, K>;
+    selectAll<T extends Query>(this: T): QuerySelectAll<T>;
+    _selectAll<T extends Query>(this: T): QuerySelectAll<T>;
+}
+
+declare type 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 ColumnTypesBase> = Db & {
+    <Table extends string, Shape extends ColumnsShape = ColumnsShape>(table: Table, shape?: ((t: CT) => Shape) | Shape, options?: DbTableOptions): Db<Table, Shape>;
+    adapter: Adapter;
+    destroy: Adapter['destroy'];
+};
+declare type DbOptions<CT extends ColumnTypesBase = ColumnTypes> = ({
+    adapter: Adapter;
+} | Omit<AdapterOptions, 'log'>) & QueryLogOptions & {
+    columnTypes?: CT;
+};
+declare const createDb: <CT extends ColumnTypesBase>({ 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 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 | getValueKey, 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 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'>;
+};
+
+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;
+        optional: 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 function min<T extends {
+    data: {
+        min?: number;
+    };
+}, Value extends number>(this: T, value: Value): Omit<T, "data"> & {
+    data: Omit<T["data"], "min"> & {
+        min: Value;
+    };
+};
+declare function max<T extends {
+    data: {
+        max?: number;
+    };
+}, Value extends number>(this: T, value: Value): Omit<T, "data"> & {
+    data: Omit<T["data"], "max"> & {
+        max: Value;
+    };
+};
+declare function length<T extends {
+    data: {
+        length?: number;
+    };
+}, Value extends number>(this: T, value: Value): Omit<T, "data"> & {
+    data: Omit<T["data"], "length"> & {
+        length: Value;
+    };
+};
+declare function size<T extends {
+    data: {
+        size?: number;
+    };
+}, Value extends number>(this: T, value: Value): Omit<T, "data"> & {
+    data: Omit<T["data"], "size"> & {
+        size: Value;
+    };
+};
+declare function nonempty<T extends {
+    data: {
+        min?: number;
+    };
+}>(this: T): Omit<T, "data"> & {
+    data: Omit<T["data"], "min"> & {
+        min: number;
+    };
+};
+declare type ArrayMethods$1 = typeof arrayMethods;
+declare const arrayMethods: {
+    min: typeof min;
+    max: typeof max;
+    length: typeof length;
+    nonempty: typeof nonempty;
+};
+declare type SetMethods = typeof setMethods;
+declare const setMethods: {
+    min: typeof min;
+    max: typeof max;
+    size: typeof size;
+    nonempty: typeof nonempty;
+};
+declare const numberTypeMethods: {
+    lt<T extends {
+        data: {
+            lt?: number;
+        };
+    }, Value extends number>(this: T, value: Value): Omit<T, "data"> & {
+        data: Omit<T["data"], "lt"> & {
+            lt: Value;
+        };
+    };
+    lte<T_1 extends {
+        data: {
+            lte?: number;
+        };
+    }, Value_1 extends number>(this: T_1, value: Value_1): Omit<T_1, "data"> & {
+        data: Omit<T_1["data"], "lte"> & {
+            lte: Value_1;
+        };
+    };
+    max<T_2 extends {
+        data: {
+            lte?: number;
+        };
+    }, Value_2 extends number>(this: T_2, value: Value_2): Omit<T_2, "data"> & {
+        data: Omit<T_2["data"], "lte"> & {
+            lte: Value_2;
+        };
+    };
+    gt<T_3 extends {
+        data: {
+            gt?: number;
+        };
+    }, Value_3 extends number>(this: T_3, value: Value_3): Omit<T_3, "data"> & {
+        data: Omit<T_3["data"], "gt"> & {
+            gt: Value_3;
+        };
+    };
+    gte<T_4 extends {
+        data: {
+            gte?: number;
+        };
+    }, Value_4 extends number>(this: T_4, value: Value_4): Omit<T_4, "data"> & {
+        data: Omit<T_4["data"], "gte"> & {
+            gte: Value_4;
+        };
+    };
+    min<T_5 extends {
+        data: {
+            gte?: number;
+        };
+    }, Value_5 extends number>(this: T_5, value: Value_5): Omit<T_5, "data"> & {
+        data: Omit<T_5["data"], "gte"> & {
+            gte: Value_5;
+        };
+    };
+    positive<T_6 extends {
+        data: {
+            gt?: number;
+        };
+    }>(this: T_6): Omit<T_6, "data"> & {
+        data: Omit<T_6["data"], "gt"> & {
+            gt: number;
+        };
+    };
+    nonNegative<T_7 extends {
+        data: {
+            gte?: number;
+        };
+    }>(this: T_7): Omit<T_7, "data"> & {
+        data: Omit<T_7["data"], "gte"> & {
+            gte: number;
+        };
+    };
+    negative<T_8 extends {
+        data: {
+            lt?: number;
+        };
+    }>(this: T_8): Omit<T_8, "data"> & {
+        data: Omit<T_8["data"], "lt"> & {
+            lt: number;
+        };
+    };
+    nonPositive<T_9 extends {
+        data: {
+            lte?: number;
+        };
+    }>(this: T_9): Omit<T_9, "data"> & {
+        data: Omit<T_9["data"], "lte"> & {
+            lte: number;
+        };
+    };
+    multipleOf<T_10 extends {
+        data: {
+            multipleOf?: number;
+        };
+    }, Value_6 extends number>(this: T_10, value: Value_6): Omit<T_10, "data"> & {
+        data: Omit<T_10["data"], "multipleOf"> & {
+            multipleOf: any;
+        };
+    };
+    step<T_11 extends {
+        data: {
+            multipleOf?: number;
+        };
+    }, Value_7 extends number>(this: T_11, value: Value_7): Omit<T_11, "data"> & {
+        data: Omit<T_11["data"], "multipleOf"> & {
+            multipleOf: any;
+        };
+    };
+    int<T_12 extends {
+        data: {
+            int?: boolean;
+        };
+    }>(this: T_12): Omit<T_12, "data"> & {
+        data: Omit<T_12["data"], "int"> & {
+            int: boolean;
+        };
+    };
+};
+declare const dateTypeMethods: {
+    min<T extends {
+        data: {
+            min?: Date;
+        };
+    }, Value extends Date>(this: T, value: Value): Omit<T, "data"> & {
+        data: Omit<T["data"], "min"> & {
+            min: any;
+        };
+    };
+    max<T_1 extends {
+        data: {
+            max?: Date;
+        };
+    }, Value_1 extends Date>(this: T_1, value: Value_1): Omit<T_1, "data"> & {
+        data: Omit<T_1["data"], "max"> & {
+            max: any;
+        };
+    };
+};
+
+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$1 {
+    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 = ColumnData & {
+    optional?: true;
+    nullable?: true;
+};
+declare type Primitive = string | number | bigint | boolean | null | undefined;
+declare type JSONType<Type, DataType extends string = string> = {
+    type: Type;
+    data: JSONTypeData;
+    dataType: DataType;
+    chain: (['transform', (input: unknown, ctx: ValidationContext) => unknown] | ['to', (input: unknown) => JSONTypeAny | undefined, JSONTypeAny] | ['refine', (input: unknown) => unknown] | ['superRefine', (input: unknown, ctx: ValidationContext) => 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'], ctx: ValidationContext) => 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'], ctx: ValidationContext) => 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 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 ColumnOutput<T extends ColumnType> = T['type'];
+declare type ColumnInput<T extends ColumnType> = T['inputType'];
+declare type NullableColumn<T extends ColumnType> = Omit<T, 'type' | 'inputType' | 'operators'> & {
+    type: T['type'] | null;
+    inputType: T['inputType'] | 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 type ColumnTypesBase = Record<string, AnyColumnTypeCreator>;
+declare type ValidationContext = any;
+declare type ColumnData = {
+    default?: unknown;
+    validationDefault?: unknown;
+    index?: Omit<SingleColumnIndexOptions, 'column'>;
+    comment?: string;
+    collate?: string;
+    compression?: string;
+    foreignKey?: ForeignKey<string, string[]>;
+};
+declare type ForeignKeyMatch = 'FULL' | 'PARTIAL' | 'SIMPLE';
+declare type ForeignKeyAction = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
+declare type ForeignKey<Table extends string, Columns extends string[]> = ({
+    fn(): new () => {
+        table: Table;
+    };
+} | {
+    table: Table;
+}) & {
+    columns: Columns;
+} & ForeignKeyOptions;
+declare type DropMode = 'CASCADE' | 'RESTRICT';
+declare type ForeignKeyOptions = {
+    name?: string;
+    match?: ForeignKeyMatch;
+    onUpdate?: ForeignKeyAction;
+    onDelete?: ForeignKeyAction;
+    dropMode?: DropMode;
+};
+declare type IndexColumnOptions = {
+    column: string;
+    expression?: number | string;
+    collate?: string;
+    operator?: string;
+    order?: string;
+};
+declare type IndexOptions = {
+    name?: string;
+    unique?: boolean;
+    using?: string;
+    include?: MaybeArray<string>;
+    with?: string;
+    tablespace?: string;
+    where?: string;
+    dropMode?: 'CASCADE' | 'RESTRICT';
+};
+declare type SingleColumnIndexOptions = IndexColumnOptions & IndexOptions;
+declare type ForeignKeyModel = new () => {
+    table: string;
+};
+declare type ForeignKeyModelWithColumns = new () => {
+    table: string;
+    columns: {
+        shape: ColumnsShape;
+    };
+};
+declare type ColumnNameOfModel<Model extends ForeignKeyModelWithColumns> = StringKey<keyof InstanceType<Model>['columns']['shape']>;
+declare abstract class ColumnType<Type = unknown, Ops extends Operators = Operators, InputType = Type> {
+    abstract dataType: string;
+    abstract operators: Ops;
+    type: Type;
+    inputType: InputType;
+    data: ColumnData;
+    isPrimaryKey: boolean;
+    isHidden: boolean;
+    isNullable: boolean;
+    encodeFn?: (input: any) => unknown;
+    parseFn?: (input: unknown) => unknown;
+    parseItem?: (input: string) => unknown;
+    chain: (["transform", (input: unknown, ctx: ValidationContext) => unknown] | ["to", (input: unknown) => JSONTypeAny | undefined, JSONTypeAny] | ["refine", (input: unknown) => unknown] | ["superRefine", (input: unknown, ctx: ValidationContext) => unknown])[];
+    primaryKey<T extends ColumnType>(this: T): T & {
+        isPrimaryKey: true;
+    };
+    foreignKey<T extends ColumnType, Model extends ForeignKeyModelWithColumns, Column extends ColumnNameOfModel<Model>>(this: T, fn: () => Model, column: Column, options?: ForeignKeyOptions): Omit<T, 'foreignKeyData'> & {
+        foreignKeyData: ForeignKey<InstanceType<Model>['table'], [Column]>;
+    };
+    foreignKey<T extends ColumnType, Table extends string, Column extends string>(this: T, table: Table, column: Column, options?: ForeignKeyOptions): Omit<T, 'foreignKeyData'> & {
+        foreignKeyData: ForeignKey<Table, [Column]>;
+    };
+    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;
+    default<T extends ColumnType>(this: T, value: T['type'] | RawExpression): T;
+    index<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column'>): any;
+    unique<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column' | 'unique'>): T;
+    comment<T extends ColumnType>(this: T, comment: string): T;
+    validationDefault<T extends ColumnType>(this: T, value: T['type']): T;
+    compression<T extends ColumnType>(this: T, compression: string): T;
+    collate<T extends ColumnType>(this: T, collate: string): T;
+    transform<T extends ColumnType, Transformed>(this: T, fn: (input: T['type'], ctx: ValidationContext) => Transformed): Omit<T, 'type'> & {
+        type: Transformed;
+    };
+    to<T extends ColumnType, ToType extends ColumnType>(this: T, fn: (input: T['type']) => ToType['type'] | undefined, type: ToType): ToType;
+    refine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type']) => unknown): T & {
+        type: RefinedOutput;
+    };
+    superRefine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type'], ctx: ValidationContext) => unknown): T & {
+        type: RefinedOutput;
+    };
+}
+
+declare type BaseNumberData = ColumnData & {
+    lt?: number;
+    lte?: number;
+    gt?: number;
+    gte?: number;
+    multipleOf?: number;
+    int?: boolean;
+};
+declare type NumberColumn = ColumnType<number>;
+declare type NumberColumnData = BaseNumberData;
+declare type NumberMethods = typeof numberTypeMethods;
+interface NumberBaseColumn extends ColumnType<number, typeof Operators.number>, NumberMethods {
+}
+declare abstract class NumberBaseColumn extends ColumnType<number, 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[];
+        };
+    };
+}
+declare abstract class IntegerBaseColumn extends NumberBaseColumn {
+    data: BaseNumberData;
+}
+declare abstract class NumberAsStringBaseColumn extends ColumnType<string, typeof Operators.number> {
+    data: {};
+    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[];
+        };
+    };
+}
+declare type DecimalColumnData = ColumnData & {
+    precision?: number;
+    scale?: number;
+};
+declare class DecimalBaseColumn<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined> extends ColumnType<string, typeof Operators.number> {
+    data: DecimalColumnData & {
+        precision: Precision;
+        scale: Scale;
+    };
+    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[];
+        };
+    };
+    dataType: "decimal";
+    constructor(precision?: Precision, scale?: Scale);
+    toSQL(): string;
+}
+declare class SmallIntColumn extends IntegerBaseColumn {
+    dataType: "smallint";
+    parseItem: typeof parseInt;
+}
+declare class IntegerColumn extends IntegerBaseColumn {
+    dataType: "integer";
+    parseItem: typeof parseInt;
+}
+declare class BigIntColumn extends NumberAsStringBaseColumn {
+    dataType: "bigint";
+}
+declare class DecimalColumn<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined> extends DecimalBaseColumn<Precision, Scale> {
+}
+declare class RealColumn extends NumberBaseColumn {
+    dataType: "real";
+    parseItem: typeof parseFloat;
+}
+declare class DoublePrecisionColumn extends NumberAsStringBaseColumn {
+    dataType: "double precision";
+}
+declare class SmallSerialColumn extends IntegerBaseColumn {
+    dataType: "smallserial";
+    parseItem: typeof parseInt;
+}
+declare class SerialColumn extends IntegerBaseColumn {
+    dataType: "serial";
+    parseItem: typeof parseInt;
+}
+declare class BigSerialColumn extends NumberAsStringBaseColumn {
+    dataType: "bigserial";
+}
+
+declare type BaseStringData = ColumnData & {
+    min?: number;
+    max?: number;
+    length?: number;
+    email?: boolean;
+    url?: boolean;
+    uuid?: boolean;
+    cuid?: boolean;
+    regex?: RegExp;
+    startsWith?: string;
+    endsWith?: string;
+    trim?: boolean;
+};
+declare type StringColumn = ColumnType<string>;
+declare type TextColumnData = BaseStringData;
+declare type TextMethods = typeof textMethods;
+declare const textMethods: {
+    email<T extends {
+        data: {
+            email?: boolean | undefined;
+        };
+    }>(this: T): Omit<T, "data"> & {
+        data: Omit<T["data"], "email"> & {
+            email: boolean;
+        };
+    };
+    url<T_1 extends {
+        data: {
+            url?: boolean | undefined;
+        };
+    }>(this: T_1): Omit<T_1, "data"> & {
+        data: Omit<T_1["data"], "url"> & {
+            url: boolean;
+        };
+    };
+    uuid<T_2 extends {
+        data: {
+            uuid?: boolean | undefined;
+        };
+    }>(this: T_2): Omit<T_2, "data"> & {
+        data: Omit<T_2["data"], "uuid"> & {
+            uuid: boolean;
+        };
+    };
+    cuid<T_3 extends {
+        data: {
+            cuid?: boolean | undefined;
+        };
+    }>(this: T_3): Omit<T_3, "data"> & {
+        data: Omit<T_3["data"], "cuid"> & {
+            cuid: boolean;
+        };
+    };
+    regex<T_4 extends {
+        data: {
+            regex?: RegExp | undefined;
+        };
+    }, Value extends RegExp>(this: T_4, value: Value): Omit<T_4, "data"> & {
+        data: Omit<T_4["data"], "regex"> & {
+            regex: Value;
+        };
+    };
+    startsWith<T_5 extends {
+        data: {
+            startsWith?: string | undefined;
+        };
+    }, Value_1 extends string>(this: T_5, value: Value_1): Omit<T_5, "data"> & {
+        data: Omit<T_5["data"], "startsWith"> & {
+            startsWith: Value_1;
+        };
+    };
+    endsWith<T_6 extends {
+        data: {
+            endsWith?: string | undefined;
+        };
+    }, Value_2 extends string>(this: T_6, value: Value_2): Omit<T_6, "data"> & {
+        data: Omit<T_6["data"], "endsWith"> & {
+            endsWith: Value_2;
+        };
+    };
+    trim<T_7 extends {
+        data: {
+            trim?: boolean | undefined;
+        };
+    }>(this: T_7): Omit<T_7, "data"> & {
+        data: Omit<T_7["data"], "trim"> & {
+            trim: boolean;
+        };
+    };
+    min: <T_8 extends {
+        data: {
+            min?: number | undefined;
+        };
+    }, Value_3 extends number>(this: T_8, value: Value_3) => Omit<T_8, "data"> & {
+        data: Omit<T_8["data"], "min"> & {
+            min: Value_3;
+        };
+    };
+    max: <T_9 extends {
+        data: {
+            max?: number | undefined;
+        };
+    }, Value_4 extends number>(this: T_9, value: Value_4) => Omit<T_9, "data"> & {
+        data: Omit<T_9["data"], "max"> & {
+            max: Value_4;
+        };
+    };
+    length: <T_10 extends {
+        data: {
+            length?: number | undefined;
+        };
+    }, Value_5 extends number>(this: T_10, value: Value_5) => Omit<T_10, "data"> & {
+        data: Omit<T_10["data"], "length"> & {
+            length: Value_5;
+        };
+    };
+    nonempty: <T_11 extends {
+        data: {
+            min?: number | undefined;
+        };
+    }>(this: T_11) => Omit<T_11, "data"> & {
+        data: Omit<T_11["data"], "min"> & {
+            min: number;
+        };
+    };
+};
+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 TextBaseColumn {
+    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 ColumnType<Buffer, typeof Operators.text> {
+    dataType: "bytea";
+    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 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 {
+    dataType: "money";
+    parseFn: (input: unknown) => number;
+}
+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> 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: ColumnData & {
+        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: ColumnData & {
+        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: "xml";
+    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 type DateColumnData = ColumnData & {
+    min?: Date;
+    max?: Date;
+};
+declare type DateMethods = typeof dateTypeMethods;
+interface DateBaseColumn extends ColumnType<string, typeof Operators.date, string | Date>, DateMethods {
+}
+declare abstract class DateBaseColumn extends ColumnType<string, typeof Operators.date, string | Date> {
+    data: DateColumnData;
+    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[];
+        };
+    };
+}
+declare class DateColumn extends DateBaseColumn {
+    dataType: "date";
+}
+declare type DateTimeColumnData = DateColumnData & {
+    precision?: number;
+};
+declare abstract class DateTimeBaseClass<Precision extends number | undefined = undefined> extends DateBaseColumn {
+    data: DateTimeColumnData & {
+        precision: Precision;
+    };
+    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 type TimeInterval = {
+    years?: number;
+    months?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+};
+declare class IntervalColumn<Fields extends string | undefined = undefined, Precision extends number | undefined = undefined> extends ColumnType<TimeInterval, 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[];
+        };
+    };
+    parseItem: (input: string) => boolean;
+}
+
+declare class EnumColumn<U extends string = string, T extends [U, ...U[]] = [U]> extends ColumnType<T[number], typeof Operators.any> {
+    enumName: string;
+    options: T;
+    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>>;
+        };
+    };
+    dataType: string;
+    constructor(enumName: string, options: T);
+    toSql(): 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 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 JSONLiteral<T extends Primitive> extends JSONType<T, 'literal'> {
+    value: Primitive;
+}
+
+interface JSONLazy<T extends JSONTypeAny> extends JSONType<T['type'], 'lazy'> {
+    typeCache?: T;
+    getter(): T;
+    deepPartial(): JSONLazy<ReturnType<T['deepPartial']>>;
+}
+
+interface JSONInstanceOf<T extends Class> extends JSONType<T, 'instanceOf'> {
+    class: T;
+}
+declare type Class = new (...args: any[]) => any;
+
+interface JSONEnum<U extends string = string, T extends [U, ...U[]] = [U]> extends JSONType<T[number], 'enum'> {
+    enum: {
+        [k in T[number]]: k;
+    };
+    options: T;
+}
+
+interface JSONDiscriminatedUnion<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends JSONDiscriminatedObject<Discriminator, DiscriminatorValue>> extends JSONType<Option['type'], 'discriminatedUnion'> {
+    discriminator: Discriminator;
+    discriminatorValue: DiscriminatorValue;
+    options: Map<DiscriminatorValue, Option>;
+    _option: Option;
+}
+declare type JSONDiscriminatedObject<Discriminator extends string, DiscriminatorValue extends Primitive> = JSONObject<{
+    [K in Discriminator]: JSONLiteral<DiscriminatorValue>;
+} & JSONObjectShape, any>;
+
+declare type JSONAny = JSONTypeAny & {
+    dataType: 'any';
+};
+declare type JSONBigInt = JSONType<bigint, 'bigint'> & {
+    data: BaseNumberData;
+} & typeof bigIntMethods;
+declare const bigIntMethods: {
+    lt<T extends {
+        data: {
+            lt?: number | undefined;
+        };
+    }, Value extends number>(this: T, value: Value): Omit<T, "data"> & {
+        data: Omit<T["data"], "lt"> & {
+            lt: Value;
+        };
+    };
+    lte<T_1 extends {
+        data: {
+            lte?: number | undefined;
+        };
+    }, Value_1 extends number>(this: T_1, value: Value_1): Omit<T_1, "data"> & {
+        data: Omit<T_1["data"], "lte"> & {
+            lte: Value_1;
+        };
+    };
+    max<T_2 extends {
+        data: {
+            lte?: number | undefined;
+        };
+    }, Value_2 extends number>(this: T_2, value: Value_2): Omit<T_2, "data"> & {
+        data: Omit<T_2["data"], "lte"> & {
+            lte: Value_2;
+        };
+    };
+    gt<T_3 extends {
+        data: {
+            gt?: number | undefined;
+        };
+    }, Value_3 extends number>(this: T_3, value: Value_3): Omit<T_3, "data"> & {
+        data: Omit<T_3["data"], "gt"> & {
+            gt: Value_3;
+        };
+    };
+    gte<T_4 extends {
+        data: {
+            gte?: number | undefined;
+        };
+    }, Value_4 extends number>(this: T_4, value: Value_4): Omit<T_4, "data"> & {
+        data: Omit<T_4["data"], "gte"> & {
+            gte: Value_4;
+        };
+    };
+    min<T_5 extends {
+        data: {
+            gte?: number | undefined;
+        };
+    }, Value_5 extends number>(this: T_5, value: Value_5): Omit<T_5, "data"> & {
+        data: Omit<T_5["data"], "gte"> & {
+            gte: Value_5;
+        };
+    };
+    positive<T_6 extends {
+        data: {
+            gt?: number | undefined;
+        };
+    }>(this: T_6): Omit<T_6, "data"> & {
+        data: Omit<T_6["data"], "gt"> & {
+            gt: number;
+        };
+    };
+    nonNegative<T_7 extends {
+        data: {
+            gte?: number | undefined;
+        };
+    }>(this: T_7): Omit<T_7, "data"> & {
+        data: Omit<T_7["data"], "gte"> & {
+            gte: number;
+        };
+    };
+    negative<T_8 extends {
+        data: {
+            lt?: number | undefined;
+        };
+    }>(this: T_8): Omit<T_8, "data"> & {
+        data: Omit<T_8["data"], "lt"> & {
+            lt: number;
+        };
+    };
+    nonPositive<T_9 extends {
+        data: {
+            lte?: number | undefined;
+        };
+    }>(this: T_9): Omit<T_9, "data"> & {
+        data: Omit<T_9["data"], "lte"> & {
+            lte: number;
+        };
+    };
+    multipleOf<T_10 extends {
+        data: {
+            multipleOf?: number | undefined;
+        };
+    }, Value_6 extends number>(this: T_10, value: Value_6): Omit<T_10, "data"> & {
+        data: Omit<T_10["data"], "multipleOf"> & {
+            multipleOf: any;
+        };
+    };
+    step<T_11 extends {
+        data: {
+            multipleOf?: number | undefined;
+        };
+    }, Value_7 extends number>(this: T_11, value: Value_7): Omit<T_11, "data"> & {
+        data: Omit<T_11["data"], "multipleOf"> & {
+            multipleOf: any;
+        };
+    };
+    int<T_12 extends {
+        data: {
+            int?: boolean | undefined;
+        };
+    }>(this: T_12): Omit<T_12, "data"> & {
+        data: Omit<T_12["data"], "int"> & {
+            int: boolean;
+        };
+    };
+    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 {
+        data: {
+            lt?: number | undefined;
+        };
+    }, Value extends number>(this: T, value: Value): Omit<T, "data"> & {
+        data: Omit<T["data"], "lt"> & {
+            lt: Value;
+        };
+    };
+    lte<T_1 extends {
+        data: {
+            lte?: number | undefined;
+        };
+    }, Value_1 extends number>(this: T_1, value: Value_1): Omit<T_1, "data"> & {
+        data: Omit<T_1["data"], "lte"> & {
+            lte: Value_1;
+        };
+    };
+    max<T_2 extends {
+        data: {
+            lte?: number | undefined;
+        };
+    }, Value_2 extends number>(this: T_2, value: Value_2): Omit<T_2, "data"> & {
+        data: Omit<T_2["data"], "lte"> & {
+            lte: Value_2;
+        };
+    };
+    gt<T_3 extends {
+        data: {
+            gt?: number | undefined;
+        };
+    }, Value_3 extends number>(this: T_3, value: Value_3): Omit<T_3, "data"> & {
+        data: Omit<T_3["data"], "gt"> & {
+            gt: Value_3;
+        };
+    };
+    gte<T_4 extends {
+        data: {
+            gte?: number | undefined;
+        };
+    }, Value_4 extends number>(this: T_4, value: Value_4): Omit<T_4, "data"> & {
+        data: Omit<T_4["data"], "gte"> & {
+            gte: Value_4;
+        };
+    };
+    min<T_5 extends {
+        data: {
+            gte?: number | undefined;
+        };
+    }, Value_5 extends number>(this: T_5, value: Value_5): Omit<T_5, "data"> & {
+        data: Omit<T_5["data"], "gte"> & {
+            gte: Value_5;
+        };
+    };
+    positive<T_6 extends {
+        data: {
+            gt?: number | undefined;
+        };
+    }>(this: T_6): Omit<T_6, "data"> & {
+        data: Omit<T_6["data"], "gt"> & {
+            gt: number;
+        };
+    };
+    nonNegative<T_7 extends {
+        data: {
+            gte?: number | undefined;
+        };
+    }>(this: T_7): Omit<T_7, "data"> & {
+        data: Omit<T_7["data"], "gte"> & {
+            gte: number;
+        };
+    };
+    negative<T_8 extends {
+        data: {
+            lt?: number | undefined;
+        };
+    }>(this: T_8): Omit<T_8, "data"> & {
+        data: Omit<T_8["data"], "lt"> & {
+            lt: number;
+        };
+    };
+    nonPositive<T_9 extends {
+        data: {
+            lte?: number | undefined;
+        };
+    }>(this: T_9): Omit<T_9, "data"> & {
+        data: Omit<T_9["data"], "lte"> & {
+            lte: number;
+        };
+    };
+    multipleOf<T_10 extends {
+        data: {
+            multipleOf?: number | undefined;
+        };
+    }, Value_6 extends number>(this: T_10, value: Value_6): Omit<T_10, "data"> & {
+        data: Omit<T_10["data"], "multipleOf"> & {
+            multipleOf: any;
+        };
+    };
+    step<T_11 extends {
+        data: {
+            multipleOf?: number | undefined;
+        };
+    }, Value_7 extends number>(this: T_11, value: Value_7): Omit<T_11, "data"> & {
+        data: Omit<T_11["data"], "multipleOf"> & {
+            multipleOf: any;
+        };
+    };
+    int<T_12 extends {
+        data: {
+            int?: boolean | undefined;
+        };
+    }>(this: T_12): Omit<T_12, "data"> & {
+        data: Omit<T_12["data"], "int"> & {
+            int: boolean;
+        };
+    };
+};
+declare type JSONDate = JSONType<Date, 'date'> & {
+    data: DateColumnData;
+} & typeof dateTypeMethods;
+declare type JSONString = JSONType<string, 'string'> & {
+    data: BaseStringData;
+} & typeof stringMethods;
+declare const stringMethods: {
+    dataType: "string";
+    email<T extends {
+        data: {
+            email?: boolean | undefined;
+        };
+    }>(this: T): Omit<T, "data"> & {
+        data: Omit<T["data"], "email"> & {
+            email: boolean;
+        };
+    };
+    url<T_1 extends {
+        data: {
+            url?: boolean | undefined;
+        };
+    }>(this: T_1): Omit<T_1, "data"> & {
+        data: Omit<T_1["data"], "url"> & {
+            url: boolean;
+        };
+    };
+    uuid<T_2 extends {
+        data: {
+            uuid?: boolean | undefined;
+        };
+    }>(this: T_2): Omit<T_2, "data"> & {
+        data: Omit<T_2["data"], "uuid"> & {
+            uuid: boolean;
+        };
+    };
+    cuid<T_3 extends {
+        data: {
+            cuid?: boolean | undefined;
+        };
+    }>(this: T_3): Omit<T_3, "data"> & {
+        data: Omit<T_3["data"], "cuid"> & {
+            cuid: boolean;
+        };
+    };
+    regex<T_4 extends {
+        data: {
+            regex?: RegExp | undefined;
+        };
+    }, Value extends RegExp>(this: T_4, value: Value): Omit<T_4, "data"> & {
+        data: Omit<T_4["data"], "regex"> & {
+            regex: Value;
+        };
+    };
+    startsWith<T_5 extends {
+        data: {
+            startsWith?: string | undefined;
+        };
+    }, Value_1 extends string>(this: T_5, value: Value_1): Omit<T_5, "data"> & {
+        data: Omit<T_5["data"], "startsWith"> & {
+            startsWith: Value_1;
+        };
+    };
+    endsWith<T_6 extends {
+        data: {
+            endsWith?: string | undefined;
+        };
+    }, Value_2 extends string>(this: T_6, value: Value_2): Omit<T_6, "data"> & {
+        data: Omit<T_6["data"], "endsWith"> & {
+            endsWith: Value_2;
+        };
+    };
+    trim<T_7 extends {
+        data: {
+            trim?: boolean | undefined;
+        };
+    }>(this: T_7): Omit<T_7, "data"> & {
+        data: Omit<T_7["data"], "trim"> & {
+            trim: boolean;
+        };
+    };
+    min: <T_8 extends {
+        data: {
+            min?: number | undefined;
+        };
+    }, Value_3 extends number>(this: T_8, value: Value_3) => Omit<T_8, "data"> & {
+        data: Omit<T_8["data"], "min"> & {
+            min: Value_3;
+        };
+    };
+    max: <T_9 extends {
+        data: {
+            max?: number | undefined;
+        };
+    }, Value_4 extends number>(this: T_9, value: Value_4) => Omit<T_9, "data"> & {
+        data: Omit<T_9["data"], "max"> & {
+            max: Value_4;
+        };
+    };
+    length: <T_10 extends {
+        data: {
+            length?: number | undefined;
+        };
+    }, Value_5 extends number>(this: T_10, value: Value_5) => Omit<T_10, "data"> & {
+        data: Omit<T_10["data"], "length"> & {
+            length: Value_5;
+        };
+    };
+    nonempty: <T_11 extends {
+        data: {
+            min?: number | undefined;
+        };
+    }>(this: T_11) => Omit<T_11, "data"> & {
+        data: Omit<T_11["data"], "min"> & {
+            min: number;
+        };
+    };
+};
+declare type JSONUndefined = JSONType<undefined, 'undefined'>;
+declare type JSONUnknown = JSONType<unknown, 'unknown'>;
+declare type JSONVoid = JSONType<void, 'void'>;
+
+interface JSONUnion<T extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]> extends JSONType<T[number]['type'], 'union'> {
+    types: T;
+}
+
+interface JSONTuple<T extends JSONTupleItems | [] = JSONTupleItems, Rest extends JSONTypeAny | null = null> extends JSONType<OutputTypeOfTupleWithRest<T, Rest>, 'tuple'> {
+    items: T;
+    restType: Rest;
+    rest<Rest extends JSONTypeAny | null>(rest: Rest): JSONTuple<T, Rest>;
+    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'>, SetMethods {
+    data: JSONTypeData & {
+        min?: number;
+        max?: number;
+        size?: number;
+    };
+    valueType: Value;
+    deepPartial(): JSONSet<ReturnType<Value['deepPartial']>>;
+    nonEmpty(this: JSONSet<Value>): JSONSet<Value> & {
+        data: {
+            min: 1;
+        };
+    };
+}
+
+interface JSONRecord<Key extends JSONRecordKeyType, Value extends JSONTypeAny> extends JSONType<Record<Key['type'], Value['type']>, 'record'> {
+    keyType: Key;
+    valueType: Value;
+    deepPartial(): JSONRecord<Key, ReturnType<Value['deepPartial']>>;
+}
+declare type JSONRecordKeyType = JSONType<string | number, 'string' | 'number'>;
+declare type Args<Key extends JSONRecordKeyType, Value extends JSONTypeAny> = Args2<Key, Value> | Args1<Key>;
+declare type Args2<Key extends JSONRecordKeyType, Value extends JSONTypeAny> = [
+    key: Key,
+    value: Value
+];
+declare type Args1<Value extends JSONTypeAny> = [value: Value];
+declare function record<KeyType extends JSONString | JSONNumber, ValueType extends JSONTypeAny>(...args: Args<KeyType, ValueType>): JSONRecord<KeyType, ValueType>;
+
+declare type JSONTypes = typeof jsonTypes;
+declare const jsonTypes: {
+    set: <Value extends JSONTypeAny>(valueType: Value) => JSONSet<Value>;
+    tuple: <T extends [] | JSONTupleItems, Rest extends JSONTypeAny | null = null>(items: T, rest?: Rest) => JSONTuple<T, Rest>;
+    union: <T_1 extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]>(types: T_1) => JSONUnion<T_1>;
+    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, DiscriminatorValue extends Primitive, Types extends [JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]>;
+    enum: <U extends string, T_2 extends [U, ...U[]]>(options: T_2) => JSONEnum<U, T_2>;
+    instanceOf: <T_3 extends new (...args: any[]) => any>(cls: T_3) => JSONInstanceOf<T_3>;
+    intersection: <Left extends JSONTypeAny, Right extends JSONTypeAny>(left: Left, right: Right) => JSONIntersection<Left, Right>;
+    lazy: <T_4 extends JSONTypeAny>(fn: () => T_4) => JSONLazy<T_4>;
+    literal: <T_5 extends Primitive>(value: T_5) => JSONLiteral<T_5>;
+    map: <Key extends JSONTypeAny, Value_1 extends JSONTypeAny>(keyType: Key, valueType: Value_1) => JSONMap<Key, Value_1>;
+    nativeEnum: <T_6 extends EnumLike>(givenEnum: T_6) => JSONNativeEnum<T_6>;
+    nullable: <T_7 extends JSONTypeAny>(type: T_7) => JSONNullable<T_7>;
+    nullish: <T_8 extends JSONTypeAny>(type: T_8) => JSONNullish<T_8>;
+    object: <T_9 extends JSONObjectShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends JSONTypeAny = JSONTypeAny>(shape: T_9) => JSONObject<T_9, UnknownKeys, Catchall, JSONTypeAny extends Catchall ? addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }> extends infer T_10 ? { [k in keyof T_10]: addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }>[k]; } : never : (addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }> extends infer T_10 ? { [k in keyof T_10]: addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }>[k]; } : never) & {
+        [k: string]: Catchall["type"];
+    } extends infer T_11 ? { [k_2 in keyof T_11]: ((addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }> extends infer T_10 ? { [k in keyof T_10]: addQuestionMarks<{ [k_1 in keyof T_9]: T_9[k_1]["type"]; }>[k]; } : never) & {
+        [k: string]: Catchall["type"];
+    })[k_2]; } : never>;
+    optional: <T_12 extends JSONTypeAny>(type: T_12) => JSONOptional<T_12>;
+    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: ColumnData & {
+        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 type ArrayData<Item extends ColumnType> = ColumnData & {
+    item: Item;
+    min?: number;
+    max?: number;
+    length?: number;
+};
+declare type ArrayMethods = typeof arrayMethods;
+interface ArrayColumn<Item extends ColumnType> extends ColumnType<Item['type'][], typeof Operators.array>, ArrayMethods {
+}
+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: ArrayData<Item>;
+    constructor(item: Item);
+    toSQL(): string;
+    parseFn: (input: unknown) => unknown[];
+}
+
+declare type ColumnTypes = typeof columnTypes;
+declare type TableData = {
+    primaryKey?: {
+        columns: string[];
+        options?: {
+            name?: string;
+        };
+    };
+    indexes: {
+        columns: IndexColumnOptions[];
+        options: IndexOptions;
+    }[];
+    foreignKeys: {
+        columns: string[];
+        fnOrTable: (() => ForeignKeyModel) | string;
+        foreignColumns: string[];
+        options: ForeignKeyOptions;
+    }[];
+};
+declare const newTableData: () => TableData;
+declare const getTableData: () => TableData;
+declare const resetTableData: (data?: TableData) => void;
+declare const getColumnTypes: <CT extends ColumnTypesBase, Shape extends ColumnsShape>(types: CT, fn: (t: CT) => Shape, data?: TableData) => Shape;
+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>;
+    decimal: <Precision_1 extends number | undefined = undefined, Scale_1 extends number | undefined = undefined>(precision?: Precision_1 | undefined, scale?: Scale_1 | undefined) => DecimalColumn<Precision_1, Scale_1>;
+    real: () => RealColumn;
+    doublePrecision: () => DoublePrecisionColumn;
+    smallSerial: () => SmallSerialColumn;
+    serial: () => SerialColumn;
+    bigSerial: () => BigSerialColumn;
+    money: () => MoneyColumn;
+    varchar: <Limit extends number | undefined = undefined>(limit?: Limit | undefined) => VarCharColumn<Limit>;
+    char: <Limit_1 extends number | undefined = undefined>(limit?: Limit_1 | undefined) => CharColumn<Limit_1>;
+    text: () => TextColumn;
+    string: () => TextColumn;
+    bytea: () => ByteaColumn;
+    date: () => DateColumn;
+    timestamp: <Precision_2 extends number | undefined = undefined>(precision?: Precision_2 | undefined) => TimestampColumn<Precision_2>;
+    timestampWithTimeZone: <Precision_3 extends number | undefined = undefined>(precision?: Precision_3 | undefined) => TimestampWithTimeZoneColumn<Precision_3>;
+    time: <Precision_4 extends number | undefined = undefined>(precision?: Precision_4 | undefined) => TimeColumn<Precision_4>;
+    timeWithTimeZone: <Precision_5 extends number | undefined = undefined>(precision?: Precision_5 | undefined) => TimeWithTimeZoneColumn<Precision_5>;
+    interval: <Fields extends string | undefined = undefined, Precision_6 extends number | undefined = undefined>(fields?: Fields | undefined, precision?: Precision_6 | undefined) => IntervalColumn<Fields, Precision_6>;
+    boolean: () => BooleanColumn;
+    enum: <U extends string, T extends [U, ...U[]]>(dataType: string, type: T) => EnumColumn<U, T>;
+    point: () => PointColumn;
+    line: () => LineColumn;
+    lseg: () => LsegColumn;
+    box: () => BoxColumn;
+    path: () => PathColumn;
+    polygon: () => PolygonColumn;
+    circle: () => CircleColumn;
+    cidr: () => CidrColumn;
+    inet: () => InetColumn;
+    macaddr: () => MacAddrColumn;
+    macaddr8: () => MacAddr8Column;
+    bit: <Length extends number>(length: Length) => BitColumn<Length>;
+    bitVarying: <Length_1 extends number | undefined = undefined>(length?: Length_1 | undefined) => BitVaryingColumn<Length_1 | undefined>;
+    tsvector: () => TsVectorColumn;
+    tsquery: () => TsQueryColumn;
+    uuid: () => UUIDColumn;
+    xml: () => XMLColumn;
+    json: <Type extends JSONTypeAny>(schemaOrFn: Type | ((j: JSONTypes) => Type)) => JSONColumn<Type>;
+    jsonText: () => JSONTextColumn;
+    array: <Item extends ColumnType<unknown, Operators, unknown>>(item: Item) => ArrayColumn<Item>;
+    timestamps: () => {
+        createdAt: TimestampColumn<undefined>;
+        updatedAt: TimestampColumn<undefined>;
+    };
+    primaryKey(columns: string[], options?: {
+        name?: string;
+    }): {};
+    index(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+    unique(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+    foreignKey: typeof foreignKey;
+};
+declare function foreignKey<Model extends ForeignKeyModelWithColumns, Columns extends [ColumnNameOfModel<Model>, ...ColumnNameOfModel<Model>[]]>(columns: string[], fn: () => Model, foreignColumns: Columns, options?: ForeignKeyOptions): EmptyObject;
+declare function foreignKey<Table extends string, Columns extends [string, ...string[]]>(columns: string[], table: Table, foreignColumns: Columns, options?: ForeignKeyOptions): EmptyObject;
+
+declare const cloneInstance: <T>(instance: T) => T;
+declare const assignMethodsToClass: <Methods extends Record<string, unknown>>(klass: {
+    prototype: unknown;
+}, methods: Methods) => void;
+
+declare const utils_cloneInstance: typeof cloneInstance;
+declare const utils_assignMethodsToClass: typeof assignMethodsToClass;
+declare namespace utils {
+  export {
+    utils_cloneInstance as cloneInstance,
+    utils_assignMethodsToClass as assignMethodsToClass,
+  };
+}
+
+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, AfterCallback, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, AnyColumnType, AnyColumnTypeCreator, ArrayColumn, ArrayData, ArrayOfColumnsObjects, BaseNumberData, BaseRelation, BaseStringData, BeforeCallback, BelongsToNestedInsert, BelongsToNestedUpdate, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, Clear, ClearStatement, CoalesceString, ColumnData, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnInput, ColumnNameOfModel, ColumnOperators, ColumnOutput, ColumnParser, ColumnShapeInput, ColumnShapeOutput, ColumnType, ColumnTypes, ColumnTypesBase, ColumnsObject, ColumnsParsers, ColumnsShape, CommonQueryData, DateBaseColumn, DateColumn, DateColumnData, DateTimeBaseClass, DateTimeColumnData, DateTimeWithTimeZoneBaseClass, Db, DbOptions, DbTableOptions, DecimalBaseColumn, DecimalColumn, DecimalColumnData, DefaultSelectColumns, Delete, DeleteQueryData, DoublePrecisionColumn, DropMode, EMPTY_OBJECT, EmptyObject, EnumColumn, Expression, ExpressionOfType, ExpressionOutput, FilterTuple, For, ForeignKey, ForeignKeyModel, ForeignKeyModelWithColumns, ForeignKeyOptions, From, GetArg, GetTypeOrRaw, GetTypesOrRaw, HasAndBelongsToManyRelation, HasManyNestedInsert, HasManyNestedUpdate, HasManyRelation, HasOneNestedInsert, HasOneNestedUpdate, HasOneRelation, Having, HavingArg, HavingItem, IndexColumnOptions, IndexOptions, InetColumn, Insert, InsertData, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, JSONColumn, JSONTextColumn, JSONTypes, Join, JoinArgs, JoinCallback, JoinCallbackArg, JoinItem, JoinedTablesBase, Json, JsonItem, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MaybeArray, MoneyColumn, MoreThanOneRowError, NestedInsertItem, NestedInsertManyItems, NestedInsertOneItem, NestedUpdateItem, NestedUpdateManyItems, NestedUpdateOneItem, NotFoundError, NullableColumn, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OptionalKeys, OrderArg, OrderItem, PathColumn, PointColumn, PolygonColumn, PropertyKeyUnionToArray, Query, QueryArraysResult, QueryBase, QueryCallbacks, QueryData, QueryGet, QueryInput, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryResultRow, QueryReturnType, QuerySelectAll, QueryUpsert, QueryWithTable, RawExpression, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SerialColumn, SetOptional, SetQueryJoinedTables, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumnInfo, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWindows, SetQueryWith, SimpleSpread, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, Spread, Sql, StringColumn, StringExpression, StringKey, TableData, TableSchema, TextBaseColumn, TextColumn, TextColumnData, Then, ThenResult, TimeColumn, TimeInterval, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, Transaction, TransactionAdapter, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, Union, UnionArg, UnionItem, UnionToArray, UnionToIntersection, UnionToOvlds, Update, UpdateData, UpdateQueryData, UpsertData, UpsertResult, UpsertThis, ValidationContext, VarCharColumn, Where, WhereArg, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereQueryBuilder, WhereResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addParserToQuery, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, applyMixins, columnTypes, utils as columnUtils, createDb, createOperator, defaultsKey, emptyObject, getClonedQueryData, getColumnTypes, getQueryAs, getQueryParsers, getRaw, getTableData, getValueKey, handleResult, isRaw, isRequiredRelationKey, joinTruthy, jsonTypes, logColors, logParamToLogObject, newTableData, noop, parseRecord, parseResult, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryKeysOfNotSimpleQuery, queryMethodByReturnType, quote, raw, relationQueryKey, removeFromQuery, resetTableData, setQueryObjectValue, toArray, toSql };