import type { ClientRequestArgs } from 'http';
import type { WebSocket as NodeWebSocket, ErrorEvent, ClientOptions, MessageEvent } from 'ws';
import EventEmitter from './lib/EventEmitter';
export type onTextEvent = [text: string];
export type onMessageEvent = [message: MessageEvent];
export type onCloseEvent = [code: number, reason?: Buffer | string];
export type onOpenEvent = [url: string];
export type onMaxAttemptEvent = [];
interface CustomError extends ErrorEvent {
    code?: string;
}
export type onErrorEvent = [err: CustomError];
export type onSendEvent = [data: string];
export type onRetryEvent = [attempt: number, maxAttempts: number];
export type ReconnexEvents = {
    text: onTextEvent;
    message: onMessageEvent;
    close: onCloseEvent;
    open: onOpenEvent;
    max_attempt: onMaxAttemptEvent;
    error: onErrorEvent;
    send: onSendEvent;
    retry: onRetryEvent;
};
export type ReconnexT = {
    url: string;
    reconnect?: {
        maxAttempts?: number;
        connectTimeout?: number;
    };
    ping?: {
        data: any;
        interval: number;
    };
    options?: ClientOptions | ClientRequestArgs | undefined;
};
export declare class Reconnex extends EventEmitter<ReconnexEvents> {
    private connectionOpenned;
    private sendOnConnectStrings;
    private reconnectOpts;
    private pingOpts;
    private currentRetries;
    socket?: NodeWebSocket;
    private url;
    private options;
    constructor({ url, ping, reconnect, options }: ReconnexT);
    private connect;
    private addWSListeners;
    isConnected(): this is {
        socket: WebSocket & {
            readyState: 1;
        };
    };
    waitForSocketConnect(): Promise<unknown>;
    disconnect: (reason?: string) => void;
    open: () => false | Promise<NodeWebSocket>;
    send: (text: string | Buffer) => Promise<void>;
    json: (data: any) => Promise<void>;
    sendJSONBinary: (data: any) => Promise<void>;
    sendOnConnect: (content?: string) => string[];
    removeSendOnConnect: (content: string) => string[];
}
export {};