import RedisClient, { Redis } from 'ioredis';
import { Observable } from 'rxjs';
export interface JsonObject {
    [key: string]: Json;
}
export interface JsonArray extends Array<Json> {
}
export declare type Json = JsonObject | JsonArray | string | number | boolean | null;
export declare class PublishEvent {
    readonly key: string;
    readonly value: string;
    constructor(key: string, value: string);
}
export declare class RedisEvent {
    readonly type: string;
    readonly key: string;
    constructor(type: string, key: string);
}
export interface RedisPromiseCacheOptions {
    resourceTag: string;
    ttl?: number;
}
export declare class RedisPromiseCache<R = Json> {
    protected readonly options: RedisPromiseCacheOptions;
    protected readonly clientOptions?: RedisClient.RedisOptions | undefined;
    client: Redis;
    subscriber: Redis;
    events: Observable<RedisEvent>;
    constructor(options: RedisPromiseCacheOptions, clientOptions?: RedisClient.RedisOptions | undefined);
    protected getKey(key: string): string;
    get<T extends R = R>(key: string): Promise<T | null>;
    set(key: string, value: R | Promise<R>, { timeout, ttl }?: {
        timeout?: number;
        ttl?: number;
    }): Promise<void>;
    protected _get(key: string): Promise<string | null>;
    protected _set(key: string, value: string, { ttl }: {
        ttl?: number;
    }): Promise<void>;
    del(key: string): Promise<void>;
    flush(): Promise<[Error | null, any][]>;
    keys(): Promise<string[]>;
    values(): Promise<(Json | null)[]>;
    entries(): Promise<[string, Json | null][]>;
    getResource<T extends R = R>(id: string, resolver: () => T | Promise<T>, options?: {
        noCache?: boolean;
    }): Promise<T>;
}