baja-lite 1.6.4 → 1.6.6

package/sql.d.ts

@@ -0,0 +1,2151 @@
+import { ExtensionCodec } from "@msgpack/msgpack";
+import { _columns, _columnsNoId, _def, _deleteState, _fields, _ids, _index, _logicIds, _stateFileName, AField, DBType, EnumMap, FieldOption } from 'baja-lite-field';
+import pino from 'pino';
+import { XML } from './convert-xml.js';
+export declare const extensionCodec: ExtensionCodec<undefined>;
+declare const _daoDBName: unique symbol;
+declare const _tableName: unique symbol;
+declare const _className: unique symbol;
+declare const _ClassName: unique symbol;
+declare const _vueName: unique symbol;
+declare const _transformer: unique symbol;
+declare const _comment: unique symbol;
+export declare const _sqlCache: unique symbol;
+export declare const _dao: unique symbol;
+export declare const _primaryDB = "______primaryDB_______";
+declare const _dbType: unique symbol;
+declare const _sqlite_version: unique symbol;
+declare const _daoConnection: unique symbol;
+declare const _inTransaction: unique symbol;
+declare const _daoDB: unique symbol;
+declare const _sqliteRemoteName: unique symbol;
+declare const _SqlOption: unique symbol;
+export declare const _DataConvert: unique symbol;
+export declare const _Context: unique symbol;
+export declare const _enum: unique symbol;
+export declare const _GlobalSqlOption: unique symbol;
+export declare const _EventBus: unique symbol;
+export declare const _path: unique symbol;
+export declare const _fs: unique symbol;
+export declare const logger: pino.Logger<never, boolean>;
+export declare enum MapperIfUndefined {
+    Null = 0,
+    Skip = 1,
+    Zero = 2,
+    EmptyString = 3
+}
+export declare enum SyncMode {
+    /** 同步执行 */
+    Sync = 0,
+    /** 异步执行 */
+    Async = 1
+}
+export declare enum InsertMode {
+    /**
+    # 默认使用
+    ** 支持单个、批量,语法 `INSERT INTO XX VALUES (第一条数据), (第二条数据);`
+    ** 批量执行有性能优势，但无法利用数据库的sql预编译功能
+    */
+    Insert = 0,
+    /**
+    # 利用临时表
+    ## 执行步骤
+    1. 建立临时表(从正式表复制)
+    2. 数据全部进入临时表
+    3. 临时表数据转移到正式表: `INSERT INTO 正式表 SELECT * FROM 临时表`
+    4. 删除临时表
+    ## 注意
+    1. 适用于：主键不会冲突、非自增
+    2. 临时表的结构复制正式表
+     */
+    InsertWithTempTable = 1,
+    /**
+     * 如果不存在则插入
+     * 来源是数据库，根据ID或者指定字段查询
+     */
+    InsertIfNotExists = 2,
+    /**
+    # 插入或者更新
+    1. 判断依据是主键,来源是从数据库查询
+     */
+    Replace = 3
+}
+export declare enum DeleteMode {
+    /**
+     ##常规删除 默认
+     ### 例一
+     `DELETE FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `DELETE FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    Common = 0,
+    TempTable = 1
+}
+export declare enum SelectMode {
+    /**
+     ##常规 默认
+     ### 例一
+     `SELECT * FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `SELECT * FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    Common = 0,
+    TempTable = 1
+}
+export declare enum TemplateResult {
+    /** 确定返回一条记录，如果不是一个，将报错，返回类型是T */
+    AssertOne = 0,
+    /** 可能返回一条记录，返回类型是T|null */
+    NotSureOne = 1,
+    /** 返回多条记录 */
+    Many = 2,
+    /** 仅查询记录数量 */
+    Count = 3
+}
+export declare enum SelectResult {
+    /** 一行一列 确定非空 */
+    R_C_Assert = 0,
+    /** 一行一列 可能空 */
+    R_C_NotSure = 1,
+    /** 一行多列 确定非空 */
+    R_CS_Assert = 2,
+    /** 一行多列 可能空 */
+    R_CS_NotSure = 3,
+    /** 多行一列 */
+    RS_C = 4,
+    /** 多行多列 */
+    RS_CS = 5
+}
+export declare enum ColumnMode {
+    NONE = 0,
+    HUMP = 1
+}
+export declare const SqliteMemory = ":memory:";
+interface MethodOption {
+    tableName?: string;
+    /** 数据库、连接名称，对于MYSQL、mongo，适用于多数据源，对于sqlite，适用于不同的数据库文件  */
+    dbName?: string;
+    dbType?: DBType;
+    /** 调用时，永远不需要传
+     * @deprecated
+     * */
+    dao?: Dao;
+    /** 调用时，仅在开启事务时需要主动传入,传入方式： */
+    conn?: Connection | null;
+}
+export declare const _defOption: {
+    maxDeal: number;
+    skipUndefined: boolean;
+    skipNull: boolean;
+    skipEmptyString: boolean;
+};
+/**
+ 数据服务注解
+ */
+interface ServiceOption {
+    /** 增改忽略Undefined */
+    skipUndefined?: boolean;
+    /** 增改忽略NULL */
+    skipNull?: boolean;
+    /** 增改忽略空字符串 */
+    skipEmptyString?: boolean;
+    /** 批量增改时，每次执行最多处理的记录数量 */
+    maxDeal?: number;
+    tableName?: string;
+    /** 数据库、连接名称，对于MYSQL、mongo，适用于多数据源，对于sqlite，适用于不同的数据库文件  */
+    dbName?: string;
+    /** 调用时，永远不需要传
+     * @deprecated
+     * */
+    dao?: Dao;
+    /** 调用时，仅在开启事务时需要主动传入,传入方式： */
+    conn?: Connection | null;
+    /** 对应的实体类,必须是Class */
+    clz?: any;
+    /** 默认mysql */
+    dbType?: DBType;
+    /** SQLite版本以及升级为该版本时需要执行的SQL,初始版本为0.0.1,切记每个位置不要变为两位数*/
+    sqliteVersion?: string;
+    /** 备注 */
+    comment?: string;
+}
+/**
+ # 全局行为配置文件
+ ### `sqlDir?: string;` 数据库查询语句存放目录.存放格式为 export.default 的js、ts， 存放内容满足格式：
+
+    ```
+    interface SqlModel {
+        [key: string]: string | ((params: { [k: string]: any }, context: any, isCount?: boolean) => string)
+    }
+    ```
+    可以继承该接口来约束格式
+ */
+export interface GlobalSqlOptionForWeb {
+    /** 增改忽略Undefined */
+    skipUndefined?: boolean;
+    /** 增改忽略NULL */
+    skipNull?: boolean;
+    /** 增改忽略空字符串 */
+    skipEmptyString?: boolean;
+    /** 批量增改时，每次执行最多处理的记录数量 */
+    maxDeal?: number;
+    SqliteRemote?: {
+        /**
+         ## 单一数据源
+        ```
+        db: 'd:/1.db'
+        ```
+        ## 多数据源：传入多个连接配置
+        ```
+        db: {
+                db1: 'd:/1.db',
+                db2: 'd:/2.db'
+        }
+        ```
+        不支持 `SqliteMemory`
+        */
+        db?: Record<string, string> | string;
+        /** 远程SQLITE接口实现，适用于Electron, 采用Ipc 的handel机制实现 */
+        service: SqliteRemoteInterface;
+    };
+    /** 日志等级 */
+    log?: 'trace' | 'debug' | 'info' | 'warn';
+    /**
+     作用与sqlDir类似，不同在于sqlMap`不需要`目录，而是直接指定一个sqlModel对象，对象的格式和sqlDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlMap?: _SqlModel;
+    /**
+     作用与sqlFnDir类似，不同在于sqlFNMap`不需要`目录，而是直接指定一个 Record<string, string>，对象的格式和sqlFnDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlFNMap?: Record<string, string>;
+    /**
+    // 第一个元素=列名，第二个元素是属性路径，
+    [
+        ['dit_id', ['id']], // 列名ditid,对应属性id
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id
+    ]
+     */
+    sqlMapperMap?: SqlMappers;
+    /** 提供的枚举MAP */
+    enums?: EnumMap;
+    /**
+     * `列名与属性映射` 是否自动将下划线转为驼峰，默认NONE，即不转.
+     * 当设置为columnMode.HUMP时，切记将代码生成器中属性名称改对
+     * # 自定义sql查询时，无法自动转换哦,可使用标签转换：
+     *```
+        SELECT
+     *  {{#hump}} seller_sku2, seller_sku {{/hump}}
+     * ```
+     * 转换为
+     *```
+        SELECT
+     *  {{#hump}} seller_sku2 sellerSku2, seller_sku sellerSku {{/hump}}
+     * ```
+     */
+    columnMode?: ColumnMode;
+    /** 对于WEB模式，默认为SqliteRemote */
+    dbType?: DBType;
+    /**
+     * * 数据转换器，用于service的select、page方法，以及stream查询
+     * * 例如
+     * ```
+     * dataConvert: {
+     *      // 使用时，传入qiniu和列名，将根据列名对应的值生成URL
+     *      qiniu: data => qiniuConvertUrl(data)
+     * }
+     * ```
+     */
+    dataConvert?: Record<string, (data: any) => any>;
+    /** 公开上下文 */
+    ctx?: any;
+}
+/**
+ # 全局行为配置文件
+   MYSQL编码： 'utf8mb4', utf8mb4_general_ci'
+ ### `sqlDir?: string;` 数据库查询语句存放目录.存放格式为 export.default 的js、ts， 存放内容满足格式：
+ 
+    ```
+    interface SqlModel {
+        [key: string]: string | ((params: { [k: string]: any }, context: any, isCount?: boolean) => string)
+    }
+    ```
+    可以继承该接口来约束格式
+ */
+export interface GlobalSqlOption extends GlobalSqlOptionForWeb {
+    /**
+       初始化MYSQL链接 支持多数据源
+       ## 单一数据源: 直接传入Mysql2的连接配置
+       [MYSQL初始化文档](https://github.com/mysqljs/mysql#connection-options)
+       ```
+       Mysql: {
+          host: '127.0.0.1',
+          ...
+       }
+       ```
+       ## 多数据源：传入多个Mysql2的连接配置
+       ```
+       Mysql: {
+          db1: {
+              host: '127.0.0.1',
+              ...
+          },
+          db2: {
+              host: '127.0.0.1',
+              ...
+          },
+          ...
+       }
+       ```
+      */
+    Mysql?: Record<string, Record<string, any>> | Record<string, any>;
+    /**
+         初始化postgresql链接 支持多数据源
+         ## 单一数据源: 直接传入postgresql的连接配置
+         [Postgresql初始化文档](https://github.com/brianc/node-postgres/tree/master/packages/pg-pool)
+         ```
+         Postgresql: {
+            database: 'postgres',
+            user: 'brianc',
+            password: 'secret!',
+            port: 5432,
+            ssl: true,
+            max: 20, // set pool max size to 20
+            idleTimeoutMillis: 1000, // close idle clients after 1 second
+            connectionTimeoutMillis: 1000, // return an error after 1 second if connection could not be established
+            maxUses: 7500, // close (and replace) a connection after it has been used 7500 times (see below for discussion)
+            host?: string | undefined;
+            connectionString?: string | undefined;
+            keepAlive?: boolean | undefined;
+            stream?: () => stream.Duplex | stream.Duplex | undefined;
+            statement_timeout?: false | number | undefined;
+            query_timeout?: number | undefined;
+            keepAliveInitialDelayMillis?: number | undefined;
+            idle_in_transaction_session_timeout?: number | undefined;
+            application_name?: string | undefined;
+            types?: CustomTypesConfig | undefined;
+            options?: string | undefined;
+         }
+         ```
+         ## 多数据源：传入多个Postgresql的连接配置
+         ```
+         Postgresql: {
+            db1: {
+              database: 'postgres',
+              user: 'brianc',
+              password: 'secret!',
+              port: 5432,
+              ssl: true,
+              max: 20, // set pool max size to 20
+              idleTimeoutMillis: 1000, // close idle clients after 1 second
+              connectionTimeoutMillis: 1000, // return an error after 1 second if connection could not be established
+              maxUses: 7500, // close (and replace) a connection after it has been used 7500 times (see below for discussion)
+            },
+            db2: {
+              database: 'postgres',
+              user: 'brianc',
+              password: 'secret!',
+              port: 5432,
+              ssl: true,
+              max: 20, // set pool max size to 20
+              idleTimeoutMillis: 1000, // close idle clients after 1 second
+              connectionTimeoutMillis: 1000, // return an error after 1 second if connection could not be established
+              maxUses: 7500, // close (and replace) a connection after it has been used 7500 times (see below for discussion)
+            },
+            ...
+         }
+         ```
+        */
+    Postgresql?: Record<string, Record<string, any>> | Record<string, any>;
+    /**
+     ## 单一数据源
+     ```
+     Sqlite: 'd:/1.db'
+     ```
+     ## 多数据源：传入多个连接配置
+     ```
+       Sqlite: {
+            db1: 'd:/1.db',
+            db2: 'd:/2.db'
+       }
+     ```
+       路径 = `SqliteMemory` 将创建内存库
+     */
+    Sqlite?: Record<string, string> | string;
+    /**
+     ## 日志文件存放路径,该目录下文件名是模块名，例如有一个文件名为 `user.js`,内容为:
+     ```
+       export default {
+            'sql_1': 'SELECT * FROM user WHERE username = :username',
+            'sql_2': (options: {
+                ctx?: any;
+                isCount?: boolean;
+                isSum?: boolean;
+                limitStart?: number;
+                limitEnd?: number;
+                sortName?: string; sortType?: string;
+                params?: Record<string, any>;
+            }) => {
+                return   `
+                    SELECT * FROM user u LEFT JOIN organ o ON u.orgid = o.orgid
+                    WHERE o.orgid = :orgid;
+                `;
+            }
+        } as SqlModel;
+     ```
+     ** 可以看到，sql语句支持直接映射一个sql语句，也可以通过函数返回,返回字符串支持[mustache](https://github.com/janl/mustache.js)
+     ** 上面的文件中，将注册两个SQL：`user.sql_1` 和 `user.sql_2`.
+     ** `[k: string]: any;` 是用查询时传入的参数，可以指定为任意类型，可以用来生成sql，例如进行循环语句
+     ** ctx 是框架的上下文，可以自行指定类型
+     ** 其他 是保留参数
+     ** 函数类型中，可以调用自己定义的通用sql
+     ### 注意
+     1. 不要直接拼接参数：不安全且效率低
+     2. sqlite不支持多语句拼接
+    ## 也支持.mu文件,格式略
+    */
+    sqlDir?: string;
+    /**
+    ## [mustache](https://mustache.github.io/) 编译时的[模板](https://github.com/janl/mustache.js#:~:text=requires%20only%20this%3A-,%7B%7B%3E%20next_more%7D%7D,-Why%3F%20Because%20the)
+      ## 文件名就是模板名
+     */
+    sqlFNDir?: string;
+    /**
+     *  #TODO 未完成读取 sqlMapDir
+     *  # sqlMapDir 目录定义如下，
+     *      `test.ts`
+     *      ```
+     *         export const dict:SqlMappers = [
+     *             {columnName: 'dit_id', mapNames: ['DTID'], def: 0, convert: 转换函数},  // 列名ditid,对应属性DTID,如果没有值，将返回默认值0,其中默认值0是可选的
+     *             {columnName: 'event_id', mapNames: ['eventMainInfo', 'id'], def: 0,  convert: 转换函数},// 列名event_id对应属性eventMainInfo.id,这种方式将返回嵌套的json对象,其中默认值null是可选的
+     *         ]
+     *      ```
+     *      将得到 test.dict 这个map
+     */
+    sqlMapDir?: string;
+    /**
+      ## 映射数据为对象，文件名就是模板名
+    ```
+    // 第一个元素=列名，第二个元素是属性路径，
+    // 该目录下可存放json文件，内容如下
+    //
+    // 可以在查询时使用，优先级高于hump
+    // 例如:
+    [
+        ['dit_id', ['id'], 可选的默认值], // 列名ditid,对应属性id,当未查询返回时，使用默认值
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id,当未查询返回时，该属性不存在
+    ]
+    ```
+     */
+    sqlMapperDir?: string;
+    /**
+     [REDIS初始化文档](https://github.com/redis/ioredis?tab=readme-ov-file#:~:text=connect%20to%20by%3A-,new%20Redis()%3B,-//%20Connect%20to%20127.0.0.1)
+    ```
+    Redis: {
+        host: '127.0.0.1',
+        ...
+    }
+    ```
+    ## 多数据源：传入多个Redis的连接配置
+    ```
+    Redis: {
+        db1: {
+            host: '127.0.0.1',
+            ...
+        },
+        db2: {
+            host: '127.0.0.1',
+            ...
+        },
+        ...
+    }
+    ```
+     */
+    Redis?: Record<string, Record<string, any>> | Record<string, any>;
+    /** sqlite数据库驱动初始化函数 */
+    BetterSqlite3?: any;
+    /**
+     * 读取查询语句时，是否扫描JS文件？
+     * JS文件需要默认导出一个 SqlModel对象
+     */
+    jsMode?: boolean;
+}
+export interface PageQuery<L> {
+    sum?: Record<string, string | number>;
+    total?: number;
+    size?: number;
+    records?: L[];
+}
+/** sqlite electron服务端需要支持的接口 */
+export interface SqliteRemoteInterface {
+    execute(inData: Uint8Array): Promise<Uint8Array>;
+    pluck(inData: Uint8Array): Promise<Uint8Array>;
+    get(inData: Uint8Array): Promise<Uint8Array>;
+    raw(inData: Uint8Array): Promise<Uint8Array>;
+    query(inData: Uint8Array): Promise<Uint8Array>;
+    initDB(dbName: string): void;
+    export(dbName: string, exportPath: string): Promise<void>;
+    restore(dbName: string, importPath: string): void;
+    close(dbName?: string): void;
+}
+export interface Connection {
+    [_daoConnection]: any;
+    [_inTransaction]: boolean;
+    execute(sync: SyncMode.Sync, sql?: string, params?: any): {
+        affectedRows: number;
+        insertId: bigint;
+    };
+    execute(sync: SyncMode.Async, sql?: string, params?: any): Promise<{
+        affectedRows: number;
+        insertId: bigint;
+    }>;
+    /** 一行一列 */
+    pluck<One_Row_One_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): One_Row_One_Column | null;
+    pluck<One_Row_One_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<One_Row_One_Column | null>;
+    /** 一行多列 */
+    get<One_Row_Many_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): One_Row_Many_Column | null;
+    get<One_Row_Many_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<One_Row_Many_Column | null>;
+    /** 多行一列 */
+    raw<Many_Row_One_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): Many_Row_One_Column[];
+    raw<Many_Row_One_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<Many_Row_One_Column[]>;
+    /** 多行多列 */
+    query<Many_Row_Many_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): Many_Row_Many_Column[];
+    query<Many_Row_Many_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<Many_Row_Many_Column[]>;
+    realse(sync: SyncMode.Sync): void;
+    realse(sync: SyncMode.Async): Promise<void>;
+}
+interface Dao {
+    [_daoDB]: any;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+}
+export declare class Mysql implements Dao {
+    [_daoDB]: any;
+    constructor(pool: any);
+    keepAlive(): Promise<void>;
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+}
+export declare class Postgresql implements Dao {
+    [_daoDB]: any;
+    constructor(pool: any);
+    keepAlive(): Promise<void>;
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+}
+export declare class Sqlite implements Dao {
+    [_daoDB]: any;
+    constructor(db: any);
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+}
+export declare class SqliteRemoteConnection implements Connection {
+    [_daoConnection]: SqliteRemoteInterface;
+    [_sqliteRemoteName]: string;
+    [_inTransaction]: boolean;
+    constructor(conn: SqliteRemoteInterface, name: string);
+    execute(sync: SyncMode.Sync, sql?: string, params?: any): {
+        affectedRows: number;
+        insertId: bigint;
+    };
+    execute(sync: SyncMode.Async, sql?: string, params?: any): Promise<{
+        affectedRows: number;
+        insertId: bigint;
+    }>;
+    pluck<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    pluck<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    get<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    get<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    raw<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    raw<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    query<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    query<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    realse(sync: SyncMode.Sync): void;
+    realse(sync: SyncMode.Async): Promise<void>;
+}
+export declare class SqliteRemote implements Dao {
+    [_sqliteRemoteName]: string;
+    [_daoDB]: SqliteRemoteInterface;
+    private connection?;
+    constructor(db: SqliteRemoteInterface, name: string);
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, exportPath: string): void;
+    backup(sync: SyncMode.Async, exportPath: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, importPath: string): void;
+    restore(sync: SyncMode.Async, importPath: string): Promise<void>;
+}
+export type SqlMapper = {
+    columnName: string;
+    mapNames: string[];
+    def?: any;
+    convert?: (data: any) => any;
+}[];
+export type SqlMappers = Record<string, SqlMapper>;
+export type SqlModel = Record<string, string | ((options: {
+    ctx?: any;
+    isCount?: boolean;
+    isSum?: boolean;
+    limitStart?: number;
+    limitEnd?: number;
+    sortName?: string;
+    sortType?: string;
+    params?: any;
+}) => string)>;
+type _SqlModel = Record<string, string | ((options: {
+    ctx?: any;
+    isCount?: boolean;
+    isSum?: boolean;
+    limitStart?: number;
+    limitEnd?: number;
+    sortName?: string;
+    sortType?: string;
+    params?: any;
+}) => string) | XML[]>;
+/**
+ * ifUndefined默认是MapperIfUndefined.Skip
+ */
+export declare function flatData<M>(options: {
+    data: any;
+    mapper: string | SqlMapper;
+    mapperIfUndefined?: MapperIfUndefined;
+}): M;
+export declare class SqlCache {
+    private sqlMap;
+    private sqlFNMap;
+    private _read;
+    /**
+     *
+     * ```
+    // 第一个元素=列名，第二个元素是属性路径，
+    [
+        ['dit_id', ['id']], // 列名ditid,对应属性id
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id
+    ]
+     * ```
+     * @param am
+     * @param keys
+     */
+    private readResultMap;
+    init(options: {
+        sqlMap?: _SqlModel;
+        sqlDir?: string;
+        sqlFNMap?: Record<string, string>;
+        sqlFNDir?: string;
+        sqlMapperMap?: SqlMappers;
+        sqlMapperDir?: string;
+        jsMode?: boolean;
+    }): Promise<void>;
+    load(sqlids: string[], options: {
+        ctx?: any;
+        isCount?: boolean;
+        isSum?: boolean;
+        limitStart?: number;
+        limitEnd?: number;
+        sortName?: string;
+        sortType?: string;
+        [k: string]: any;
+    }): string;
+}
+export declare const DB: (config: ServiceOption) => <C extends {
+    new (...args: any[]): {};
+}>(constructor: C) => {
+    new (...args: any[]): {
+        [_tableName]: string | undefined;
+        [_className]: string | undefined;
+        [_ClassName]: string | undefined;
+        [_vueName]: string | undefined;
+        [_daoDBName]: string | undefined;
+        [_dbType]: DBType | undefined;
+        [_sqlite_version]: string | undefined;
+        [_SqlOption]: {
+            maxDeal: number;
+            skipUndefined: boolean;
+            skipNull: boolean;
+            skipEmptyString: boolean;
+        } & ServiceOption;
+        [_ids]: any;
+        [_logicIds]: any;
+        [_fields]: any;
+        [_columns]: any;
+        [_columnsNoId]: any;
+        [_index]: any;
+        [_def]: any;
+        [_comment]: string | undefined;
+        [_stateFileName]: any;
+        [_deleteState]: any;
+        [_transformer]: <L extends Object>(data: L, option?: MethodOption & {
+            finalColumns?: Set<string>;
+            tempColumns?: Array<string>;
+            insert?: boolean;
+            skipId?: boolean;
+            skipNull?: boolean;
+            skipUndefined?: boolean;
+            skipEmptyString?: boolean;
+            onFieldExists?: (K: string, V: any) => void;
+        }) => any;
+    };
+} & C;
+/**
+  js项目中实体类注解替代品，只要确保函数被执行即可,举例：
+  ```
+  // 声明一个class
+    export class AmaFuck {}
+    DeclareClass(AmaFuck, [
+        { type: "String", name: "SellerSKU" },
+        { type: "String", name: "SellerSKU2" },
+        { type: "String", name: "site" }
+    ]);
+  ```
+ */
+export declare function DeclareClass(clz: any, FieldOptions: FieldOption[]): void;
+/**
+ JS项目中，service注解代替,举例：
+ ```
+ // 声明一个service,注意这里的let
+    export let AmaService = class AmaService extends SqlService {};
+    AmaService = DeclareService(AmaService, {
+        tableName: "ama_fuck2",
+        clz: AmaFuck,
+        dbType: DBType.Sqlite,
+        sqliteVersion: "0.0.3"
+    });
+ ```
+ */
+export declare function DeclareService(clz: any, config: ServiceOption): any;
+/**
+ ## 数据库服务
+ ### 注解DB
+ 
+ ### 泛型 T，同DB注解中的clz
+ ** 服务中所有方法默认以该类型为准
+ **
+ 
+ */
+export declare class SqlService<T extends object> {
+    [_tableName]?: string;
+    private [_className]?;
+    private [_ClassName]?;
+    private [_vueName]?;
+    private [_daoDBName]?;
+    private [_comment]?;
+    private [_ids]?;
+    private [_fields]?;
+    private [_columns]?;
+    private [_columnsNoId]?;
+    private [_stateFileName]?;
+    private [_deleteState]?;
+    private [_SqlOption]?;
+    private [_dbType]?;
+    private [_sqlite_version]?;
+    private [_index]?;
+    private [_def]?;
+    [_transformer]?: <L = T>(data: Partial<L>, option?: MethodOption & {
+        finalColumns?: Set<string>;
+        insert?: boolean;
+        skipId?: boolean;
+        skipNull?: boolean;
+        skipUndefined?: boolean;
+        skipEmptyString?: boolean;
+        onFieldExists?: (K: string, V: any) => void;
+    }) => Partial<T>;
+    private _insert;
+    /**
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认 `异步`
+    1. `data`：可是数组或者单对象
+    2. `skipUndefined`: boolean; 是否不处理值为undefined的字段,默认 true
+    3. `skipNull`: boolean; 是否不处理值为null的字段,默认 true
+    4. `skipEmptyString`: boolean; 是否不处理值为空字符串(`注意：多个空格也算空字符串`)的字段,默认 true
+    5. `maxDeal`: number; 批量处理时，每次处理多少个？默认500
+    6. `tableName`: 默认使用service注解的`tableName`,可以在某个方法中覆盖
+    7. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    8. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    9.  `dao`: 永远不需要传入该值
+    10. `mode` :默认`insert`，可选如下
+        1. `insert`: 默认
+        2. `insertIfNotExists`: 通过主键或者existConditionOtherThanIds字段判断数据是否存在，不存在才插入,存在则不执行
+        3. `replace`: 只支持用主键判断, 存在更新, 不存在插入
+    11. `existConditionOtherThanIds`: insertIfNotExists时判断同一记录的字段名称，默认情况下按照ID判断，设置existConditionOtherThanIds后，不用id
+    12. `replaceWithDef` replace时，是否带入默认值? 默认true
+    ### 返回值是最后一次插入的主键ID，对于自增ID表适用
+    1. 如果主键是自增批量操作，且期望返回所有记录的ID，那么需要设置 `option 中的 every = true`,此时效率降低
+     * @param {{[P in keyof T]?: T[P]}} data
+     * @param {MethodOption} [option]
+     * @memberof SqlServer
+     */
+    insert(option: MethodOption & {
+        data: Partial<T>;
+        sync?: SyncMode.Async;
+        mode?: InsertMode;
+        existConditionOtherThanIds?: (keyof T)[];
+        every?: boolean;
+        temp?: boolean;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+        replaceWithDef?: boolean;
+    }): Promise<bigint>;
+    insert(option: MethodOption & {
+        data: Partial<T>[];
+        sync?: SyncMode.Async;
+        mode?: InsertMode;
+        existConditionOtherThanIds?: (keyof T)[];
+        every?: boolean;
+        temp?: boolean;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+        replaceWithDef?: boolean;
+    }): Promise<bigint[]>;
+    insert(option: MethodOption & {
+        data: Partial<T>;
+        sync: SyncMode.Sync;
+        mode?: InsertMode;
+        existConditionOtherThanIds?: (keyof T)[];
+        every?: boolean;
+        temp?: boolean;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+        replaceWithDef?: boolean;
+    }): bigint;
+    insert(option: MethodOption & {
+        data: Partial<T>[];
+        sync: SyncMode.Sync;
+        mode?: InsertMode;
+        existConditionOtherThanIds?: (keyof T)[];
+        every?: boolean;
+        temp?: boolean;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+        replaceWithDef?: boolean;
+    }): bigint[];
+    private _update;
+    /**
+    ## 根据主键修改
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. `data`：可是数组或者单对象
+    2. `skipUndefined`: boolean; 是否不处理值为undefined的字段,默认 true
+    3. `skipNull`: boolean; 是否不处理值为null的字段,默认 true
+    4. `skipEmptyString`: boolean; 是否不处理值为空字符串(`注意：多个空格也算空字符串`)的字段,默认 true
+    5. `maxDeal`: number; 批量处理时，每次处理多少个？默认500
+    6. `tableName`: 默认使用service注解的`tableName`,可以在某个方法中覆盖
+    7. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    8. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    9.  `dao`: 永远不需要传入该值
+     */
+    update(option: MethodOption & {
+        data: Partial<T> | Array<Partial<T>>;
+        sync?: SyncMode.Async;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+    }): Promise<number>;
+    update(option: MethodOption & {
+        data: Partial<T> | Array<Partial<T>>;
+        sync: SyncMode.Sync;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+    }): number;
+    /**
+    ## 删除
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. 支持按ID删除：可以单个ID或者ID数组 `需要实体类只有一个ID`
+    2. 支持实体类删除: 用于多个ID或者按实体类某些字段删除
+    3. 两种模式：`mode`=`Common` 或者 `TempTable`
+    3. 如果数据多，使用 `TempTable`模式
+    4. 当设置实体类的字段有 `logicDelete` ，将进行逻辑删除，除非设置 `forceDelete` = true
+    5. 支持`whereSql`直接拼接，此时必须传递`whereParams`,不建议直接使用这种方式！为了简化逻辑，它不会和ID、WHERE共存，且优先级更高。且不支持 `TempTable` Mode
+    6. `tableName`: 默认使用service注解的`tableName`,可以在某个方法中覆盖
+    7. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    8. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    9.  `dao`: 永远不需要传入该值
+    */
+    delete(option: MethodOption & {
+        sync?: SyncMode.Async;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: DeleteMode;
+        forceDelete?: boolean;
+        whereSql?: string;
+        whereParams?: Record<string, any>;
+    }): Promise<number>;
+    delete(option: MethodOption & {
+        sync: SyncMode.Sync;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: DeleteMode;
+        forceDelete?: boolean;
+        whereSql?: string;
+        whereParams?: Record<string, any>;
+    }): number;
+    private _template;
+    /**
+    #根据条件查询对象
+    ## 特点：快速、简单，可快速根据某些字段是否等于来查询返回，可以查询记录和记录数
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. `templateResult`: 返回值类型断言，4种
+        1. `AssertOne` 确定返回一个，如果不是一个，将报错，返回类型是T `默认`
+        2. `NotSureOne` 可能返回一个，返回类型是T|null
+        3. `Many` 返回多个
+        4. `Count` 返回记录数
+    2. 支持按ID查询：可以单个ID或者ID数组 `需要实体类只有一个ID`
+    3. 支持实体类查询: 用于多个ID或者按实体类某些字段查询
+    4. 两种查询方式：`mode`=`Common`(默认) 或者 `TempTable`
+    5. `tableName`: 默认使用service注解的`tableName`,可以在某个方法中覆盖
+    6. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    7. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    8.  `dao`: 永远不需要传入该值
+
+     */
+    template<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        templateResult?: TemplateResult.AssertOne;
+        id?: string | number | Array<string | number>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        mode?: SelectMode;
+        error?: string;
+        columns?: (keyof L)[];
+    }): L;
+    template<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        templateResult?: TemplateResult.AssertOne;
+        id?: string | number | Array<string | number>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        mode?: SelectMode;
+        error?: string;
+        columns?: (keyof L)[];
+    }): Promise<L>;
+    template<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        templateResult: TemplateResult.Count;
+        id?: string | number | Array<string | number>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        mode?: SelectMode;
+        error?: string;
+        columns?: (keyof L)[];
+    }): number;
+    template<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        templateResult: TemplateResult.Count;
+        id?: string | number | Array<string | number>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        mode?: SelectMode;
+        error?: string;
+        columns?: (keyof L)[];
+    }): Promise<number>;
+    template<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        templateResult: TemplateResult.NotSureOne;
+        id?: string | number | Array<string | number>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        mode?: SelectMode;
+        error?: string;
+        columns?: (keyof L)[];
+    }): L | null;
+    template<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        templateResult: TemplateResult.NotSureOne;
+        id?: string | number | Array<string | number>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        mode?: SelectMode;
+        error?: string;
+        columns?: (keyof L)[];
+    }): Promise<L | null>;
+    template<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        templateResult: TemplateResult.Many;
+        id?: string | number | Array<string | number>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        mode?: SelectMode;
+        error?: string;
+        columns?: (keyof L)[];
+    }): L[];
+    template<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        templateResult: TemplateResult.Many;
+        id?: string | number | Array<string | number>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        mode?: SelectMode;
+        error?: string;
+        columns?: (keyof L)[];
+    }): Promise<L[]>;
+    private _select;
+    /**
+    # 自由查询
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. `templateResult`: 返回值类型断言，6种, R表示行，C表示列，带S表示复数
+        1. R_C_Assert,
+        2. R_C_NotSure,
+        3. R_CS_Assert,
+        4. R_CS_NotSure,
+        5. RS_C,
+        7. RS_CS[默认]
+    2. `sql` 或者 `sqlid`
+    3. `params`
+    4. `defValue`: One_Row_One_Column 时有效
+    5. 禁止一次查询多个语句
+    6. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    7. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    9.  `dao`: 永远不需要传入该值
+    10. `hump`: 是否将列名改为驼峰写法？默认情况下按照全局配置
+    11. `mapper`: 列名-属性 映射工具，优先级高于hump
+     ```
+     //    该属性支持传入mybatis.xml中定义的resultMap块ID，或者读取sqlMapDir目录下的JSON文件.
+     //    注意：resultMap块ID与sql语句逻辑一致，同样是 目录.ID
+     //    或者自定义Mapper,自定义Mapper格式如下:
+     [
+     {columnName: 'dit_id', mapNames: ['DTID'], def: 0, convert: 转换函数},  // 列名ditid,对应属性DTID,如果没有值，将返回默认值0,其中默认值0是可选的
+     {columnName: 'event_id', mapNames: ['eventMainInfo', 'id'], def: 0,  convert: 转换函数},// 列名event_id对应属性eventMainInfo.id,这种方式将返回嵌套的json对象,其中默认值是可选的
+     ]
+     12. dataConvert 数据转换器
+     ```
+     dataConvert: {
+         fileName: 'qiniu'
+     }
+         // 表示列 fileName 按 qiniu的函数格式化
+         // qiniu 在项目初始化时定义
+     ```
+     */
+    select<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult?: SelectResult.RS_CS | SelectResult.RS_C;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isCount?: boolean;
+        defValue?: L | null;
+        errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): Promise<L[]>;
+    select<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isCount?: boolean;
+        defValue?: L | null;
+        errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): Promise<L>;
+    select<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isCount?: boolean;
+        defValue?: L | null;
+        errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): Promise<L | null>;
+    select<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult?: SelectResult.RS_CS | SelectResult.RS_C;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isCount?: boolean;
+        defValue?: L | null;
+        errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): L[];
+    select<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isCount?: boolean;
+        defValue?: L | null;
+        errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): L;
+    select<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isCount?: boolean;
+        defValue?: L | null;
+        errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): L | null;
+    /**
+    # 自由查询:一次执行多个SQL语句!
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. `sql` 或者 `sqlid`
+    2. `params`
+    3. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    4. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    5.  `dao`: 永远不需要传入该值
+    6. `hump`: 是否将列名改为驼峰写法？默认情况下按照全局配置
+    7. `mapper`: 列名-属性 映射工具，优先级高于hump
+     ```
+     //    该属性支持传入mybatis.xml中定义的resultMap块ID，或者读取sqlMapDir目录下的JSON文件(暂未实现).
+     //    注意：resultMap块的寻找逻辑与sql语句逻辑一致，同样是 文件名.ID
+     //    或者自定义Mapper,自定义Mapper格式如下:
+     [
+        // 数据列名ditid将转换为属性`DTID`,如果没有值，将返回默认值0,其中默认值0是可选的
+        {columnName: 'dit_id', mapNames: ['DTID'], def?: 0, convert: 转换函数},
+        // 数据列名event_id将转换为属性`eventMainInfo.id`,这种方式将返回嵌套的json对象,其中默认值0是可选的
+        {columnName: 'event_id', mapNames: ['eventMainInfo', 'id'], def?: 0,  convert: 转换函数},
+     ]
+     ```
+     8. `dataConvert` 数据转换器
+     ```
+     dataConvert: {
+         fileName: 'qiniu'
+     }
+    // 表示列 fileName 按 qiniu的函数格式化
+    // qiniu 在开始时定义
+     ```
+     */
+    selectBatch<T extends any[] = []>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult?: SelectResult.RS_CS | SelectResult.RS_C;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): Promise<{
+        [K in keyof T]: T[K][];
+    }>;
+    selectBatch<T extends any[] = []>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): Promise<{
+        [K in keyof T]: T[K];
+    }>;
+    selectBatch<T extends any[] = []>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): Promise<{
+        [K in keyof T]: T[K] | null;
+    }>;
+    selectBatch<T extends any[] = []>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult?: SelectResult.RS_CS | SelectResult.RS_C;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): {
+        [K in keyof T]: T[K][];
+    };
+    selectBatch<T extends any[] = []>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): {
+        [K in keyof T]: T[K];
+    };
+    selectBatch<T extends any[] = []>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): {
+        [K in keyof T]: T[K] | null;
+    };
+    /**
+     # 自由执行sql
+     0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+     1. `sql` 或者 `sqlid`
+     2. `params`
+     3. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+     4. `conn`: 仅在开启事务时需要主动传入,传入示例:
+         ```
+             service.transaction(async conn => {
+                 service.insert({conn});
+             });
+         ```
+     5.  `dao`: 永远不需要传入该值
+     
+      */
+    excute<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+    }): Promise<number>;
+    excute<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+    }): number;
+    /**
+     ### 开启事务
+     ### 这里面的所有数据方法，都必须传递CONN，否则会引起
+     # 死锁
+     ### 举例说明：
+     #### 假设有两条代码，都操作同一个表A，其中代码1传了conn，但代码2没有传
+     #### 代码1：插入数据，代码2：更新数据
+     #### 二者操作的是不同的数据
+     #### 以上为前提，开始分析：
+     ** 当事务打开后，会创建一个连接1，开始执行代码1
+     ** 代码1执行完毕，由于`transaction`方法尚未结束，所以不会提交事务。
+     ** 代码1是插入数据，因此会导致全表锁
+     ** 代码2开始执行，由于没有传入conn，所以会创建一个新的连接2
+     ** 代码2执行时，会等待连接1的锁释放
+     ** 但是连接1的锁是在`transaction`方法执行完后才会提交并释放锁，这导致死循环，开启死锁
+     **
+     */
+    transaction<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        fn: (conn: Connection) => Promise<L>;
+    }): Promise<L | null>;
+    transaction<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        fn: (conn: Connection) => L;
+    }): L | null;
+    stream<L extends object = T>(): StreamQuery<L>;
+    page<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        sqlId: string;
+        context?: any;
+        params: Record<string, any>;
+        pageSize?: number;
+        pageNumber?: number;
+        limitSelf?: boolean;
+        countSelf?: boolean;
+        sum?: boolean;
+        sumSelf?: boolean;
+        sortName?: string;
+        sortType?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): Promise<PageQuery<L>>;
+    page<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        sqlId: string;
+        context?: any;
+        params: Record<string, any>;
+        pageSize?: number;
+        pageNumber?: number;
+        limitSelf?: boolean;
+        countSelf?: boolean;
+        sum?: boolean;
+        sumSelf?: boolean;
+        sortName?: string;
+        sortType?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): PageQuery<L>;
+    /**
+     * 导出数据，可以为EJS-EXCEL直接使用
+     * @param list
+     * @returns
+     */
+    exp<L = T>(list: L[]): {
+        title: string | undefined;
+        titleSpan: string;
+        columnTitles: string[];
+        datas: any[][];
+    };
+    /**
+     * 导入数据的模板
+     * @returns
+     */
+    imp(): {
+        title: string | undefined;
+        titleSpan: string;
+        columnTitles: string[];
+    };
+    /**
+     * 初始化表结构
+     * 只有sqlite、sqliteremote需要
+     * force: 是否强制，默认false, 强制时会删除再创建
+     * @param option
+     */
+    init(option?: MethodOption & {
+        sync?: SyncMode.Async;
+        force?: boolean;
+    }): Promise<void>;
+    init(option: MethodOption & {
+        sync: SyncMode.Sync;
+        force?: boolean;
+    }): void;
+    close(option?: MethodOption & {
+        sync?: SyncMode.Async;
+    }): Promise<void>;
+    close(option: MethodOption & {
+        sync: SyncMode.Sync;
+    }): void;
+    /**
+    #创建表
+    ** `tableName` 表名称
+    ** `temp` 是否是临时表，默认true
+    ** `columns` 字符串数组，默认是当前实体类全部字段，通过`columns` 可以创建部分字段临时表
+    ** `id` 表的主键设置 4种：
+    1. `auto`: `columns`中已经在当前实体类配置的ID作为主键 `默认`
+    2. `all`: `columns`中所有字段全部当主键
+    3. `none`: 没有主键
+    4. 自定义字段名称：字符串数组
+    ** `index` 表的索引，设置方式同ID
+     */
+    private _createTable;
+    private _matchSqlid;
+    private _setParam;
+    private _generSql;
+}
+declare class StreamQuery<T extends object> {
+    private _prefix;
+    private _index;
+    private _wheres;
+    private _andQuerys;
+    private _orQuerys;
+    private _paramKeys;
+    private _param;
+    if_proceed: boolean;
+    if_exec: boolean;
+    private _distinct;
+    private _columns;
+    private _updates?;
+    private _updateColumns;
+    private _groups;
+    private _orders;
+    private _startRow;
+    private _pageSize;
+    private _service;
+    private [_fields];
+    private [_columns];
+    constructor(service: SqlService<T>, __fields: Record<string, AField>, __columns: string[]);
+    /** 将当前stream重置 */
+    reset(): this;
+    /** 为下次链条执行提供条件判断：非异步方法跳过，异步方法不执行并返回默认值 */
+    if(condition: boolean): this;
+    /**
+     * AND(key1 = :value OR key2 = :value)
+     * @param keys [key1, key2, ...]
+     */
+    eqs(keys: (keyof T)[], value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /*** AND key = :value */
+    eq(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /*** AND key1 = :value1 AND  key2 = :value2 */
+    eqT(t: Partial<T>, { name: paramName, breakExcuteIfEmpty }?: {
+        name?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /*** AND key <> :value */
+    notEq(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key1 = key2 */
+    eqWith(key1: keyof T, key2: keyof T): this;
+    /** AND key1 <> key2 */
+    notEqWith(key1: keyof T, key2: keyof T): this;
+    /** AND key > :value */
+    grate(key: keyof T, value: string | number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key >= :value */
+    grateEq(key: keyof T, value: string | number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key1 > key2 */
+    grateWith(key1: keyof T, key2: keyof T): this;
+    /** AND key1 >= key2 */
+    grateEqWith(key1: keyof T, key2: keyof T): this;
+    /** AND key < :value */
+    less(key: keyof T, value: string | number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key <= :value */
+    lessEq(key: keyof T, value: string | number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key1 < key2 */
+    lessWith(key1: keyof T, key2: keyof T): this;
+    /** AND key1 <= key2 */
+    lessEqWith(key1: keyof T, key2: keyof T): this;
+    /** AND key REGEXP :regexp */
+    regexp(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT REGEXP :regexp */
+    notRegexp(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :regexp REGEXP key */
+    regexp2(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :regexp NOT REGEXP key */
+    notRegexp2(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND (key1 << 8) + key2 = value */
+    shiftEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND (key1 << 8) + key2 <> value */
+    shiftNotEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key LIKE CONCAT('%', :value, '%') */
+    like(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT LIKE CONCAT('%', :value, '%') */
+    notLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT LIKE CONCAT('%', :value) */
+    leftLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key LIKE CONCAT('%', :value) */
+    notLeftLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key LIKE CONCAT(:value, '%') */
+    rightLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT LIKE CONCAT(:value, '%') */
+    notRightLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key LIKE :value 注意：不会拼接% */
+    PreciseLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT LIKE :value 注意：不会拼接%*/
+    notPreciseLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key GLOB CONCAT('%', :value, '%') 注意：GLOB是大小写敏感like */
+    glob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT GLOB CONCAT('%', :value, '%') 注意：GLOB是大小写敏感like*/
+    notGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key GLOB CONCAT('%', :value) 注意：GLOB是大小写敏感like*/
+    leftGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT GLOB CONCAT('%', :value) 注意：GLOB是大小写敏感like*/
+    notLeftGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key GLOB CONCAT(:value, '%') 注意：GLOB是大小写敏感like*/
+    rightGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT GLOB CONCAT(:value, '%') 注意：GLOB是大小写敏感like*/
+    notRightGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key GLOB :value 注意：GLOB是大小写敏感like,这里不拼接%*/
+    preciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT GLOB :value 注意：GLOB是大小写敏感like,这里不拼接%*/
+    notPreciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value LIKE CONCAT('%', key, '%') */
+    like2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT LIKE CONCAT('%', key, '%') */
+    notLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT LIKE CONCAT('%', key) */
+    leftLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value LIKE CONCAT('%', key) */
+    notLeftLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value LIKE CONCAT(key, '%') */
+    rightLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT LIKE CONCAT(key, '%') */
+    notRightLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value LIKE key 注意：不会拼接% */
+    PreciseLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT LIKE key 注意：不会拼接%*/
+    notPreciseLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value GLOB CONCAT('%', key, '%') 注意：GLOB是大小写敏感like */
+    glob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT GLOB CONCAT('%', key, '%') 注意：GLOB是大小写敏感like*/
+    notGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value GLOB CONCAT('%', key) 注意：GLOB是大小写敏感like*/
+    leftGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT GLOB CONCAT('%', key) 注意：GLOB是大小写敏感like*/
+    notLeftGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value GLOB CONCAT(key, '%') 注意：GLOB是大小写敏感like*/
+    rightGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT GLOB CONCAT(key, '%') 注意：GLOB是大小写敏感like*/
+    notRightGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value GLOB key 注意：GLOB是大小写敏感like,这里不拼接%*/
+    preciseGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT GLOB key 注意：GLOB是大小写敏感like,这里不拼接%*/
+    notPreciseGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key IN (:value) */
+    in(key: keyof T, value: Array<string | number>, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT IN (:value) */
+    notIn(key: keyof T, value: Array<string | number>, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value IN (key1, key2, ...) */
+    in2(key: (keyof T)[], value: string | number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT IN (key1, key2, ...) */
+    notIn2(key: (keyof T)[], value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key IS NULL */
+    isNULL(key: keyof T): this;
+    /** AND key IS NOT NULL */
+    isNotNULL(key: keyof T): this;
+    /** AND (key IS NULL OR key = '') */
+    isEmpty(key: keyof T): this;
+    /** AND key IS NOT NULL AND key <> ''*/
+    isNotEmpty(key: keyof T): this;
+    /** AND key BETWEEN :value1 AND :value2 */
+    between(key: keyof T, value1: string | number, value2: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT BETWEEN :value1 AND :value2 */
+    notBetween(key: keyof T, value1: string | number, value2: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND POW(2, key) & :value */
+    pow(key: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND NOT POW(2, key) & :value */
+    notPow(key: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND POW(2, :value) & key */
+    pow2(key: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND NOT POW(2, :value) & key */
+    notPow2(key: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND POW(2, key1) & key2 */
+    powWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND NOT POW(2, key1) & key2 */
+    notPowWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND MATCH(key1, key2, key3...) AGAINST (:value) */
+    match(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND NOT MATCH(key1, key2, key3...) AGAINST (:value) */
+    notMatch(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND MATCH(key1, key2, key3...) AGAINST (:value) IN BOOLEAN MODE*/
+    matchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND NOT MATCH(key1, key2, key3...) AGAINST (:value) IN BOOLEAN MODE */
+    notMatchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND MATCH(key1, key2, key3...) AGAINST (:value) WITH QUERY EXPANSION*/
+    matchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND NOT MATCH(key1, key2, key3...) AGAINST (:value) WITH QUERY EXPANSION*/
+    notMatchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND LOCATE(key, :value) > 0 */
+    includes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND NOT LOCATE(key, :value) = 0 */
+    notIncludes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND LOCATE(:value, key) > 0 */
+    includes2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND NOT LOCATE(:value, key) = 0 */
+    notIncludes2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND FIND_IN_SET(:value, key) */
+    findInSet(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND FIND_IN_SET(key, :value) */
+    findInSet2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    and(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)): this;
+    or(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)): this;
+    /**
+     * sql WHERE 查询语句拼接：注意若有JOIN，需要写明别名。本表别名为t.例如:
+     * ```
+     * where('t.name > :name', {name: 1});
+     * where('(t.name > :name OR t.name <> :name)', {name: 1});
+     * ```
+     */
+    where(sql: string, param?: Record<string, any>): this;
+    /** SET key = IFNULL(key, 0) + :value */
+    incr(key: keyof T, value?: number): this;
+    /** GROUP BY key1, key2, ... */
+    groupBy(...keys: (keyof T)[]): this;
+    /** GROUP BY key1, key2, ... */
+    groupBy2(...keys: string[]): this;
+    /** ORDER BY key1 ASC, key2 ASC, ... */
+    asc(...keys: (keyof T)[]): this;
+    /** ORDER BY key1 ASC, key2 ASC, ... */
+    asc2(...keys: string[]): this;
+    /** ORDER BY key1 DESC, key2 DESC, ... */
+    desc(...keys: (keyof T)[]): this;
+    /** ORDER BY key1 DESC, key2 DESC, ... */
+    desc2(...keys: string[]): this;
+    /** LIMIT :startRow, :pageSize */
+    limit(startRow: number, pageSize: number): this;
+    /** LIMIT ((:pageNumber || 1) - 1) * :pageSize, :pageSize */
+    page(pageNumber: number, pageSize: number): this;
+    distinct(on?: boolean): this;
+    /** COUNT(DISTINCT key) */
+    countDistinct(key: keyof T, countName?: string): this;
+    count(countName?: string): this;
+    sum(key: keyof T, legName?: string, distinct?: boolean): this;
+    avg(key: keyof T, legName?: string, distinct?: boolean): this;
+    max(key: keyof T, legName?: string, distinct?: boolean): this;
+    min(key: keyof T, legName?: string, distinct?: boolean): this;
+    /** GROUP_CONCAT([DISTINCT] key [ORDER BY :asc ASC] [ORDER BY :asc DESC] [SEPARATOR :separator]) */
+    groupConcat(key: keyof T, param?: {
+        distinct?: boolean;
+        separator?: string;
+        asc?: (keyof T)[];
+        desc?: (keyof T)[];
+        groupName?: string;
+    }): this;
+    select(...key: (keyof T)[]): this;
+    /**
+     * sql查询语句拼接：注意若有JOIN，需要写明别名。本表别名为t.例如:
+     * ```
+     * select2('t.name, t.age, ISNULL(t.type, :type)', {type: 1});
+     * select2('MAX(t.age) MAXAge');
+     * ```
+     */
+    select2(sql: string, param?: Record<string, any>): this;
+    update(key: keyof T, value: T[keyof T]): this;
+    /** update语句拼接：注意若有JOIN，需要写明别名。本表别名为t */
+    update2(sql: string, param?: Record<string, any>): this;
+    updateT(t: Partial<T>): this;
+    /** SET key = REPLACE(key, :valueToFind,  :valueToReplace) */
+    replace(key: keyof T, valueToFind: T[keyof T], valueToReplace: T[keyof T]): this;
+    excuteSelect<L = T>(option?: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult?: SelectResult.RS_CS | SelectResult.RS_C;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): Promise<L[]>;
+    excuteSelect<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert;
+        errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): Promise<L>;
+    excuteSelect<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): Promise<L | null>;
+    excuteSelect<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult: SelectResult.RS_CS | SelectResult.RS_C;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): L[];
+    excuteSelect<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert;
+        errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): L;
+    excuteSelect<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): L | null;
+    excutePage<L = T>(option?: MethodOption & {
+        sync?: SyncMode;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+        dataConvert?: Record<string, string>;
+    }): PageQuery<L> | Promise<PageQuery<L>>;
+    excuteUpdate(option?: MethodOption & {
+        sync?: SyncMode.Async;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+    }): Promise<number>;
+    excuteUpdate(option: MethodOption & {
+        sync: SyncMode.Sync;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+    }): number;
+    excuteDelete(option?: MethodOption & {
+        sync?: SyncMode.Async;
+        forceDelete?: boolean;
+    }): Promise<number>;
+    excuteDelete(option: MethodOption & {
+        sync: SyncMode.Sync;
+        forceDelete?: boolean;
+    }): number;
+    private _where;
+    private _;
+    private _2;
+    private __;
+    private _null;
+    private _key;
+    private _between;
+    private _in;
+    private _in2;
+    private _shift;
+    private _match;
+    private _pow;
+    private _pow2;
+    private _like;
+    private _like2;
+    private _includes;
+    private _includes2;
+}
+/**
+ 获取REDIS客户端，
+ # [查看库的API](https://redis.github.io/ioredis/)
+ # [REDIS API](http://doc.redisfans.com/)
+ REDIS 的API 可以直接用，将方法名转为小写
+ ```
+ // 设置<Redis>来获得代码提示
+ getRedisDB<Redis>('').exists(?)
+ ```
+ */
+export declare function getRedisDB<T = any>(db?: string): T;
+/**
+ redlock
+ */
+export declare function GetRedisLock(key: string, lockMaxActive?: number): Promise<boolean>;
+/** 对FN加锁、缓存执行 */
+export declare function excuteWithLock<T>(config: {
+    /** 返回缓存key,参数=方法的参数+当前用户对象，可以用来清空缓存。 */
+    key: ((...args: any[]) => string) | string;
+    /** 被锁定线程是否sleep直到解锁为止? 默认true */
+    lockWait?: boolean;
+    /** 当设置了lockWait=true时，等待多少【毫秒】进行一次锁查询? 默认：100MS */
+    lockRetryInterval?: number;
+    /** 当设置了lockWait=true时，等待多少【毫秒】即视为超时，放弃本次访问？默认：永不放弃 */
+    lockMaxWaitTime?: number;
+    /** 错误信息 */
+    errorMessage?: string;
+    /** 允许的并发数，默认：1 */
+    lockMaxActive?: number;
+    /** 单个锁多少【毫秒】后自动释放?默认：60*1000MS  */
+    lockMaxTime?: number;
+}, fn__: () => Promise<T>): Promise<T>;
+/** 与缓存共用时，需要在缓存之前:有缓存则返回缓存,否则加锁执行并缓存,后续队列全部返回缓存,跳过执行 */
+export declare function MethodLock<T = any>(config: {
+    /** 返回缓存key,参数=方法的参数[注意：必须和主方法的参数数量、完全一致，同时会追加一个当前用户对象]+当前用户对象，可以用来清空缓存。 */
+    key: ((this: T, ...args: any[]) => string) | string;
+    /** 被锁定线程是否sleep直到解锁为止? 默认true */
+    lockWait?: boolean;
+    /** 当设置了lockWait=true时，等待多少【毫秒】进行一次锁查询? 默认100ms */
+    lockRetryInterval?: number;
+    /** 当设置了lockWait=true时，等待多少【毫秒】即视为超时，放弃本次访问？默认永不放弃 */
+    lockMaxWaitTime?: number;
+    /** 错误信息 */
+    errorMessage?: string;
+    /** 允许的并发数，默认=1 */
+    lockMaxActive?: number;
+    /** 单个锁多少【毫秒】后自动释放?即时任务没有执行完毕或者没有主动释放锁?  */
+    lockMaxTime?: number;
+}): (target: T, _propertyKey: string, descriptor: PropertyDescriptor) => void;
+/** 清空方法缓存 */
+export declare function clearMethodCache(key: string): Promise<void>;
+/**
+ * 执行一个方法fn，
+ * 如果有缓存，则返回缓存，否则执行方法并缓存
+ */
+export declare function excuteWithCache<T>(config: {
+    /** 返回缓存key,参数=方法的参数+当前用户对象，可以用来清空缓存。 */
+    key: string;
+    /** 返回缓存清除key,参数=方法的参数+当前用户对象，可以用来批量清空缓存 */
+    clearKey?: string[];
+    /** 自动清空缓存的时间，单位分钟 */
+    autoClearTime?: number;
+    /** 随着当前用户sesion的清空而一起清空 */
+    clearWithSession?: boolean;
+}, fn: () => Promise<T>): Promise<T>;
+/** 缓存注解 */
+export declare function MethodCache<T = any>(config: {
+    /** 返回缓存key,参数=方法的参数[注意：必须和主方法的参数数量、完全一致，同时会追加一个当前用户对象]+当前用户对象，可以用来清空缓存。 */
+    key: ((this: T, ...args: any[]) => string) | string;
+    /** 返回缓存清除key,参数=方法的参数[注意：必须和主方法的参数数量、完全一致，同时会追加一个当前用户对象]+当前用户对象，可以用来批量清空缓存 */
+    clearKey?: ((this: T, ...args: any[]) => string[]) | string[];
+    /** 自动清空缓存的时间，单位分钟 */
+    autoClearTime?: number;
+    /** 随着当前用户sesion的清空而一起清空 */
+    clearWithSession?: boolean;
+}): (target: T, _propertyKey: string, descriptor: PropertyDescriptor) => void;
+export {};