imodel 0.16.2 → 0.17.1

package/index.d.mts

@@ -1,14 +1,14 @@
 /*!
- * imodel v0.16.2
+ * imodel v0.17.1
  * (c) 2019-2026 undefined
  * @license undefined
  */
 
 declare const now: unique symbol;
-/** @type {typeof now} now */
-declare const uuid: symbol;
-/** @type {typeof uuid} uuid */
-declare const increment$1: typeof uuid;
+/** @typeof {typeof now} now */
+declare const uuid: unique symbol;
+/** @typeof {typeof uuid} uuid */
+declare const increment$1: unique symbol;
 declare const decrement$1: unique symbol;
 declare const multiply$1: unique symbol;
 declare const divide$1: unique symbol;
@@ -21,878 +21,16 @@ declare namespace values {
 }
 
 /**
- * @param {WhereValue[]?} [items]
- * @returns {WhereValue[]?}
- */
-declare function toNot(items?: WhereValue[] | null): WhereValue[] | null;
-type WhereLike = {
-    toWhereValue(): WhereValue[][];
-};
-type Wheres = WhereLike | Record<string, any> | (WhereLike | Record<string, any>)[];
-type WhereItem = {
-    where?: null | undefined;
-    or?: null | undefined;
-    field: string | {
-        table?: string;
-        field: string;
-    } | (string | {
-        table?: string;
-        field: string;
-    })[];
-    value: any;
-    not?: boolean | undefined;
-    operator?: string | null | undefined;
-};
-type WhereRaw = {
-    field?: null | undefined;
-    or?: null | undefined;
-    where: readonly string[];
-    values: readonly any[];
-    not?: boolean | undefined;
-};
-type WhereOr = {
-    where?: null | undefined;
-    field?: null | undefined;
-    or: WhereValue[][];
-    not?: boolean | undefined;
-};
-type WhereValue = WhereItem | WhereRaw | WhereOr;
-declare class Where {
-    /**
-     * @overload
-     * @param {Wheres} matches
-     * @returns {WhereValue[]?}
-     */
-    static parse(matches: Wheres): WhereValue[] | null;
-    /**
-     * @overload
-     * @param {string | string[]} field
-     * @param {any} value
-     * @returns {WhereValue[]?}
-     */
-    static parse(field: string | string[], value: any): WhereValue[] | null;
-    /**
-     * @overload
-     * @param {string | string[]} field
-     * @param {string} operator
-     * @param {any} value
-     * @param {boolean} [not]
-     * @returns {WhereValue[]?}
-     */
-    static parse(field: string | string[], operator: string, value: any, not?: boolean | undefined): WhereValue[] | null;
-    /**
-     * @overload
-     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
-     * @returns {WhereValue[]?}
-     */
-    static parse(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): WhereValue[] | null;
-    /**
-     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
-     * @returns {WhereValue[]?}
-     */
-    static parseParams(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): WhereValue[] | null;
-    /**
-     * @overload
-     * @param {Wheres} matches
-     * @returns {Where}
-     */
-    static and(matches: Wheres): Where;
-    /**
-     *
-     * @overload
-     * @param {TemplateStringsArray} where
-     * @param  {...any} values
-     * @returns {Where}
-     */
-    static and(where: TemplateStringsArray, ...values: any[]): Where;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {any} value
-     * @returns {Where}
-     */
-    static and(field: string, value: any): Where;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {any[]} value
-     * @returns {Where}
-     */
-    static and(field: string[], value: any[]): Where;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {string} operator
-     * @param {any} value
-     * @param {boolean} [not]
-     * @returns {Where}
-     */
-    static and(field: string, operator: string, value: any, not?: boolean | undefined): Where;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {string} operator
-     * @param {any[]} value
-     * @param {boolean} [not]
-     * @returns {Where}
-     */
-    static and(field: string[], operator: string, value: any[], not?: boolean | undefined): Where;
-    /**
-     * @overload
-     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
-     * @returns {Where}
-     */
-    static and(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): Where;
-    /**
-     * @overload
-     * @param {Wheres} matches
-     * @returns {Where}
-     */
-    static or(matches: Wheres): Where;
-    /**
-     *
-     * @overload
-     * @param {TemplateStringsArray} where
-     * @param  {...any} values
-     * @returns {Where}
-     */
-    static or(where: TemplateStringsArray, ...values: any[]): Where;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {any} value
-     * @returns {Where}
-     */
-    static or(field: string, value: any): Where;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {any[]} value
-     * @returns {Where}
-     */
-    static or(field: string[], value: any[]): Where;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {string} operator
-     * @param {any} value
-     * @param {boolean} [not]
-     * @returns {Where}
-     */
-    static or(field: string, operator: string, value: any, not?: boolean | undefined): Where;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {string} operator
-     * @param {any[]} value
-     * @param {boolean} [not]
-     * @returns {Where}
-     */
-    static or(field: string[], operator: string, value: any[], not?: boolean | undefined): Where;
-    /**
-     * @overload
-     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
-     * @returns {Where}
-     */
-    static or(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): Where;
-    /**
-     * @overload
-     * @param {Wheres} matches
-     * @returns {Where}
-     */
-    static not(matches: Wheres): Where;
-    /**
-     *
-     * @overload
-     * @param {TemplateStringsArray} where
-     * @param  {...any} values
-     * @returns {Where}
-     */
-    static not(where: TemplateStringsArray, ...values: any[]): Where;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {any} value
-     * @returns {Where}
-     */
-    static not(field: string, value: any): Where;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {any[]} value
-     * @returns {Where}
-     */
-    static not(field: string[], value: any[]): Where;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {string} operator
-     * @param {any} value
-     * @param {boolean} [not]
-     * @returns {Where}
-     */
-    static not(field: string, operator: string, value: any, not?: boolean | undefined): Where;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {string} operator
-     * @param {any[]} value
-     * @param {boolean} [not]
-     * @returns {Where}
-     */
-    static not(field: string[], operator: string, value: any[], not?: boolean | undefined): Where;
-    /**
-     * @overload
-     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
-     * @returns {Where}
-     */
-    static not(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): Where;
-    /**
-     * @overload
-     * @param {Wheres} matches
-     * @returns {Where}
-     */
-    static orNot(matches: Wheres): Where;
-    /**
-     *
-     * @overload
-     * @param {TemplateStringsArray} where
-     * @param  {...any} values
-     * @returns {Where}
-     */
-    static orNot(where: TemplateStringsArray, ...values: any[]): Where;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {any} value
-     * @returns {Where}
-     */
-    static orNot(field: string, value: any): Where;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {any[]} value
-     * @returns {Where}
-     */
-    static orNot(field: string[], value: any[]): Where;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {string} operator
-     * @param {any} value
-     * @param {boolean} [not]
-     * @returns {Where}
-     */
-    static orNot(field: string, operator: string, value: any, not?: boolean | undefined): Where;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {string} operator
-     * @param {any[]} value
-     * @param {boolean} [not]
-     * @returns {Where}
-     */
-    static orNot(field: string[], operator: string, value: any[], not?: boolean | undefined): Where;
-    /**
-     * @overload
-     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
-     * @returns {Where}
-     */
-    static orNot(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): Where;
-    toWhereValue(): WhereValue[][];
-    /**
-     * @overload
-     * @param {Wheres} matches
-     * @returns {this}
-     */
-    and(matches: Wheres): this;
-    /**
-     *
-     * @overload
-     * @param {TemplateStringsArray} where
-     * @param  {...any} values
-     * @returns {this}
-     */
-    and(where: TemplateStringsArray, ...values: any[]): this;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {any} value
-     * @returns {this}
-     */
-    and(field: string, value: any): this;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {any[]} value
-     * @returns {this}
-     */
-    and(field: string[], value: any[]): this;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {string} operator
-     * @param {any} value
-     * @param {boolean} [not]
-     * @returns {this}
-     */
-    and(field: string, operator: string, value: any, not?: boolean | undefined): this;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {string} operator
-     * @param {any[]} value
-     * @param {boolean} [not]
-     * @returns {this}
-     */
-    and(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
-    /**
-     * @overload
-     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
-     * @returns {this}
-     */
-    and(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
-    /**
-     * @overload
-     * @param {Wheres} matches
-     * @returns {this}
-     */
-    or(matches: Wheres): this;
-    /**
-     *
-     * @overload
-     * @param {TemplateStringsArray} where
-     * @param  {...any} values
-     * @returns {this}
-     */
-    or(where: TemplateStringsArray, ...values: any[]): this;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {any} value
-     * @returns {this}
-     */
-    or(field: string, value: any): this;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {any[]} value
-     * @returns {this}
-     */
-    or(field: string[], value: any[]): this;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {string} operator
-     * @param {any} value
-     * @param {boolean} [not]
-     * @returns {this}
-     */
-    or(field: string, operator: string, value: any, not?: boolean | undefined): this;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {string} operator
-     * @param {any[]} value
-     * @param {boolean} [not]
-     * @returns {this}
-     */
-    or(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
-    /**
-     * @overload
-     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
-     * @returns {this}
-     */
-    or(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
-    /**
-     * @overload
-     * @param {Wheres} matches
-     * @returns {this}
-     */
-    not(matches: Wheres): this;
-    /**
-     *
-     * @overload
-     * @param {TemplateStringsArray} where
-     * @param  {...any} values
-     * @returns {this}
-     */
-    not(where: TemplateStringsArray, ...values: any[]): this;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {any} value
-     * @returns {this}
-     */
-    not(field: string, value: any): this;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {any[]} value
-     * @returns {this}
-     */
-    not(field: string[], value: any[]): this;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {string} operator
-     * @param {any} value
-     * @param {boolean} [not]
-     * @returns {this}
-     */
-    not(field: string, operator: string, value: any, not?: boolean | undefined): this;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {string} operator
-     * @param {any[]} value
-     * @param {boolean} [not]
-     * @returns {this}
-     */
-    not(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
-    /**
-     * @overload
-     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
-     * @returns {this}
-     */
-    not(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
-    /**
-     * @overload
-     * @param {Wheres} matches
-     * @returns {this}
-     */
-    orNot(matches: Wheres): this;
-    /**
-     *
-     * @overload
-     * @param {TemplateStringsArray} where
-     * @param  {...any} values
-     * @returns {this}
-     */
-    orNot(where: TemplateStringsArray, ...values: any[]): this;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {any} value
-     * @returns {this}
-     */
-    orNot(field: string, value: any): this;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {any[]} value
-     * @returns {this}
-     */
-    orNot(field: string[], value: any[]): this;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {string} operator
-     * @param {any} value
-     * @param {boolean} [not]
-     * @returns {this}
-     */
-    orNot(field: string, operator: string, value: any, not?: boolean | undefined): this;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {string} operator
-     * @param {any[]} value
-     * @param {boolean} [not]
-     * @returns {this}
-     */
-    orNot(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
-    /**
-     * @overload
-     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
-     * @returns {this}
-     */
-    orNot(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
-    #private;
-}
-
-interface Environment<T extends object> {
-    transaction: T | null;
-    isDevelopment: boolean;
-    values: typeof values;
-}
-
-/** @typedef {SetValue.Increment | SetValue.Decrement | SetValue.Multiply | SetValue.Divide | SetValue.Coefficient | string | number | bigint | boolean | null | typeof now | typeof uuid | (string | number | bigint | boolean)[]} SetValue */
-/** @typedef {{[values.increment]: number | bigint}} SetValue.Increment */
-/** @typedef {{[values.decrement]: number | bigint}} SetValue.Decrement */
-/** @typedef {{[values.multiply]: number | bigint}} SetValue.Multiply */
-/** @typedef {{[values.divide]: number | bigint}} SetValue.Divide */
-/** @typedef {{[values.coefficient]: (number | bigint)[]}} SetValue.Coefficient */
-/**
- * @param {number | bigint} value
- * @returns {SetValue.Increment}
- */
-declare function increment(value: number | bigint): SetValue.Increment;
-/**
- * @param {number | bigint} value
- * @returns {SetValue.Decrement}
- */
-declare function decrement(value: number | bigint): SetValue.Decrement;
-/**
- * @param {number | bigint} value
- * @returns {SetValue.Multiply}
- */
-declare function multiply(value: number | bigint): SetValue.Multiply;
-/**
- * @param {number | bigint} value
- * @returns {SetValue.Divide}
- */
-declare function divide(value: number | bigint): SetValue.Divide;
-/**
- * @param {...number | bigint} value
- * @returns {SetValue.Coefficient}
- */
-declare function coefficient(...value: (number | bigint)[]): SetValue.Coefficient;
-type SetValue = SetValue.Increment | SetValue.Decrement | SetValue.Multiply | SetValue.Divide | SetValue.Coefficient | string | number | bigint | boolean | null | typeof now | typeof uuid | (string | number | bigint | boolean)[];
-declare namespace SetValue {
-    type Increment = {};
-    type Decrement = {
-        [decrement$1]: number | bigint;
-    };
-    type Multiply = {
-        [multiply$1]: number | bigint;
-    };
-    type Divide = {
-        [divide$1]: number | bigint;
-    };
-    type Coefficient = {
-        [coefficient$1]: (number | bigint)[];
-    };
-}
-
-interface VirtualTable<E extends object = object> {
-    insert(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, data: object[], key: string[], ignoreConflict?: boolean): PromiseLike<any[]>;
-    upsert(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, data: object[], key: string[], conflict: true | string[], conflictSet?: Record<string, SetValue>): PromiseLike<any[]>;
-    update(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<number>;
-    updateReturn(environment: Environment<E>, conn: IConnection<E>, returning: string[], columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<any[]>;
-    updateMany(environment: Environment<E>, conn: IConnection<E>, fields: Fields<keyof FieldType>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[]): PromiseLike<number>;
-    updateManyReturn(environment: Environment<E>, conn: IConnection<E>, fields: Fields<keyof FieldType>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[], returning: string[]): PromiseLike<any[]>;
-    count(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, where: WhereValue[]): PromiseLike<number>;
-    find(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, argv: FindArg): PromiseLike<any[]>;
-    select(environment: Environment<E>, conn: IConnection<E>, select: SelectItem[]): PromiseLike<any[]>;
-    delete(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<number>;
-    deleteReturn(environment: Environment<E>, conn: IConnection<E>, returning: string[], columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<any[]>;
-}
-
-/** 字段基本类型 */
-interface FieldType {
-    i16: number;
-    i32: number;
-    i64: bigint;
-    f32: number;
-    f64: number;
-    decimal: number;
-    numeric: number;
-    money: number;
-    /** 文本类型（含字符串类型） */
-    string: string;
-    text: string;
-    char: string;
-    uuid: string;
-    ip: string;
-    ipv4: string;
-    ipv6: string;
-    ipnet: string;
-    ipnetv4: string;
-    ipnetv6: string;
-    mac48: string;
-    mac64: string;
-    /** 布尔型 */
-    bool: boolean;
-    /** 日期类型 */
-    date: Date;
-    /** 时间类型 */
-    time: Date;
-    /** 时间类型 */
-    timetz: Date;
-    /** 日期时间类型 */
-    datetime: Date;
-    /** 时间戳类型 */
-    timestamp: Date;
-    interval: number | bigint;
-    /** 对象类型 */
-    object: Record<string, unknown>;
-    /** JSON 类型 */
-    json: any;
-}
-interface Constraint {
-    noField?: boolean;
-    field?: string;
-    value?: any;
-    writeOnly?: boolean;
-}
-type MainFieldType = keyof FieldType | TableDefine | null;
-type ToFieldType<T> = T extends keyof FieldType ? FieldType[T] : unknown;
-type FieldSpecificValue = (string | number | bigint | boolean)[] | string | number | bigint | boolean | null | typeof now | typeof uuid;
-type FieldSpecific = FieldSpecificValue | {
-    value?: FieldSpecificValue;
-    computed?(): PromiseLike<FieldSpecificValue> | FieldSpecificValue;
-};
-interface FieldDefineOption {
-    column?: string;
-    /** 缩放比 */
-    scale?: number;
-    /** 占用空间大小 */
-    size?: number;
-    /** 是否为主键 */
-    primary?: number;
-    /** 唯一索引? */
-    unique?: boolean;
-    /** 索引信息 */
-    index?: string | boolean;
-    /** 创建时，自定义数据 */
-    creating?: FieldSpecific;
-    /** 更新时，自定义数据 */
-    updating?: FieldSpecific;
-    /** 伪删除时，自定义数据 */
-    deleting?: FieldSpecific;
-    /** 是否为可创建 */
-    uncreatable?: boolean;
-    /** 是否为固定值 */
-    immutable?: boolean;
-    /** 固定值 */
-    fixedValue?: any;
-    /** 文本查询 */
-    text?: boolean;
-    /** 排序顺序，绝对值表示在排序列表中的顺序，负数表示逆序排序, 0 表示不排序 */
-    sort?: number;
-    constraints?: Record<string, Constraint>;
-}
-/** 字段类型信息 */
-interface FieldDefine<T extends MainFieldType = MainFieldType, A extends boolean = boolean, N extends boolean = boolean> extends FieldTypeDefine<T, A, N>, FieldDefineOption {
-    /** 默认值 */
-    default?: ToType<T, A, N>;
-}
-interface FieldTypeDefine<T extends MainFieldType = MainFieldType, A extends boolean = boolean, N extends boolean = boolean> {
-    /** 字段的基本类型 */
-    type: T;
-    /** 是否可为空 */
-    nullable: N;
-    /** 是否为数组 */
-    array: A;
-}
-type ToType<T extends MainFieldType = MainFieldType, A extends boolean = boolean, N extends boolean = boolean> = N extends false ? A extends false ? ToFieldType<T> : A extends true ? ToFieldType<T>[] : ToFieldType<T> | ToFieldType<T>[] : A extends false ? ToFieldType<T> | null : A extends true ? ToFieldType<T>[] | null : ToFieldType<T> | ToFieldType<T>[] | null;
-type FieldDefineType<F extends FieldTypeDefine> = F extends FieldTypeDefine<infer T, infer A, infer N> ? ToType<T, A, N> : never;
-type Fields<T extends MainFieldType = MainFieldType> = Record<string, FieldDefine<T>>;
-type FieldValue<T extends Fields> = {
-    [K in keyof T]: FieldDefineType<T[K]>;
-};
-interface IndexOptions {
-    unique?: boolean;
-    name?: string;
-    includes?: string[];
-}
-interface IndexInfo extends IndexOptions {
-    fields: string[];
-}
-interface Index extends IndexInfo {
-    name: string;
-}
-interface Hooks<T extends Record<string, any> = Record<string, any>> {
-    where(conn: Connection, model: TableDefine): PromiseLike<void | Where> | void;
-    beforeCreateMany(conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void | Record<string, any>[]> | void | Record<string, any>[];
-    afterCreateMany(conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void> | void;
-    beforeCreate(conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
-    afterCreate(conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void> | void;
-    beforeUpdate(conn: Connection, model: TableDefine, record: Record<string, any>, set: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
-    afterUpdate(conn: Connection, model: TableDefine, record: Record<string, any>, oldRecord: Record<string, any>): PromiseLike<void> | void;
-    beforeDelete(conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
-    afterDelete(conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
-}
-interface TableDefine<T extends Fields = Fields, TT extends string | VirtualTable | undefined = string | VirtualTable | undefined> {
-    /** 字段信息 */
-    readonly fields: T;
-    /** 表名 */
-    readonly table: TT;
-    /** 是否启用软删除 */
-    readonly pseudo?: string;
-    /** 索引信息 */
-    readonly indexes?: readonly IndexInfo[];
-    /** 钩子 */
-    readonly hooks?: Partial<Hooks>;
-}
-
-type deleted = typeof deleted;
-declare const deleted: unique symbol;
-type undeleted = typeof undeleted;
-declare const undeleted: unique symbol;
-type withDeleted = typeof withDeleted;
-declare const withDeleted: unique symbol;
-type FindRange = deleted | undeleted | withDeleted;
-
-type Select = {
-    field: string;
-    table?: string;
-    fn?: string;
-};
-declare namespace Select {
-    type Param = boolean | string | Select;
-}
-type JoinType = 'left' | 'right' | 'inner' | 'full';
-interface Join<T extends TableDefine = TableDefine> {
-    type: JoinType;
-    table: T;
-    /** 关联项目 { [this table field]: base table field } */
-    on: {
-        [k: string]: string;
-    };
-}
-interface Options {
-    range?: FindRange;
-    select?: Record<string, Select> | null;
-    /** 排序配置，true 表示逆序 */
-    sort?: [field: string, desc: boolean][];
-    /** 匹配信息 */
-    where: WhereValue[];
-    /** 偏移量 */
-    offset?: number;
-    /** 最大返回数 */
-    limit?: number;
-    update?: Record<string, SetValue>;
-    alias?: string;
-    group?: string[];
-}
-interface Queryable<T extends Fields = Fields> extends TableDefine<T> {
-    readonly options: Options;
-}
-
-interface ColumnOptions<T = unknown> extends FieldDefineOption {
-    /**
-     * 是否可为空
-     * @default true
-     */
-    nullable?: boolean;
-    /** 是否为数组格式 */
-    array?: boolean;
-    /** 默认值 */
-    default?: T extends never ? never : T;
-}
-interface Column<T> extends ColumnOptions<T> {
-    column: string;
-    type: string;
-}
-
-type TableType = '' | 'table' | 'view';
-interface FindArg {
-    /** 排序配置，true 表示逆序 */
-    sort?: [field: string, desc: boolean][];
-    /** 匹配信息 */
-    where: WhereValue[];
-    select: [string, Select][];
-    /** 偏移量 */
-    offset?: number;
-    /** 最大返回数 */
-    limit?: number;
-}
-interface JOIN {
-    type?: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS';
-    table: string;
-    columns: Record<string, DBColumn>;
-    alias?: string;
-    condition?: WhereValue[];
-}
-interface SelectItem {
-    distinct?: boolean;
-    select: [string, Select][];
-    table: string;
-    columns: Record<string, DBColumn>;
-    alias?: string;
-    /** 匹配信息 */
-    where: WhereValue[];
-    group: string[];
-    having: WhereValue[];
-    /** 排序配置，true 表示逆序 */
-    sort: [field: string, desc: boolean][];
-    /** 偏移量 */
-    offset?: number;
-    /** 最大返回数 */
-    limit?: number;
-}
-type GetName = (table?: string) => string;
-interface DBColumn {
-    type: string;
-    size?: number;
-    scale?: number;
-    default?: any;
-    nullable?: boolean;
-    array?: boolean;
-    primary?: number;
-}
-interface DBIndex {
-    fields: string[];
-    includes?: string[];
-    unique?: boolean;
-    name?: string;
-}
-interface DBTable {
-    table: string;
-    fields: Record<string, DBColumn>;
-    indexes?: DBIndex[];
-    primary?: string;
-}
-interface IConnection<E extends object = object> {
-    /** 数据库类型 */
-    readonly dbType: string;
-    /** 数据库版本 */
-    dbVersion(environment: Environment<E>): PromiseLike<string>;
-    exec(environment: Environment<E>, ...values: any): Promise<number>;
-    /**
-     * 执行一条语句
-     * @param sql 要执行的 SQL 语句
-     */
-    query(environment: Environment<E>, ...values: any): PromiseLike<any[]>;
-    type(environment: Environment<E>, table: string): PromiseLike<TableType | null>;
-    insert(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, data: object[], key: string[], ignoreConflict?: boolean): PromiseLike<any[]>;
-    upsert(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, data: object[], key: string[], conflict: true | string[], conflictSet?: Record<string, SetValue>): PromiseLike<any[]>;
-    update(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<number>;
-    updateReturn(environment: Environment<E>, returning: string[], table: string, columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<any[]>;
-    updateMany(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[]): PromiseLike<number>;
-    updateManyReturn(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[], returning: string[]): PromiseLike<any[]>;
-    count(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<number>;
-    find(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, argv: FindArg): PromiseLike<any[]>;
-    select(environment: Environment<E>, select: SelectItem[]): PromiseLike<any[]>;
-    delete(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<number>;
-    deleteReturn(environment: Environment<E>, returning: string[], table: string, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<any[]>;
-    createTable(environment: Environment<E>, table: string, columns: Column<any>[]): PromiseLike<number>;
-    dropTable(environment: Environment<E>, table: string): PromiseLike<number>;
-    renameTable(environment: Environment<E>, table: string, newName: string): PromiseLike<number>;
-    addColumn(environment: Environment<E>, table: string, column: string, type: string, options: ColumnOptions<any>): PromiseLike<number>;
-    changeColumn(environment: Environment<E>, table: string, column: string, type: string, options: ColumnOptions<any>): PromiseLike<number>;
-    changeColumnNull(environment: Environment<E>, table: string, column: string, nullable: boolean): PromiseLike<number>;
-    dropColumn(environment: Environment<E>, table: string, column: string): PromiseLike<number>;
-    renameColumn(environment: Environment<E>, table: string, column: string, newName: string): PromiseLike<number>;
-    addIndex(environment: Environment<E>, table: string, name: string, columns: string[], options: IndexOptions): PromiseLike<number>;
-    dropIndex(environment: Environment<E>, table: string, name: string): PromiseLike<number>;
-    loadTables(environment: Environment<E>, tables: string[]): PromiseLike<DBTable[]>;
-    syncTables(environment: Environment<E>, tables: DBTable[]): PromiseLike<void>;
-    transaction<R>(environment: Environment<E>, fn: (t: E) => R | PromiseLike<R>): PromiseLike<R>;
-}
-interface Skip {
-    uncreatable?: boolean;
-    immutable?: boolean;
-    specific?: boolean;
-    where?: boolean;
-}
-interface TransactionFn {
-    <T>(fn: (t: Connection) => PromiseLike<T> | T): Promise<T>;
-}
-
-/**
- * @template {keyof FieldType} T
- * @overload
- * @param {T} type
- * @param {{
- * 	nullable?: false;
- * 	array?: false;
- * 	default?: ToType<T, false, false> | symbol;
- * 	[k: string]: any;
- * } & FieldDefineOption} [options]
- * @returns {FieldDecorator<ToType<T, false, false>>}
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array?: false;
+ * 	default?: ToType<T, false, false> | symbol;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} [options]
+ * @returns {FieldDecorator<ToType<T, false, false>>}
  */
 declare function field$1<T extends keyof FieldType>(type: T, options?: ({
     [k: string]: any;
@@ -1313,67 +451,937 @@ declare function model<T extends Record<string, any>>(type: TableDefine, constra
  */
 declare function model<T extends Record<string, any>, A extends boolean = boolean>(type: TableDefine, constraints: Record<string, Constraint>, array: A, options?: FieldDefineOption | undefined): FieldDecorator<A extends false ? T : A extends true ? T[] : T | T[]>;
 
-/**
- * @param {number} [size]
- * @returns {FieldDecorator<Date?>}
- */
-declare function creating(size?: number): FieldDecorator<Date | null>;
-/**
- * @param {number} [size]
- * @returns {FieldDecorator<Date?>}
- */
-declare function updating(size?: number): FieldDecorator<Date | null>;
-/**
- * @param {number} [size]
- * @returns {FieldDecorator<Date?>}
- */
-declare function deleting(size?: number): FieldDecorator<Date | null>;
+/**
+ * @param {number} [size]
+ * @returns {FieldDecorator<Date?>}
+ */
+declare function creating(size?: number): FieldDecorator<Date | null>;
+/**
+ * @param {number} [size]
+ * @returns {FieldDecorator<Date?>}
+ */
+declare function updating(size?: number): FieldDecorator<Date | null>;
+/**
+ * @param {number} [size]
+ * @returns {FieldDecorator<Date?>}
+ */
+declare function deleting(size?: number): FieldDecorator<Date | null>;
+
+/** @type {Hook<Hooks['where']>} */
+declare const where: Hook<Hooks["where"]>;
+/** @type {Hook<Hooks['beforeCreateMany']>} */
+declare const beforeCreateMany: Hook<Hooks["beforeCreateMany"]>;
+/** @type {Hook<Hooks['afterCreateMany']>} */
+declare const afterCreateMany: Hook<Hooks["afterCreateMany"]>;
+/** @type {Hook<Hooks['beforeCreate']>} */
+declare const beforeCreate: Hook<Hooks["beforeCreate"]>;
+/** @type {Hook<Hooks['afterCreate']>} */
+declare const afterCreate: Hook<Hooks["afterCreate"]>;
+/** @type {Hook<Hooks['beforeUpdate']>} */
+declare const beforeUpdate: Hook<Hooks["beforeUpdate"]>;
+/** @type {Hook<Hooks['afterUpdate']>} */
+declare const afterUpdate: Hook<Hooks["afterUpdate"]>;
+/** @type {Hook<Hooks['beforeDelete']>} */
+declare const beforeDelete: Hook<Hooks["beforeDelete"]>;
+/** @type {Hook<Hooks['afterDelete']>} */
+declare const afterDelete: Hook<Hooks["afterDelete"]>;
+
+type ClassDecorator = (val: Function, ctx: ClassDecoratorContext) => any;
+type FieldDecorator<T> = (val: {
+    get(): T;
+    set(v: T): void;
+}, ctx: ClassAccessorDecoratorContext) => any;
+type MethodDecorator<T extends Function> = (val: T, ctx: ClassMethodDecoratorContext<any, T>) => any;
+
+interface Environment<T extends object> {
+    transaction: T | null;
+    isDevelopment: boolean;
+    values: typeof values;
+}
+
+/** 特性支持情况 */
+interface Support {
+    /** 是否支持 sql 查询 */
+    sql?: boolean;
+    /** 是否支持数组类型 */
+    array?: boolean;
+    /** 是否支持对象存储 */
+    object?: boolean;
+    /** 是否支持递归查询 */
+    recursive?: boolean;
+    [key: string]: undefined | boolean;
+}
+
+interface ColumnOptions<T = unknown> extends FieldDefineOption {
+    /**
+     * 是否可为空
+     * @default true
+     */
+    nullable?: boolean;
+    /** 是否为数组格式 */
+    array?: boolean;
+    /** 默认值 */
+    default?: T extends never ? never : T;
+}
+interface Column<T> extends ColumnOptions<T> {
+    column: string;
+    type: string;
+}
+
+/** @typedef {SetValue.Increment | SetValue.Decrement | SetValue.Multiply | SetValue.Divide | SetValue.Coefficient | string | number | bigint | boolean | null | typeof now | typeof uuid | (string | number | bigint | boolean)[]} SetValue */
+/** @typedef {{[values.increment]: number | bigint}} SetValue.Increment */
+/** @typedef {{[values.decrement]: number | bigint}} SetValue.Decrement */
+/** @typedef {{[values.multiply]: number | bigint}} SetValue.Multiply */
+/** @typedef {{[values.divide]: number | bigint}} SetValue.Divide */
+/** @typedef {{[values.coefficient]: (number | bigint)[]}} SetValue.Coefficient */
+/**
+ * @param {number | bigint} value
+ * @returns {SetValue.Increment}
+ */
+declare function increment(value: number | bigint): SetValue.Increment;
+/**
+ * @param {number | bigint} value
+ * @returns {SetValue.Decrement}
+ */
+declare function decrement(value: number | bigint): SetValue.Decrement;
+/**
+ * @param {number | bigint} value
+ * @returns {SetValue.Multiply}
+ */
+declare function multiply(value: number | bigint): SetValue.Multiply;
+/**
+ * @param {number | bigint} value
+ * @returns {SetValue.Divide}
+ */
+declare function divide(value: number | bigint): SetValue.Divide;
+/**
+ * @param {...number | bigint} value
+ * @returns {SetValue.Coefficient}
+ */
+declare function coefficient(...value: (number | bigint)[]): SetValue.Coefficient;
+type SetValue = SetValue.Increment | SetValue.Decrement | SetValue.Multiply | SetValue.Divide | SetValue.Coefficient | string | number | bigint | boolean | null | typeof now | typeof uuid | (string | number | bigint | boolean)[];
+declare namespace SetValue {
+    type Increment = {
+        [increment$1]: number | bigint;
+    };
+    type Decrement = {
+        [decrement$1]: number | bigint;
+    };
+    type Multiply = {
+        [multiply$1]: number | bigint;
+    };
+    type Divide = {
+        [divide$1]: number | bigint;
+    };
+    type Coefficient = {
+        [coefficient$1]: (number | bigint)[];
+    };
+}
+
+interface VirtualTable<E extends object = object> {
+    insert(environment: Environment<E>, conn: TableConnection<E>, columns: Record<string, DBColumn>, data: object[], key: string[], ignoreConflict?: boolean): PromiseLike<any[]>;
+    upsert(environment: Environment<E>, conn: TableConnection<E>, columns: Record<string, DBColumn>, data: object[], key: string[], conflict: true | string[], conflictSet?: Record<string, SetValue>): PromiseLike<any[]>;
+    update(environment: Environment<E>, conn: TableConnection<E>, columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<number>;
+    updateReturn(environment: Environment<E>, conn: TableConnection<E>, returning: string[], columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<any[]>;
+    updateMany(environment: Environment<E>, conn: TableConnection<E>, fields: Fields<keyof FieldType>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[]): PromiseLike<number>;
+    updateManyReturn(environment: Environment<E>, conn: TableConnection<E>, fields: Fields<keyof FieldType>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[], returning: string[]): PromiseLike<any[]>;
+    count(environment: Environment<E>, conn: TableConnection<E>, columns: Record<string, DBColumn>, where: WhereValue[]): PromiseLike<number>;
+    select(environment: Environment<E>, conn: TableConnection<E>, select: SelectItem[]): PromiseLike<any[]>;
+    delete(environment: Environment<E>, conn: TableConnection<E>, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<number>;
+    deleteReturn(environment: Environment<E>, conn: TableConnection<E>, returning: string[], columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<any[]>;
+}
+
+type MaybePromise<T> = PromiseLike<T> | T;
+
+interface Hook<T extends Hooks[keyof Hooks]> {
+    (approach?: boolean): MethodDecorator<T>;
+    (hook: T, approach?: boolean): ClassDecorator;
+    (Model: Function, hook: T, approach?: boolean): void;
+}
+
+/**
+ * @param {WhereValue[]?} [items]
+ * @returns {WhereValue[]?}
+ */
+declare function toNot(items?: WhereValue[] | null): WhereValue[] | null;
+type WhereItem = {
+    where?: null | undefined;
+    or?: null | undefined;
+    field: string | {
+        table?: string;
+        field: string;
+    } | (string | {
+        table?: string;
+        field: string;
+    })[];
+    value: any;
+    subquery?: SelectItem[] | null | undefined;
+    not?: boolean | undefined;
+    operator?: string | null | undefined;
+};
+type WhereRaw = {
+    field?: null | undefined;
+    or?: null | undefined;
+    where: readonly string[];
+    values: readonly any[];
+    not?: boolean | undefined;
+};
+type WhereOr = {
+    where?: null | undefined;
+    field?: null | undefined;
+    or: WhereValue[][];
+    not?: boolean | undefined;
+};
+type WhereValue = WhereItem | WhereRaw | WhereOr;
+type WhereLike = {
+    toWhereValue(): WhereValue[][];
+};
+type Wheres = WhereLike | Record<string, any> | (WhereLike | Record<string, any>)[];
+declare class Where {
+    /**
+     * @overload
+     * @param {Wheres} matches
+     * @returns {WhereValue[]?}
+     */
+    static parse(matches: Wheres): WhereValue[] | null;
+    /**
+     * @overload
+     * @param {string | string[]} field
+     * @param {any} value
+     * @returns {WhereValue[]?}
+     */
+    static parse(field: string | string[], value: any): WhereValue[] | null;
+    /**
+     * @overload
+     * @param {string | string[]} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {WhereValue[]?}
+     */
+    static parse(field: string | string[], operator: string, value: any, not?: boolean | undefined): WhereValue[] | null;
+    /**
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {WhereValue[]?}
+     */
+    static parse(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): WhereValue[] | null;
+    /**
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {WhereValue[]?}
+     */
+    static parseParams(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): WhereValue[] | null;
+    /**
+     * @overload
+     * @param {Wheres} matches
+     * @returns {Where}
+     */
+    static and(matches: Wheres): Where;
+    /**
+     *
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {Where}
+     */
+    static and(where: TemplateStringsArray, ...values: any[]): Where;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {Where}
+     */
+    static and(field: string, value: any): Where;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {Where}
+     */
+    static and(field: string[], value: any[]): Where;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {Where}
+     */
+    static and(field: string, operator: string, value: any, not?: boolean | undefined): Where;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {Where}
+     */
+    static and(field: string[], operator: string, value: any[], not?: boolean | undefined): Where;
+    /**
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {Where}
+     */
+    static and(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): Where;
+    /**
+     * @overload
+     * @param {Wheres} matches
+     * @returns {Where}
+     */
+    static or(matches: Wheres): Where;
+    /**
+     *
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {Where}
+     */
+    static or(where: TemplateStringsArray, ...values: any[]): Where;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {Where}
+     */
+    static or(field: string, value: any): Where;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {Where}
+     */
+    static or(field: string[], value: any[]): Where;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {Where}
+     */
+    static or(field: string, operator: string, value: any, not?: boolean | undefined): Where;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {Where}
+     */
+    static or(field: string[], operator: string, value: any[], not?: boolean | undefined): Where;
+    /**
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {Where}
+     */
+    static or(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): Where;
+    /**
+     * @overload
+     * @param {Wheres} matches
+     * @returns {Where}
+     */
+    static not(matches: Wheres): Where;
+    /**
+     *
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {Where}
+     */
+    static not(where: TemplateStringsArray, ...values: any[]): Where;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {Where}
+     */
+    static not(field: string, value: any): Where;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {Where}
+     */
+    static not(field: string[], value: any[]): Where;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {Where}
+     */
+    static not(field: string, operator: string, value: any, not?: boolean | undefined): Where;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {Where}
+     */
+    static not(field: string[], operator: string, value: any[], not?: boolean | undefined): Where;
+    /**
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {Where}
+     */
+    static not(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): Where;
+    /**
+     * @overload
+     * @param {Wheres} matches
+     * @returns {Where}
+     */
+    static orNot(matches: Wheres): Where;
+    /**
+     *
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {Where}
+     */
+    static orNot(where: TemplateStringsArray, ...values: any[]): Where;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {Where}
+     */
+    static orNot(field: string, value: any): Where;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {Where}
+     */
+    static orNot(field: string[], value: any[]): Where;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {Where}
+     */
+    static orNot(field: string, operator: string, value: any, not?: boolean | undefined): Where;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {Where}
+     */
+    static orNot(field: string[], operator: string, value: any[], not?: boolean | undefined): Where;
+    /**
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {Where}
+     */
+    static orNot(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): Where;
+    toWhereValue(): WhereValue[][];
+    /**
+     * @overload
+     * @param {Wheres} matches
+     * @returns {this}
+     */
+    and(matches: Wheres): this;
+    /**
+     *
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {this}
+     */
+    and(where: TemplateStringsArray, ...values: any[]): this;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {this}
+     */
+    and(field: string, value: any): this;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {this}
+     */
+    and(field: string[], value: any[]): this;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {this}
+     */
+    and(field: string, operator: string, value: any, not?: boolean | undefined): this;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {this}
+     */
+    and(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
+    /**
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {this}
+     */
+    and(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
+    /**
+     * @overload
+     * @param {Wheres} matches
+     * @returns {this}
+     */
+    or(matches: Wheres): this;
+    /**
+     *
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {this}
+     */
+    or(where: TemplateStringsArray, ...values: any[]): this;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {this}
+     */
+    or(field: string, value: any): this;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {this}
+     */
+    or(field: string[], value: any[]): this;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {this}
+     */
+    or(field: string, operator: string, value: any, not?: boolean | undefined): this;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {this}
+     */
+    or(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
+    /**
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {this}
+     */
+    or(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
+    /**
+     * @overload
+     * @param {Wheres} matches
+     * @returns {this}
+     */
+    not(matches: Wheres): this;
+    /**
+     *
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {this}
+     */
+    not(where: TemplateStringsArray, ...values: any[]): this;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {this}
+     */
+    not(field: string, value: any): this;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {this}
+     */
+    not(field: string[], value: any[]): this;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {this}
+     */
+    not(field: string, operator: string, value: any, not?: boolean | undefined): this;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {this}
+     */
+    not(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
+    /**
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {this}
+     */
+    not(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
+    /**
+     * @overload
+     * @param {Wheres} matches
+     * @returns {this}
+     */
+    orNot(matches: Wheres): this;
+    /**
+     *
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {this}
+     */
+    orNot(where: TemplateStringsArray, ...values: any[]): this;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {this}
+     */
+    orNot(field: string, value: any): this;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {this}
+     */
+    orNot(field: string[], value: any[]): this;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {this}
+     */
+    orNot(field: string, operator: string, value: any, not?: boolean | undefined): this;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {this}
+     */
+    orNot(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
+    /**
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {this}
+     */
+    orNot(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
+    #private;
+}
+
+/** 字段基本类型 */
+interface FieldType {
+    i16: number;
+    i32: number;
+    i64: bigint;
+    f32: number;
+    f64: number;
+    decimal: number;
+    numeric: number;
+    money: number;
+    /** 文本类型（含字符串类型） */
+    string: string;
+    text: string;
+    char: string;
+    uuid: string;
+    ip: string;
+    ipv4: string;
+    ipv6: string;
+    ipnet: string;
+    ipnetv4: string;
+    ipnetv6: string;
+    mac48: string;
+    mac64: string;
+    /** 布尔型 */
+    bool: boolean;
+    /** 日期类型 */
+    date: Date;
+    /** 时间类型 */
+    time: Date;
+    /** 时间类型 */
+    timetz: Date;
+    /** 日期时间类型 */
+    datetime: Date;
+    /** 时间戳类型 */
+    timestamp: Date;
+    interval: number | bigint;
+    /** 对象类型 */
+    object: Record<string, unknown>;
+    /** JSON 类型 */
+    json: any;
+}
+interface Constraint {
+    noField?: boolean;
+    field?: string;
+    value?: any;
+    writeOnly?: boolean;
+}
+type MainFieldType = keyof FieldType | TableDefine | null;
+type ToFieldType<T> = T extends keyof FieldType ? FieldType[T] : unknown;
+type FieldSpecificValue = (string | number | bigint | boolean)[] | string | number | bigint | boolean | null | typeof now | typeof uuid;
+type FieldSpecific = FieldSpecificValue | {
+    value?: FieldSpecificValue;
+    computed?(): PromiseLike<FieldSpecificValue> | FieldSpecificValue;
+};
+interface FieldDefineOption {
+    column?: string;
+    /** 缩放比 */
+    scale?: number;
+    /** 占用空间大小 */
+    size?: number;
+    /** 是否为主键 */
+    primary?: number;
+    /** 唯一索引? */
+    unique?: boolean;
+    /** 索引信息 */
+    index?: string | boolean;
+    /** 创建时，自定义数据 */
+    creating?: FieldSpecific;
+    /** 更新时，自定义数据 */
+    updating?: FieldSpecific;
+    /** 伪删除时，自定义数据 */
+    deleting?: FieldSpecific;
+    /** 是否为可创建 */
+    uncreatable?: boolean;
+    /** 是否为固定值 */
+    immutable?: boolean;
+    /** 固定值 */
+    fixedValue?: any;
+    /** 文本查询 */
+    text?: boolean;
+    /** 排序顺序，绝对值表示在排序列表中的顺序，负数表示逆序排序, 0 表示不排序 */
+    sort?: number;
+    constraints?: Record<string, Constraint>;
+}
+/** 字段类型信息 */
+interface FieldDefine<T extends MainFieldType = MainFieldType, A extends boolean = boolean, N extends boolean = boolean> extends FieldTypeDefine<T, A, N>, FieldDefineOption {
+    /** 默认值 */
+    default?: ToType<T, A, N>;
+}
+interface FieldTypeDefine<T extends MainFieldType = MainFieldType, A extends boolean = boolean, N extends boolean = boolean> {
+    /** 字段的基本类型 */
+    type: T;
+    /** 是否可为空 */
+    nullable: N;
+    /** 是否为数组 */
+    array: A;
+}
+type ToType<T extends MainFieldType = MainFieldType, A extends boolean = boolean, N extends boolean = boolean> = N extends false ? A extends false ? ToFieldType<T> : A extends true ? ToFieldType<T>[] : ToFieldType<T> | ToFieldType<T>[] : A extends false ? ToFieldType<T> | null : A extends true ? ToFieldType<T>[] | null : ToFieldType<T> | ToFieldType<T>[] | null;
+type FieldDefineType<F extends FieldTypeDefine> = F extends FieldTypeDefine<infer T, infer A, infer N> ? ToType<T, A, N> : never;
+type Fields<T extends MainFieldType = MainFieldType> = Record<string, FieldDefine<T>>;
+type FieldValue<T extends Fields> = {
+    [K in keyof T]: FieldDefineType<T[K]>;
+};
+interface IndexOptions {
+    unique?: boolean;
+    name?: string;
+    includes?: string[];
+}
+interface IndexInfo extends IndexOptions {
+    fields: string[];
+}
+interface Index extends IndexInfo {
+    name: string;
+}
+interface Hooks<T extends Record<string, any> = Record<string, any>> {
+    where(conn: Connection, model: TableDefine): PromiseLike<void | Where> | void;
+    beforeCreateMany(conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void | Record<string, any>[]> | void | Record<string, any>[];
+    afterCreateMany(conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void> | void;
+    beforeCreate(conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
+    afterCreate(conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void> | void;
+    beforeUpdate(conn: Connection, model: TableDefine, record: Record<string, any>, set: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
+    afterUpdate(conn: Connection, model: TableDefine, record: Record<string, any>, oldRecord: Record<string, any>): PromiseLike<void> | void;
+    beforeDelete(conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
+    afterDelete(conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
+}
+interface TableDefine<T extends Fields = Fields, TT extends string | VirtualTable | undefined = string | VirtualTable | undefined> {
+    readonly connect?: TableConnect<any> | null;
+    /** 字段信息 */
+    readonly fields: T;
+    /** 表名 */
+    readonly table: TT;
+    /** 是否启用软删除 */
+    readonly pseudo?: string;
+    /** 索引信息 */
+    readonly indexes?: readonly IndexInfo[];
+    /** 钩子 */
+    readonly hooks?: Partial<Hooks>;
+}
+type TableValue<T extends TableDefine> = T extends TableDefine<infer F> ? FieldValue<F> : never;
 
-/** @type {Hook<Hooks['where']>} */
-declare const where: Hook<Hooks["where"]>;
-/** @type {Hook<Hooks['beforeCreateMany']>} */
-declare const beforeCreateMany: Hook<Hooks["beforeCreateMany"]>;
-/** @type {Hook<Hooks['afterCreateMany']>} */
-declare const afterCreateMany: Hook<Hooks["afterCreateMany"]>;
-/** @type {Hook<Hooks['beforeCreate']>} */
-declare const beforeCreate: Hook<Hooks["beforeCreate"]>;
-/** @type {Hook<Hooks['afterCreate']>} */
-declare const afterCreate: Hook<Hooks["afterCreate"]>;
-/** @type {Hook<Hooks['beforeUpdate']>} */
-declare const beforeUpdate: Hook<Hooks["beforeUpdate"]>;
-/** @type {Hook<Hooks['afterUpdate']>} */
-declare const afterUpdate: Hook<Hooks["afterUpdate"]>;
-/** @type {Hook<Hooks['beforeDelete']>} */
-declare const beforeDelete: Hook<Hooks["beforeDelete"]>;
-/** @type {Hook<Hooks['afterDelete']>} */
-declare const afterDelete: Hook<Hooks["afterDelete"]>;
+type deleted = typeof deleted;
+declare const deleted: unique symbol;
+type undeleted = typeof undeleted;
+declare const undeleted: unique symbol;
+type withDeleted = typeof withDeleted;
+declare const withDeleted: unique symbol;
+type FindRange = deleted | undeleted | withDeleted;
 
-type ClassDecorator = (val: Function, ctx: ClassDecoratorContext) => any;
-type FieldDecorator<T> = (val: {
-    get(): T;
-    set(v: T): void;
-}, ctx: ClassAccessorDecoratorContext) => any;
-type MethodDecorator<T extends Function> = (val: T, ctx: ClassMethodDecoratorContext<any, T>) => any;
+type Select = {
+    field: string;
+    table?: string;
+    fn?: string;
+};
+declare namespace Select {
+    type Param = boolean | string | Select;
+}
+type JoinType = 'left' | 'right' | 'inner' | 'full';
+interface Join<T extends TableDefine = TableDefine> {
+    type: JoinType;
+    table: T;
+    /** 关联项目 { [this table field]: base table field } */
+    on: {
+        [k: string]: string;
+    };
+}
+interface Options {
+    range?: FindRange;
+    select?: Record<string, Select> | null;
+    /** 排序配置，true 表示逆序 */
+    sort?: [field: string, desc: boolean][];
+    /** 匹配信息 */
+    where: WhereValue[];
+    /** 偏移量 */
+    offset?: number;
+    /** 最大返回数 */
+    limit?: number;
+    update?: Record<string, SetValue>;
+    alias?: string;
+    group?: string[];
+}
+interface Queryable<T extends Fields = Fields> extends TableDefine<T> {
+    readonly options: Options;
+}
 
-/** 特性支持情况 */
-interface Support {
-    /** 是否支持 sql 查询 */
-    sql?: boolean;
-    /** 是否支持数组类型 */
+type TableType = '' | 'table' | 'view';
+interface FindArg {
+    /** 排序配置，true 表示逆序 */
+    sort?: [field: string, desc: boolean][];
+    /** 匹配信息 */
+    where: WhereValue[];
+    select: [string, Select][];
+    /** 偏移量 */
+    offset?: number;
+    /** 最大返回数 */
+    limit?: number;
+}
+interface JOIN {
+    type?: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS';
+    table: string;
+    columns: Record<string, DBColumn>;
+    alias?: string;
+    condition?: WhereValue[];
+}
+interface SelectItem {
+    distinct?: boolean;
+    select: [string, Select][];
+    table: string;
+    columns: Record<string, DBColumn>;
+    alias?: string;
+    /** 匹配信息 */
+    where: WhereValue[];
+    group: string[];
+    having: WhereValue[];
+    /** 排序配置，true 表示逆序 */
+    sort: [field: string, desc: boolean][];
+    /** 偏移量 */
+    offset?: number;
+    /** 最大返回数 */
+    limit?: number;
+}
+type GetName = (table?: string) => string;
+interface DBColumn {
+    type: string;
+    size?: number;
+    scale?: number;
+    default?: any;
+    nullable?: boolean;
     array?: boolean;
-    /** 是否支持对象存储 */
-    object?: boolean;
-    /** 是否支持递归查询 */
-    recursive?: boolean;
-    [key: string]: undefined | boolean;
+    primary?: number;
 }
-
-type MaybePromise<T> = PromiseLike<T> | T;
-
-interface Hook<T extends Hooks[keyof Hooks]> {
-    (approach?: boolean): MethodDecorator<T>;
-    (hook: T, approach?: boolean): ClassDecorator;
-    (Model: Function, hook: T, approach?: boolean): void;
+interface DBIndex {
+    fields: string[];
+    includes?: string[];
+    unique?: boolean;
+    name?: string;
+}
+interface DBTable {
+    table: string;
+    fields: Record<string, DBColumn>;
+    indexes?: DBIndex[];
+    primary?: string;
+}
+interface TableConnection<E extends object = object> {
+    insert(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, data: object[], key: string[], ignoreConflict?: boolean): PromiseLike<any[]>;
+    upsert(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, data: object[], key: string[], conflict: true | string[], conflictSet?: Record<string, SetValue>): PromiseLike<any[]>;
+    update(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<number>;
+    updateReturn(environment: Environment<E>, returning: string[], table: string, columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<any[]>;
+    updateMany(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[]): PromiseLike<number>;
+    updateManyReturn(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[], returning: string[]): PromiseLike<any[]>;
+    count(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<number>;
+    select(environment: Environment<E>, select: SelectItem[]): PromiseLike<any[]>;
+    delete(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<number>;
+    deleteReturn(environment: Environment<E>, returning: string[], table: string, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<any[]>;
+}
+interface IConnection<E extends object = object> extends TableConnection<E> {
+    /** 数据库类型 */
+    readonly dbType: string;
+    /** 数据库版本 */
+    dbVersion(environment: Environment<E>): PromiseLike<string>;
+    exec(environment: Environment<E>, ...values: any): Promise<number>;
+    /**
+     * 执行一条语句
+     * @param sql 要执行的 SQL 语句
+     */
+    query(environment: Environment<E>, ...values: any): PromiseLike<any[]>;
+    type(environment: Environment<E>, table: string): PromiseLike<TableType | null>;
+    createTable(environment: Environment<E>, table: string, columns: Column<any>[]): PromiseLike<number>;
+    dropTable(environment: Environment<E>, table: string): PromiseLike<number>;
+    renameTable(environment: Environment<E>, table: string, newName: string): PromiseLike<number>;
+    addColumn(environment: Environment<E>, table: string, column: string, type: string, options: ColumnOptions<any>): PromiseLike<number>;
+    changeColumn(environment: Environment<E>, table: string, column: string, type: string, options: ColumnOptions<any>): PromiseLike<number>;
+    changeColumnNull(environment: Environment<E>, table: string, column: string, nullable: boolean): PromiseLike<number>;
+    dropColumn(environment: Environment<E>, table: string, column: string): PromiseLike<number>;
+    renameColumn(environment: Environment<E>, table: string, column: string, newName: string): PromiseLike<number>;
+    addIndex(environment: Environment<E>, table: string, name: string, columns: string[], options: IndexOptions): PromiseLike<number>;
+    dropIndex(environment: Environment<E>, table: string, name: string): PromiseLike<number>;
+    loadTables(environment: Environment<E>, tables: string[]): PromiseLike<DBTable[]>;
+    syncTables(environment: Environment<E>, tables: DBTable[]): PromiseLike<void>;
+    transaction<R>(environment: Environment<E>, fn: (t: E) => R | PromiseLike<R>): PromiseLike<R>;
+}
+interface TableConnect<E extends object = object> {
+    (conn: IConnection<E>): TableConnection<E>;
+}
+interface Skip {
+    uncreatable?: boolean;
+    immutable?: boolean;
+    specific?: boolean;
+    where?: boolean;
+}
+interface TransactionFn {
+    <T>(fn: (t: Connection) => PromiseLike<T> | T): Promise<T>;
 }
 
 declare const Destroy: unique symbol;
@@ -1697,7 +1705,7 @@ declare class Connection<E extends {} = {}> {
      * @param {Record<string, SetValue>} [conflictSet]
      * @returns {Promise<T>}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: boolean | string[] | Record<string, SetValue> | null | undefined, conflictKeys?: boolean | string[] | Record<string, SetValue> | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: boolean | Record<string, SetValue> | string[] | null | undefined, conflictKeys?: boolean | Record<string, SetValue> | string[] | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
     /**
      * @template {object} T
      * @overload
@@ -1708,7 +1716,7 @@ declare class Connection<E extends {} = {}> {
      * @param {Record<string, SetValue>} [conflictSet]
      * @returns {Promise<T[]>}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: boolean | string[] | Record<string, SetValue> | null | undefined, conflictKeys?: boolean | string[] | Record<string, SetValue> | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: boolean | Record<string, SetValue> | string[] | null | undefined, conflictKeys?: boolean | Record<string, SetValue> | string[] | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
     /**
      * @template {object} T
      * @overload
@@ -1719,7 +1727,7 @@ declare class Connection<E extends {} = {}> {
      * @param {Record<string, SetValue>} [conflictSet]
      * @returns {Promise<T | T[]>}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T | T[], keys?: boolean | string[] | Record<string, SetValue> | null | undefined, conflictKeys?: boolean | string[] | Record<string, SetValue> | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T | T[]>;
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T | T[], keys?: boolean | Record<string, SetValue> | string[] | null | undefined, conflictKeys?: boolean | Record<string, SetValue> | string[] | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T | T[]>;
     /**
      * @param {TableDefine} tableDefine
      * @param {Record<string, any>} update
@@ -1727,7 +1735,7 @@ declare class Connection<E extends {} = {}> {
      * @param {boolean | Skip} [skip]
      * @returns {Promise<number>}
      */
-    update({ table, fields }: TableDefine, update: Record<string, any>, where?: Wheres | null, skip?: boolean | Skip): Promise<number>;
+    update({ connect, table, fields }: TableDefine, update: Record<string, any>, where?: Wheres | null, skip?: boolean | Skip): Promise<number>;
     /**
      * @template {Fields<MainFieldType>} T
      * @param {TableDefine<T>} tableDefine
@@ -1737,7 +1745,7 @@ declare class Connection<E extends {} = {}> {
      * @param {boolean | Skip} [skip]
      * @returns {Promise<any[]>}
      */
-    updateReturn<T extends Fields<MainFieldType>>({ table, fields }: TableDefine<T>, update: Record<string, any>, returning?: string[] | null, where?: Wheres | null, skip?: boolean | Skip): Promise<any[]>;
+    updateReturn<T extends Fields<MainFieldType>>({ connect, table, fields }: TableDefine<T>, update: Record<string, any>, returning?: string[] | null, where?: Wheres | null, skip?: boolean | Skip): Promise<any[]>;
     /**
      * @param {TableDefine} tableDefine
      * @param {string[]} pKeys
@@ -1746,7 +1754,7 @@ declare class Connection<E extends {} = {}> {
      * @param {boolean | Skip} [skip]
      * @returns {Promise<number>}
      */
-    updateMany({ table, fields }: TableDefine, pKeys: string[], setKeys: string[], list: Record<string, any>[], skip?: boolean | Skip): Promise<number>;
+    updateMany({ connect, table, fields }: TableDefine, pKeys: string[], setKeys: string[], list: Record<string, any>[], skip?: boolean | Skip): Promise<number>;
     /**
      * @template {Fields<MainFieldType>} T
      * @param {TableDefine<T>} tableDefine
@@ -1757,13 +1765,13 @@ declare class Connection<E extends {} = {}> {
      * @param {boolean | Skip} [skip]
      * @returns {Promise<any[]>}
      */
-    updateManyReturn<T extends Fields<MainFieldType>>({ table, fields }: TableDefine<T>, pKeys: string[], setKeys: string[], list: Record<string, any>[], returning?: string[] | null, skip?: boolean | Skip): Promise<any[]>;
+    updateManyReturn<T extends Fields<MainFieldType>>({ connect, table, fields }: TableDefine<T>, pKeys: string[], setKeys: string[], list: Record<string, any>[], returning?: string[] | null, skip?: boolean | Skip): Promise<any[]>;
     /**
      * @param {TableDefine} tableDefine
      * @param {Wheres?} [where]
      * @returns {Promise<number>}
      */
-    delete({ table, fields }: TableDefine, where?: Wheres | null): Promise<number>;
+    delete({ connect, table, fields }: TableDefine, where?: Wheres | null): Promise<number>;
     /**
      * @template {Fields<MainFieldType>} T
      * @param {TableDefine<T>} tableDefine
@@ -1771,7 +1779,7 @@ declare class Connection<E extends {} = {}> {
      * @param {Wheres?} [where]
      * @returns {Promise<any[]>}
      */
-    deleteReturn<T extends Fields<MainFieldType>>({ table, fields }: TableDefine<T>, returning?: string[] | null, where?: Wheres | null): Promise<any[]>;
+    deleteReturn<T extends Fields<MainFieldType>>({ connect, table, fields }: TableDefine<T>, returning?: string[] | null, where?: Wheres | null): Promise<any[]>;
     /**
      *
      * @param {Queryable} queryable
@@ -1901,7 +1909,14 @@ declare function getPrimaryKeys(fieldsOrColumns: Fields): string[];
  */
 declare function isPseudo(model: Queryable): boolean;
 
+/** @import { SelectItem } from './types' */
+declare class Subquery {
+    /** @returns {SelectItem[]} */
+    toSubquery(): SelectItem[];
+}
+
 type QueryOptions<T extends Fields, TB extends unknown = any> = {
+    connect?: TableConnect<any> | null | undefined;
     table?: string | VirtualTable<object> | undefined;
     fields: T;
     pseudo?: string | undefined;
@@ -1911,6 +1926,7 @@ type QueryOptions<T extends Fields, TB extends unknown = any> = {
  * @template {Fields} T
  * @template {object} [TB=object]
  * @typedef {object} QueryOptions
+ * @property {TableConnect<any>?} [connect]
  * @property {string | VirtualTable} [table]
  * @property {T} fields
  * @property {string} [pseudo]
@@ -1921,7 +1937,7 @@ type QueryOptions<T extends Fields, TB extends unknown = any> = {
  * @template {object} [TB=object]
  * @implements {Queryable<T>}
  */
-declare class Query<T extends Fields, TB extends unknown = any> implements Queryable {
+declare class Query<T extends Fields, TB extends unknown = any> extends Subquery implements Queryable {
     /**
      * @template {Fields} F
      * @template {new (o: QueryOptions<F>) => Query<F>} T
@@ -1937,6 +1953,8 @@ declare class Query<T extends Fields, TB extends unknown = any> implements Query
      * @param {boolean} [noBuild]
      */
     constructor(options: QueryOptions<T, TB> | Query<T, TB>, noBuild?: boolean);
+    /** @readonly @type {TableConnect | null | undefined} */
+    readonly connect: TableConnect | null | undefined;
     /** @readonly @type {string | VirtualTable | undefined} */
     readonly table: string | VirtualTable | undefined;
     /** @readonly @type {T} */
@@ -2518,4 +2536,4 @@ declare function field<T extends MainFieldType>(type: T, options: {
 declare function setDevelopment(d?: boolean): void;
 declare let isDevelopment: boolean;
 
-export { Build, type ClassDecorator, type Column, type ColumnOptions, Connection, type Constraint, Create, type DBColumn, type DBIndex, type DBTable, Destroy, type Environment, type FieldDecorator, type FieldDefine, type FieldDefineOption, type FieldDefineType, type FieldSpecific, type FieldSpecificValue, type FieldType, type FieldTypeDefine, type FieldValue, type Fields, type FindArg, type FindRange, type GetName, type Hook, type Hooks, type IConnection, type Index, type IndexInfo, type IndexOptions, type JOIN, type Join, type JoinType, type MainFieldType, type MaybePromise, type MethodDecorator, Model, type Options, PseudoDestroy, Query, type QueryOptions, type Queryable, Save, Scene, Select, type SelectItem, SetValue, type Skip, Submodel, type Support, type TableDefine, type TableType, type ToFieldType, type ToType, type TransactionFn, type VirtualTable, Where, type WhereItem, type WhereLike, type WhereOr, type WhereRaw, type WhereValue, type Wheres, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, coefficient, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, where, withDeleted };
+export { Build, type ClassDecorator, type Column, type ColumnOptions, Connection, type Constraint, Create, type DBColumn, type DBIndex, type DBTable, Destroy, type Environment, type FieldDecorator, type FieldDefine, type FieldDefineOption, type FieldDefineType, type FieldSpecific, type FieldSpecificValue, type FieldType, type FieldTypeDefine, type FieldValue, type Fields, type FindArg, type FindRange, type GetName, type Hook, type Hooks, type IConnection, type Index, type IndexInfo, type IndexOptions, type JOIN, type Join, type JoinType, type MainFieldType, type MaybePromise, type MethodDecorator, Model, type Options, PseudoDestroy, Query, type QueryOptions, type Queryable, Save, Scene, Select, type SelectItem, SetValue, type Skip, Submodel, type Support, type TableConnect, type TableConnection, type TableDefine, type TableType, type TableValue, type ToFieldType, type ToType, type TransactionFn, type VirtualTable, Where, type WhereItem, type WhereLike, type WhereOr, type WhereRaw, type WhereValue, type Wheres, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, coefficient, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, where, withDeleted };