import { type Decoder, type Encoder, type Packet } from './socket.io-parser';
import type { Socket as RawSocket } from './engine.io';
import type { Server } from './';
import type { Socket } from './socket';
import type { EventsMap } from '../types/typed-events';
import type { DefaultSocketData } from '../types/socket-types';
interface WriteOptions {
    compress?: boolean;
    volatile?: boolean;
    preEncoded?: boolean;
    wsPreEncoded?: string;
}
export declare class Client<
/** strict types */
ListenEvents extends EventsMap, EmitEvents extends EventsMap, ServerSideEvents extends EventsMap, SocketData extends DefaultSocketData = DefaultSocketData> {
    private readonly id;
    readonly conn: RawSocket;
    readonly server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>;
    readonly encoder: Encoder;
    readonly decoder: Decoder;
    private sockets;
    private nsps;
    private connectTimeout?;
    constructor(
    /** strict types */
    conn: RawSocket, server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>);
    /**
     * @return the reference to the request that originated the Engine.IO connection
     */
    get ctx(): import("hono").Context<any, any, {}>;
    /**
     * Sets up event listeners.
     *
     * @private
     */
    private setup;
    /**
     * Connects a client to a namespace.
     *
     * @param {String} name - the namespace
     * @param {Object} auth - the auth parameters
     * @private
     */
    private connect;
    /**
     * Connects a client to a namespace.
     *
     * @param name - the namespace
     * @param {Object} data - the auth parameters
     *
     * @private
     */
    private doConnect;
    /**
     * Disconnects from all namespaces and closes transport.
     *
     * @private
     */
    _disconnect(): void;
    /**
     * Removes a socket. Called by each `Socket`.
     *
     * @private
     */
    _remove(socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>): void;
    /**
     * Closes the underlying connection.
     *
     * @private
     */
    private close;
    /**
     * Writes a packet to the transport.
     *
     * @param {Object} packet object
     * @param {Object} opts
     * @private
     */
    _packet(packet: Packet | any[], opts?: WriteOptions): void;
    /** @private */
    writeToEngine(encodedPackets: Array<string | Buffer>, opts: WriteOptions): void;
    /**
     * Called with incoming transport data.
     *
     * @private
     */
    private ondata;
    /**
     * Called when parser fully decodes a packet.
     *
     * @private
     */
    private ondecoded;
    /**
     * Handles an error.
     *
     * @param {Object} err object
     * @private
     */
    private onerror;
    /**
     * Called upon transport close.
     *
     * @param reason
     * @param description
     * @private
     */
    private onclose;
    /**
     * Cleans up event listeners.
     * @private
     */
    private destroy;
}
export {};