/// <reference types="socket.io-client" />
import StickySocketConnection from './stickySocketConnection';
import EventEmitter from '../../tools/eventEmitter';
/**
 * Client sticky socket
 */
declare class ClientStickySocket extends EventEmitter<ClientStickySocket.Events> {
    private _logger;
    private _pool;
    private _stickyConnectionWaitTimeout?;
    private _id;
    private _label;
    private _stopped;
    private _connected;
    /**
     * Constructs instance
     * @param url URL
     * @param options options
     */
    constructor(url: string, options?: ClientStickySocket.Options);
    /**
     * Returns socket ID
     * @returns socket ID
     */
    get id(): string;
    /**
     * Returns current native socket
     * @returns socket.io socket
     * @internal intended for tests only
     */
    get socket(): SocketIOClient.Socket;
    /**
     * Returns current transport name, using socket.io internals
     * @returns transport name, e.g. "websocket"
     * @internal intended for tests only
     */
    get transportName(): string;
    /**
     * Returns first present packet index in last emit history
     * @returns first history index
     * @internal intended for tests only
     */
    get firstHistoryIndex(): number | undefined;
    /**
     * Returns whether socket connected
     * @returns is connected
     */
    get connected(): boolean;
    /**
     * @inheritdoc
     * @remarks Socket events `ClientStickySockets.INTERNAL_EVENTS` cannot be subscribed to
     * @throws `ValidationError` if attempting to subscribe to an internal event
     */
    on<U extends EventEmitter.Event<ClientStickySocket.Events>>(event: U, callback: ClientStickySocket.Events[U]): void;
    /**
     * Emits a data event. All events are buffered if no connection
     * @param event The event that we're emitting
     * @param args Optional arguments to send with the event
     */
    send(event: string, ...args: any[]): void;
    /**
     * Disconnects socket
     * @param err error if disconnecting with error
     * @returns promise resolving when disconnected
     */
    disconnect(err?: Error): Promise<void>;
    /**
     * Destroys underlying socket, using socket.io internals. The socket must have `websocket` transport
     * @param err optional error
     * @internal intended for tests only, e.g. to test connection loss
     */
    destroyInternalSocket(err?: Error): void;
    /**
     * Removes expired emit history
     * @internal intended for tests only
     */
    removeExpiredEmitHistory(): void;
}
declare namespace ClientStickySocket {
    /** Constructing options */
    type Options = Pick<StickySocketConnection.Options, 'connection' | 'label' | 'useNativeSocketIoServer'> & {
        /**
         * Emit history buffer TTL. Defaults to `stickyConnectionTtlInSeconds` + `reconnectThrottleDelayInMs`
         * (converted to seconds)
         */
        emitHistoryTtlInSeconds?: number;
        /** Timeout within of which a connection can be restored as previous one. Defaults to `10` */
        stickyConnectionTtlInSeconds?: number;
        /** Reconnection delay. The delay will be increased by 2x each failed connection attempt. Defaults to `1000` */
        reconnectionDelayInMs?: number;
        /** Max reconnection delay. Defaults to `10000` */
        reconnectionDelayMaxInMs?: number;
        /** Reconnection delay randomization factor in range [0; 1]. Defaults to `0.5` */
        reconnectionRandomizationFactor?: number;
    };
    /** Event listeners */
    type Events = {
        /** Fired only once upon first connection */
        connect: () => void;
        /** Fired only once upon the last disconnection. Will be fired anyway, even if was never connected */
        disconnect: (err?: Error) => void;
        /** Custom subscription events */
        [event: string]: (...args: any[]) => any;
    };
    /** Connection events */
    const CONNECTION_EVENTS: string[];
    /** Internal events */
    const INTERNAL_EVENTS: string[];
}
export default ClientStickySocket;