/// <reference types="ws" />
import WebSocket from 'isomorphic-ws';
export declare type Message = string | object;
/**
 * A template object or a matcher function.
 */
export declare type Template = any | ((msg: any) => boolean);
export declare type Listener<T = any> = (msg: T) => void;
export declare type ListenerOptions = {
    /**
     * Normally listeners are removed after close.
     * Keep listening after reconnect.
     */
    keep?: boolean;
};
interface TemplateListener {
    template: Template;
    listener: Listener;
    options: ListenerOptions;
}
export declare type WsListenerServiceConfig = {
    /**
     * Timeout for `open` and for `once`.
     */
    timeoutMs?: number;
    /**
     * Force delay between `send`s.
     */
    throttleMs?: number;
} & ({
    url: string;
} | {
    ws: WebSocket;
});
export declare class WsListenerService {
    protected ws: WebSocket;
    protected url: string;
    protected timeoutMs: number;
    protected throttleMs: number;
    protected liteners: TemplateListener[];
    protected openPromise: any;
    get isOpen(): boolean;
    constructor({ ...conf }: WsListenerServiceConfig);
    open(): Promise<void>;
    /**
     * Close connection, cleanup.
     */
    close(code?: number, reason?: string): Promise<void>;
    protected _reconnectableClose(event: any): void;
    /**
     * This method exists so that reconnect implementation can use it where reconnectableClose is needed.
     */
    protected reconnectableClose(code?: number, reason?: string): Promise<void>;
    /**
     * It is possible for an 'open' event and the first 'message's to come on the same event loop cycle (only if server and client are in the same thread?).
     * Add sleep before processing each message to avoid skipped messages.
     */
    protected _handleMessage(event: any): Promise<void>;
    send(msg: Message): Promise<void>;
    /**
     * Listen for messages that match a template.
     * Return template and listener function passed as arguments (can be used in `off` later).
     */
    on<T = any>(template: Template, listener: Listener<T>, options?: ListenerOptions): {
        template: Template;
        listener: Listener;
    };
    /**
     * Remove listener.
     */
    off<T = any>(template: Template, listener: Listener<T>): void;
    /**
     * Get a promise for one message matching a template.
     * @throws Error on timeout.
     */
    once<T = any>(template: Template, { timeoutMs, ...options }?: ListenerOptions & {
        timeoutMs?: number;
    }): Promise<T>;
}
export {};