imodel 0.0.0 → 0.2.0

package/index.d.mts

@@ -0,0 +1,2190 @@
+/*!
+ * imodel v0.2.0
+ * (c) 2019-2025 undefined
+ * @license undefined
+ */
+
+declare const now: unique symbol;
+declare const increment$1: unique symbol;
+declare const decrement$1: unique symbol;
+declare const multiply$1: unique symbol;
+declare const divide$1: unique symbol;
+
+declare const values_now: typeof now;
+declare namespace values {
+  export { decrement$1 as decrement, divide$1 as divide, increment$1 as increment, multiply$1 as multiply, values_now as now };
+}
+
+interface Environment<T extends object> {
+    transaction: T | null;
+    isDevelopment: boolean;
+    names?: Record<string, string> | null;
+    getName(table: string): string;
+    values: typeof 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;
+}
+
+/** @typedef {SetValue.Increment | SetValue.Decrement | SetValue.Multiply | SetValue.Divide | string | number | bigint | boolean | null | typeof now | (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 */
+/**
+ * @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;
+
+type SetValue = SetValue.Increment | SetValue.Decrement | SetValue.Multiply | SetValue.Divide | string | number | bigint | boolean | null | typeof now | (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;
+    };
+}
+
+interface VirtualTable<E extends object = object> {
+    insert(environment: Environment<E>, conn: IConnection<E>, table: string, fields: Fields<keyof FieldType>, data: object[], key: string[]): PromiseLike<any[]>;
+    update(environment: Environment<E>, conn: IConnection<E>, args: MatchArg, update: Record<string, SetValue>): PromiseLike<number>;
+    updateReturn(environment: Environment<E>, conn: IConnection<E>, args: MatchArg, update: Record<string, SetValue>, returning: string[]): PromiseLike<any[]>;
+    updateMany(environment: Environment<E>, conn: IConnection<E>, table: string, 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>, table: string, 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>, argv: CountArg): PromiseLike<number>;
+    select(environment: Environment<E>, conn: IConnection<E>, argv: SelectArg): PromiseLike<any[]>;
+    delete(environment: Environment<E>, conn: IConnection<E>, argv: MatchArg): PromiseLike<number>;
+    deleteReturn(environment: Environment<E>, conn: IConnection<E>, argv: MatchArg, returning: string[]): PromiseLike<any[]>;
+}
+
+/** 字段基本类型 */
+interface FieldType {
+    /** 基本的 Id 类型，具体数据库实现由数据库决定 */
+    id: string;
+    /** 引用类型，具体数据库实现由数据库决定，需要与 id 类型一致 */
+    rid: string;
+    /** 弱引用类型，需要考虑跨数据库引擎实现 */
+    ref: string;
+    i16: number;
+    i32: number;
+    i64: bigint;
+    u16: number;
+    u32: number;
+    u64: 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;
+    mac48: string;
+    mac64: string;
+    /** 布尔型 */
+    bool: boolean;
+    /** 二进制类型 */
+    binary: ArrayBuffer | ArrayBufferView;
+    /** 日期类型 */
+    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;
+}
+type MainFieldType = keyof FieldType | TableDefine;
+type ToFieldType<T> = T extends keyof FieldType ? FieldType[T] : unknown;
+type FieldSpecificValue = (string | number | bigint | boolean)[] | string | number | bigint | boolean | null | typeof now;
+type FieldSpecific = FieldSpecificValue | {
+    value: FieldSpecificValue;
+    computed?(): PromiseLike<FieldSpecificValue> | FieldSpecificValue;
+};
+interface FieldDefineOption {
+    /** 精确度 */
+    precision?: number;
+    /** 缩放比 */
+    scale?: number;
+    /** 占用空间大小 */
+    size?: number;
+    /** 是否为主键 */
+    primary?: number | boolean;
+    /** 序列字段 */
+    serial?: boolean;
+    /** 唯一索引? */
+    unique?: boolean;
+    /** 索引信息 */
+    index?: string | boolean;
+    /** 创建时，自定义数据 */
+    creating?: FieldSpecific;
+    /** 更新时，自定义数据 */
+    updating?: FieldSpecific;
+    /** 伪删除时，自定义数据 */
+    deleting?: FieldSpecific;
+    /** 是否为固定值 */
+    immutable?: boolean;
+    /** 文本查询 */
+    text?: boolean;
+    /** 排序顺序，绝对值表示在排序列表中的顺序，负数表示逆序排序, 0 表示不排序 */
+    sort?: number;
+}
+/** 字段类型信息 */
+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 FieldDefine<T extends MainFieldType = MainFieldType, A extends boolean = boolean, N extends boolean = boolean> extends FieldTypeDefine<T, A, N>, FieldDefineOption {
+    /** 默认值 */
+    default?: ToType<T, A, N>;
+    constraints?: Record<string, Constraint>;
+}
+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;
+    include?: string[];
+}
+interface IndexInfo extends IndexOptions {
+    fields: string[];
+}
+interface Index extends IndexInfo {
+    name: string;
+}
+interface TableDefine<T extends Fields = Fields> {
+    /** 字段信息 */
+    readonly fields: T;
+    /** 表名 */
+    readonly table?: string | VirtualTable;
+    /** 是否启用软删除 */
+    readonly pseudo?: string;
+    /** 索引信息 */
+    readonly indexes?: readonly IndexInfo[];
+}
+
+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;
+}
+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> {
+    name: string;
+    type: string;
+}
+
+/** 特性支持情况 */
+interface Support {
+    /** 是否支持 sql 查询 */
+    sql?: boolean;
+    /** 是否支持数组类型 */
+    array?: boolean;
+    /** 是否支持对象存储 */
+    object?: boolean;
+    /** 是否支持递归查询 */
+    recursive?: boolean;
+    [key: string]: undefined | boolean;
+}
+
+type MaybePromise<T> = PromiseLike<T> | T;
+
+declare const Destroy: unique symbol;
+interface Destroy {
+    [Destroy](connection: Connection, run: (data: any) => Promise<object | null>, table: TableDefine<Fields<MainFieldType>>): PromiseLike<this | null>;
+}
+declare const PseudoDestroy: unique symbol;
+interface PseudoDestroy {
+    [PseudoDestroy](connection: Connection, update: Record<string, SetValue>, run: (data: any) => Promise<object | null>, table: TableDefine<Fields<MainFieldType>>): PromiseLike<this | null>;
+}
+declare const Save: unique symbol;
+interface Save {
+    [Save](connection: Connection, run: (data: any, newData?: any) => Promise<object | null>, newData: Record<string, any> | null, table: TableDefine): PromiseLike<this | null>;
+}
+declare const Create: unique symbol;
+interface Create<T = unknown> {
+    [Create](connection: Connection, data: object, run: (data: any) => Promise<object>, table: TableDefine): PromiseLike<T>;
+}
+declare const Build: unique symbol;
+interface Build<T = unknown> {
+    [Build](data: object, others: object | boolean): T;
+}
+
+type TableType = '' | 'table' | 'view';
+interface CountArg extends Omit<TableDefine, 'table'>, Omit<Options, 'select'> {
+    table: string;
+}
+interface SelectArg extends CountArg {
+    select: [string, Select][];
+}
+type GetName = (table?: string) => string;
+interface MatchArg extends Omit<TableDefine<Fields<keyof FieldType>>, 'table'> {
+    table: string;
+    where?: WhereValue[];
+}
+type BuildValue<T extends TableDefine> = T extends Build<infer R> ? R : object;
+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, fields: Fields<keyof FieldType>, data: object[], key: string[]): PromiseLike<any[]>;
+    update(environment: Environment<E>, args: MatchArg, update: Record<string, SetValue>): PromiseLike<number>;
+    updateReturn(environment: Environment<E>, args: MatchArg, update: Record<string, SetValue>, returning: string[]): PromiseLike<any[]>;
+    updateMany(environment: Environment<E>, table: string, fields: Fields<keyof FieldType>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[]): PromiseLike<number>;
+    updateManyReturn(environment: Environment<E>, table: string, 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>, argv: CountArg): PromiseLike<number>;
+    select(environment: Environment<E>, argv: SelectArg): PromiseLike<any[]>;
+    delete(environment: Environment<E>, argv: MatchArg): PromiseLike<number>;
+    deleteReturn(environment: Environment<E>, argv: MatchArg, returning: string[]): PromiseLike<any[]>;
+    createTable(environment: Environment<E>, table: string, fields: 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, fields: string[], options: IndexOptions): PromiseLike<number>;
+    dropIndex(environment: Environment<E>, table: string, name: string): PromiseLike<number>;
+    createView(environment: Environment<E>, name: string, q: SelectArg): PromiseLike<number>;
+    dropView(environment: Environment<E>, name: string): PromiseLike<number>;
+    createMaterializedView(environment: Environment<E>, name: string, q: SelectArg): PromiseLike<number>;
+    dropMaterializedView(environment: Environment<E>, name: string): PromiseLike<number>;
+    transaction<R>(environment: Environment<E>, fn: (t: E) => R | PromiseLike<R>): PromiseLike<R>;
+}
+interface Skip {
+    immutable?: boolean;
+    specific?: boolean;
+}
+interface TransactionFn {
+    <T>(fn: (t: Connection) => PromiseLike<T> | T): Promise<T>;
+}
+/** @deprecated */
+interface Querier<T> {
+    (t: Connection): PromiseLike<T> | T;
+}
+
+/**
+ * @template {{}} [E={}]
+ */
+declare class Connection<E extends {} = {}> {
+    /**
+     *
+     * @param {PromiseLike<IConnection<E>> | IConnection<E>} connection
+     * @param {E?} [transaction]
+     * @param {Record<string, string>?} [names]
+     */
+    constructor(connection: PromiseLike<IConnection<E>> | IConnection<E>, transaction?: E | null, names?: Record<string, string> | null);
+    /**
+     *
+     * @param {object} [options]
+     * @param {Record<string, string>?} [options.names]
+     * @returns {Connection<E>}
+     */
+    clone({ names }?: {
+        names?: Record<string, string> | null | undefined;
+    }): Connection<E>;
+    /** @return {Promise<string>} */
+    dbType(): Promise<string>;
+    /** @return {Promise<string>} */
+    dbVersion(): Promise<string>;
+    /**
+     *
+     * @param {...any} values
+     * @returns {Promise<any[]>}
+     */
+    query(...values: any[]): Promise<any[]>;
+    /**
+     *
+     * @param {...any} values
+     * @returns {Promise<number>}
+     */
+    exec(...values: any[]): Promise<number>;
+    /**
+     *
+     * @param {string} table
+     * @returns {Promise<TableType?>}
+     */
+    type(table: string): Promise<TableType | null>;
+    /**
+     * @template T
+     * @overload
+     * @param {Build<T>} build
+     * @param {object} data
+     * @param {object | boolean} [saved]
+     * @returns {T}
+     */
+    build<T extends Fields>(build: Build<T>, data: object, saved?: object | boolean): T;
+    /**
+     * @template {Fields} T
+     * @overload
+     * @param {TableDefine<T>} table
+     * @param {object} data
+     * @param {object | boolean} [saved]
+     * @returns {FieldValue<T>}
+     */
+    build<T extends Fields>(table: TableDefine<T>, data: object, saved?: object | boolean): FieldValue<T>;
+    /**
+     * @template {TableDefine} T
+     * @overload
+     * @param {T} model
+     * @param {object[]} list
+     * @returns {Promise<object[]>}
+     */
+    create<T extends TableDefine>(model: T, list: object[]): Promise<object[]>;
+    /**
+     * @template {TableDefine} T
+     * @overload
+     * @param {T} model
+     * @param {object} value
+     * @returns {Promise<T extends Build<infer R> ? R : object>}
+     */
+    create<T extends TableDefine>(model: T, value: object): Promise<T extends Build<infer R> ? R : object>;
+    /**
+     * @template {TableDefine} T
+     * @overload
+     * @param {T} model
+     * @param {object | object[]} value
+     * @returns {Promise<object[] | (T extends Build<infer R> ? R : object)>}
+     */
+    create<T extends TableDefine>(model: T, value: object | object[]): Promise<object[] | (T extends Build<infer R> ? R : object)>;
+    /**
+     *
+     * @template {TableDefine} T
+     * @param {T} sql
+     * @returns {Promise<T extends Build<infer R > ? R[] : T extends TableDefine<infer F> ? FieldValue<F>[] : never>}
+     */
+    find<T extends TableDefine>(sql: T): Promise<T extends Build<infer R> ? R[] : T extends TableDefine<infer F> ? FieldValue<F>[] : never>;
+    /**
+     *
+     * @template {TableDefine} T
+     * @param {T} sql
+     * @returns {Promise<T extends Build<infer R > ? R : T extends TableDefine<infer F> ? FieldValue<F> : never>}
+     */
+    first<T extends TableDefine>(sql: T): Promise<T extends Build<infer R> ? R : T extends TableDefine<infer F> ? FieldValue<F> : never>;
+    /**
+     * @template T
+     * @param {TableDefine} model
+     * @param {T} data
+     * @param {Record<string, any>?} [newData]
+     * @returns {Promise<(T extends Save ? T : object)?>}
+     */
+    save<T>(model: TableDefine, data: T, newData?: Record<string, any> | null): Promise<(T extends Save ? T : object) | null>;
+    /**
+     *
+     * @template T
+     * @param {TableDefine} tableDef
+     * @param {T} data
+     * @returns {Promise<(T extends Destroy ? T : object)?>}
+     */
+    completelyDestroy<T>(tableDef: TableDefine, data: T): Promise<(T extends Destroy ? T : object) | null>;
+    /**
+     *
+     * @template {object} T
+     * @param {TableDefine} tableDef
+     * @param {T} data
+     * @param {Record<string, SetValue>} value
+     * @returns {Promise<(T extends PseudoDestroy ? T : object)?>}
+     */
+    pseudoDestroy<T extends unknown>(tableDef: TableDefine, data: T, value: Record<string, SetValue>): Promise<(T extends PseudoDestroy ? T : object) | null>;
+    /**
+     * @template {Destroy & PseudoDestroy} T
+     * @overload
+     * @param {TableDefine} table
+     * @param {T} data
+     * @param {Record<string, any> | boolean} [update]
+     * @returns {Promise<T?>}
+     */
+    destroy<T extends Destroy & PseudoDestroy>(table: TableDefine, data: T, update?: boolean | Record<string, any> | undefined): Promise<T | null>;
+    /**
+     * @template {Destroy & PseudoDestroy} T
+     * @overload
+     * @param {TableDefine} table
+     * @param {T} data
+     * @param {Record<string, any> | boolean} [update]
+     * @returns {Promise<T | object | null>}
+     */
+    destroy<T extends Destroy & PseudoDestroy>(table: TableDefine, data: T, update?: boolean | Record<string, any> | undefined): Promise<T | object | null>;
+    /**
+     * @overload
+     * @param {TableDefine} table
+     * @param {any} data
+     * @param {Record<string, any> | boolean} [update]
+     * @returns {Promise<object?>}
+     */
+    destroy(table: TableDefine, data: any, update?: boolean | Record<string, any> | undefined): Promise<object | null>;
+    /**
+     * @param {Queryable} queryable
+     * @param {Record<string, SetValue> | boolean} [update]
+     * @returns {Promise<number>}
+     */
+    destroyMany(queryable: Queryable, update?: Record<string, SetValue> | boolean): Promise<number>;
+    /**
+     * @template {object | object[]} T
+     * @param {TableDefine} tableDefine
+     * @param {T} data
+     * @param {string[]} [keys]
+     * @returns {Promise<T extends object[] ? object[] : object>}
+     */
+    insert<T extends unknown>({ table, fields }: TableDefine, data: T, keys?: string[]): Promise<T extends object[] ? object[] : object>;
+    /**
+     * @param {TableDefine} tableDefine
+     * @param {Record<string, any>} update
+     * @param {WhereValue[]?} [where]
+     * @param {boolean | Skip} [skip]
+     * @returns {Promise<number>}
+     */
+    update({ table, fields }: TableDefine, update: Record<string, any>, where?: WhereValue[] | null, skip?: boolean | Skip): Promise<number>;
+    /**
+     * @template {Fields<MainFieldType>} T
+     * @param {TableDefine<T>} tableDefine
+     * @param {Record<string, any>} update
+     * @param {string[]?} [returning]
+     * @param {WhereValue[]?} [where]
+     * @param {boolean | Skip} [skip]
+     * @returns {Promise<any[]>}
+     */
+    updateReturn<T extends Fields<MainFieldType>>({ table, fields }: TableDefine<T>, update: Record<string, any>, returning?: string[] | null, where?: WhereValue[] | null, skip?: boolean | Skip): Promise<any[]>;
+    /**
+     * @param {TableDefine} tableDefine
+     * @param {string[]} pKeys
+     * @param {string[]} setKeys
+     * @param {Record<string, any>[]} list
+     * @param {boolean | Skip} [skip]
+     * @returns {Promise<number>}
+     */
+    updateMany({ table, fields }: TableDefine, pKeys: string[], setKeys: string[], list: Record<string, any>[], skip?: boolean | Skip): Promise<number>;
+    /**
+     * @template {Fields<MainFieldType>} T
+     * @param {TableDefine<T>} tableDefine
+     * @param {string[]} pKeys
+     * @param {string[]} setKeys
+     * @param {Record<string, any>[]} list
+     * @param {string[]?} [returning]
+     * @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[]>;
+    /**
+     * @param {TableDefine} tableDefine
+     * @param {WhereValue[]} [where]
+     * @returns {Promise<number>}
+     */
+    delete({ table, fields }: TableDefine, where?: WhereValue[]): Promise<number>;
+    /**
+     * @template {Fields<MainFieldType>} T
+     * @param {TableDefine<T>} tableDefine
+     * @param {string[]?} [returning]
+     * @param {WhereValue[]} [where]
+     * @returns {Promise<any[]>}
+     */
+    deleteReturn<T extends Fields<MainFieldType>>({ table, fields }: TableDefine<T>, returning?: string[] | null, where?: WhereValue[]): Promise<any[]>;
+    /**
+     *
+     * @param {Queryable} queryable
+     * @returns {Promise<number>}
+     */
+    count(queryable: Queryable): Promise<number>;
+    /**
+     * @param {Queryable} queryable
+     * @returns {Promise<any[]>}
+     */
+    select(queryable: Queryable): Promise<any[]>;
+    /**
+     * @param {string} table
+     * @param {string} column
+     * @param {string} type
+     * @param {ColumnOptions<any>} options
+     * @returns {Promise<number>}
+     */
+    addColumn(table: string, column: string, type: string, options: ColumnOptions<any>): Promise<number>;
+    /**
+     * @param {string} table
+     * @param {string} column
+     * @param {string} type
+     * @param {ColumnOptions<any>} options
+     * @returns {Promise<number>}
+     */
+    changeColumn(table: string, column: string, type: string, options: ColumnOptions<any>): Promise<number>;
+    /**
+     * @param {string} table
+     * @param {string} column
+     * @param {boolean} nullable
+     * @returns {Promise<number>}
+     */
+    changeColumnNull(table: string, column: string, nullable: boolean): Promise<number>;
+    /**
+     * @param {string} table
+     * @param {string} column
+     * @returns {Promise<number>}
+     */
+    dropColumn(table: string, column: string): Promise<number>;
+    /**
+     * @param {string} table
+     * @param {string} column
+     * @param {string} newName
+     * @returns {Promise<number>}
+     */
+    renameColumn(table: string, column: string, newName: string): Promise<number>;
+    /**
+     * @param {string} table
+     * @param {string} name
+     * @param {string[]} fields
+     * @param {IndexOptions} [options]
+     * @returns {Promise<number>}
+     */
+    addIndex(table: string, name: string, fields: string[], options?: IndexOptions): Promise<number>;
+    /**
+     * @param {string} table
+     * @param {string} name
+     * @returns {Promise<number>}
+     */
+    dropIndex(table: string, name: string): Promise<number>;
+    /**
+     * @param {string} table
+     * @param {Column<any>[]} fields
+     * @returns {Promise<number>}
+     */
+    createTable(table: string, fields: Column<any>[]): Promise<number>;
+    /**
+     * @param {string} table
+     * @returns {Promise<number>}
+     */
+    dropTable(table: string): Promise<number>;
+    /**
+     * @param {string} table
+     * @param {string} newName
+     * @returns {Promise<number>}
+     */
+    renameTable(table: string, newName: string): Promise<number>;
+    /**
+     * @param {string} view
+     * @param {Queryable} queryable
+     * @returns {Promise<number>}
+     */
+    createView(view: string, queryable: Queryable): Promise<number>;
+    /**
+     * @param {string} view
+     * @returns {Promise<number>}
+     */
+    dropView(view: string): Promise<number>;
+    /**
+     * @param {string} view
+     * @param {Queryable} queryable
+     * @returns {Promise<number>}
+     */
+    createMaterializedView(view: string, queryable: Queryable): Promise<number>;
+    /**
+     * @param {string} view
+     * @returns {Promise<number>}
+     */
+    dropMaterializedView(view: string): Promise<number>;
+    abort(): boolean;
+    /**
+     * @template T
+     * @overload
+     * @param {(t: Connection) => PromiseLike<T> | T} fn
+     * @returns {Promise<T>}
+     */
+    transaction<T>(fn: (t: Connection) => PromiseLike<T> | T): Promise<T>;
+    /**
+     * @overload
+     * @returns {[Promise<void>, commit: () => Promise<void>, rollback: (e?: any) => Promise<void>]}
+     */
+    transaction(): [Promise<void>, commit: () => Promise<void>, rollback: (e?: any) => Promise<void>];
+    #private;
+}
+
+/** @import { Fields } from './types' */
+/**
+ *
+ * @param {Fields} fields
+ * @returns {string[]}
+ */
+declare function getPrimaryKeys(fields: Fields): string[];
+
+/**
+ *
+ * @param {Queryable} model
+ * @returns
+ */
+declare function isPseudo(model: Queryable): boolean;
+
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array?: false;
+ * 	default?: ToType<T, false, false>;
+ * 	[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;
+    nullable?: false;
+    array?: false;
+    default?: ToType<T, false, false>;
+} & FieldDefineOption) | undefined): FieldDecorator<ToType<T, false, false>>;
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array: true;
+ * 	default?: ToType<T, true, false>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, false>>}
+ */
+declare function field$1<T extends keyof FieldType>(type: T, options: {
+    nullable?: false;
+    array: true;
+    default?: ToType<T, true, false>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, true, false>>;
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {true} array
+ * @param {{
+ * 	nullable?: false;
+ * 	default?: ToType<T, true, false>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, false>>}
+ */
+declare function field$1<T extends keyof FieldType>(type: T, array: true, options: {
+    nullable?: false;
+    default?: ToType<T, true, false>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, true, false>>;
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array?: false;
+ * 	default?: ToType<T, false, true>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, false, true>>}
+ */
+declare function field$1<T extends keyof FieldType>(type: T, options: {
+    nullable: true;
+    array?: false;
+    default?: ToType<T, false, true>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, false, true>>;
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array: true;
+ * 	default?: ToType<T, true, true>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, true>>}
+ */
+declare function field$1<T extends keyof FieldType>(type: T, options: {
+    nullable: true;
+    array: true;
+    default?: ToType<T, true, true>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, true, true>>;
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {true} array
+ * @param {{
+ * 	nullable: true;
+ * 	default?: ToType<T, true, true>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, true>>}
+ */
+declare function field$1<T extends keyof FieldType>(type: T, array: true, options: {
+    nullable: true;
+    default?: ToType<T, true, true>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, true, true>>;
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} A
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array: A;
+ * 	default?: ToType<T, A, true>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, A, true>>}
+ */
+declare function field$1<T extends keyof FieldType, A extends boolean>(type: T, options: {
+    nullable: true;
+    array: A;
+    default?: ToType<T, A, true>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, A, true>>;
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} A
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array: A;
+ * 	default?: ToType<T, A, false>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, A, false>>}
+ */
+declare function field$1<T extends keyof FieldType, A extends boolean>(type: T, options: {
+    nullable?: false;
+    array: A;
+    default?: ToType<T, A, false>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, A, false>>;
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array?: false;
+ * 	default?: ToType<T, false, N>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, false, N>>}
+ */
+declare function field$1<T extends keyof FieldType, N extends boolean>(type: T, options: {
+    nullable: N;
+    array?: false;
+    default?: ToType<T, false, N>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, false, N>>;
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array: true;
+ * 	default?: ToType<T, true, N>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, N>>}
+ */
+declare function field$1<T extends keyof FieldType, N extends boolean>(type: T, options: {
+    nullable: N;
+    array: true;
+    default?: ToType<T, true, N>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, true, N>>;
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {true} array
+ * @param {{
+ * 	nullable: N;
+ * 	default?: ToType<T, true, N>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, N>>}
+ */
+declare function field$1<T extends keyof FieldType, N extends boolean>(type: T, array: true, options: {
+    nullable: N;
+    default?: ToType<T, true, N>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, true, N>>;
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} A
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array: A;
+ * 	default?: ToType<T, A, N>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, A, N>>}
+ */
+declare function field$1<T extends keyof FieldType, A extends boolean, N extends boolean>(type: T, options: {
+    nullable: N;
+    array: A;
+    default?: ToType<T, A, N>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, A, N>>;
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: boolean;
+ * 	array?: boolean;
+ * 	default?: ToType<T, boolean, boolean>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, boolean, boolean>>}
+ */
+declare function field$1<T extends keyof FieldType>(type: T, options: {
+    nullable?: boolean;
+    array?: boolean;
+    default?: ToType<T, boolean, boolean>;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, boolean, boolean>>;
+
+/** @import { ToFieldType } from '../types' */
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ * @param {object} [options]
+ * @param {number?} [options.sort]
+ * @returns {FieldDecorator<ToFieldType<'id'>>}
+ */
+declare function id({ sort }?: {
+    sort?: number | null | undefined;
+}): FieldDecorator<ToFieldType<"id">>;
+
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ * @param {string} prop
+ * @param {any} value
+ * @returns {FieldDecorator<any>}
+ */
+declare function prop(prop: string, value: any): FieldDecorator<any>;
+
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ *
+ * @param {number} [primary]
+ * @returns {FieldDecorator<any>}
+ */
+declare function primary(primary?: number): FieldDecorator<any>;
+
+/** @import { FieldDecorator } from './index.mjs' */
+/** @returns {FieldDecorator<any>} */
+declare function immutable(): FieldDecorator<any>;
+
+/**
+ * 索引信息
+ * @overload
+ * @param {string[]} fields
+ * @param {IndexOptions} [options]
+ * @returns {ClassDecorator}
+ */
+declare function index(fields: string[], options?: IndexOptions | undefined): ClassDecorator;
+/**
+ * 索引信息
+ * @overload
+ * @param {string} [name]
+ * @param {boolean} [unique]
+ * @returns {FieldDecorator<any>}
+ */
+declare function index(name?: string | undefined, unique?: boolean | undefined): FieldDecorator<any>;
+/**
+ * 索引信息
+ * @overload
+ * @param {boolean} [unique]
+ * @returns {FieldDecorator<any>}
+ */
+declare function index(unique?: boolean | undefined): FieldDecorator<any>;
+
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ * 默认排序顺序，绝对值表示在排序列表中的顺序，负数表示逆序排序, 0 表示不排序
+ * @param {number} sort
+ * @returns {FieldDecorator<any>}
+ */
+declare function sort(sort: number): FieldDecorator<any>;
+
+/** @import { ClassDecorator } from './index.mjs' */
+/**
+ *
+ * @param {string} pseudo
+ * @returns {ClassDecorator}
+ */
+declare function pseudo(pseudo: string): ClassDecorator;
+
+/**
+ *
+ * @overload
+ * @param {string} table
+ * @returns {ClassDecorator}
+ */
+declare function submodel(table: string): ClassDecorator;
+/**
+ * @template {Record<string, any>} T
+ * @overload
+ * @param {TableDefine & {new(...a: any): T}} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {true} array
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T[]>}
+ */
+declare function submodel<T extends Record<string, any>>(type: TableDefine & {
+    new (...a: any): T;
+}, constraints: Record<string, Constraint>, array: true, options?: FieldDefineOption | undefined): FieldDecorator<T[]>;
+/**
+ * @template {Record<string, any>} T
+ * @overload
+ * @param {TableDefine & {new(...a: any): T}} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {false} [array]
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T>}
+ */
+declare function submodel<T extends Record<string, any>>(type: TableDefine & {
+    new (...a: any): T;
+}, constraints: Record<string, Constraint>, array?: false | undefined, options?: FieldDefineOption | undefined): FieldDecorator<T>;
+/**
+ * @template {Record<string, any>} T
+ * @overload
+ * @param {TableDefine & {new(...a: any): T}} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T>}
+ */
+declare function submodel<T extends Record<string, any>>(type: TableDefine & {
+    new (...a: any): T;
+}, constraints: Record<string, Constraint>, options?: FieldDefineOption | undefined): FieldDecorator<T>;
+/**
+ * @template {Record<string, any>} T
+ * @template {boolean} [A=boolean]
+ * @overload
+ * @param {TableDefine & {new(...a: any): T}} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {A} array
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<A extends false ? T : A extends true ? T[] : T | T[]>}
+ */
+declare function submodel<T extends Record<string, any>, A extends boolean = boolean>(type: TableDefine & {
+    new (...a: any): T;
+}, constraints: Record<string, Constraint>, array: A, options?: FieldDefineOption | undefined): FieldDecorator<A extends false ? T : A extends true ? T[] : T | T[]>;
+/**
+ * @template {object} T
+ * @overload
+ * @param {TableDefine} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {true} array
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T[]>}
+ */
+declare function submodel<T extends Record<string, any>>(type: TableDefine, constraints: Record<string, Constraint>, array: true, options?: FieldDefineOption | undefined): FieldDecorator<T[]>;
+/**
+ * @template {object} T
+ * @overload
+ * @param {TableDefine} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {false} [array]
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T>}
+ */
+declare function submodel<T extends Record<string, any>>(type: TableDefine, constraints: Record<string, Constraint>, array?: false | undefined, options?: FieldDefineOption | undefined): FieldDecorator<T>;
+/**
+ * @template {object} T
+ * @overload
+ * @param {TableDefine} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T>}
+ */
+declare function submodel<T extends Record<string, any>>(type: TableDefine, constraints: Record<string, Constraint>, options?: FieldDefineOption | undefined): FieldDecorator<T>;
+/**
+ * @template {object} T
+ * @template {boolean} [A=boolean]
+ * @overload
+ * @param {TableDefine} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {A} array
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<A extends false ? T :A extends true ? T[] : T | T[]>}
+ */
+declare function submodel<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} [precision]
+ * @returns {FieldDecorator<Date?>}
+ */
+declare function creating(precision?: number): FieldDecorator<Date | null>;
+/**
+ * @param {number} [precision]
+ * @returns {FieldDecorator<Date?>}
+ */
+declare function updating(precision?: number): FieldDecorator<Date | null>;
+/**
+ * @param {number} [precision]
+ * @returns {FieldDecorator<Date?>}
+ */
+declare function deleting(precision?: number): FieldDecorator<Date | null>;
+
+type ClassDecorator = (val: Function, ctx: ClassDecoratorContext) => any;
+type FieldDecorator<T> = (val: {
+    get(): T;
+    set(v: T): void;
+}, ctx: ClassAccessorDecoratorContext) => any;
+
+type QueryOptions<T extends Fields, TB extends unknown = any> = {
+    table: string;
+    fields: T;
+    pseudo?: string | undefined;
+    build?: ((a: object, b?: object | boolean) => TB) | null | undefined;
+};
+/**
+ * @template {Fields} T
+ * @template {object} [TB=object]
+ * @typedef {object} QueryOptions
+ * @property {string} table
+ * @property {T} fields
+ * @property {string} [pseudo]
+ * @property {((a: object, b?: object | boolean) => TB)?} [build]
+ */
+/**
+ * @template {Fields} T
+ * @template {object} [TB=object]
+ * @implements {Queryable<T>}
+ */
+declare class Query<T extends Fields, TB extends unknown = any> implements Queryable {
+    /**
+     * @template {Fields} F
+     * @template {new (o: QueryOptions<F>) => Query<F>} T
+     * @this {T}
+     * @param {string} table
+     * @param {F} fields
+     * @param {string} [pseudo]
+     * @returns {InstanceType<T>}
+     */
+    static table<F extends Fields, T_1 extends new (o: QueryOptions<F>) => Query<F>>(this: T_1, table: string, fields: F, pseudo?: string): InstanceType<T_1>;
+    /**
+     * @param {QueryOptions<T, TB> | Query<T, TB>} options
+     */
+    constructor(options: QueryOptions<T, TB> | Query<T, TB>);
+    /** @readonly @type {string} */
+    readonly table: string;
+    /** @readonly @type {T} */
+    readonly fields: T;
+    /** @readonly @type {string} */
+    readonly pseudo: string;
+    get options(): Options;
+    /**
+     * @param {QueryOptions<T, TB> | Query<T, TB>} options
+     * @returns {Query<T, TB>}
+     */
+    _create(options: QueryOptions<T, TB> | Query<T, TB>): Query<T, TB>;
+    /**
+     * @returns {ReturnType<this['_create']>}
+     */
+    clone(): ReturnType<this["_create"]>;
+    /** @returns {this} */
+    deleted(): this;
+    /** @returns {this} */
+    undeleted(): this;
+    /** @returns {this} */
+    withDeleted(): this;
+    /**
+     * 增加排序项
+     * @param {...string | boolean | [string, boolean?]} sort
+     * @returns {this}
+     */
+    sort(...sort: (string | boolean | [string, boolean?])[]): this;
+    /**
+     * 设置获取到的最大数量
+     * @param {number} [limit]
+     * @returns {this}
+     */
+    limit(limit?: number): this;
+    /**
+     * 跳过的记录数
+     * @param {number} [offset]
+     * @returns {this}
+     */
+    offset(offset?: number): this;
+    /**
+     * @overload
+     * @param {Wheres} matches
+     * @returns {this}
+     */
+    where(matches: Wheres): this;
+    /**
+     *
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {this}
+     */
+    where(where: TemplateStringsArray, ...values: any[]): this;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {this}
+     */
+    where(field: string, value: any): this;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {this}
+     */
+    where(field: string[], value: any[]): this;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {this}
+     */
+    where(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}
+     */
+    where(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}
+     */
+    where(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
+    /**
+     * 选择字段
+     * @param {...string | string[] | Record<string, Select.Param>} newSelect
+     * @returns {this}
+     */
+    select(...newSelect: (string | string[] | Record<string, Select.Param>)[]): this;
+    /**
+     * 字段求和
+     * @param {...string | string[] | Record<string, string>} newSelect
+     * @returns {this}
+     */
+    sum(...newSelect: (string | string[] | Record<string, string>)[]): this;
+    /**
+     * 字段最小值
+     * @param {...string | string[] | Record<string, string>} newSelect
+     * @returns {this}
+     */
+    min(...newSelect: (string | string[] | Record<string, string>)[]): this;
+    /**
+     * 字段最大值
+     * @param {...string | string[] | Record<string, string>} newSelect
+     * @returns {this}
+     */
+    max(...newSelect: (string | string[] | Record<string, string>)[]): this;
+    /**
+     * 字段平均值
+     * @param {...string | string[] | Record<string, string>} newSelect
+     * @returns {this}
+     */
+    avg(...newSelect: (string | string[] | Record<string, string>)[]): this;
+    /**
+     * 字段计数
+     * @param {...string | string[] | Record<string, string>} newSelect
+     * @returns {this}
+     */
+    count(...newSelect: (string | string[] | Record<string, string>)[]): this;
+    /**
+     *
+     * @param {Record<string, any>} update
+     * @returns {this}
+     */
+    set(update: Record<string, any>): this;
+    /**
+     *
+     * @param {string} alias
+     * @returns
+     */
+    as(alias: string): ReturnType<this["_create"]>;
+    /**
+     *
+     * @param {string} [text]
+     * @returns {this}
+     */
+    contains(text?: string): this;
+    /**
+     * @param {any} [primary]
+     * @returns {this}
+     */
+    primary(primary?: any, ...args: any[]): this;
+    /**
+     *
+     * @param {object} a
+     * @param {object | boolean | null} [b]
+     * @returns {TB}
+     */
+    [Build](a: object, b?: object | boolean | null): TB;
+    #private;
+}
+
+/**
+ * @implements {Save}
+ * @implements {Destroy}
+ * @implements {PseudoDestroy}
+ */
+declare class Model implements Save, Destroy, PseudoDestroy {
+    /** @readonly @type {string | undefined} */
+    static readonly pseudo: string | undefined;
+    /** @readonly @type {string} */
+    static readonly table: string;
+    /** @readonly @type {Fields} */
+    static readonly fields: Fields;
+    /** @readonly @type {readonly IndexInfo[]} */
+    static readonly indexes: readonly IndexInfo[];
+    /**
+     * @template {typeof Model} T
+     * @this {T}
+     * @returns {Query<T['fields'], InstanceType<T>>}
+     */
+    static toQuery<T extends typeof Model>(this: T): Query<T["fields"], InstanceType<T>>;
+    /**
+     * @template {typeof Model} T
+     * @this {T}
+     * @param {string[]} [fields]
+     * @returns {T}
+     */
+    static bindFields<T extends typeof Model>(this: T, fields?: string[]): T;
+    /**
+     * @template {typeof Model} T
+     * @this {T}
+     * @param {Connection} t
+     * @param {object} p
+     * @param {(data: object) => Promise<object>} run
+     * @returns {Promise<InstanceType<T>>}
+     */
+    static [Create]<T extends typeof Model>(this: T, t: Connection, p: object, run: (data: object) => Promise<object>): Promise<InstanceType<T>>;
+    /**
+     * @template {typeof Model} T
+     * @this {T}
+     * @param {object} a
+     * @param {object | boolean} [b]
+     * @returns {InstanceType<T>}
+     */
+    static [Build]<T extends typeof Model>(this: T, a: object, b?: object | boolean): InstanceType<T>;
+    /**
+     * @param {object} data
+     * @param {boolean | object} [saved]
+     */
+    constructor(data: object, saved?: boolean | object);
+    get $model(): typeof Model;
+    get $saved(): boolean;
+    get $deleted(): boolean;
+    get $oldData(): Record<string, any> | undefined;
+    get $savedData(): {
+        [x: string]: any;
+    };
+    get $changedData(): {
+        [x: string]: any;
+    };
+    $clone(): Model;
+    toJSON(): {
+        [x: string]: any;
+    };
+    get $fieldChanged(): boolean;
+    /**
+     * @overload
+     * @param {Record<string, any>} key
+     * @param {any} [value]
+     * @returns {boolean}
+     */
+    $set(key: Record<string, any>, value?: any): boolean;
+    /**
+     * @overload
+     * @param {string} key
+     * @param {any} value
+     * @returns {boolean}
+     */
+    $set(key: string, value: any): boolean;
+    /**
+     * @template {Record<string, any>} T
+     * @overload
+     * @param {string} [key]
+     * @param {boolean} [saved]
+     * @returns {T}
+     */
+    $get<T extends Record<string, any>>(key?: string | undefined, saved?: boolean | undefined): T;
+    /**
+     * @template T
+     * @overload
+     * @param {string} key
+     * @param {boolean} [saved]
+     * @returns {T | undefined}
+     */
+    $get<T extends Record<string, any>>(key: string, saved?: boolean | undefined): T | undefined;
+    /**
+     * @param {(this: this)=> PromiseLike<boolean> | boolean} q
+     * @returns {PromiseLike<boolean> | boolean}
+     */
+    $exec(q: (this: this) => PromiseLike<boolean> | boolean): PromiseLike<boolean> | boolean;
+    /**
+     * @param {Connection} t
+     * @param {boolean} update
+     * @returns {VoidReturn}
+     */
+    $onBeforeSave(t: Connection, update: boolean): VoidReturn;
+    /**
+     * @param {Connection} t
+     * @param {boolean} update
+     * @returns {VoidReturn}
+     */
+    $onAfterSave(t: Connection, update: boolean): VoidReturn;
+    /**
+     * @param {Connection} t
+     * @param {boolean} update
+     * @returns {VoidReturn}
+     */
+    $_onBeforeSave(t: Connection, update: boolean): VoidReturn;
+    /**
+     * @param {Connection} t
+     * @param {boolean} update
+     * @returns {VoidReturn}
+     */
+    $_onAfterSave(t: Connection, update: boolean): VoidReturn;
+    /**
+     * @param {Connection} t
+     * @param {object?} update
+     * @returns {VoidReturn}
+     */
+    $onBeforeDelete(t: Connection, update: object | null): VoidReturn;
+    /**
+     * @param {Connection} t
+     * @param {object?} update
+     * @returns {VoidReturn}
+     */
+    $onAfterDelete(t: Connection, update: object | null): VoidReturn;
+    /**
+     * @param {Connection} t
+     * @param {object?} update
+     * @returns {VoidReturn}
+     */
+    $_onBeforeDelete(t: Connection, update: object | null): VoidReturn;
+    /**
+     * @param {Connection} t
+     * @param {object?} update
+     * @returns {VoidReturn}
+     */
+    $_onAfterDelete(t: Connection, update: object | null): VoidReturn;
+    /**
+     * @param {Connection} t
+     * @param {(data: any, newData?: any) => Promise<object?>} run
+     * @param {Record<string, any>?} newData
+     * @returns {Promise<this?>}
+     */
+    [Save](t: Connection, run: (data: any, newData?: any) => Promise<object | null>, newData: Record<string, any> | null): Promise<this | null>;
+    /**
+     * @param {Connection} t
+     * @param {(data: any) => Promise<object?>} run
+     * @returns {Promise<this?>}
+     */
+    [Destroy](t: Connection, run: (data: any) => Promise<object | null>): Promise<this | null>;
+    /**
+     * @param {Connection} t
+     * @param {object} update
+     * @param {(data: any) => Promise<object?>} run
+     * @returns {Promise<this?>}
+     */
+    [PseudoDestroy](t: Connection, update: object, run: (data: any) => Promise<object | null>): Promise<this | null>;
+    #private;
+}
+type VoidReturn = PromiseLike<void> | void;
+
+/** @import { FieldDefine, FieldType, IndexInfo } from './types' */
+declare class Submodel {
+    /** @readonly @type {string} */
+    static readonly table: string;
+    /** @readonly @type {Record<string, FieldDefine<keyof FieldType>>} */
+    static readonly fields: Record<string, FieldDefine<keyof FieldType>>;
+    /** @readonly @type {readonly IndexInfo[]} */
+    static readonly indexes: readonly IndexInfo[];
+    #private;
+}
+
+/**
+ * @template {MainFieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array?: false;
+ * 	default?: ToType<T, false, false>;
+ * } & FieldDefineOption} [options]
+ * @returns {FieldDefine<T, false, false>}
+ */
+declare function field<T extends MainFieldType>(type: T, options?: ({
+    nullable?: false;
+    array?: false;
+    default?: ToType<T, false, false>;
+} & FieldDefineOption) | undefined): FieldDefine<T, false, false>;
+/**
+ * @template {MainFieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array: true;
+ * 	default?: ToType<T, true, false>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, true, false>}
+ */
+declare function field<T extends MainFieldType>(type: T, options: {
+    nullable?: false;
+    array: true;
+    default?: ToType<T, true, false>;
+} & FieldDefineOption): FieldDefine<T, true, false>;
+/**
+ * @template {MainFieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array?: false;
+ * 	default?: ToType<T, false, true>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, false, true>}
+ */
+declare function field<T extends MainFieldType>(type: T, options: {
+    nullable: true;
+    array?: false;
+    default?: ToType<T, false, true>;
+} & FieldDefineOption): FieldDefine<T, false, true>;
+/**
+ * @template {MainFieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array: true;
+ * 	default?: ToType<T, true, true>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, true, true>}
+ */
+declare function field<T extends MainFieldType>(type: T, options: {
+    nullable: true;
+    array: true;
+    default?: ToType<T, true, true>;
+} & FieldDefineOption): FieldDefine<T, true, true>;
+/**
+ * @template {MainFieldType} T
+ * @template {boolean} A
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array: A;
+ * 	default?: ToType<T, A, true>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, A, true>}
+ */
+declare function field<T extends MainFieldType, A extends boolean>(type: T, options: {
+    nullable: true;
+    array: A;
+    default?: ToType<T, A, true>;
+} & FieldDefineOption): FieldDefine<T, A, true>;
+/**
+ * @template {MainFieldType} T
+ * @template {boolean} A
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array: A;
+ * 	default?: ToType<T, A, false>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, A, false>}
+ */
+declare function field<T extends MainFieldType, A extends boolean>(type: T, options: {
+    nullable?: false;
+    array: A;
+    default?: ToType<T, A, false>;
+} & FieldDefineOption): FieldDefine<T, A, false>;
+/**
+ * @template {MainFieldType} T
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array?: false;
+ * 	default?: ToType<T, false, N>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, false, N>}
+ */
+declare function field<T extends MainFieldType, N extends boolean>(type: T, options: {
+    nullable: N;
+    array?: false;
+    default?: ToType<T, false, N>;
+} & FieldDefineOption): FieldDefine<T, false, N>;
+/**
+ * @template {MainFieldType} T
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array: true;
+ * 	default?: ToType<T, true, N>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, true, N>}
+ */
+declare function field<T extends MainFieldType, N extends boolean>(type: T, options: {
+    nullable: N;
+    array: true;
+    default?: ToType<T, true, N>;
+} & FieldDefineOption): FieldDefine<T, true, N>;
+/**
+ * @template {MainFieldType} T
+ * @template {boolean} A
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array: A;
+ * 	default?: ToType<T, A, N>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, A, N>}
+ */
+declare function field<T extends MainFieldType, A extends boolean, N extends boolean>(type: T, options: {
+    nullable: N;
+    array: A;
+    default?: ToType<T, A, N>;
+} & FieldDefineOption): FieldDefine<T, A, N>;
+/**
+ * @template {MainFieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: boolean;
+ * 	array?: boolean;
+ * 	default?: ToType<T, boolean, boolean>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, boolean, boolean>}
+ */
+declare function field<T extends MainFieldType>(type: T, options: {
+    nullable?: boolean;
+    array?: boolean;
+    default?: ToType<T, boolean, boolean>;
+} & FieldDefineOption): FieldDefine<T, boolean, boolean>;
+
+/**
+ *
+ * @param {boolean} [d]
+ */
+declare function setDevelopment(d?: boolean): void;
+declare let isDevelopment: boolean;
+
+export { Build, type BuildValue, type ClassDecorator, type Column, type ColumnOptions, Connection, type Constraint, type CountArg, Create, Destroy, type Environment, type FieldDecorator, type FieldDefine, type FieldDefineOption, type FieldDefineType, type FieldSpecific, type FieldSpecificValue, type FieldType, type FieldTypeDefine, type FieldValue, type Fields, type FindRange, type GetName, type IConnection, type Index, type IndexInfo, type IndexOptions, type Join, type JoinType, type MainFieldType, type MatchArg, type MaybePromise, Model, type Options, PseudoDestroy, type Querier, Query, type QueryOptions, type Queryable, Save, Select, type SelectArg, SetValue, type Skip, Submodel, type Support, type TableDefine, type TableType, type ToFieldType, type ToType, type TransactionFn, Where, type WhereItem, type WhereLike, type WhereOr, type WhereRaw, type WhereValue, type Wheres, creating, decrement, field as define, deleted, deleting, divide, field$1 as field, getPrimaryKeys, id, immutable, increment, index, isDevelopment, isPseudo, submodel as model, multiply, now, primary, prop, pseudo, setDevelopment, sort, submodel, toNot, undeleted, updating, values, withDeleted };