/*!
* @Author: richen
* @Date: 2026-04-24 16:20:23
* @License: BSD (3-Clause)
* @Copyright (c) - <richenlin(at)gmail.com>
* @HomePage: https://koatty.org/
*/
import { Cluster } from 'ioredis';
import { ClusterOptions } from 'ioredis';
import { default as default_2 } from 'ioredis';
import { EventEmitter } from 'events';
import genericPool from 'generic-pool';
import { Redis } from 'ioredis';
import { RedisOptions } from 'ioredis';

/**
 *
 *
 * @export
 * @class Store
 */
export declare class CacheStore implements CacheStoreInterface {
    client: MemoryStore | RedisStore;
    options: StoreOptions;
    /**
     * Creates an instance of CacheStore.
     * @param {StoreOptions} options
     * @memberof CacheStore
     */
    constructor(options?: StoreOptions);
    /**
     * 获取单例实例，支持多配置实例管理
     * @static
     * @param {StoreOptions} [options]
     * @param {string} [instanceKey='default'] 实例键名，用于区分不同配置的实例
     * @returns {CacheStore}
     */
    static getInstance(options?: StoreOptions, instanceKey?: string): CacheStore;
    /**
     * 生成配置哈希
     * @private
     * @static
     * @param {StoreOptions} options
     * @returns {string}
     */
    /**
     * 清理指定实例
     * @static
     * @param {string} [instanceKey='default']
     */
    static clearInstance(instanceKey?: string): Promise<void>;
    /**
     * 清理所有实例
     * @static
     */
    static clearAllInstances(): Promise<void>;
    getConnection(): Promise<default_2 | Cluster> | MemoryCache;
    close(): Promise<void>;
    release(conn: any): Promise<void>;
    /**
     * 获取底层实现客户端，用于访问特定实现的功能
     * 例如：Redis的defineCommand, getCompare等
     * @returns {MemoryStore | RedisStore}
     */
    getRawClient(): MemoryStore | RedisStore;
    /**
     * handler for native client
     *
     * @param {string} name
     * @param {any[]} data
     * @returns {*}
     * @memberof RedisStore
     */
    /**
     * 字符串获取
     * @param name
     */
    get(name: string): Promise<string | null>;
    /**
     * 字符串写入
     * @param name
     * @param value
     * @param timeout
     * @returns {Promise}
     */
    set(name: string, value: string | number, timeout?: number): Promise<string>;
    /**
     * 以秒为单位，返回给定 key 的剩余生存时间
     * @param name
     * @returns {*}
     */
    ttl(name: string): Promise<number>;
    /**
     * 设置key超时属性
     * @param name
     * @param timeout
     */
    expire(name: string, timeout: number): Promise<number>;
    /**
     *
     *
     * @param {*} name
     * @returns
     */
    del(name: string): Promise<number>;
    /**
     * 判断key是否存在
     * @param name
     */
    exists(name: string): Promise<number>;
    /**
     * 自增
     * @param name
     */
    incr(name: string): Promise<number>;
    /**
     * 自减
     * @param name
     * @returns {*}
     */
    decr(name: string): Promise<number>;
    /**
     * 将 key 所储存的值增加增量
     * @param name
     * @param incr
     * @returns {*}
     */
    incrby(name: string, increment: number): Promise<number>;
    /**
     * 将 key 所储存的值减去减量
     *
     * @param {any} name
     * @param {any} decr
     */
    decrby(name: string, decrement: number): Promise<number>;
    /**
     * 哈希写入
     * @param name
     * @param key
     * @param value
     * @param timeout
     */
    hset(name: string, key: string, value: string | number, timeout?: number): Promise<number>;
    /**
     * 哈希获取
     * @param name
     * @param key
     * @returns {*}
     */
    hget(name: string, key: string): Promise<string | null>;
    /**
     * 查看哈希表 hashKey 中，给定域 key 是否存在
     * @param name
     * @param key
     * @returns {*}
     */
    hexists(name: string, key: string): Promise<number>;
    /**
     * 哈希删除
     * @param name
     * @param key
     * @returns {*}
     */
    hdel(name: string, key: string): Promise<number>;
    /**
     * 返回哈希表 key 中域的数量
     * @param name
     * @returns {*}
     */
    hlen(name: string): Promise<number>;
    /**
     * 给哈希表指定key，增加increment
     * @param name
     * @param key
     * @param increment
     * @returns {*}
     */
    hincrby(name: string, key: string, increment: number): Promise<number>;
    /**
     * 返回哈希表所有key-value
     * @param name
     * @returns {*}
     */
    hgetall(name: string): Promise<any>;
    /**
     * 返回哈希表所有key
     * @param name
     * @returns {*}
     */
    hkeys(name: string): Promise<string[]>;
    /**
     * 返回哈希表所有value
     * @param name
     * @returns {*}
     */
    hvals(name: string): Promise<any[]>;
    /**
     * 判断列表长度，若不存在则表示为空
     * @param name
     * @returns {*}
     */
    llen(name: string): Promise<number>;
    /**
     * 将值插入列表表尾
     * @param name
     * @param value
     * @returns {*}
     */
    rpush(name: string, value: string | number): Promise<number>;
    /**
     *
     *
     * @param {string} name
     * @param {(string | number)} value
     * @returns {*}
     * @memberof RedisStore
     */
    lpush(name: string, value: string | number): Promise<number>;
    /**
     * 将列表表头取出，并去除
     * @param name
     * @returns {*}
     */
    lpop(name: string): Promise<string | null>;
    /**
     *
     *
     * @param {string} name
     * @returns {*}
     * @memberof RedisStore
     */
    rpop(name: string): Promise<string | null>;
    /**
     * 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定
     * @param name
     * @param start
     * @param stop
     * @returns {*}
     */
    lrange(name: string, start: number, stop: number): Promise<any[]>;
    /**
     * 集合新增
     * @param name
     * @param value
     * @param timeout
     * @returns {*}
     */
    sadd(name: string, value: string | number, timeout?: number): Promise<number>;
    /**
     * 返回集合的基数(集合中元素的数量)
     * @param name
     * @returns {*}
     */
    scard(name: string): Promise<number>;
    /**
     * 判断 member 元素是否集合的成员
     * @param name
     * @param key
     * @returns {*}
     */
    sismember(name: string, key: string): Promise<number>;
    /**
     * 返回集合中的所有成员
     * @param name
     * @returns {*}
     */
    smembers(name: string): Promise<any[]>;
    /**
     * 移除并返回集合中的一个随机元素
     * @param name
     * @returns {*}
     */
    spop(name: string): Promise<any>;
    /**
     * 移除集合 key 中的一个 member 元素
     * @param name
     * @param key
     * @returns {*}
     */
    srem(name: string, key: string): Promise<number>;
    /**
     * 将 member 元素从 source 集合移动到 destination 集合
     * @param source
     * @param destination
     * @param member
     * @returns {*}
     */
    smove(source: string, destination: string, member: string): Promise<number>;
    /**
     * Begin a transaction
     * Note: Only supported by RedisStore, will throw error for MemoryStore
     * @returns {Promise<void>}
     */
    beginTransaction(): Promise<void>;
    /**
     * Commit a transaction
     * Note: Only supported by RedisStore, will throw error for MemoryStore
     * @returns {Promise<void>}
     */
    commit(): Promise<void>;
    /**
     * Rollback a transaction
     * Note: Only supported by RedisStore, will throw error for MemoryStore
     * @returns {Promise<void>}
     */
    rollback(): Promise<void>;
}

declare interface CacheStoreInterface {
    getConnection(): any;
    close(): Promise<void>;
    release(conn: any): Promise<void>;
    get(name: string): Promise<string | null>;
    set(name: string, value: string | number, timeout?: number): Promise<string>;
    del(name: string): Promise<number>;
    exists(name: string): Promise<number>;
    ttl(name: string): Promise<number>;
    expire(name: string, timeout: number): Promise<number>;
    incr(name: string): Promise<number>;
    decr(name: string): Promise<number>;
    incrby(name: string, increment: number): Promise<number>;
    decrby(name: string, decrement: number): Promise<number>;
    hset(name: string, key: string, value: string | number, timeout?: number): Promise<number>;
    hget(name: string, key: string): Promise<string | null>;
    hdel(name: string, key: string): Promise<number>;
    hexists(name: string, key: string): Promise<number>;
    hgetall(name: string): Promise<any>;
    hkeys(name: string): Promise<string[]>;
    hvals(name: string): Promise<any[]>;
    hlen(name: string): Promise<number>;
    hincrby(name: string, key: string, increment: number): Promise<number>;
    lpush(name: string, value: string | number): Promise<number>;
    rpush(name: string, value: string | number): Promise<number>;
    lpop(name: string): Promise<string | null>;
    rpop(name: string): Promise<string | null>;
    llen(name: string): Promise<number>;
    lrange(name: string, start: number, stop: number): Promise<any[]>;
    sadd(name: string, value: string | number, timeout?: number): Promise<number>;
    srem(name: string, key: string): Promise<number>;
    scard(name: string): Promise<number>;
    sismember(name: string, key: string): Promise<number>;
    smembers(name: string): Promise<any[]>;
    spop(name: string): Promise<any>;
    smove(source: string, destination: string, member: string): Promise<number>;
}

declare type CallbackFunction<T = any> = (err: Error | null, result?: T) => void;

declare class MemoryCache extends EventEmitter {
    options: MemoryCacheOptions;
    currentDBIndex: number;
    connected: boolean;
    lastSave: number;
    multiMode: boolean;
    /**
     * Creates an instance of MemoryCache.
     * @param {MemoryCacheOptions} options
     * @memberof MemoryCache
     */
    constructor(options: MemoryCacheOptions);
    /**
     * 创建LRU缓存实例
     */
    /**
     * 启动TTL检查定时器
     */
    /**
     * 清理过期键
     */
    /**
     * 停止TTL检查
     */
    /**
     * 清理所有资源
     * @private
     */
    /**
     *
     *
     * @returns {*}
     * @memberof MemoryCache
     */
    createClient(): this;
    /**
     *
     *
     * @returns {*}
     * @memberof MemoryCache
     */
    quit(): this;
    /**
     *
     *
     * @returns {*}
     * @memberof MemoryCache
     */
    end(): this;
    /**
     * 获取缓存统计信息
     */
    info(): any;
    /**
     * 估算内存使用量
     */
    /**
     *
     *
     * @param {string} message
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    echo(message: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} message
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    ping(message: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} password
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    auth(password: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {number} dbIndex
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    select(dbIndex: number, callback?: CallbackFunction): any;
    get(key: string, callback?: CallbackFunction): any;
    /**
     * set(key, value, ttl, pttl, notexist, onlyexist, callback)
     *
     * @param {string} key
     * @param {(string | number)} value
     * @param {...any[]} params
     * @returns {*}
     * @memberof MemoryCache
     */
    set(key: string, value: string | number, ...params: any[]): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    ttl(key: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {number} seconds
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    expire(key: string, seconds: number, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {...any[]} keys
     * @returns {*}
     * @memberof MemoryCache
     */
    del(...keys: any[]): any;
    /**
     *
     *
     * @param {...any[]} keys
     * @returns {*}
     * @memberof MemoryCache
     */
    exists(...keys: any[]): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    incr(key: string, callback?: CallbackFunction): Promise<any>;
    /**
     *
     *
     * @param {string} key
     * @param {number} amount
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    incrby(key: string, amount: number, callback?: CallbackFunction): Promise<any>;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    decr(key: string, callback?: CallbackFunction): Promise<any>;
    /**
     *
     *
     * @param {string} key
     * @param {number} amount
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    decrby(key: string, amount: number, callback?: CallbackFunction): Promise<any>;
    hset(key: string, field: string, value: string | number, timeout?: number, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {string} field
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    hget(key: string, field: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {string} field
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    hexists(key: string, field: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {...any[]} fields
     * @returns {*}
     * @memberof MemoryCache
     */
    hdel(key: string, ...fields: any[]): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    hlen(key: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {string} field
     * @param {*} value
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    hincrby(key: string, field: string, value: any, callback?: CallbackFunction): Promise<any>;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    hgetall(key: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    hkeys(key: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    hvals(key: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    llen(key: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {(string | number)} value
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    rpush(key: string, value: string | number, callback?: CallbackFunction): any;
    /**
     * List：从左侧推入
     * @param key
     * @param value
     * @param callback
     */
    lpush(key: string, value: any, callback?: CallbackFunction): any;
    /**
     * List：获取指定索引的元素
     * @param key
     * @param index
     * @param callback
     */
    lindex(key: string, index: number, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    lpop(key: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    rpop(key: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {number} start
     * @param {number} stop
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    lrange(key: string, start: number, stop: number, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {...any[]} members
     * @returns {*}
     * @memberof MemoryCache
     */
    sadd(key: string, ...members: string[]): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    scard(key: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {string} member
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    sismember(key: string, member: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    smembers(key: string, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {number} [count]
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    spop(key: string, count?: number, callback?: CallbackFunction): any;
    /**
     *
     *
     * @param {string} key
     * @param {...any[]} members
     * @returns {*}
     * @memberof MemoryCache
     */
    srem(key: string, ...members: any[]): any;
    /**
     *
     *
     * @param {string} sourcekey
     * @param {string} destkey
     * @param {string} member
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    smove(sourcekey: string, destkey: string, member: string, callback?: CallbackFunction): any;
    discard(callback?: CallbackFunction, silent?: boolean): any;
    /**
     *
     *
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {string} key
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {string} key
     * @returns {*}  {boolean}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {*} value
     * @param {string} type
     * @param {number} timeout
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {string} key
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {string} key
     * @param {number} amount
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {string} key
     * @param {string} type
     * @param {boolean} [throwError]
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {string} key
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {string} key
     * @param {(number | string)} value
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {string} key
     * @param {string} field
     * @param {number} [amount]
     * @param {boolean} [useFloat]
     * @param {Function} [callback]
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {string} key
     * @param {string} field
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {string} key
     * @param {string} field
     * @returns {*}  {boolean}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @param {string} key
     * @param {string} field
     * @param {*} value
     * @memberof MemoryCache
     */
    _setField(key: string, field: string, value: any): void;
    /**
     *
     *
     * @private
     * @param {Function} [callback]
     * @param {(any)} [message]
     * @param {*} [error]
     * @param {boolean} [nolog]
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     *
     *
     * @private
     * @param {any[]} [params]
     * @returns {*}
     * @memberof MemoryCache
     */
    /**
     * 字符串追加操作
     * @param key
     * @param value
     * @param callback
     */
    append(key: string, value: string, callback?: CallbackFunction): any;
    /**
     * 获取字符串长度
     * @param key
     * @param callback
     */
    strlen(key: string, callback?: CallbackFunction): any;
    /**
     * 获取子字符串
     * @param key
     * @param start
     * @param end
     * @param callback
     */
    getrange(key: string, start: number, end: number, callback?: CallbackFunction): any;
    /**
     * 设置子字符串
     * @param key
     * @param offset
     * @param value
     * @param callback
     */
    setrange(key: string, offset: number, value: string, callback?: CallbackFunction): any;
    /**
     * 批量获取
     * @param keys
     * @param callback
     */
    mget(...keys: any[]): any;
    /**
     * 批量设置
     * @param keyValuePairs
     * @param callback
     */
    mset(...keyValuePairs: any[]): any;
    /**
     * 获取所有键
     * @param pattern
     * @param callback
     */
    keys(pattern?: string, callback?: CallbackFunction): any;
    /**
     * 简单的模式匹配
     * @param key
     * @param pattern
     */
    /**
     * 获取随机键
     * @param callback
     */
    randomkey(callback?: CallbackFunction): any;
    /**
     * 重命名键
     * @param oldKey
     * @param newKey
     * @param callback
     */
    rename(oldKey: string, newKey: string, callback?: CallbackFunction): any;
    /**
     * 安全重命名键（目标键不存在时才重命名）
     * @param oldKey
     * @param newKey
     * @param callback
     */
    renamenx(oldKey: string, newKey: string, callback?: CallbackFunction): any;
    /**
     * 获取键的类型
     * @param key
     * @param callback
     */
    type(key: string, callback?: CallbackFunction): any;
    /**
     * 清空当前数据库
     * @param callback
     */
    flushdb(callback?: CallbackFunction): any;
    /**
     * 清空所有数据库
     * @param callback
     */
    flushall(callback?: CallbackFunction): any;
    /**
     * 获取数据库大小
     * @param callback
     */
    dbsize(callback?: CallbackFunction): any;
    /**
     * Sorted Set基础实现 - 添加成员
     * @param key
     * @param score
     * @param member
     * @param callback
     */
    zadd(key: string, score: number, member: string, callback?: CallbackFunction): any;
    /**
     * Sorted Set - 获取成员分数
     * @param key
     * @param member
     * @param callback
     */
    zscore(key: string, member: string, callback?: CallbackFunction): any;
    /**
     * Sorted Set - 获取范围内的成员
     * @param key
     * @param start
     * @param stop
     * @param callback
     */
    zrange(key: string, start: number, stop: number, callback?: CallbackFunction): any;
    /**
     * Sorted Set - 获取成员数量
     * @param key
     * @param callback
     */
    zcard(key: string, callback?: CallbackFunction): any;
    /**
     * Sorted Set - 删除成员
     * @param key
     * @param member
     * @param callback
     */
    zrem(key: string, member: string, callback?: CallbackFunction): any;
}

/**
 *
 *
 * @interface MemoryCacheOptions
 */
declare interface MemoryCacheOptions {
    database: number;
    maxKeys?: number;
    maxMemory?: number;
    evictionPolicy?: 'lru' | 'lfu' | 'random';
    ttlCheckInterval?: number;
    maxAge?: number;
}

declare class MemoryStore {
    client: MemoryCache;
    options: MemoryStoreOpt;
    /**
     * Creates an instance of MemoryStore.
     * @param {MemoryStoreOpt} options
     * @memberof MemoryStore
     */
    constructor(options: MemoryStoreOpt);
    /**
     * getConnection
     *
     * @returns {*}
     * @memberof MemoryStore
     */
    getConnection(): MemoryCache;
    /**
     * close
     *
     * @returns {*}  {Promise<void>}
     * @memberof MemoryStore
     */
    close(): Promise<void>;
    /**
     * release
     *
     * @param {*} _conn
     * @returns {*}  {Promise<void>}
     * @memberof MemoryStore
     */
    release(_conn: any): Promise<void>;
    /**
     * defineCommand
     *
     * @param {string} _name
     * @param {*} _scripts
     * @memberof MemoryStore
     */
    defineCommand(_name: string, _scripts: any): Promise<void>;
    /**
     * get and compare value
     *
     * @param {string} name
     * @param {(string | number)} value
     * @returns {*}  {Promise<any>}
     * @memberof MemoryStore
     */
    getCompare(name: string, value: string | number): Promise<any>;
    /**
     * 获取缓存统计信息
     */
    getStats(): any;
    /**
     * Begin a transaction (not supported by MemoryStore)
     * @throws {Error} Transactions are not supported by MemoryStore
     */
    beginTransaction(): Promise<void>;
    /**
     * Commit a transaction (not supported by MemoryStore)
     * @throws {Error} Transactions are not supported by MemoryStore
     */
    commit(): Promise<void>;
    /**
     * Rollback a transaction (not supported by MemoryStore)
     * @throws {Error} Transactions are not supported by MemoryStore
     */
    rollback(): Promise<void>;
}

declare interface MemoryStoreOpt {
    type: string;
    keyPrefix?: string;
    db?: number;
    timeout?: number;
    maxKeys?: number;
    maxMemory?: number;
    evictionPolicy?: 'lru' | 'lfu' | 'random';
    ttlCheckInterval?: number;
}

/**
 *
 *
 * @export
 * @class RedisStore
 */
declare class RedisStore {
    options: RedisStoreOpt;
    pool: genericPool.Pool<Redis | Cluster>;
    client: Redis | Cluster;
    /**
     * Creates an instance of RedisStore.
     * @param {RedisStoreOpt} options
     * @memberof RedisStore
     */
    constructor(options: RedisStoreOpt);
    /**
     * create connection by native with improved error handling
     *
     * @param {number} [connNum=0]
     * @returns {*}  {Promise<Redis | Cluster>}
     * @memberof RedisStore
     */
    /**
     * 计划重连，使用指数退避策略
     * @private
     * @param {number} connNum
     */
    /**
     * get connection from pool with improved configuration
     *
     * @returns {*}
     * @memberof RedisStore
     */
    getConnection(): Promise<Redis | Cluster>;
    /**
     * close connection with proper cleanup
     *
     * @returns {*}
     * @memberof RedisStore
     */
    close(): Promise<void>;
    /**
     *
     *
     * @param {*} conn
     * @returns {*}
     * @memberof RedisStore
     */
    release(conn: any): Promise<void>;
    /**
     * defineCommand
     *
     * @param {string} name
     * @param {{ numberOfKeys?: number; lua?: string; }} scripts
     * @returns {*}
     * @memberof RedisStore
     */
    defineCommand(name: string, scripts: {
        numberOfKeys?: number;
        lua?: string;
    }): Promise<any>;
    /**
     * get and compare value
     *
     * @param {string} name
     * @param {(string | number)} value
     * @returns {*}  {Promise<any>}
     * @memberof RedisStore
     */
    getCompare(name: string, value: string | number): Promise<any>;
}

/**
 * @description:
 * @return {*}
 */
declare interface RedisStoreOpt extends RedisOptions, ClusterOptions {
    type: string;
    timeout?: number;
    poolSize?: number;
    clusters?: Array<{
        host: string;
        port: number;
    }>;
}

export declare type StoreOptions = MemoryStoreOpt | RedisStoreOpt;

export { }