export interface RawChannelsWebsocketMessage {
    action: string;
    response_status: number;
    data: string;
}
export interface Options {
    maxReconnectionDelay?: number;
    minReconnectionDelay: number;
    reconnectionDelayGrowFactor: number;
    connectionTimeout?: number;
    maxRetries?: number;
    debug?: boolean;
    url?: string;
    protocols?: string | string[];
}
export interface EventListener {
    (event?: any): any;
}
export interface EventListeners {
    [key: string]: [EventListener, any][];
}
export declare class WebSocketOptions implements Options {
    debug: boolean;
    [key: string]: any;
    maxReconnectionDelay: number;
    minReconnectionDelay: number;
    reconnectionDelayGrowFactor: number;
    connectionTimeout: number;
    maxRetries: number;
    constructor(debug: boolean);
    static readonly WebSocket: {
        new (url: string, protocols?: string | string[]): WebSocket;
        prototype: WebSocket;
        readonly CLOSED: number;
        readonly CLOSING: number;
        readonly CONNECTING: number;
        readonly OPEN: number;
    };
}
export default class DemultiplexedReconnectingWebsocket {
    ws: WebSocket;
    connectingTimeout: number;
    reconnectDelay: number;
    retriesCount: number;
    shouldRetry: boolean;
    savedOnClose: any;
    listeners: EventListeners;
    config: WebSocketOptions;
    log: Function;
    streams: {
        [key: string]: Function;
    };
    default_cb: Function;
    url: string;
    protocols: string | string[];
    constructor(options: WebSocketOptions);
    readonly isOpen: boolean;
    readonly isClosed: boolean;
    readonly isClosing: boolean;
    readonly isConnecting: boolean;
    connect(url?: string, force?: boolean): void;
    createUrl(url: string): any;
    private createOrOverwriteWebSocket(url);
    /**
     * Starts listening for messages on the websocket, demultiplexing if necessary.
     *
     * @param      {Function}  [cb] Callback to be execute when a message
     * arrives. The callback will receive `action` and `stream` parameters
     *
     * @example
     * const webSocketBridge = new WebSocketBridge();
     * webSocketBridge.connect();
     * webSocketBridge.listen(function(action, stream) {
     *   console.this.log(action, stream);
     * });
     */
    listen: (cb: Function) => void;
    _onmessage(event: RawChannelsWebsocketMessage): void;
    demultiplex(stream: string, cb: Function): void;
    send(data: any): void;
    /**
     * Returns an object to send messages to a specific stream
     *
     * @param      {String}  stream  The stream name
     * @return     {Object}  convenience object to send messages to `stream`.
     * @example
     * webSocketBridge.stream('mystream').send({prop1: 'value1', prop2: 'value1'})
     */
    stream(stream: string): {
        send: (payload: object) => void;
    };
    /**
     * Not using dispatchEvent, otherwise we must use a DOM Event object
     * Deferred because we want to handle the close event before this
     */
    emitError: (code: string, msg: string) => number;
    handleClose(): void;
    readonly closeHandler: () => void;
    close(code?: number, reason?: string, {keepClosed, fastClose, delay}?: {
        keepClosed?: boolean;
        fastClose?: boolean;
        delay?: number;
    }): void;
    addEventListener(type: string, listener: EventListener, options?: any): void;
    removeEventListener(type: string, listener: EventListener, options?: any): void;
}