/// <reference path="../library/typings/cross-service.d.ts" />
declare module "copyright" {
    export class FoundationDeviceServiceCopyright {
        static toString(): string;
    }
}
declare module "foundation/device/service/cache/CacheDeviceTypeEnum" {
    export class CacheDeviceTypeEnum {
        static Memcache: string;
        static Redis: string;
    }
}
declare module "foundation/device/service/cache/redis/RedisDataBlock" {
    export type RedisDataBlock = {
        tick: number;
        value: any;
    };
}
declare module "foundation/device/service/cache/redis/RedisOptions" {
    import { CacheOptions } from 'cross/service/module/cache/CacheOptions';
    export class RedisOptions extends CacheOptions {
    }
}
declare module "foundation/device/service/cache/redis/RedisUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CacheConnectionPool } from 'cross/service/module/cache/CacheConnectionPool';
    import { CacheConnectionService } from 'cross/service/module/cache/CacheConnectionService';
    import { RedisConnection } from "foundation/device/service/cache/redis/RedisConnection";
    import { RedisOptions } from "foundation/device/service/cache/redis/RedisOptions";
    export type RedisQueueData = {
        id: string;
        content: any;
    };
    export type RedlockOption = {
        retryCount: number;
        retryDelay: number;
    };
    export class RedisUtil {
        static DEFAULT_LOCK_TTL: number;
        static DATA_QUEUE_PRO_KEY: string;
        static QUEUE_DATA_INFO_PRE_KEY: string;
        static DEFAULT_QUEUE_DATA_INFO_TIMEOUT: number;
        protected static _connectionService: CacheConnectionService;
        static makeUrl(options: RedisOptions): string;
        static makeQueueKey(key: string): string;
        static makeQueueInfoKey(key: string, id: string): string;
        static getDataQueueAsync(key: string, redisConnection: RedisConnection): Promise<ResultObject>;
        static getQueueDataAsync(key: string, id: string, connection: RedisConnection): Promise<ResultObject<RedisQueueData>>;
        static delQueueDataAsync(key: string, id: string, connection: RedisConnection): Promise<ResultObject>;
        static dataQueueLpopAsync(key: string, redisConnection: RedisConnection): Promise<ResultObject<RedisQueueData>>;
        static setDataForDataQueueAsync(key: string, data: RedisQueueData, redisConnection: RedisConnection, timeout?: number): Promise<ResultObject>;
        static dataQueueRpushAsync(key: string, data: RedisQueueData | RedisQueueData[], redisConnection: RedisConnection, timeout?: number): Promise<ResultObject>;
        static getDefaultConnectionAsync(): Promise<ResultObject<RedisConnection>>;
        static freeConnection(connection: RedisConnection, pool?: CacheConnectionPool): void;
        static lockAsync(key: string, redisConnections: RedisConnection[] | any[], lockOption?: RedlockOption, ttl?: number): Promise<ResultObject<any>>;
        static processLockAsync(key: string, redisConnections: RedisConnection[], owner: any, callback: Function, callback2?: Function, lockOption?: RedlockOption, ttl?: number): Promise<ResultObject>;
    }
}
declare module "foundation/device/service/cache/redis/RedisConnection" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { CacheConnection } from 'cross/service/module/cache/CacheConnection';
    import { CacheResult } from 'cross/service/module/cache/CacheResult';
    import { RedisOptions } from "foundation/device/service/cache/redis/RedisOptions";
    export class RedisConnection extends CacheConnection {
        options: RedisOptions;
        protected _client: any;
        protected _redlock: any;
        protected _environmentService: EnvironmentService;
        constructor();
        get client(): any;
        errorHandle: (error: any) => void;
        connectHandle: (error: any) => void;
        readyHandle: (error: any) => void;
        setupAsync(): Promise<ResultObject>;
        getAsync(key: string, timeout?: number): Promise<CacheResult>;
        setAsync(key: string, value: any, timeout?: number): Promise<CacheResult>;
        rpopAsync(key: string, timeout?: number): Promise<CacheResult>;
        lpopAsync(key: string, timeout?: number): Promise<CacheResult>;
        lremAsync(key: string, count: number, value: string, timeout?: number): Promise<CacheResult>;
        keysAsync(pattern?: string): Promise<CacheResult>;
        lpushAsync(key: string, value: string | string[]): Promise<CacheResult>;
        rpushAsync(key: string, value: string | string[]): Promise<CacheResult>;
        delAsync(keys: string | string[]): Promise<CacheResult>;
        flushdbAsync(): Promise<CacheResult>;
        flushAllAsync(): Promise<CacheResult>;
        free(): void;
        shutdown(): void;
        disconnectAsync(): Promise<CacheResult>;
    }
}
declare module "foundation/device/service/cache/redis/RedisConnectionPool" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ObjectPool } from 'cross/runtime/lang/ObjectPool';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CacheConnectionPool } from 'cross/service/module/cache/CacheConnectionPool';
    import { RedisConnection } from "foundation/device/service/cache/redis/RedisConnection";
    import { RedisOptions } from "foundation/device/service/cache/redis/RedisOptions";
    export class RedisConnectionPool extends CacheConnectionPool {
        protected _options: RedisOptions;
        protected _pool: ObjectPool<RedisConnection>;
        protected _connections: Types<RedisConnection>;
        constructor();
        get pool(): ObjectPool<RedisConnection>;
        loadConfig(jconfig: any): void;
        allocAsync(): Promise<ResultObject<RedisConnection>>;
        free(connection: RedisConnection): void;
        shutdownAsync(): Promise<ResultObject>;
        testAsync(): Promise<ResultObject>;
    }
}
declare module "foundation/device/service/cache/redis/RedisCacheDevice" {
    import { CacheDevice } from 'cross/core/device/cache/CacheDevice';
    import { ICachePool } from 'cross/core/device/cache/ICachePool';
    import { CacheOptions } from 'cross/service/module/cache/CacheOptions';
    export class RedisCacheDevice extends CacheDevice {
        makeUrl(options: CacheOptions): string;
        createConnection(): any;
        createPool(): ICachePool;
    }
}
declare module "foundation/device/service/cache/redis/RedisCacheDeviceProvider" {
    import { DeviceProvider } from 'cross/runtime/module/device/DeviceProvider';
    import { RedisCacheDevice } from "foundation/device/service/cache/redis/RedisCacheDevice";
    export class RedisCacheDeviceProvider extends DeviceProvider {
        create(parameters?: any): RedisCacheDevice;
    }
}
declare module "foundation/device/service/cache/redis/RedisLock" {
    import { CacheLock } from 'cross/service/module/cache/CacheLock';
    import { CacheResult } from 'cross/service/module/cache/CacheResult';
    import { RedisConnection } from "foundation/device/service/cache/redis/RedisConnection";
    export class RedisLock extends CacheLock {
        protected _key: string;
        protected _connections: RedisConnection[];
        protected _timeout: number;
        protected _handle: any;
        protected _locker: any;
        constructor(key: string, connections: RedisConnection[], timeout?: number);
        lockAsync(timeout?: number): Promise<CacheResult>;
        unlockAsync(): Promise<CacheResult>;
        processAsync(owner: any, callback: any, parameters?: Array<any>): Promise<CacheResult>;
        dispose(): void;
    }
}
declare module "foundation/device/service/cache/redis/RedisQueueData" {
    export type RedisQueueData = {
        id: string;
        content: any;
    };
}
declare module "foundation/device/service/cache/redis/RedisQueue" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CacheQueue } from 'cross/service/module/cache/CacheQueue';
    import { RedisConnection } from "foundation/device/service/cache/redis/RedisConnection";
    import { RedisQueueData } from "foundation/device/service/cache/redis/RedisQueueData";
    export class RedisQueue extends CacheQueue {
        queueKey: string;
        protected _connection: RedisConnection;
        constructor(connection: RedisConnection);
        deleteDataAsync(host: string, id: string): Promise<ResultObject<RedisQueueData>>;
        getDataAsync(host: string, id: string): Promise<ResultObject<RedisQueueData>>;
        delDataAsync(host: string, id: string): Promise<ResultObject<RedisQueueData>>;
        pushAsync(host: string, data: RedisQueueData | RedisQueueData[], timeout?: number): Promise<ResultObject>;
        popAsync(host?: string): Promise<ResultObject<RedisQueueData>>;
    }
}
declare module "foundation/device/service/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "foundation/device/service/lock/RedisGlobalLockDevice" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { GlobalLockDevice, GlobalLockOption } from 'cross/system/device/lock/GlobalLockDevice';
    import { GlobalLockOptions } from 'cross/system/device/lock/GlobalLockOptions';
    import { CacheConnection } from 'cross/service/module/cache/CacheConnection';
    import { RedisOptions } from "foundation/device/service/cache/redis/RedisOptions";
    import { RedlockOption } from "foundation/device/service/cache/redis/RedisUtil";
    export class RedisGlobalLockDevice extends GlobalLockDevice {
        protected options: RedisOptions;
        protected _environmentService: EnvironmentService;
        constructor();
        loadConfig(jconfig: any): void;
        getLockAsync(key: string, connections: any[], lockOption?: RedlockOption, ttl?: number): Promise<ResultObject<any>>;
        lockAsync(key: string, owner: any, callback: Function, options?: GlobalLockOptions): Promise<ResultObject>;
        innerDefaultConnectionAsync(): Promise<ResultObject<CacheConnection>>;
        innerLockAsync(key: string, redisConnections: CacheConnection[] | any[], lockOption?: GlobalLockOption, ttl?: number): Promise<ResultObject<any>>;
    }
}
declare module "foundation/device/service/lock/RedisGlobalLockDeviceProvider" {
    import { DeviceProvider } from 'cross/runtime/module/device/DeviceProvider';
    import { RedisGlobalLockDevice } from "foundation/device/service/lock/RedisGlobalLockDevice";
    export class RedisGlobalLockDeviceProvider extends DeviceProvider {
        create(parameters?: any): RedisGlobalLockDevice;
    }
}
declare module "foundation/device/service/lock/RedisGlobalLockService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { RedisOptions } from "foundation/device/service/cache/redis/RedisOptions";
    import { RedlockOption } from "foundation/device/service/cache/redis/RedisUtil";
    export class RedisGlobalLockService extends Service {
        protected options: RedisOptions;
        protected _environmentService: EnvironmentService;
        constructor();
        initializeConfig(jconfig: any): void;
        lockAsync(key: string, connections: any[], lockOption?: RedlockOption, ttl?: number): Promise<ResultObject<any>>;
        processLockAsync(key: string, owner: any, callback: Function, callback2?: Function, lockOption?: RedlockOption, ttl?: number): Promise<ResultObject>;
    }
}