imodel 0.19.3 → 0.20.1

package/index.d.mts

@@ -1,7 +1,7 @@
 /*!
- * imodel v0.19.3
- * (c) 2019-2026 undefined
- * @license undefined
+ * imodel v0.20.1
+ * (c) 2019-2026 猛火Fierflame
+ * @license MIT
  */
 
 declare const now: unique symbol;
@@ -17,2115 +17,1783 @@ declare const coefficient$1: unique symbol;
 declare const values_now: typeof now;
 declare const values_uuid: typeof uuid;
 declare namespace values {
-  export { coefficient$1 as coefficient, decrement$1 as decrement, divide$1 as divide, increment$1 as increment, multiply$1 as multiply, values_now as now, values_uuid as uuid };
+  export {
+    coefficient$1 as coefficient,
+    decrement$1 as decrement,
+    divide$1 as divide,
+    increment$1 as increment,
+    multiply$1 as multiply,
+    values_now as now,
+    values_uuid as uuid,
+  };
 }
 
+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;
+
+/** @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 */
 /**
- * @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>>}
+ * @param {number | bigint} value
+ * @returns {SetValue.Increment}
  */
-declare function field$1<T extends keyof FieldType>(type: T, options?: ({
-    [k: string]: any;
-    nullable?: false;
-    array?: false;
-    default?: ToType<T, false, false> | symbol;
-} & FieldDefineOption) | undefined): FieldDecorator<ToType<T, false, false>>;
+declare function increment(value: number | bigint): SetValue.Increment;
 /**
- * @template {keyof FieldType} T
- * @overload
- * @param {T} type
- * @param {{
- * 	nullable?: false;
- * 	array: true;
- * 	default?: ToType<T, true, false> | symbol;
- * 	[k: string]: any;
- * } & FieldDefineOption} options
- * @returns {FieldDecorator<ToType<T, true, false>>}
+ * @param {number | bigint} value
+ * @returns {SetValue.Decrement}
  */
-declare function field$1<T extends keyof FieldType>(type: T, options: {
-    nullable?: false;
-    array: true;
-    default?: ToType<T, true, false> | symbol;
-    [k: string]: any;
-} & FieldDefineOption): FieldDecorator<ToType<T, true, false>>;
+declare function decrement(value: number | bigint): SetValue.Decrement;
 /**
- * @template {keyof FieldType} T
- * @overload
- * @param {T} type
- * @param {true} array
- * @param {{
- * 	nullable?: false;
- * 	default?: ToType<T, true, false> | symbol;
- * 	[k: string]: any;
- * } & FieldDefineOption} options
- * @returns {FieldDecorator<ToType<T, true, false>>}
+ * @param {number | bigint} value
+ * @returns {SetValue.Multiply}
  */
-declare function field$1<T extends keyof FieldType>(type: T, array: true, options: {
-    nullable?: false;
-    default?: ToType<T, true, false> | symbol;
-    [k: string]: any;
-} & FieldDefineOption): FieldDecorator<ToType<T, true, false>>;
+declare function multiply(value: number | bigint): SetValue.Multiply;
 /**
- * @template {keyof FieldType} T
- * @overload
- * @param {T} type
- * @param {{
- * 	nullable: true;
- * 	array?: false;
- * 	default?: ToType<T, false, true> | symbol;
- * 	[k: string]: any;
- * } & FieldDefineOption} options
- * @returns {FieldDecorator<ToType<T, false, true>>}
+ * @param {number | bigint} value
+ * @returns {SetValue.Divide}
  */
-declare function field$1<T extends keyof FieldType>(type: T, options: {
-    nullable: true;
-    array?: false;
-    default?: ToType<T, false, true> | symbol;
-    [k: string]: any;
-} & FieldDefineOption): FieldDecorator<ToType<T, false, true>>;
+declare function divide(value: number | bigint): SetValue.Divide;
 /**
- * @template {keyof FieldType} T
- * @overload
- * @param {T} type
- * @param {{
- * 	nullable: true;
- * 	array: true;
- * 	default?: ToType<T, true, true> | symbol;
- * 	[k: string]: any;
- * } & FieldDefineOption} options
- * @returns {FieldDecorator<ToType<T, true, true>>}
+ * @param {...number | bigint} value
+ * @returns {SetValue.Coefficient}
  */
-declare function field$1<T extends keyof FieldType>(type: T, options: {
-    nullable: true;
-    array: true;
-    default?: ToType<T, true, true> | symbol;
-    [k: string]: any;
-} & FieldDefineOption): FieldDecorator<ToType<T, true, true>>;
+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)[];
+    };
+}
+
+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 {
+    distinct?: boolean;
+    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[];
+    lock?: 'S' | 'X' | null;
+}
+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;
+}
+
+declare class ConnectionError extends Error {
+    /**
+     * @param {string} code - 自定义通用错误码 (例如 constraint:unique)
+     * @param {string} message - 原始错误信息或自定义信息
+     */
+    constructor(code: string, message: string);
+    /** @type {string} */
+    code: string;
+}
 /**
- * @template {keyof FieldType} T
- * @overload
- * @param {T} type
- * @param {true} array
- * @param {{
- * 	nullable: true;
- * 	default?: ToType<T, true, true> | symbol;
- * 	[k: string]: any;
- * } & FieldDefineOption} options
- * @returns {FieldDecorator<ToType<T, true, true>>}
+ * 非空约束违规
+ * 对应 PG 23502 / MySQL 1048
+ * 场景：插入数据时，必填字段为空
  */
-declare function field$1<T extends keyof FieldType>(type: T, array: true, options: {
-    nullable: true;
-    default?: ToType<T, true, true> | symbol;
-    [k: string]: any;
-} & FieldDefineOption): FieldDecorator<ToType<T, true, true>>;
+declare class NotNullViolationError extends ConnectionError {
+    /** @type {string} */
+    table: string;
+    /** @type {string} */
+    column: string;
+}
 /**
- * @template {keyof FieldType} T
- * @template {boolean} A
- * @overload
- * @param {T} type
- * @param {{
- * 	nullable: true;
- * 	array: A;
- * 	default?: ToType<T, A, true> | symbol;
- * 	[k: string]: any;
- * } & FieldDefineOption} options
- * @returns {FieldDecorator<ToType<T, A, true>>}
+ * 唯一性约束违规
+ * 对应 PG 23505 / MySQL 1062
+ * 支持单字段和多字段组合冲突
  */
-declare function field$1<T extends keyof FieldType, A extends boolean>(type: T, options: {
-    nullable: true;
-    array: A;
-    default?: ToType<T, A, true> | symbol;
-    [k: string]: any;
-} & FieldDefineOption): FieldDecorator<ToType<T, A, true>>;
+declare class UniqueViolationError extends ConnectionError {
+    /**
+     * @param {string} table - 表名
+     * @param {string | string[]} columns - 冲突的列名（可以是字符串或字符串数组）
+     * @param {any} [values] - 导致冲突的值（可选，多字段时为对象或数组）
+     */
+    constructor(table: string, columns: string | string[], values?: any);
+    /** @type {string} */
+    table: string;
+    /** @type {string[]} */
+    columns: string[];
+    /** @type {any} */
+    values: any;
+}
 /**
- * @template {keyof FieldType} T
- * @template {boolean} A
- * @overload
- * @param {T} type
- * @param {{
- * 	nullable?: false;
- * 	array: A;
- * 	default?: ToType<T, A, false> | symbol;
- * 	[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> | symbol;
-    [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> | symbol;
- * 	[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> | symbol;
-    [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> | symbol;
- * 	[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> | symbol;
-    [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> | symbol;
- * 	[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> | symbol;
-    [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> | symbol;
- * 	[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> | symbol;
-    [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> | symbol;
- * 	[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> | symbol;
-    [k: string]: any;
-} & FieldDefineOption): FieldDecorator<ToType<T, boolean, boolean>>;
-
-/** @import { FieldDecorator } from './index.mjs' */
-/**
- * @param {string} prop
- * @param {any} value
- * @param {boolean} [array]
- * @param {boolean} [end]
- * @returns {FieldDecorator<any>}
- */
-declare function prop(prop: string, value: any, array?: boolean, end?: boolean): FieldDecorator<any>;
-
-/** @import { FieldDecorator } from './index.mjs' */
-/**
- *
- * @param {string} [column]
- * @returns {FieldDecorator<any>}
- */
-declare function column(column?: string): FieldDecorator<any>;
-
-/** @import { FieldDecorator } from './index.mjs' */
-/**
- *
- * @param {number} [primary]
- * @returns {FieldDecorator<any>}
+ * 外键约束违规
+ * 对应 PG 23503 / MySQL 1452
+ * 场景：插入了一个不存在的 user_id
  */
-declare function primary(primary?: number): FieldDecorator<any>;
-
-/** @import { FieldDecorator } from './index.mjs' */
-/** @returns {FieldDecorator<any>} */
-declare function uncreatable(): FieldDecorator<any>;
-
-/** @import { FieldDecorator } from './index.mjs' */
-/** @returns {FieldDecorator<any>} */
-declare function immutable(): FieldDecorator<any>;
-
+declare class ForeignKeyViolationError extends ConnectionError {
+    /**
+     * @param {string} table - 当前操作的表
+     * @param {string | string[]} columns - 当前操作的外键列
+     * @param {string} [referencedTable] - 被引用的父表
+     */
+    constructor(table: string, columns: string | string[], referencedTable?: string);
+    /** @type {string} */
+    table: string;
+    /** @type {string[]} */
+    columns: string[];
+    /** @type {string} */
+    referencedTable: string;
+}
 /**
- * 索引信息
- * @overload
- * @param {string[]} fields
- * @param {IndexOptions} [options]
- * @returns {ClassDecorator}
+ * 检查约束违规
+ * 对应 PG 23514
+ * 场景：年龄字段要求 > 0，但插入了 -5
  */
-declare function index(fields: string[], options?: IndexOptions | undefined): ClassDecorator;
+declare class CheckViolationError extends ConnectionError {
+    /**
+     * @param {string} table - 当前操作的表
+     * @param {string} [constraint] - 当前操作的外键列
+     */
+    constructor(table: string, constraint?: string);
+    /** @type {string} */
+    table: string;
+    /** @type {string} */
+    constraint: string;
+}
 /**
- * 索引信息
- * @overload
- * @param {string} [name]
- * @param {boolean} [unique]
- * @returns {FieldDecorator<any>}
+ * 无效的类型输入语法错误
+ * 对应 PG 22P02
+ * 场景：无效的 UUID、日期格式错误等
  */
-declare function index(name?: string | undefined, unique?: boolean | undefined): FieldDecorator<any>;
+declare class InvalidInputSyntaxError extends ConnectionError {
+    /**
+     * @param {string} message - 目标数据类型
+     */
+    constructor(message: string);
+}
 /**
- * 索引信息
- * @overload
- * @param {boolean} [unique]
- * @returns {FieldDecorator<any>}
+ * 操作符不匹配错误
+ * 对应 PG 42883
+ * 场景：uuid = integer 等类型不兼容的操作
  */
-declare function index(unique?: boolean | undefined): FieldDecorator<any>;
+declare class OperatorMismatchError extends ConnectionError {
+    /**
+     * @param {string} message
+     */
+    constructor(message: string);
+}
 
-/** @import { FieldDecorator } from './index.mjs' */
-/**
- * 默认排序顺序，绝对值表示在排序列表中的顺序，负数表示逆序排序, 0 表示不排序
- * @param {number} sort
- * @returns {FieldDecorator<any>}
- */
-declare function sort(sort: number): FieldDecorator<any>;
+type errors_CheckViolationError = CheckViolationError;
+declare const errors_CheckViolationError: typeof CheckViolationError;
+type errors_ConnectionError = ConnectionError;
+declare const errors_ConnectionError: typeof ConnectionError;
+type errors_ForeignKeyViolationError = ForeignKeyViolationError;
+declare const errors_ForeignKeyViolationError: typeof ForeignKeyViolationError;
+type errors_InvalidInputSyntaxError = InvalidInputSyntaxError;
+declare const errors_InvalidInputSyntaxError: typeof InvalidInputSyntaxError;
+type errors_NotNullViolationError = NotNullViolationError;
+declare const errors_NotNullViolationError: typeof NotNullViolationError;
+type errors_OperatorMismatchError = OperatorMismatchError;
+declare const errors_OperatorMismatchError: typeof OperatorMismatchError;
+type errors_UniqueViolationError = UniqueViolationError;
+declare const errors_UniqueViolationError: typeof UniqueViolationError;
+declare namespace errors {
+  export {
+    errors_CheckViolationError as CheckViolationError,
+    errors_ConnectionError as ConnectionError,
+    errors_ForeignKeyViolationError as ForeignKeyViolationError,
+    errors_InvalidInputSyntaxError as InvalidInputSyntaxError,
+    errors_NotNullViolationError as NotNullViolationError,
+    errors_OperatorMismatchError as OperatorMismatchError,
+    errors_UniqueViolationError as UniqueViolationError,
+  };
+}
 
-/** @import { ClassDecorator } from './index.mjs' */
-/**
- *
- * @param {string} pseudo
- * @returns {ClassDecorator}
- */
-declare function pseudo(pseudo: string): ClassDecorator;
+interface BaseEnvironment {
+    isDevelopment: boolean;
+    values: typeof values;
+    errors: typeof errors;
+}
+interface Environment<T extends object> extends BaseEnvironment {
+    readonly transaction: T | null;
+}
 
-/**
- * @template T
- * @overload
- * @param {now} value
- * @returns {FieldDecorator<string | Date>}
- */
-declare function defaultValue<T>(value: symbol): FieldDecorator<string | Date>;
-/**
- * @template T
- * @overload
- * @param {uuid} value
- * @returns {FieldDecorator<string>}
- */
-declare function defaultValue<T>(value: symbol): FieldDecorator<string>;
-/**
- * @template T
- * @overload
- * @param {T} value
- * @returns {FieldDecorator<T>}
- */
-declare function defaultValue<T>(value: T): FieldDecorator<T>;
-
-/**
- *
- * @overload
- * @param {string} table
- * @returns {ClassDecorator}
- */
-declare function model(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 model<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 model<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 model<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 model<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 model<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 model<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 model<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 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>;
-
-/**
- * @overload
- * @param {Partial<Hooks>} hook
- * @param  {boolean} [approach] 插入位置是否为更靠近执行的位置
- * @returns {ClassDecorator}
- */
-declare function hooks(hook: Partial<Hooks>, approach?: boolean | undefined): ClassDecorator;
-/**
- * @overload
- * @param {Function} Model
- * @param {Partial<Hooks>} hook
- * @param  {boolean} [approach] 插入位置是否为更靠近执行的位置
- * @returns {void}
- */
-declare function hooks(Model: Function, hook: Partial<Hooks>, approach?: boolean | undefined): void;
-/** @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;
-
-declare class ConnectionError extends Error {
-    /**
-     * @param {string} code - 自定义通用错误码 (例如 constraint:unique)
-     * @param {string} message - 原始错误信息或自定义信息
-     */
-    constructor(code: string, message: string);
-    /** @type {string} */
-    code: string;
-}
-/**
- * 非空约束违规
- * 对应 PG 23502 / MySQL 1048
- * 场景：插入数据时，必填字段为空
- */
-declare class NotNullViolationError extends ConnectionError {
-    /** @type {string} */
-    table: string;
-    /** @type {string} */
-    column: string;
+type TableType = '' | 'table' | 'view';
+interface FindArg {
+    /** 排序配置，true 表示逆序 */
+    sort?: [field: string, desc: boolean][];
+    /** 匹配信息 */
+    where: WhereValue[];
+    select: [string, Select][];
+    /** 偏移量 */
+    offset?: number;
+    /** 最大返回数 */
+    limit?: number;
 }
-/**
- * 唯一性约束违规
- * 对应 PG 23505 / MySQL 1062
- * 支持单字段和多字段组合冲突
- */
-declare class UniqueViolationError extends ConnectionError {
-    /**
-     * @param {string} table - 表名
-     * @param {string | string[]} columns - 冲突的列名（可以是字符串或字符串数组）
-     * @param {any} [values] - 导致冲突的值（可选，多字段时为对象或数组）
-     */
-    constructor(table: string, columns: string | string[], values?: any);
-    /** @type {string} */
+interface JOIN {
+    type?: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS';
     table: string;
-    /** @type {string[]} */
-    columns: string[];
-    /** @type {any} */
-    values: any;
+    columns: Record<string, DBColumn>;
+    alias?: string;
+    condition?: WhereValue[];
 }
-/**
- * 外键约束违规
- * 对应 PG 23503 / MySQL 1452
- * 场景：插入了一个不存在的 user_id
- */
-declare class ForeignKeyViolationError extends ConnectionError {
-    /**
-     * @param {string} table - 当前操作的表
-     * @param {string | string[]} columns - 当前操作的外键列
-     * @param {string} [referencedTable] - 被引用的父表
-     */
-    constructor(table: string, columns: string | string[], referencedTable?: string);
-    /** @type {string} */
+type LockType = 'S' | 'X';
+interface IDBTable {
     table: string;
-    /** @type {string[]} */
-    columns: string[];
-    /** @type {string} */
-    referencedTable: string;
+    columns: Record<string, DBColumn>;
 }
-/**
- * 检查约束违规
- * 对应 PG 23514
- * 场景：年龄字段要求 > 0，但插入了 -5
- */
-declare class CheckViolationError extends ConnectionError {
-    /**
-     * @param {string} table - 当前操作的表
-     * @param {string} [constraint] - 当前操作的外键列
-     */
-    constructor(table: string, constraint?: string);
-    /** @type {string} */
-    table: string;
-    /** @type {string} */
-    constraint: string;
+interface SelectItem extends IDBTable {
+    distinct?: boolean;
+    select: [string, Select][];
+    alias?: string;
+    /** 匹配信息 */
+    where: WhereValue[];
+    group: string[];
+    having: WhereValue[];
+    /** 排序配置，true 表示逆序 */
+    sort: [field: string, desc: boolean][];
+    /** 偏移量 */
+    offset?: number;
+    /** 最大返回数 */
+    limit?: number;
+    lock?: LockType | null;
 }
-/**
- * 无效的类型输入语法错误
- * 对应 PG 22P02
- * 场景：无效的 UUID、日期格式错误等
- */
-declare class InvalidInputSyntaxError extends ConnectionError {
-    /**
-     * @param {string} message - 目标数据类型
-     */
-    constructor(message: string);
+type GetName = (table?: string) => string;
+interface DBColumn {
+    type: string;
+    size?: number;
+    scale?: number;
+    default?: any;
+    nullable?: boolean;
+    array?: boolean;
+    primary?: number;
 }
-/**
- * 操作符不匹配错误
- * 对应 PG 42883
- * 场景：uuid = integer 等类型不兼容的操作
- */
-declare class OperatorMismatchError extends ConnectionError {
-    /**
-     * @param {string} message
-     */
-    constructor(message: string);
+interface DBIndex {
+    fields: string[];
+    includes?: string[];
+    unique?: boolean;
+    name?: string;
 }
-
-type errors_CheckViolationError = CheckViolationError;
-declare const errors_CheckViolationError: typeof CheckViolationError;
-type errors_ConnectionError = ConnectionError;
-declare const errors_ConnectionError: typeof ConnectionError;
-type errors_ForeignKeyViolationError = ForeignKeyViolationError;
-declare const errors_ForeignKeyViolationError: typeof ForeignKeyViolationError;
-type errors_InvalidInputSyntaxError = InvalidInputSyntaxError;
-declare const errors_InvalidInputSyntaxError: typeof InvalidInputSyntaxError;
-type errors_NotNullViolationError = NotNullViolationError;
-declare const errors_NotNullViolationError: typeof NotNullViolationError;
-type errors_OperatorMismatchError = OperatorMismatchError;
-declare const errors_OperatorMismatchError: typeof OperatorMismatchError;
-type errors_UniqueViolationError = UniqueViolationError;
-declare const errors_UniqueViolationError: typeof UniqueViolationError;
-declare namespace errors {
-  export { errors_CheckViolationError as CheckViolationError, errors_ConnectionError as ConnectionError, errors_ForeignKeyViolationError as ForeignKeyViolationError, errors_InvalidInputSyntaxError as InvalidInputSyntaxError, errors_NotNullViolationError as NotNullViolationError, errors_OperatorMismatchError as OperatorMismatchError, errors_UniqueViolationError as UniqueViolationError };
+interface DBTable {
+    table: string;
+    fields: Record<string, DBColumn>;
+    indexes?: DBIndex[];
+    primary?: string;
 }
-
-interface Environment<T extends object> {
-    transaction: T | null;
-    isDevelopment: boolean;
-    values: typeof values;
-    errors: typeof errors;
+interface Savepoint {
+    readonly name: string;
+    rollback(): Promise<void>;
+    release(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
 }
-
-/** 特性支持情况 */
-interface Support {
-    /** 是否支持 sql 查询 */
-    sql?: boolean;
-    /** 是否支持数组类型 */
-    array?: boolean;
-    /** 是否支持对象存储 */
-    object?: boolean;
-    /** 是否支持递归查询 */
-    recursive?: boolean;
-    [key: string]: undefined | boolean;
+interface ConnectionInterface {
+    dbType(): Promise<string>;
+    dbVersion(): Promise<string>;
+    query(...values: any[]): Promise<any[]>;
+    exec(...values: any[]): Promise<number>;
+    type(table: string): Promise<TableType | null>;
+    insert(table: IDBTable, data: object[], key: string[], conflictTarget?: string[] | boolean, conflictSet?: Record<string, SetValue> | boolean, conflictWhere?: WhereValue[]): PromiseLike<any[]>;
+    update(table: IDBTable, update: Record<string, SetValue>, where?: WhereValue[]): PromiseLike<number>;
+    updateReturn(returning: string[], table: IDBTable, update: Record<string, SetValue>, where?: WhereValue[]): PromiseLike<any[]>;
+    updateList(table: IDBTable, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[]): PromiseLike<number>;
+    updateListReturn(returning: string[], table: IDBTable, update: Record<string, any>, primaryKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[]): PromiseLike<any[]>;
+    count(table: IDBTable, where?: WhereValue[]): PromiseLike<number>;
+    select(select: SelectItem): PromiseLike<any[]>;
+    delete(table: IDBTable, where?: WhereValue[]): PromiseLike<number>;
+    deleteReturn(returning: string[], table: IDBTable, where?: WhereValue[]): PromiseLike<any[]>;
+    transaction<T>(fn: (signal: AbortSignal) => PromiseLike<T> | T): PromiseLike<T>;
+    abort(): boolean;
+    savepoint(): PromiseLike<Savepoint>;
 }
-
-interface ColumnOptions<T = unknown> extends FieldDefineOption {
+interface TableConnect {
+    (conn: ConnectionInterface, env: BaseEnvironment): ConnectionInterface;
+}
+interface Action<T> {
+    invoke(connect: () => Promise<ConnectionInterface>, connection: Connection, environment: BaseEnvironment): PromiseLike<T> | T;
+    connect?: TableConnect | null;
+}
+interface TableConnection<E extends object = object> {
+    insert(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, data: object[], key: string[], conflictTarget?: string[] | boolean, conflictSet?: Record<string, SetValue> | boolean, conflictWhere?: WhereValue[] | null): 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>;
     /**
-     * 是否可为空
-     * @default true
+     * 执行一条语句
+     * @param sql 要执行的 SQL 语句
      */
-    nullable?: boolean;
-    /** 是否为数组格式 */
-    array?: boolean;
-    /** 默认值 */
-    default?: T extends never ? never : T;
+    query(environment: Environment<E>, ...values: any): PromiseLike<any[]>;
+    type(environment: Environment<E>, table: string): PromiseLike<TableType | null>;
+    createSavepoint(environment: Environment<E>, name: string): PromiseLike<void>;
+    rollbackSavepoint(environment: Environment<E>, name: string): PromiseLike<void>;
+    releaseSavepoint(environment: Environment<E>, name: string): PromiseLike<void>;
+    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 Column<T> extends ColumnOptions<T> {
-    column: string;
-    type: string;
+interface Skip {
+    uncreatable?: boolean;
+    immutable?: boolean;
+    specific?: boolean;
+    where?: boolean;
 }
-
-/** @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 TransactionFn {
+    <T>(fn: (t: Connection) => PromiseLike<T> | T): Promise<T>;
 }
-
-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 TransactionHandlerArray = [
+    promise: TransactionHandler['promise'],
+    commit: TransactionHandler['commit'],
+    rollback: TransactionHandler['rollback']
+];
+interface TransactionHandler extends TransactionHandlerArray {
+    promise: Promise<void>;
+    commit(): Promise<void>;
+    rollback(e?: any): Promise<void>;
+    [Symbol.dispose](): void;
 }
 
-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 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;
 }
-
-/**
- * @param {WhereValue[]?} [items]
- * @returns {WhereValue[]?}
- */
-declare function toNot(items?: WhereValue[] | null): WhereValue[] | null;
-type WhereItem = {
-    exists?: false | null | undefined;
-    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 WhereExists = {
-    where?: null | undefined;
-    or?: null | undefined;
-    field?: null | undefined;
-    exists: true;
-    subquery: SelectItem[];
-    not?: boolean | undefined;
-};
-type WhereRaw = {
-    exists?: false | null | undefined;
-    field?: null | undefined;
-    or?: null | undefined;
-    where: readonly string[];
-    values: readonly any[];
-    not?: boolean | undefined;
-};
-type WhereOr = {
-    exists?: false | null | undefined;
-    where?: null | undefined;
-    field?: null | undefined;
-    or: WhereValue[][];
-    not?: boolean | undefined;
+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;
 };
-type WhereValue = WhereItem | WhereExists | WhereRaw | WhereOr;
-type WhereLike = {
-    toWhereValue(): WhereValue[][];
+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]>;
 };
-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 where(matches: Wheres): Where;
-    /**
-     *
-     * @overload
-     * @param {TemplateStringsArray} where
-     * @param  {...any} values
-     * @returns {Where}
-     */
-    static where(where: TemplateStringsArray, ...values: any[]): Where;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {any} value
-     * @returns {Where}
-     */
-    static where(field: string, value: any): Where;
-    /**
-     * @overload
-     * @param {string[]} field
-     * @param {any[]} value
-     * @returns {Where}
-     */
-    static where(field: string[], value: any[]): Where;
-    /**
-     * @overload
-     * @param {string} field
-     * @param {string} operator
-     * @param {any} value
-     * @param {boolean} [not]
-     * @returns {Where}
-     */
-    static where(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 where(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 where(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;
-    /**
-     *
-     * @param  {...SelectItem} subquery
-     * @returns {Where}
-     */
-    static exists(...subquery: SelectItem[]): Where;
-    /**
-     *
-     * @param  {...SelectItem} subquery
-     * @returns {Where}
-     */
-    static notExists(...subquery: SelectItem[]): 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;
-    /**
-     *
-     * @param  {...SelectItem} subquery
-     * @returns {this}
-     */
-    exists(...subquery: SelectItem[]): this;
-    /**
-     *
-     * @param  {...SelectItem} subquery
-     * @returns {this}
-     */
-    notExists(...subquery: SelectItem[]): this;
-    #private;
+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(this: unknown, conn: Connection, model: TableDefine): PromiseLike<void | Where> | void;
+    beforeCreateMany(this: unknown, conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void | Record<string, any>[]> | void | Record<string, any>[];
+    afterCreateMany(this: unknown, conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void> | void;
+    beforeCreate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
+    afterCreate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void> | void;
+    beforeUpdate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>, set: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
+    afterUpdate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>, oldRecord: Record<string, any>): PromiseLike<void> | void;
+    beforeDelete(this: unknown, conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
+    afterDelete(this: unknown, conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
+}
+interface TableDefine<T extends Fields = Fields, TT extends string | undefined = string | undefined> {
+    readonly connect?: TableConnect | 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;
+
+/**
+ * @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;
+    nullable?: false;
+    array?: false;
+    default?: ToType<T, false, false> | symbol;
+} & 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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [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> | symbol;
+ * 	[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> | symbol;
+    [k: string]: any;
+} & FieldDefineOption): FieldDecorator<ToType<T, boolean, boolean>>;
+
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ * @param {string} prop
+ * @param {any} value
+ * @param {boolean} [array]
+ * @param {boolean} [end]
+ * @returns {FieldDecorator<any>}
+ */
+declare function prop(prop: string, value: any, array?: boolean, end?: boolean): FieldDecorator<any>;
+
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ *
+ * @param {string} [column]
+ * @returns {FieldDecorator<any>}
+ */
+declare function column(column?: string): 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 uncreatable(): 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;
+
+/**
+ * @template T
+ * @overload
+ * @param {now} value
+ * @returns {FieldDecorator<string | Date>}
+ */
+declare function defaultValue<T>(value: typeof now): FieldDecorator<string | Date>;
+/**
+ * @template T
+ * @overload
+ * @param {uuid} value
+ * @returns {FieldDecorator<string>}
+ */
+declare function defaultValue<T>(value: typeof uuid): FieldDecorator<string>;
+/**
+ * @template T
+ * @overload
+ * @param {T} value
+ * @returns {FieldDecorator<T>}
+ */
+declare function defaultValue<T>(value: T): FieldDecorator<T>;
+
+/**
+ *
+ * @overload
+ * @param {string} table
+ * @returns {ClassDecorator}
+ */
+declare function model(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 model<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 model<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 model<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 model<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 model<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 model<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 model<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 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[]>;
 
-/** 字段基本类型 */
-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(this: unknown, conn: Connection, model: TableDefine): PromiseLike<void | Where> | void;
-    beforeCreateMany(this: unknown, conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void | Record<string, any>[]> | void | Record<string, any>[];
-    afterCreateMany(this: unknown, conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void> | void;
-    beforeCreate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
-    afterCreate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void> | void;
-    beforeUpdate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>, set: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
-    afterUpdate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>, oldRecord: Record<string, any>): PromiseLike<void> | void;
-    beforeDelete(this: unknown, conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
-    afterDelete(this: unknown, 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;
+/**
+ * @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 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;
+/**
+ * @overload
+ * @param {Partial<Hooks>} hook
+ * @param  {boolean} [approach] 插入位置是否为更靠近执行的位置
+ * @returns {ClassDecorator}
+ */
+declare function hooks(hook: Partial<Hooks>, approach?: boolean | undefined): ClassDecorator;
+/**
+ * @overload
+ * @param {Function} Model
+ * @param {Partial<Hooks>} hook
+ * @param  {boolean} [approach] 插入位置是否为更靠近执行的位置
+ * @returns {void}
+ */
+declare function hooks(Model: Function, hook: Partial<Hooks>, approach?: boolean | undefined): void;
+/** @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 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 {
-    distinct?: boolean;
-    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[];
-    lock?: 'S' | 'X' | null;
-}
-interface Queryable<T extends Fields = Fields> extends TableDefine<T> {
-    readonly options: Options;
-}
+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 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[];
-}
-type LockType = 'S' | 'X';
-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;
-    lock?: LockType | null;
-}
-type GetName = (table?: string) => string;
-interface DBColumn {
-    type: string;
-    size?: number;
-    scale?: number;
-    default?: any;
-    nullable?: boolean;
+/** 特性支持情况 */
+interface Support {
+    /** 是否支持 sql 查询 */
+    sql?: 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;
+    /** 是否支持对象存储 */
+    object?: boolean;
+    /** 是否支持递归查询 */
+    recursive?: boolean;
+    [key: string]: undefined | boolean;
 }
-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[]>;
+
+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 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 {WhereValue[]?} [items]
+ * @returns {WhereValue[]?}
+ */
+declare function toNot(items?: WhereValue[] | null): WhereValue[] | null;
+type WhereItem = {
+    exists?: false | null | undefined;
+    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 WhereExists = {
+    where?: null | undefined;
+    or?: null | undefined;
+    field?: null | undefined;
+    exists: true;
+    subquery: SelectItem[];
+    not?: boolean | undefined;
+};
+type WhereRaw = {
+    exists?: false | null | undefined;
+    field?: null | undefined;
+    or?: null | undefined;
+    where: readonly string[];
+    values: readonly any[];
+    not?: boolean | undefined;
+};
+type WhereOr = {
+    exists?: false | null | undefined;
+    where?: null | undefined;
+    field?: null | undefined;
+    or: WhereValue[][];
+    not?: boolean | undefined;
+};
+type WhereValue = WhereItem | WhereExists | 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 where(matches: Wheres): Where;
+    /**
+     *
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {Where}
+     */
+    static where(where: TemplateStringsArray, ...values: any[]): Where;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {Where}
+     */
+    static where(field: string, value: any): Where;
+    /**
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {Where}
+     */
+    static where(field: string[], value: any[]): Where;
+    /**
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {Where}
+     */
+    static where(field: string, operator: string, value: any, not?: boolean | undefined): Where;
     /**
-     * 执行一条语句
-     * @param sql 要执行的 SQL 语句
+     * @overload
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {Where}
      */
-    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>;
-}
-type TransactionHandlerArray = [
-    promise: TransactionHandler['promise'],
-    commit: TransactionHandler['commit'],
-    rollback: TransactionHandler['rollback']
-];
-interface TransactionHandler extends TransactionHandlerArray {
-    promise: Promise<void>;
-    commit(): Promise<void>;
-    rollback(e?: any): Promise<void>;
-    [Symbol.dispose](): void;
-}
-
-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, that: any) => Promise<object>, table: TableDefine): PromiseLike<T>;
-}
-declare const Build: unique symbol;
-interface Build<T = unknown> {
-    [Build](data: object, others: object | boolean): T;
-}
-
-/**
- * @template {{}} [E={}]
- */
-declare class Connection<E extends {} = {}> {
+    static where(field: string[], operator: string, value: any[], not?: boolean | undefined): Where;
     /**
-     *
-     * @param {PromiseLike<IConnection<E>> | IConnection<E>} connection
-     * @param {E?} [transaction]
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {Where}
      */
-    constructor(connection: PromiseLike<IConnection<E>> | IConnection<E>, transaction?: E | null);
+    static where(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): Where;
     /**
-     *
-     * @returns {Connection<E>}
+     * @overload
+     * @param {Wheres} matches
+     * @returns {Where}
      */
-    clone(): Connection<E>;
-    /** @return {Promise<string>} */
-    dbType(): Promise<string>;
-    /** @return {Promise<string>} */
-    dbVersion(): Promise<string>;
+    static or(matches: Wheres): Where;
     /**
      *
-     * @param {...any} values
-     * @returns {Promise<any[]>}
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {Where}
      */
-    query(...values: any[]): Promise<any[]>;
+    static or(where: TemplateStringsArray, ...values: any[]): Where;
     /**
-     *
-     * @param {...any} values
-     * @returns {Promise<number>}
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {Where}
      */
-    exec(...values: any[]): Promise<number>;
+    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;
     /**
      *
-     * @param {string} table
-     * @returns {Promise<TableType?>}
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {Where}
      */
-    type(table: string): Promise<TableType | null>;
+    static not(where: TemplateStringsArray, ...values: any[]): Where;
     /**
-     * @template T
      * @overload
-     * @param {Build<T>} build
-     * @param {object} data
-     * @param {object | boolean} [saved]
-     * @returns {T}
+     * @param {string} field
+     * @param {any} value
+     * @returns {Where}
      */
-    build<T extends Fields>(build: Build<T>, data: object, saved?: object | boolean): T;
+    static not(field: string, value: any): Where;
     /**
-     * @template {Fields} T
      * @overload
-     * @param {TableDefine<T>} table
-     * @param {object} data
-     * @param {object | boolean} [saved]
-     * @returns {FieldValue<T>}
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {Where}
      */
-    build<T extends Fields>(table: TableDefine<T>, data: object, saved?: object | boolean): FieldValue<T>;
+    static not(field: string[], value: any[]): Where;
     /**
-     * @template {TableDefine} T
      * @overload
-     * @param {T} model
-     * @param {object[]} list
-     * @returns {Promise<TableValue<T>[]>}
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {Where}
      */
-    create<T extends TableDefine>(model: T, list: object[]): Promise<TableValue<T>[]>;
+    static not(field: string, operator: string, value: any, not?: boolean | undefined): Where;
     /**
-     * @template {TableDefine} T
      * @overload
-     * @param {T} model
-     * @param {object} value
-     * @returns {Promise<T extends Build<infer R> ? R : TableValue<T>>}
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {Where}
      */
-    create<T extends TableDefine>(model: T, value: object): Promise<T extends Build<infer R> ? R : TableValue<T>>;
+    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;
     /**
-     * @template {TableDefine} T
      * @overload
-     * @param {T} model
-     * @param {object | object[]} value
-     * @returns {Promise<TableValue<T>[] | (T extends Build<infer R> ? R : TableValue<T>)>}
+     * @param {Wheres} matches
+     * @returns {Where}
      */
-    create<T extends TableDefine>(model: T, value: object | object[]): Promise<TableValue<T>[] | (T extends Build<infer R> ? R : TableValue<T>)>;
+    static orNot(matches: Wheres): Where;
     /**
      *
-     * @template {TableDefine} T
-     * @param {T} sql
-     * @param {string[]} fields
-     * @param {Skip} [skip]
-     * @returns {Promise<T extends TableDefine<infer F> ? FieldValue<F>[] : never>}
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {Where}
      */
-    search<T extends TableDefine>(sql: T, fields: string[], skip?: Skip): Promise<T extends TableDefine<infer F> ? FieldValue<F>[] : never>;
+    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;
     /**
      *
-     * @template {TableDefine} T
-     * @param {T} sql
-     * @param {Skip} [skip]
-     * @returns {Promise<T extends Build<infer R > ? R[] : T extends TableDefine<infer F> ? FieldValue<F>[] : never>}
+     * @param  {...SelectItem} subquery
+     * @returns {Where}
      */
-    find<T extends TableDefine>(sql: T, skip?: Skip): Promise<T extends Build<infer R> ? R[] : T extends TableDefine<infer F> ? FieldValue<F>[] : never>;
+    static exists(...subquery: SelectItem[]): Where;
     /**
      *
-     * @template {TableDefine} T
-     * @param {T} sql
-     * @param {Skip} [skip]
-     * @returns {Promise<T extends Build<infer R > ? R : T extends TableDefine<infer F> ? FieldValue<F> : never>}
+     * @param  {...SelectItem} subquery
+     * @returns {Where}
      */
-    first<T extends TableDefine>(sql: T, skip?: Skip): Promise<T extends Build<infer R> ? R : T extends TableDefine<infer F> ? FieldValue<F> : never>;
+    static notExists(...subquery: SelectItem[]): Where;
+    toWhereValue(): WhereValue[][];
     /**
-     * @template T
-     * @param {TableDefine} model
-     * @param {T} data
-     * @param {Record<string, any>?} [newData]
-     * @param {Skip} [skip]
-     * @returns {Promise<(T extends Save ? T : object)?>}
+     * @overload
+     * @param {Wheres} matches
+     * @returns {this}
      */
-    save<T>(model: TableDefine, data: T, newData?: Record<string, any> | null, skip?: Skip): Promise<(T extends Save ? T : object) | null>;
+    and(matches: Wheres): this;
     /**
      *
-     * @template T
-     * @param {TableDefine} tableDef
-     * @param {T} data
-     * @returns {Promise<(T extends Destroy ? T : object)?>}
+     * @overload
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {this}
      */
-    completelyDestroy<T>(tableDef: TableDefine, data: T): Promise<(T extends Destroy ? T : object) | null>;
+    and(where: TemplateStringsArray, ...values: any[]): this;
     /**
-     *
-     * @template {object} T
-     * @param {TableDefine} tableDef
-     * @param {T} data
-     * @param {Record<string, SetValue>} value
-     * @returns {Promise<(T extends PseudoDestroy ? T : object)?>}
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {this}
      */
-    pseudoDestroy<T extends unknown>(tableDef: TableDefine, data: T, value: Record<string, SetValue>): Promise<(T extends PseudoDestroy ? T : object) | null>;
+    and(field: string, value: any): this;
     /**
-     * @template {Destroy & PseudoDestroy} T
      * @overload
-     * @param {TableDefine} table
-     * @param {T} data
-     * @param {Record<string, any> | boolean} [update]
-     * @returns {Promise<T?>}
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {this}
      */
-    destroy<T extends Destroy & PseudoDestroy>(table: TableDefine, data: T, update?: boolean | Record<string, any> | undefined): Promise<T | null>;
+    and(field: string[], value: any[]): this;
     /**
-     * @template {Destroy & PseudoDestroy} T
      * @overload
-     * @param {TableDefine} table
-     * @param {T} data
-     * @param {Record<string, any> | boolean} [update]
-     * @returns {Promise<T | object | null>}
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {this}
      */
-    destroy<T extends Destroy & PseudoDestroy>(table: TableDefine, data: T, update?: boolean | Record<string, any> | undefined): Promise<T | object | null>;
+    and(field: string, operator: string, value: any, not?: boolean | undefined): this;
     /**
      * @overload
-     * @param {TableDefine} table
-     * @param {any} data
-     * @param {Record<string, any> | boolean} [update]
-     * @returns {Promise<object?>}
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {this}
      */
-    destroy(table: TableDefine, data: any, update?: boolean | Record<string, any> | undefined): Promise<object | null>;
+    and(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
     /**
-     * @param {Queryable} queryable
-     * @param {Record<string, SetValue> | boolean} [update]
-     * @returns {Promise<number>}
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {this}
      */
-    destroyMany(queryable: Queryable, update?: Record<string, SetValue> | boolean): Promise<number>;
+    and(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T} data
-     * @param {boolean} [ignoreConflict]
-     * @returns {Promise<T>}
+     * @param {Wheres} matches
+     * @returns {this}
      */
-    insert<T extends unknown>(tableDefine: TableDefine, data: T, ignoreConflict?: boolean | undefined): Promise<T>;
+    or(matches: Wheres): this;
     /**
-     * @template {object} T
+     *
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T[]} data
-     * @param {boolean} [ignoreConflict]
-     * @returns {Promise<T[]>}
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {this}
      */
-    insert<T extends unknown>(tableDefine: TableDefine, data: T[], ignoreConflict?: boolean | undefined): Promise<T[]>;
+    or(where: TemplateStringsArray, ...values: any[]): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T} data
-     * @param {string[]} [keys]
-     * @param {boolean} [ignoreConflict]
-     * @returns {Promise<T>}
+     * @param {string} field
+     * @param {any} value
+     * @returns {this}
      */
-    insert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T>;
+    or(field: string, value: any): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T[]} data
-     * @param {string[]} [keys]
-     * @param {boolean} [ignoreConflict]
-     * @returns {Promise<T[]>}
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {this}
      */
-    insert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T[]>;
+    or(field: string[], value: any[]): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T} data
-     * @param {string[] | boolean} [keys]
-     * @param {boolean} [ignoreConflict]
-     * @returns {Promise<T>}
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {this}
      */
-    insert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: boolean | string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T>;
+    or(field: string, operator: string, value: any, not?: boolean | undefined): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T[]} data
-     * @param {string[] | boolean} [keys]
-     * @param {boolean} [ignoreConflict]
-     * @returns {Promise<T[]>}
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {this}
      */
-    insert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: boolean | string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T[]>;
+    or(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T | T[]} data
-     * @param {string[] | boolean} [keys]
-     * @param {boolean} [ignoreConflict]
-     * @returns {Promise<T | T[]>}
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {this}
      */
-    insert<T extends unknown>(tableDefine: TableDefine, data: T | T[], keys?: boolean | string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T | T[]>;
+    or(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T} data
-     * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T>}
+     * @param {Wheres} matches
+     * @returns {this}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
+    not(matches: Wheres): this;
     /**
-     * @template {object} T
+     *
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T[]} data
-     * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T[]>}
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {this}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T[], conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    not(where: TemplateStringsArray, ...values: any[]): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T} data
-     * @param {null | string[]} [keys]
-     * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T>}
+     * @param {string} field
+     * @param {any} value
+     * @returns {this}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: string[] | null | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
+    not(field: string, value: any): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T[]} data
-     * @param {null | string[]} [keys]
-     * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T[]>}
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {this}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: string[] | null | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    not(field: string[], value: any[]): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T} data
-     * @param {null | string[]} [keys]
-     * @param {string[] | boolean} [conflictKeys]
-     * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T>}
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {this}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: string[] | null | undefined, conflictKeys?: boolean | string[] | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
+    not(field: string, operator: string, value: any, not?: boolean | undefined): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T[]} data
-     * @param {null | string[]} [keys]
-     * @param {string[] | boolean} [conflictKeys]
-     * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T[]>}
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {this}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: string[] | null | undefined, conflictKeys?: boolean | string[] | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    not(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T} data
-     * @param {null | string[] | boolean | Record<string, SetValue>} [keys]
-     * @param {string[] | boolean | Record<string, SetValue>} [conflictKeys]
-     * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T>}
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {this}
      */
-    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>;
+    not(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
     /**
-     * @template {object} T
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T[]} data
-     * @param {null | string[] | boolean | Record<string, SetValue>} [keys]
-     * @param {string[] | boolean | Record<string, SetValue>} [conflictKeys]
-     * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T[]>}
+     * @param {Wheres} matches
+     * @returns {this}
      */
-    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[]>;
+    orNot(matches: Wheres): this;
     /**
-     * @template {object} T
+     *
      * @overload
-     * @param {TableDefine} tableDefine
-     * @param {T | T[]} data
-     * @param {null | string[] | boolean | Record<string, SetValue>} [keys]
-     * @param {string[] | boolean | Record<string, SetValue>} [conflictKeys]
-     * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T | T[]>}
+     * @param {TemplateStringsArray} where
+     * @param  {...any} values
+     * @returns {this}
      */
-    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[]>;
+    orNot(where: TemplateStringsArray, ...values: any[]): this;
     /**
-     * @param {TableDefine} tableDefine
-     * @param {Record<string, any>} update
-     * @param {Wheres?} [where]
-     * @param {boolean | Skip} [skip]
-     * @returns {Promise<number>}
+     * @overload
+     * @param {string} field
+     * @param {any} value
+     * @returns {this}
      */
-    update({ connect, table, fields }: TableDefine, update: Record<string, any>, where?: Wheres | null, skip?: boolean | Skip): Promise<number>;
+    orNot(field: string, value: any): this;
     /**
-     * @template {Fields<MainFieldType>} T
-     * @param {TableDefine<T>} tableDefine
-     * @param {Record<string, any>} update
-     * @param {string[]?} [returning]
-     * @param {Wheres?} [where]
-     * @param {boolean | Skip} [skip]
-     * @returns {Promise<any[]>}
+     * @overload
+     * @param {string[]} field
+     * @param {any[]} value
+     * @returns {this}
      */
-    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[]>;
+    orNot(field: string[], value: any[]): this;
     /**
-     * @param {TableDefine} tableDefine
-     * @param {string[]} pKeys
-     * @param {string[]} setKeys
-     * @param {Record<string, any>[]} list
-     * @param {boolean | Skip} [skip]
-     * @returns {Promise<number>}
+     * @overload
+     * @param {string} field
+     * @param {string} operator
+     * @param {any} value
+     * @param {boolean} [not]
+     * @returns {this}
      */
-    updateMany({ connect, table, fields }: TableDefine, pKeys: string[], setKeys: string[], list: Record<string, any>[], skip?: boolean | Skip): Promise<number>;
+    orNot(field: string, operator: string, value: any, not?: boolean | undefined): this;
     /**
-     * @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[]>}
+     * @overload
+     * @param {string[]} field
+     * @param {string} operator
+     * @param {any[]} value
+     * @param {boolean} [not]
+     * @returns {this}
      */
-    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[]>;
+    orNot(field: string[], operator: string, value: any[], not?: boolean | undefined): this;
     /**
-     * @param {TableDefine} tableDefine
-     * @param {Wheres?} [where]
-     * @returns {Promise<number>}
+     * @overload
+     * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+     * @returns {this}
      */
-    delete({ connect, table, fields }: TableDefine, where?: Wheres | null): Promise<number>;
+    orNot(items: [Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]): this;
     /**
-     * @template {Fields<MainFieldType>} T
-     * @param {TableDefine<T>} tableDefine
-     * @param {string[]?} [returning]
-     * @param {Wheres?} [where]
-     * @returns {Promise<any[]>}
+     *
+     * @param  {...SelectItem} subquery
+     * @returns {this}
      */
-    deleteReturn<T extends Fields<MainFieldType>>({ connect, table, fields }: TableDefine<T>, returning?: string[] | null, where?: Wheres | null): Promise<any[]>;
+    exists(...subquery: SelectItem[]): this;
     /**
      *
-     * @param {Queryable} queryable
-     * @returns {Promise<number>}
+     * @param  {...SelectItem} subquery
+     * @returns {this}
      */
+    notExists(...subquery: SelectItem[]): this;
+    #private;
+}
+
+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, that: any) => Promise<object>, table: TableDefine): PromiseLike<T>;
+}
+declare const Build: unique symbol;
+interface Build<T = unknown> {
+    [Build](data: object, others: object | boolean): T;
+}
+
+declare class Connection<E extends object = object> {
+    #private;
+    constructor(connection: PromiseLike<IConnection<E>> | IConnection<E>, transaction?: E | null);
+    clone(): Connection<E>;
+    call<T>(action: Action<T>): Promise<T>;
+    dbType(): Promise<string>;
+    dbVersion(): Promise<string>;
+    query(...values: any[]): Promise<any[]>;
+    exec(...values: any[]): Promise<number>;
+    type(table: string): Promise<TableType | null>;
+    build<T extends Fields>(build: Build<T>, data: object, saved?: object | boolean): T;
+    build<T extends Fields>(table: TableDefine<T>, data: object, saved?: object | boolean): FieldValue<T>;
+    build(p: Build | TableDefine, data: object, saved?: object | boolean): any;
+    /** @deprecated */
+    create<T extends TableDefine>(model: T, list: object[]): Promise<TableValue<T>[]>;
+    /** @deprecated */
+    create<T extends TableDefine>(model: T, value: object): Promise<T extends Build<infer R> ? R : TableValue<T>>;
+    /** @deprecated */
+    create<T extends TableDefine>(model: T, value: object | object[]): Promise<TableValue<T>[] | (T extends Build<infer R> ? R : TableValue<T>)>;
+    /** @deprecated */
+    search<T extends TableDefine>(sql: T, fields: string[], skip?: Skip): Promise<T extends TableDefine<infer F> ? FieldValue<F>[] : never>;
+    /** @deprecated */
+    find<T extends TableDefine>(sql: T, skip?: Skip): Promise<T extends Build<infer R> ? R[] : T extends TableDefine<infer F> ? FieldValue<F>[] : never>;
+    /** @deprecated */
+    first<T extends TableDefine>(sql: T, skip?: Skip): Promise<T extends Build<infer R> ? R : T extends TableDefine<infer F> ? FieldValue<F> : never>;
+    /** @deprecated */
+    save<T>(model: TableDefine, data: T, newData?: Record<string, any> | null, skip?: Skip): Promise<(T extends Save ? T : object) | null>;
+    /** @deprecated */
+    completelyDestroy<T>(tableDef: TableDefine, data: T): Promise<(T extends Destroy ? T : object) | null>;
+    /** @deprecated */
+    pseudoDestroy<T>(tableDef: TableDefine, data: T, value: Record<string, SetValue>): Promise<(T extends PseudoDestroy ? T : object) | null>;
+    /** @deprecated */
+    destroy<T extends Destroy & PseudoDestroy>(table: TableDefine, data: T, update?: boolean | Record<string, any> | undefined): Promise<T | null>;
+    /** @deprecated */
+    destroy<T extends Destroy & PseudoDestroy>(table: TableDefine, data: T, update?: boolean | Record<string, any> | undefined): Promise<T | object | null>;
+    /** @deprecated */
+    destroy(table: TableDefine, data: any, update?: boolean | Record<string, any> | undefined): Promise<object | null>;
+    /** @deprecated */
+    destroyMany(queryable: Queryable, update?: Record<string, SetValue> | boolean): Promise<number>;
+    /** @deprecated */
+    insert<T>(tableDefine: TableDefine, data: T, ignoreConflict?: boolean | undefined): Promise<T>;
+    /** @deprecated */
+    insert<T>(tableDefine: TableDefine, data: T[], ignoreConflict?: boolean | undefined): Promise<T[]>;
+    /** @deprecated */
+    insert<T>(tableDefine: TableDefine, data: T, keys?: string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T>;
+    /** @deprecated */
+    insert<T>(tableDefine: TableDefine, data: T[], keys?: string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T[]>;
+    /** @deprecated */
+    insert<T>(tableDefine: TableDefine, data: T, keys?: boolean | string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T>;
+    /** @deprecated */
+    insert<T>(tableDefine: TableDefine, data: T[], keys?: boolean | string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T[]>;
+    /** @deprecated */
+    insert<T>(tableDefine: TableDefine, data: T | T[], keys?: boolean | string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T | T[]>;
+    /** @deprecated */
+    upsert<T>(tableDefine: TableDefine, data: T, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
+    /** @deprecated */
+    upsert<T>(tableDefine: TableDefine, data: T[], conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    /** @deprecated */
+    upsert<T>(tableDefine: TableDefine, data: T, keys?: string[] | null | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
+    /** @deprecated */
+    upsert<T>(tableDefine: TableDefine, data: T[], keys?: string[] | null | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    /** @deprecated */
+    upsert<T>(tableDefine: TableDefine, data: T, keys?: string[] | null | undefined, conflictKeys?: boolean | string[] | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
+    /** @deprecated */
+    upsert<T>(tableDefine: TableDefine, data: T[], keys?: string[] | null | undefined, conflictKeys?: boolean | string[] | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    /** @deprecated */
+    upsert<T>(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>;
+    /** @deprecated */
+    upsert<T>(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[]>;
+    /** @deprecated */
+    upsert<T>(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[]>;
+    /** @deprecated */
+    update(table: TableDefine, update: Record<string, any>, where?: Wheres | null, skip?: boolean | Skip): Promise<number>;
+    /** @deprecated */
+    updateReturn<T extends Fields<MainFieldType>>(table: TableDefine<T>, update: Record<string, any>, returning?: string[] | null, where?: Wheres | null, skip?: boolean | Skip): Promise<any[]>;
+    /** @deprecated */
+    updateMany(table: TableDefine, pKeys: string[], setKeys: string[], list: Record<string, any>[], skip?: boolean | Skip): Promise<number>;
+    /** @deprecated */
+    updateManyReturn<T extends Fields<MainFieldType>>(table: TableDefine<T>, pKeys: string[], setKeys: string[], list: Record<string, any>[], returning?: string[] | null, skip?: boolean | Skip): Promise<any[]>;
+    /** @deprecated */
+    delete(table: TableDefine, where?: Wheres | null): Promise<number>;
+    /** @deprecated */
+    deleteReturn<T extends Fields<MainFieldType>>(table: TableDefine<T>, returning?: string[] | null, where?: Wheres | null): Promise<any[]>;
+    /** @deprecated */
     count(queryable: Queryable): Promise<number>;
-    /**
-     * @param {Queryable} queryable
-     * @returns {Promise<any[]>}
-     */
+    /** @deprecated */
     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>;
-    abort(): boolean;
-    /**
-     * @param {string} table
-     * @returns {Promise<DBTable?>}
-     */
     loadTable(table: string): Promise<DBTable | null>;
-    /**
-     * @param {string[]} tables
-     * @returns {Promise<DBTable[]>}
-     */
     loadTables(tables: string[]): Promise<DBTable[]>;
-    /**
-     * @param {TableDefine | DBTable} table
-     * @returns {Promise<void>}
-     */
     syncTable(table: TableDefine | DBTable): Promise<void>;
-    /**
-     * @param {(TableDefine | DBTable)[]} tables
-     * @returns {Promise<void>}
-     */
     syncTables(tables: (TableDefine | DBTable)[]): Promise<void>;
+    abort(): boolean;
+    savepoint(): Promise<Savepoint>;
+    [Symbol.dispose](): void;
     /**
      * @template T
      * @overload
-     * @param {(t: Connection) => PromiseLike<T> | T} fn
+     * @param {Action<T> |((t: Connection, signal: AbortSignal) => PromiseLike<T> | T)} fn
      * @returns {Promise<T>}
      */
-    transaction<T>(fn: (t: Connection) => PromiseLike<T> | T): Promise<T>;
-    /**
-     * @overload
-     * @returns {TransactionHandler}
-     */
+    transaction<T>(list: Action<T> | ((t: Connection, signal: AbortSignal) => PromiseLike<T> | T)): Promise<Awaited<T>>;
+    transaction<T extends readonly [] | []>(list: {
+        [P in keyof T]: Action<T[P]> | ((t: Connection, signal: AbortSignal) => PromiseLike<T[P]> | T[P]);
+    }): Promise<{
+        -readonly [P in keyof T]: Awaited<T[P]>;
+    }>;
     transaction(): TransactionHandler;
-    [Symbol.dispose](): void;
-    #private;
+    transaction(fn?: (Action<any> | ((t: Connection, signal: AbortSignal) => any))[] | Action<any> | ((t: Connection, signal: AbortSignal) => any)): Promise<any> | TransactionHandler;
 }
 
 /** @import { Fields } from './types' */
@@ -2154,8 +1822,8 @@ declare class Subquery {
 }
 
 type QueryOptions<T extends Fields, TB extends unknown = any> = {
-    connect?: TableConnect<any> | null | undefined;
-    table?: string | VirtualTable<object> | undefined;
+    table?: string | undefined;
+    connect?: TableConnect | null | undefined;
     fields: T;
     pseudo?: string | undefined;
     build?: ((a: object, b?: object | boolean) => TB) | null | undefined;
@@ -2164,8 +1832,8 @@ 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 {string} [table]
+ * @property {TableConnect?} [connect]
  * @property {T} fields
  * @property {string} [pseudo]
  * @property {((a: object, b?: object | boolean) => TB)?} [build]
@@ -2191,10 +1859,10 @@ declare class Query<T extends Fields, TB extends unknown = any> extends Subquery
      * @param {boolean} [noBuild]
      */
     constructor(options: QueryOptions<T, TB> | Query<T, TB>, noBuild?: boolean);
+    /** @readonly @type {string | undefined} */
+    readonly table: string | undefined;
     /** @readonly @type {TableConnect | null | undefined} */
     readonly connect: TableConnect | null | undefined;
-    /** @readonly @type {string | VirtualTable | undefined} */
-    readonly table: string | VirtualTable | undefined;
     /** @readonly @type {T} */
     readonly fields: T;
     /** @readonly @type {string} */
@@ -2400,6 +2068,91 @@ declare function mergeHooks(...hooks: (Readonly<Partial<Hooks>> | Readonly<Parti
  */
 declare function bindHooks(hooks: Readonly<Partial<Hooks>>, that: any): Readonly<Partial<Hooks>>;
 
+declare function export_default$i<T>(tableDef: TableDefine, data: T): Action<(T extends Destroy ? T : object) | null>;
+
+declare function export_default$h(queryable: Queryable): Action<number>;
+
+declare function export_default$g<T extends TableDefine>(model: T, list: object[], skip?: Skip): Action<TableValue<T>[]>;
+declare function export_default$g<T extends TableDefine>(model: T, value: object, skip?: Skip): Action<T extends Build<infer R> ? R : TableValue<T>>;
+declare function export_default$g<T extends TableDefine>(model: T, p: object | object[], skip?: Skip): Action<TableValue<T>[] | (T extends Build<infer R> ? R : TableValue<T>)>;
+
+declare function export_default$f({ table, connect, fields }: TableDefine, where?: Wheres | null): Action<number>;
+
+declare function export_default$e({ table, connect, fields }: TableDefine, returning?: string[] | null, where?: Wheres | null): Action<any[]>;
+
+declare function export_default$d(queryable: Queryable, update?: Record<string, SetValue> | boolean): Action<number>;
+
+declare function export_default$c<T extends Destroy & PseudoDestroy>(tableDef: TableDefine, data: T, update?: Record<string, any> | boolean): Action<T | null>;
+declare function export_default$c<T extends Destroy & PseudoDestroy>(tableDef: TableDefine, data: any, update?: Record<string, any> | boolean): Action<T | object | null>;
+declare function export_default$c(tableDef: TableDefine, data: any, update?: Record<string, any> | boolean): Action<object | null>;
+
+declare function export_default$b<T extends TableDefine>(sql: T, skip?: Skip): Action<T extends Build<infer R> ? R[] : T extends TableDefine<infer F> ? FieldValue<F>[] : never>;
+
+declare function export_default$a<T extends TableDefine>(sql: T, skip?: Skip): Action<T extends Build<infer R> ? R : T extends TableDefine<infer F> ? FieldValue<F> : never>;
+
+declare function export_default$9<T extends object>(tableDefine: TableDefine, data: T[], ignoreConflict?: boolean): Action<T[]>;
+declare function export_default$9<T extends object>(tableDefine: TableDefine, data: T, ignoreConflict?: boolean): Action<T>;
+declare function export_default$9<T extends object>(tableDefine: TableDefine, data: T | T[], ignoreConflict?: boolean): Action<T | T[]>;
+declare function export_default$9<T extends object>(tableDefine: TableDefine, data: T[], keys?: string[], ignoreConflict?: boolean): Action<T[]>;
+declare function export_default$9<T extends object>(tableDefine: TableDefine, data: T, keys?: string[], ignoreConflict?: boolean): Action<T>;
+declare function export_default$9<T extends object>(tableDefine: TableDefine, data: T | T[], keys?: string[], ignoreConflict?: boolean): Action<T | T[]>;
+declare function export_default$9<T extends object>(tableDefine: TableDefine, data: T[], keys?: string[] | boolean, ignoreConflict?: boolean): Action<T[]>;
+declare function export_default$9<T extends object>(tableDefine: TableDefine, data: T, keys?: string[] | boolean, ignoreConflict?: boolean): Action<T>;
+declare function export_default$9<T extends object>(tableDefine: TableDefine, data: T | T[], keys?: string[] | boolean, ignoreConflict?: boolean): Action<T | T[]>;
+
+declare function export_default$8<T>(tableDef: TableDefine, data: T, value: Record<string, SetValue>): Action<(T extends PseudoDestroy ? T : object) | null>;
+
+declare function export_default$7<T>(model: TableDefine, data: T, newData?: Record<string, any> | null, skip?: Skip): Action<(T extends Save ? T : object) | null>;
+
+declare function export_default$6<T extends TableDefine>(sql: T, fields: string[], skip?: Skip): Action<T extends TableDefine<infer F> ? FieldValue<F>[] : never>;
+
+declare function export_default$5(queryable: Queryable): Action<any[]>;
+
+declare function export_default$4({ table, connect, fields }: TableDefine, pKeys: string[], setKeys: string[], list: Record<string, any>[], skip?: Skip | boolean): Action<number>;
+
+declare function export_default$3({ table, connect, fields }: TableDefine, pKeys: string[], setKeys: string[], list: Record<string, any>[], returning?: string[] | null, skip?: Skip | boolean): Action<any[]>;
+
+declare function export_default$2({ table, connect, fields }: TableDefine, update: Record<string, any>, where?: Wheres | null, skip?: Skip | boolean): Action<number>;
+
+declare function export_default$1<T extends Fields<MainFieldType>>({ table, connect, fields }: TableDefine<T>, update: Record<string, any>, returning?: string[] | null, where?: Wheres | null, skip?: Skip | boolean): Action<any[]>;
+
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T[], conflictSet?: Record<string, SetValue>): Action<T[]>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T, conflictSet?: Record<string, SetValue>): Action<T>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T | T[], conflictSet?: Record<string, SetValue>): Action<T | T[]>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T[], keys?: null | string[], conflictSet?: Record<string, SetValue>): Action<T[]>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T, keys?: null | string[], conflictSet?: Record<string, SetValue>): Action<T>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T | T[], keys?: null | string[], conflictSet?: Record<string, SetValue>): Action<T | T[]>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T[], keys?: null | string[], conflictKeys?: string[] | boolean, conflictSet?: Record<string, SetValue>): Action<T[]>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T, keys?: null | string[], conflictKeys?: string[] | boolean, conflictSet?: Record<string, SetValue>): Action<T>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T | T[], keys?: null | string[], conflictKeys?: string[] | boolean, conflictSet?: Record<string, SetValue>): Action<T | T[]>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T[], keys?: null | string[] | boolean | Record<string, SetValue>, conflictKeys?: string[] | boolean | Record<string, SetValue>, conflictSet?: Record<string, SetValue>): Action<T[]>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T, keys?: null | string[] | boolean | Record<string, SetValue>, conflictKeys?: string[] | boolean | Record<string, SetValue>, conflictSet?: Record<string, SetValue>): Action<T>;
+declare function export_default<T extends object>(tableDefine: TableDefine, data: T | T[], keys?: null | string[] | boolean | Record<string, SetValue>, conflictKeys?: string[] | boolean | Record<string, SetValue>, conflictSet?: Record<string, SetValue>): Action<T | T[]>;
+
+declare namespace index_d {
+  export {
+    export_default$i as completelyDestroy,
+    export_default$h as count,
+    export_default$g as create,
+    export_default$f as delete,
+    export_default$e as deleteReturn,
+    export_default$c as destroy,
+    export_default$d as destroyMany,
+    export_default$b as find,
+    export_default$a as first,
+    export_default$9 as insert,
+    export_default$8 as pseudoDestroy,
+    export_default$7 as save,
+    export_default$6 as search,
+    export_default$5 as select,
+    export_default$2 as update,
+    export_default$4 as updateList,
+    export_default$3 as updateListReturn,
+    export_default$1 as updateReturn,
+    export_default as upsert,
+  };
+}
+
 /**
  * @typedef {object} Scene.Define
  * @property {string} table
@@ -2814,4 +2567,5 @@ declare function toBool(v: any): boolean;
 declare function setDevelopment(d?: boolean): void;
 declare let isDevelopment: boolean;
 
-export { Build, CheckViolationError, type ClassDecorator, type Column, type ColumnOptions, Connection, ConnectionError, 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, ForeignKeyViolationError, type GetName, type Hook, type Hooks, type IConnection, type Index, type IndexInfo, type IndexOptions, InvalidInputSyntaxError, type JOIN, type Join, type JoinType, type LockType, type MainFieldType, type MaybePromise, type MethodDecorator, Model, NotNullViolationError, OperatorMismatchError, 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 TransactionHandler, type TransactionHandlerArray, UniqueViolationError, type VirtualTable, Where, type WhereExists, type WhereItem, type WhereLike, type WhereOr, type WhereRaw, type WhereValue, type Wheres, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, bindHooks, coefficient, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, hooks, immutable, increment, index, isDevelopment, isPseudo, mergeHooks, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toBool, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, where, withDeleted };
+export { Build, CheckViolationError, Connection, ConnectionError, Create, Destroy, ForeignKeyViolationError, InvalidInputSyntaxError, Model, NotNullViolationError, OperatorMismatchError, PseudoDestroy, Query, Save, Scene, Select, SetValue, Submodel, UniqueViolationError, Where, index_d as actions, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, bindHooks, coefficient, column, export_default$i as completelyDestroy, export_default$h as count, export_default$g as create, creating, decrement, defaultValue, field as define, export_default$f as delete, export_default$e as deleteReturn, deleted, deleting, export_default$c as destroy, export_default$d as destroyMany, divide, field$1 as field, export_default$b as find, export_default$a as first, getPrimaryFields, getPrimaryKeys, hooks, immutable, increment, index, export_default$9 as insert, isDevelopment, isPseudo, mergeHooks, model, multiply, now, primary, prop, pseudo, export_default$8 as pseudoDestroy, export_default$7 as save, export_default$6 as search, export_default$5 as select, setDevelopment, sort, model as submodel, toBool, toNot, toPrimaries, toPrimary, uncreatable, undeleted, export_default$2 as update, export_default$4 as updateList, export_default$3 as updateListReturn, export_default$1 as updateReturn, updating, export_default as upsert, uuid, values, where, withDeleted };
+export type { Action, BaseEnvironment, ClassDecorator, Column, ColumnOptions, ConnectionInterface, Constraint, DBColumn, DBIndex, DBTable, Environment, FieldDecorator, FieldDefine, FieldDefineOption, FieldDefineType, FieldSpecific, FieldSpecificValue, FieldType, FieldTypeDefine, FieldValue, Fields, FindArg, FindRange, GetName, Hook, Hooks, IConnection, IDBTable, Index, IndexInfo, IndexOptions, JOIN, Join, JoinType, LockType, MainFieldType, MaybePromise, MethodDecorator, Options, QueryOptions, Queryable, Savepoint, SelectItem, Skip, Support, TableConnect, TableConnection, TableDefine, TableType, TableValue, ToFieldType, ToType, TransactionFn, TransactionHandler, TransactionHandlerArray, WhereExists, WhereItem, WhereLike, WhereOr, WhereRaw, WhereValue, Wheres };