/// <reference types="node" />
import { IncomingMessage } from "node:http";
import { type RawData } from "ws";
import { WsConnectionTerminatedError, WsError, WsConnectionEstablishmentError, WsConnectionBreakError, WsConnectionTimeoutError, WsRequestTimeoutError } from "./error";
interface WsConnectionRetries {
    count: number;
    baseDelay: number;
    factor?: number;
}
interface WsConnectionTimeouts {
    createSession: number;
    request: number;
}
interface WsConnectionErrors {
    ConnectionEstablishment: new (...args: ConstructorParameters<typeof WsConnectionEstablishmentError>) => WsConnectionEstablishmentError;
    ConnectionTerminated: new (...args: ConstructorParameters<typeof WsConnectionTerminatedError>) => WsConnectionTerminatedError;
    ConnectionBreak: new (...args: ConstructorParameters<typeof WsConnectionBreakError>) => WsConnectionBreakError;
    ConnectionTimeout: new (...args: ConstructorParameters<typeof WsConnectionTimeoutError>) => WsConnectionTimeoutError;
    RequestTimeout: new (...args: ConstructorParameters<typeof WsRequestTimeoutError>) => WsRequestTimeoutError;
}
interface WsConnectionOptions {
    headers?: Record<string, string>;
    debugFn?: (formatter: any, ...args: any[]) => void;
    retries?: WsConnectionRetries;
    timeouts: WsConnectionTimeouts;
    errors: WsConnectionErrors;
    onMessage: (data: RawData, isBinary: boolean) => void | Promise<void>;
}
export declare class WsConnection<ResponseMessageType = unknown, RequestMessageType extends string | RawData = string | RawData> {
    private readonly _endpoint;
    private readonly _requestHeaders?;
    private readonly _debugFn;
    private readonly _retries;
    private readonly _timeouts;
    private readonly _errors;
    private readonly _onMessage;
    private readonly _onResponseHeaders?;
    private readonly _onReconnect?;
    private readonly _onDisconnect?;
    private readonly _onClose?;
    private _onPong;
    private _pingShouldSkip;
    private _pingInterval;
    private _pingSubsequentFails;
    private _onConnectionCloseFn;
    private _wsConnectionStatus;
    private _wsConnection;
    private _wsConnectionPromise;
    private _requestId;
    private _pendingRequests;
    constructor(endpoint: string, options: WsConnectionOptions);
    getConnectionProperties(): Promise<{
        responseHeaders?: IncomingMessage["headers"];
    }>;
    private _responseHeaders?;
    /** @description Tries to establish ws connection with timeout */
    private _tryToEstablishWsConnection;
    /**
     * @description creates ws connection with retries or returns existing one
     * @note Concurrent requests with same params produce same ws connection
     */
    private _getWsConnection;
    /** @description Produces connection-"uniq" request ids */
    getRequestId(): number;
    /** @description Performs WS request with timeout */
    makeRequest(requestId: number, requestMessage: RequestMessageType): Promise<ResponseMessageType | WsError>;
    provideResponseFor(requestId: number, data: ResponseMessageType | WsError): void;
    forceReconnect(sessionAbortMessage: string): void;
    /** @description Used to abort all pending requests when connection is closed */
    private _abortPendingRequests;
    private _closeWsConnection;
    /**
     * @description Tries to re-establish connection after network drops
     * @note Silently gives up after failed retries attempts
     */
    private _tryToReconnect;
    /** @description Closes websocket connection, terminating all pending requests */
    close(): void;
    private _pingHealthCheckStop;
    private _isWebSocketActive;
    private _pingHealthCheckStart;
}
export {};