websocketer-cluster/dist/index.d.ts

Cluster manager using WebSocket PubSub

import EventEmitter from 'eventemitter3';
import { RequestData, Cluster, Client as Client$1, Options } from 'websocketer';

interface RedisClusterClientOptions {
    host?: string;
    username?: string;
    password?: string;
    client?: any;
    id?: string;
    timeout?: number;
    debug?: boolean;
}
declare class RedisClusterClient extends EventEmitter {
    private _options;
    private _channel;
    private _publisher?;
    private _subscriber?;
    private _id;
    constructor(options?: RedisClusterClientOptions);
    get options(): RedisClusterClientOptions;
    get id(): string;
    get channel(): string;
    get client(): any;
    get subscriber(): any;
    get redisOptions(): any;
    destroy(): void;
    setId(id: string): void;
    clients(): Promise<Record<string, any>[]>;
    clientIds(): Promise<string[]>;
    sendRequest(request: RequestData): void;
}

interface RedisClusterOptions {
    host?: string;
    username?: string;
    password?: string;
    id?: string;
    client?: any;
    timeout?: number;
    debug?: boolean;
}
declare class RedisCluster extends EventEmitter implements Cluster {
    private _clusterClient;
    private _clients;
    private _timeout;
    /** <request_id, number_clusters_registered> */
    private _requests;
    constructor(options: RedisClusterOptions);
    get cluster(): RedisClusterClient;
    get socketers(): Set<Client$1<any, any, any>>;
    get clients(): Set<Client$1<any, any, any>>;
    get requests(): Map<string, {
        clients: Set<string>;
        timeout: any;
    }>;
    destroy(): void;
    register(client: Client$1): void;
    unregister(client: Client$1): void;
    handleRequest(request: RequestData<any>): Promise<void>;
    private _handleEvents;
}

declare class Client extends Client$1<any, any, RedisCluster> {
    constructor(options?: Partial<Options>);
    protected _send(data: RequestData): void;
}

export { Client, RedisCluster, RedisClusterClient };