baja-lite 1.0.0

package/cjs/sql.d.ts

@@ -0,0 +1,1216 @@
+import 'reflect-metadata';
+declare const _daoDBName: unique symbol;
+declare const _tableName: unique symbol;
+declare const _ids: unique symbol;
+declare const _columns: unique symbol;
+declare const _columnsNoId: unique symbol;
+declare const _fields: unique symbol;
+declare const _stateFileName: unique symbol;
+declare const _deleteState: unique symbol;
+declare const _transformer: unique symbol;
+declare const _index: unique symbol;
+declare const _def: unique symbol;
+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 _SqlOption: unique symbol;
+export declare enum DBType {
+    Mysql = 0,
+    Sqlite = 1,
+    Mongo = 2,
+    SqliteRemote = 3,
+    Redis = 4,
+    RedisLock = 5
+}
+export declare enum SqlSyncMode {
+    /** 同步执行 */
+    Sync = 0,
+    /** 异步执行 */
+    Async = 1
+}
+export declare enum SqlInsertMode {
+    /**
+    # 默认使用
+    ** 支持单个、批量,语法 `INSERT INTO XX VALUES (第一条数据), (第二条数据);`
+    ** 批量执行有性能优势，但无法利用数据库的sql预编译功能
+    */
+    Insert = 0,
+    /**
+    # 利用临时表
+    ## 执行步骤
+    1. 建立临时表(从正式表复制)
+    2. 数据全部进入临时表
+    3. 临时表数据转移到正式表: `INSERT INTO 正式表 SELECT * FROM 临时表`
+    4. 删除临时表
+    ## 注意
+    1. 适用于：主键不会冲突、非自增
+    2. 临时表的结构复制正式表
+     */
+    InsertWithTempTable = 1,
+    InsertIfNotExists = 2,
+    /**
+    # 插入或者更新
+    1. 判断依据是主键
+     */
+    Replace = 3
+}
+export declare enum SqlDelMode {
+    /**
+     ##常规删除 默认
+     ### 例一
+     `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 SqlSelectMode {
+    /**
+     ##常规 默认
+     ### 例一
+     `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 SqlTemplateMode {
+    /** 确定返回一个，如果不是一个，将报错，返回类型是T */
+    AssertOne = 0,
+    /** 可能返回一个，返回类型是T|null */
+    NotSureOne = 1,
+    /** 返回多个 */
+    Many = 2,
+    /** 仅查询记录数量 */
+    Count = 3
+}
+export declare enum SqlQueryMode {
+    One_Row_One_Column_Assert = 0,
+    One_Row_One_Column_NotSure = 1,
+    One_Row_Many_Column_Assert = 2,
+    One_Row_Many_Column_NotSure = 3,
+    Many_Row_One_Column = 4,
+    Many_Row_Many_Column = 5
+}
+export declare enum SqlType {
+    bigint = 0,
+    char = 1,
+    decimal = 2,
+    int = 3,
+    longtext = 4,
+    mediumtext = 5,
+    smallint = 6,
+    text = 7,
+    tinyint = 8,
+    varchar = 9
+}
+export declare const SqliteMemory = ":memory:";
+interface MethodOption {
+    tableName?: string;
+    /** 数据库、连接名称，对于MYSQL、mongo，适用于多数据源，对于sqlite，适用于不同的数据库文件  */
+    dbName?: string;
+    /** 调用时，永远不需要传
+     * @deprecated
+     * */
+    dao?: Dao;
+    /** 调用时，仅在开启事务时需要主动传入,传入方式： */
+    conn?: Connection | null;
+}
+/**
+ 数据服务注解
+ */
+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;
+}
+/**
+ # 全局行为配置文件
+   MYSQL编码： 'utf8mb4', utf8mb4_general_ci'
+ ### `sqlDir?: string;` 数据库查询语句存放目录.存放格式为 export.default 的js、ts， 存放内容满足格式：
+
+    ```
+    interface SqlModel {
+        [key: string]: string | ((params: { [k: string]: any }, context: any, isPage?: boolean) => string)
+    }
+    ```
+    可以继承该接口来约束格式
+ */
+interface GlobalSqlOption {
+    /** 增改忽略Undefined */
+    skipUndefined?: boolean;
+    /** 增改忽略NULL */
+    skipNull?: boolean;
+    /** 增改忽略空字符串 */
+    skipEmptyString?: boolean;
+    /** 批量增改时，每次执行最多处理的记录数量 */
+    maxDeal?: number;
+    /**
+       初始化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>;
+    /**
+     ## 单一数据源
+     ```
+     Sqlite: 'd:/1.db'
+     ```
+     ## 多数据源：传入多个Mysql2的连接配置
+     ```
+       Sqlite: {
+            db1: 'd:/1.db',
+            db2: 'd:/2.db'
+       }
+     ```
+       路径 = `SqliteMemory` 将创建内存库
+     */
+    Sqlite?: Record<string, string> | string;
+    SqliteRemote?: {
+        /**
+         ## 单一数据源
+        ```
+        db: 'd:/1.db'
+        ```
+        ## 多数据源：传入多个Mysql2的连接配置
+        ```
+        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';
+    /**
+     日志文件存放路径,该目录下文件名是模块名，例如有一个文件名为 `user.js`,内容为:
+     ```
+       export default {
+            'sql_1': 'SELECT * FROM user WHERE username = :username',
+            'sql_2': (params: Record<string, any>, context: any, isPage?: boolean | undefined) => {
+                return   `
+                    SELECT * FROM user u LEFT JOIN organ o ON u.orgid = o.orgid
+                    WHERE o.orgid = :orgid;
+                `;
+            }
+        } as SqlModel;
+     ```
+     ** 可以看到，sql语句支持直接映射一个sql语句，也可以通过函数返回
+     ** 上面的文件中，将注册两个SQL：`user.sql_1` 和 `user.sql_2`.
+     ** params 是用查询时传入的参数，可以指定为任意类型，可以用来生成sql，例如进行循环语句
+     ** context 是框架的上下文，可以自行指定类型
+     ** isPage 是保留参数
+     ** 函数类型中，可以调用自己定义的通用sql
+     ### 注意
+     1. 不要直接拼接参数：不安全且效率低
+     2. sqlite不支持多语句拼接
+    */
+    sqlDir?: string;
+    /**
+     作用与sqlDir类似，不同在于sqlCache`不需要`目录，而是直接指定一个sqlModel对象，对象的格式和sqlDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlCache?: SqlModel;
+    /**
+     [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>;
+}
+interface FieldOption extends Object {
+    type?: SqlType;
+    name?: string;
+    length1?: number;
+    length2?: number;
+    def?: any;
+    index?: boolean;
+    id?: boolean;
+    logicDelete?: string;
+    notNull?: boolean;
+}
+/** sqlite electron服务端需要支持的接口 */
+export interface SqliteRemoteInterface {
+    execute(dbName: string, sql?: string, params?: any): Promise<{
+        affectedRows: number;
+        insertId: bigint;
+    }>;
+    pluck<One_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<One_Row_Many_Column | undefined>;
+    get<One_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<One_Row_Many_Column | undefined>;
+    raw<Many_Row_One_Column = any>(dbName: string, sql?: string, params?: any): Promise<Many_Row_One_Column[]>;
+    query<Many_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<Many_Row_Many_Column[]>;
+    initDB(dbName: string): Promise<void>;
+    backup(dbName: string, name: string): Promise<void>;
+    restore(dbName: string, name: string): Promise<void>;
+}
+interface Connection {
+    [_daoConnection]: any;
+    [_inTransaction]: boolean;
+    execute(sync: SqlSyncMode.Sync, sql?: string, params?: any): {
+        affectedRows: number;
+        insertId: bigint;
+    };
+    execute(sync: SqlSyncMode.Async, sql?: string, params?: any): Promise<{
+        affectedRows: number;
+        insertId: bigint;
+    }>;
+    /** 一行一列 */
+    pluck<One_Row_One_Column = any>(sync: SqlSyncMode.Sync, sql?: string, params?: any): One_Row_One_Column | null;
+    pluck<One_Row_One_Column = any>(sync: SqlSyncMode.Async, sql?: string, params?: any): Promise<One_Row_One_Column | null>;
+    /** 一行多列 */
+    get<One_Row_Many_Column = any>(sync: SqlSyncMode.Sync, sql?: string, params?: any): One_Row_Many_Column | null;
+    get<One_Row_Many_Column = any>(sync: SqlSyncMode.Async, sql?: string, params?: any): Promise<One_Row_Many_Column | null>;
+    /** 多行一列 */
+    raw<Many_Row_One_Column = any>(sync: SqlSyncMode.Sync, sql?: string, params?: any): Many_Row_One_Column[];
+    raw<Many_Row_One_Column = any>(sync: SqlSyncMode.Async, sql?: string, params?: any): Promise<Many_Row_One_Column[]>;
+    /** 多行多列 */
+    query<Many_Row_Many_Column = any>(sync: SqlSyncMode.Sync, sql?: string, params?: any): Many_Row_Many_Column[];
+    query<Many_Row_Many_Column = any>(sync: SqlSyncMode.Async, sql?: string, params?: any): Promise<Many_Row_Many_Column[]>;
+    realse(sync: SqlSyncMode.Sync): void;
+    realse(sync: SqlSyncMode.Async): Promise<void>;
+}
+interface Dao {
+    [_daoDB]: any;
+    transaction<T = any>(sync: SqlSyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SqlSyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    createConnection(sync: SqlSyncMode.Sync): Connection | null;
+    createConnection(sync: SqlSyncMode.Async): Promise<Connection | null>;
+    close(sync: SqlSyncMode.Sync): void;
+    close(sync: SqlSyncMode.Async): Promise<void>;
+    backup(sync: SqlSyncMode.Sync, name: string): void;
+    backup(sync: SqlSyncMode.Async, name: string): Promise<void>;
+    remove(sync: SqlSyncMode.Sync): void;
+    remove(sync: SqlSyncMode.Async): Promise<void>;
+    restore(sync: SqlSyncMode.Sync, name: string): void;
+    restore(sync: SqlSyncMode.Async, name: string): Promise<void>;
+}
+type SqlModel = Record<string, string | ((params: Record<string, any>, context: any, isPage?: boolean) => string)>;
+export declare const Field: (config: FieldOption) => (object: object, propertyName: string) => void;
+export declare const DB: (config: ServiceOption) => <C extends new (...args: any[]) => {}>(constructor: C) => {
+    new (...args: any[]): {
+        [_tableName]: string | undefined;
+        [_daoDBName]: string | undefined;
+        [_dbType]: DBType;
+        [_sqlite_version]: string | undefined;
+        [_SqlOption]: {
+            maxDeal: number;
+            skipUndefined: boolean;
+            skipNull: boolean;
+            skipEmptyString: boolean;
+        } & ServiceOption;
+        [_ids]: any;
+        [_fields]: any;
+        [_columns]: any;
+        [_columnsNoId]: any;
+        [_index]: any;
+        [_def]: any;
+        [_stateFileName]: any;
+        [_deleteState]: any;
+        [_transformer]: <L extends Object>(data: L, option?: MethodOption & {
+            finalColumns?: Set<string>;
+            tempColumns?: Array<string>;
+            def?: boolean;
+            skipId?: 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> {
+    private [_tableName]?;
+    private [_daoDBName]?;
+    private [_ids]?;
+    private [_fields]?;
+    private [_columns]?;
+    private [_columnsNoId]?;
+    private [_stateFileName]?;
+    private [_deleteState]?;
+    private [_SqlOption]?;
+    private [_dbType]?;
+    private [_sqlite_version]?;
+    private [_index]?;
+    private [_def]?;
+    private [_transformer]?;
+    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
+    ### 返回值是最后一次插入的主键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?: SqlSyncMode.Async;
+        mode?: SqlInsertMode;
+        existConditionOtherThanIds?: (keyof T)[];
+        every?: boolean;
+        temp?: boolean;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+    }): Promise<bigint>;
+    insert(option: MethodOption & {
+        data: Partial<T>[];
+        sync?: SqlSyncMode.Async;
+        mode?: SqlInsertMode;
+        existConditionOtherThanIds?: (keyof T)[];
+        every?: boolean;
+        temp?: boolean;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+    }): Promise<bigint[]>;
+    insert(option: MethodOption & {
+        data: Partial<T>;
+        sync: SqlSyncMode.Sync;
+        mode?: SqlInsertMode;
+        existConditionOtherThanIds?: (keyof T)[];
+        every?: boolean;
+        temp?: boolean;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+    }): bigint;
+    insert(option: MethodOption & {
+        data: Partial<T>[];
+        sync: SqlSyncMode.Sync;
+        mode?: SqlInsertMode;
+        existConditionOtherThanIds?: (keyof T)[];
+        every?: boolean;
+        temp?: boolean;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+    }): 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?: SqlSyncMode.Async;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
+        maxDeal?: number;
+    }): Promise<number>;
+    update(option: MethodOption & {
+        data: Partial<T> | Array<Partial<T>>;
+        sync: SqlSyncMode.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
+    6. `tableName`: 默认使用service注解的`tableName`,可以在某个方法中覆盖
+    7. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    8. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    9.  `dao`: 永远不需要传入该值
+    */
+    delete(option: MethodOption & {
+        sync?: SqlSyncMode.Async;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlDelMode;
+        forceDelete?: boolean;
+    }): Promise<number>;
+    delete(option: MethodOption & {
+        sync: SqlSyncMode.Sync;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlDelMode;
+        forceDelete?: boolean;
+    }): number;
+    private _select;
+    /**
+    #根据条件查询对象
+    ## 特点：快速、简单，可快速根据某些字段是否等于来查询返回，可以查询记录和记录数
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. `resultMode`: 返回值类型断言，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(option: MethodOption & {
+        resultMode?: SqlTemplateMode.AssertOne;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): Promise<T>;
+    template(option: MethodOption & {
+        sync: SqlSyncMode.Sync;
+        resultMode?: SqlTemplateMode.AssertOne;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): T;
+    template(option: MethodOption & {
+        sync: SqlSyncMode.Async;
+        resultMode?: SqlTemplateMode.AssertOne;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): Promise<T>;
+    template(option: MethodOption & {
+        resultMode: SqlTemplateMode.Count;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): Promise<number>;
+    template(option: MethodOption & {
+        sync: SqlSyncMode.Sync;
+        resultMode: SqlTemplateMode.Count;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): number;
+    template(option: MethodOption & {
+        sync: SqlSyncMode.Async;
+        resultMode: SqlTemplateMode.Count;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): Promise<number>;
+    template(option: MethodOption & {
+        resultMode: SqlTemplateMode.NotSureOne;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): Promise<T | null>;
+    template(option: MethodOption & {
+        sync: SqlSyncMode.Sync;
+        resultMode: SqlTemplateMode.NotSureOne;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): T | null;
+    template(option: MethodOption & {
+        sync: SqlSyncMode.Async;
+        resultMode: SqlTemplateMode.NotSureOne;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): Promise<T | null>;
+    template(option: MethodOption & {
+        resultMode: SqlTemplateMode.Many;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): Promise<T[]>;
+    template(option: MethodOption & {
+        sync: SqlSyncMode.Sync;
+        resultMode: SqlTemplateMode.Many;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): T[];
+    template(option: MethodOption & {
+        sync: SqlSyncMode.Async;
+        resultMode: SqlTemplateMode.Many;
+        id?: string | number | Array<string | number>;
+        where?: Partial<T> | Array<Partial<T>>;
+        mode?: SqlSelectMode;
+        error?: string;
+        columns?: (keyof T)[];
+    }): Promise<T[]>;
+    private _query;
+    /**
+    # 自由查询
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. `resultMode`: 返回值类型断言，三种
+        1. One_Row_One_Column_Assert,
+        2. One_Row_One_Column_NotSure,
+        3. One_Row_Many_Column_Assert,
+        4. One_Row_Many_Column_NotSure,
+        5. Many_Row_One_Column,
+        6. Many_Row_Many_Column[默认]
+    2. `sql` 或者 `sqlid`
+    3. `params`
+    4. `defValue`: One_Row_One_Column 时有效
+    5. `multiple`: = true 时表示多重sql查询，且每个sql的结果都是相同的resultMode, 此时 `One_Row_One_Column` `Many_Row_One_Column` `One_Row_Many_Column` 将按多重数组解析，`Many_Row_Many_Column` 不变，此时需要自己手动指定返回类型.
+        此时 `One_Row_One_Column` 将返回多个单值组成的数组: `[1, 'ok', 3]`
+             `One_Row_Many_Column` 将返回多个对象组成的数组: `[{ob1}, {ob2}, {ob3}]`
+             `Many_Row_One_Column` 将返回多个单值数组组成的数组: `[[1,2,3],  ['a', 'b']]`
+    6. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    7. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    9.  `dao`: 永远不需要传入该值
+
+     */
+    select<L = T>(option: MethodOption & {
+        sync?: SqlSyncMode.Async;
+        resultMode?: SqlQueryMode.Many_Row_Many_Column | SqlQueryMode.Many_Row_One_Column;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isPage?: boolean;
+        defValue?: L | null;
+        multiple?: boolean;
+        errorMsg?: string;
+    }): Promise<L[]>;
+    select<L = T>(option: MethodOption & {
+        sync?: SqlSyncMode.Async;
+        resultMode: SqlQueryMode.One_Row_Many_Column_Assert | SqlQueryMode.One_Row_One_Column_Assert;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isPage?: boolean;
+        defValue?: L | null;
+        multiple?: boolean;
+        errorMsg?: string;
+    }): Promise<L>;
+    select<L = T>(option: MethodOption & {
+        sync?: SqlSyncMode.Async;
+        resultMode: SqlQueryMode.One_Row_Many_Column_NotSure | SqlQueryMode.One_Row_One_Column_NotSure;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isPage?: boolean;
+        defValue?: L | null;
+        multiple?: boolean;
+        errorMsg?: string;
+    }): Promise<L | null>;
+    select<L = T>(option: MethodOption & {
+        sync: SqlSyncMode.Sync;
+        resultMode?: SqlQueryMode.Many_Row_Many_Column | SqlQueryMode.Many_Row_One_Column;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isPage?: boolean;
+        defValue?: L | null;
+        multiple?: boolean;
+        errorMsg?: string;
+    }): L[];
+    select<L = T>(option: MethodOption & {
+        sync: SqlSyncMode.Sync;
+        resultMode: SqlQueryMode.One_Row_Many_Column_Assert | SqlQueryMode.One_Row_One_Column_Assert;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isPage?: boolean;
+        defValue?: L | null;
+        multiple?: boolean;
+        errorMsg?: string;
+    }): L;
+    select<L = T>(option: MethodOption & {
+        sync: SqlSyncMode.Sync;
+        resultMode: SqlQueryMode.One_Row_Many_Column_NotSure | SqlQueryMode.One_Row_One_Column_NotSure;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isPage?: boolean;
+        defValue?: L | null;
+        multiple?: boolean;
+        errorMsg?: 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`: 永远不需要传入该值
+ 
+      */
+    excute<L = T>(option: MethodOption & {
+        sync?: SqlSyncMode.Async;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+    }): Promise<number>;
+    excute<L = T>(option: MethodOption & {
+        sync: SqlSyncMode.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?: SqlSyncMode.Async;
+        fn: (conn: Connection) => Promise<L>;
+    }): Promise<L | null>;
+    transaction<L = T>(option: MethodOption & {
+        sync: SqlSyncMode.Sync;
+        fn: (conn: Connection) => L;
+    }): L | null;
+    stream(option?: MethodOption): StreamQuery<T>;
+    /**
+    #创建表
+    ** `tableName` 表名称
+    ** `temp` 是否是临时表，默认true
+    ** `columns` 字符串数组，默认是当前实体类全部字段，通过`columns` 可以创建部分字段临时表
+    ** `id` 表的主键设置 4种：
+    1. `auto`: `columns`中已经在当前实体类配置的ID作为主键 `默认`
+    2. `all`: `columns`中所有字段全部当主键
+    3. `none`: 没有主键
+    4. 自定义字段名称：字符串数组
+    ** `index` 表的索引，设置方式同ID
+     */
+    private _createTable;
+}
+declare class StreamCondition<T extends object> {
+    protected _prefix: number;
+    protected _index: number;
+    protected _wheres: string[];
+    protected _andQuerys: StreamCondition<T>[];
+    protected _orQuerys: StreamCondition<T>[];
+    protected _paramKeys: Record<string, string[] | Record<string, string> | string>;
+    protected _param: Record<string, any>;
+    if_proceed: boolean;
+    if_exec: boolean;
+    constructor();
+    /** 将当前stream重置 */
+    reset(): this;
+    /** 为下次链条执行提供条件判断：非异步方法跳过，异步方法不执行并返回默认值 */
+    if(condition: boolean): this;
+    eq(key: keyof T, value: string | number, { name }?: {
+        name?: string;
+    }): this;
+    eqT(t: Partial<T>, { name }?: {
+        name?: string;
+    }): this;
+    notEq(key: keyof T, value: string | number, { name }?: {
+        name?: string;
+    }): this;
+    eqWith(key1: keyof T, key2: keyof T): this;
+    notEqWith(key1: keyof T, key2: keyof T): this;
+    regexp(key: keyof T, regexp: string, { name }?: {
+        name?: string;
+    }): this;
+    notRegexp(key: keyof T, regexp: string, { name }?: {
+        name?: string;
+    }): this;
+    /** (key1 << 8) + key2 = value */
+    shiftEq(key1: keyof T, key2: keyof T, value: number, { name }?: {
+        name?: string;
+    }): this;
+    /** (key1 << 8) + key2 <> value */
+    shiftNotEq(key1: keyof T, key2: keyof T, value: number, { name }?: {
+        name?: string;
+    }): this;
+    grate(key: keyof T, value: string | number, { name }?: {
+        name?: string;
+    }): this;
+    grateEq(key: keyof T, value: string | number, { name }?: {
+        name?: string;
+    }): this;
+    grateWith(key1: keyof T, key2: keyof T): this;
+    grateEqWith(key1: keyof T, key2: keyof T): this;
+    less(key: keyof T, value: string | number, { name }?: {
+        name?: string;
+    }): this;
+    lessEq(key: keyof T, value: string | number, { name }?: {
+        name?: string;
+    }): this;
+    lessWith(key1: keyof T, key2: keyof T): this;
+    lessEqWith(key1: keyof T, key2: keyof T): this;
+    like(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    notLike(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    leftLike(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    notLeftLike(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    rightLike(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    notRightLike(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    PreciseLike(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    notPreciseLike(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    glob(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    notGlob(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    leftGlob(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    notLeftGlob(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    rightGlob(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    notRightGlob(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    PreciseGlob(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    notPreciseGlob(key: keyof T, value: string | number, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    in(key: keyof T, value: Array<string | number>, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    notIn(key: keyof T, value: Array<string | number>, { name, force }?: {
+        name?: string;
+        force?: boolean;
+    }): this;
+    isNULL(key: keyof T): this;
+    isNotNULL(key: keyof T): this;
+    between(key: keyof T, value1: string | number, value2: string | number, { name }?: {
+        name?: string;
+    }): this;
+    notBetween(key: keyof T, value1: string | number, value2: string | number, { name }?: {
+        name?: string;
+    }): this;
+    pow(key: keyof T, value: number, { name }?: {
+        name?: string;
+    }): this;
+    notPow(key: keyof T, value: number, { name }?: {
+        name?: string;
+    }): this;
+    powWith(key: keyof T, values: Array<number | string>, { name }?: {
+        name?: string;
+    }): this;
+    notPowWith(key: keyof T, values: Array<number | string>, { name }?: {
+        name?: string;
+    }): this;
+    /** MATCH(key1, key2, key3) AGAINST (value) */
+    match(value: string, keys: (keyof T)[], { name }?: {
+        name?: string;
+    }): this;
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) */
+    notMatch(value: string, keys: (keyof T)[], { name }?: {
+        name?: string;
+    }): this;
+    /** MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE*/
+    matchBoolean(value: string, keys: (keyof T)[], { name }?: {
+        name?: string;
+    }): this;
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE */
+    notMatchBoolean(value: string, keys: (keyof T)[], { name }?: {
+        name?: string;
+    }): this;
+    /** MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
+    matchQuery(value: string, keys: (keyof T)[], { name }?: {
+        name?: string;
+    }): this;
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
+    notMatchQuery(value: string, keys: (keyof T)[], { name }?: {
+        name?: string;
+    }): this;
+    includes(key: keyof T, value: string | number, { name }?: {
+        name?: string;
+    }): this;
+    notIncludes(key: keyof T, value: string | number, { name }?: {
+        name?: string;
+    }): this;
+    and(fn: (stream: StreamCondition<T>) => boolean | void): this;
+    or(fn: (stream: StreamCondition<T>) => boolean | void): this;
+    protected where(): {
+        where: string;
+        params: Record<string, any>;
+    };
+    private _;
+    private _null;
+    private _key;
+    private _between;
+    private _in;
+    private _shift;
+    private _match;
+    private _pow;
+    private _like;
+    private _includes;
+}
+declare class StreamBuild<T extends object> extends StreamCondition<T> {
+    protected _table: string;
+    protected _distinct: boolean;
+    protected _columns: string[];
+    protected _updates?: Partial<T>;
+    protected _updateColumns: string[];
+    protected _groups: (keyof T)[];
+    protected _orders: string[];
+    protected _startRow: number;
+    protected _pageSize: number;
+    constructor(table: string);
+    /** 将当前stream重置 */
+    reset(): this;
+    groupBy(key: keyof T): this;
+    asc(...keys: (keyof T)[]): this;
+    desc(...keys: (keyof T)[]): this;
+    limit(startRow: number, pageSize: number): this;
+    page(pageNumber: number, pageSize: number): this;
+    table(_table: string): this;
+    distinct(on?: boolean): this;
+    count(key: keyof T, countName?: string, distinct?: boolean): 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;
+    groupConcat(key: keyof T, param?: {
+        distinct?: boolean;
+        separator?: string;
+        asc?: (keyof T)[];
+        desc?: (keyof T)[];
+        groupName?: string;
+    }): this;
+    selectColumn(...key: (keyof T)[]): this;
+    updateColumn(key: keyof T, value: T[keyof T]): this;
+    updateT(t: Partial<T>): this;
+    replace(key: keyof T, valueToFind: T[keyof T], valueToReplace: T[keyof T]): this;
+}
+declare class StreamQuery<T extends object> extends StreamBuild<T> {
+    private _service;
+    constructor(table: string, service: SqlService<T>);
+    select<L = T>(option: {
+        sync?: SqlSyncMode.Async;
+        resultMode: SqlQueryMode.Many_Row_Many_Column | SqlQueryMode.Many_Row_One_Column;
+    }): Promise<L[]>;
+    select<L = T>(option: {
+        sync?: SqlSyncMode.Async;
+        resultMode: SqlQueryMode.One_Row_Many_Column_Assert | SqlQueryMode.One_Row_One_Column_Assert;
+        errorMsg?: string;
+    }): Promise<L>;
+    select<L = T>(option: {
+        sync?: SqlSyncMode.Async;
+        resultMode: SqlQueryMode.One_Row_Many_Column_NotSure | SqlQueryMode.One_Row_One_Column_NotSure;
+    }): Promise<L | null>;
+    select<L = T>(option: {
+        sync: SqlSyncMode.Sync;
+        resultMode: SqlQueryMode.Many_Row_Many_Column | SqlQueryMode.Many_Row_One_Column;
+    }): L[];
+    select<L = T>(option: {
+        sync: SqlSyncMode.Sync;
+        resultMode: SqlQueryMode.One_Row_Many_Column_Assert | SqlQueryMode.One_Row_One_Column_Assert;
+        errorMsg?: string;
+    }): L;
+    select<L = T>(option: {
+        sync: SqlSyncMode.Sync;
+        resultMode: SqlQueryMode.One_Row_Many_Column_NotSure | SqlQueryMode.One_Row_One_Column_NotSure;
+    }): L | null;
+    update(option: {
+        sync?: SqlSyncMode.Async;
+    }): Promise<number>;
+    update(option: {
+        sync: SqlSyncMode.Sync;
+    }): number;
+    delete(option: {
+        sync?: SqlSyncMode.Async;
+    }): Promise<number>;
+    delete(option: {
+        sync: SqlSyncMode.Sync;
+    }): number;
+}
+/**
+ 获取REDIS客户端，
+ # [查看库的API](https://github.com/redis/ioredis?tab=readme-ov-file)
+ # [REDIS API](http://doc.redisfans.com/)
+ REDIS 的API 可以直接用，将方法名转为小写
+ */
+export declare function getRedisDB(db?: string): any;
+/**
+ redlock
+ */
+export declare function GetRedisLock(key: string, lockMaxActive?: number): Promise<boolean>;
+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<any>;
+/** 与缓存共用时，需要在缓存之前:有缓存则返回缓存,否则加锁执行并缓存,后续队列全部返回缓存,跳过执行 */
+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>;
+export declare function excuteWithCache<T>(config: {
+    /** 返回缓存key,参数=方法的参数+当前用户对象，可以用来清空缓存。 */
+    key: string;
+    /** 返回缓存清除key,参数=方法的参数+当前用户对象，可以用来批量清空缓存 */
+    clearKey?: string[];
+    /** 自动清空缓存的时间，单位分钟 */
+    autoClearTime?: number;
+    /** 随着当前用户sesion的清空而一起清空 */
+    clearWithSession?: boolean;
+}, fn: () => Promise<T>): Promise<any>;
+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 declare const LetsGo: (options: GlobalSqlOption) => Promise<void>;
+export {};