import { TopicResponse, TopicServerEventRequest, TopicType } from './WebSocketManager';
import { Observable } from '@dooboostore/core';
export * from '@dooboostore/core';
type TopicObserverNextCallBack<T> = <R = any>(data: T, meta: {
    socket: WebSocket;
}) => void;
type TopicObserverEventCallBack = {
    [event: string]: <T, R = any>(data: T, meta: {
        socket: WebSocket;
    }) => Promise<R> | void | any;
} | (<T, R = any>(event: string, data: T, meta: {
    socket: WebSocket;
}) => Promise<R> | void | any);
type TopicObserverErrorCallBack = <R = any>(err: any) => void;
export type TopicObserverCallBack<T> = {
    next: TopicObserverNextCallBack<T>;
    event?: TopicObserverEventCallBack;
    error?: TopicObserverErrorCallBack;
    complete?: () => void;
} | TopicObserverNextCallBack<T>;
export interface WebSocketClientConfig {
    retryConnectionCount?: number;
    retryConnectionDelay?: number;
    maxPendingMessages?: number;
    maxPendingBinaryMessages?: number;
}
type OnUnsubscribeCallback = (type: 'server' | 'manual') => void;
export type Subscription = {
    closed: boolean;
    unsubscribe: () => void;
};
export declare class WebSocketClient {
    private websocket;
    private topics;
    private observer?;
    private pendingMessages;
    private pendingBinaryMessages;
    private isConnected;
    private onOpenCallback;
    private onCloseCallback;
    private _subject;
    private connectionUrl;
    private connectionProtocols?;
    private retryConnectionCount;
    private retryConnectionDelay;
    private currentRetryCount;
    private reconnectTimeout?;
    private isManualClose;
    private isConnecting;
    private maxPendingMessages;
    private maxPendingBinaryMessages;
    constructor(connection: {
        url: string | URL;
        protocols?: string | string[];
    }, config?: WebSocketClientConfig);
    constructor(connection: string, config?: WebSocketClientConfig);
    constructor(connection: URL, config?: WebSocketClientConfig);
    private get observable();
    private connect;
    private attemptReconnect;
    private sendMessage;
    sendBinary(data: ArrayBuffer | Blob | Uint8Array): void;
    private parseIncomingTopic;
    private parseBinaryTopic;
    private isBinaryPayload;
    private hasBinaryPayload;
    private buildBinaryMessage;
    subject(target: string, option?: {
        type?: TopicType;
        subScribeBody?: any;
        observer?: TopicObserverCallBack<any>;
        onUnsubscribe?: OnUnsubscribeCallback;
    }): {
        readonly closed: boolean;
        unsubscribe: () => void;
        readonly observable: Observable<any, any>;
        send: (body?: any) => Observable<any, any>;
        onUnsubscribe: (callback: OnUnsubscribeCallback) => void;
    };
    onOpen(callback: () => void): void;
    onClose(callback: () => void): void;
    subscribe<T = any>(observer: (data: TopicResponse<T> | TopicServerEventRequest<T>) => void): void;
    close(): void;
    reconnect(): void;
    getReadyState(): number;
    isConnectionOpen(): boolean;
}
//# sourceMappingURL=WebSocketClient.d.ts.map