/**
 * Transport abstraction for the client.
 *
 * The client is deliberately decoupled from any concrete WebSocket implementation
 * so it can be unit-tested with a mock and run on Node, the browser, or a custom
 * socket. A transport is anything that can send a string frame and surface
 * incoming string frames + lifecycle events.
 */
export type TransportState = 'connecting' | 'open' | 'closing' | 'closed';
/** Minimal injectable transport contract. Mirrors the browser `WebSocket` subset. */
export interface Transport {
    readonly state: TransportState;
    /** Send a serialized frame. Throws / rejects if the transport is not open. */
    send(data: string): void;
    /** Open the connection. Resolves once the transport reaches `open`. */
    connect(): Promise<void>;
    /** Close the connection. */
    close(code?: number, reason?: string): void;
    /** Register a handler for incoming string frames. Returns an unsubscribe fn. */
    onMessage(handler: (data: string) => void): () => void;
    /** Register a handler for transport close. Returns an unsubscribe fn. */
    onClose(handler: (info: {
        code?: number;
        reason?: string;
    }) => void): () => void;
    /** Register a handler for transport-level errors. Returns an unsubscribe fn. */
    onError(handler: (err: unknown) => void): () => void;
}
/** The subset of the standard `WebSocket` interface the default transport needs. */
export interface WebSocketLike {
    readonly readyState: number;
    send(data: string): void;
    close(code?: number, reason?: string): void;
    addEventListener(type: 'open', listener: () => void): void;
    addEventListener(type: 'close', listener: (ev: {
        code?: number;
        reason?: string;
    }) => void): void;
    addEventListener(type: 'error', listener: (ev: unknown) => void): void;
    addEventListener(type: 'message', listener: (ev: {
        data: unknown;
    }) => void): void;
}
export type WebSocketFactory = (url: string) => WebSocketLike;
/**
 * Default transport backed by a `WebSocket`-like object. By default it uses the
 * global `WebSocket`; pass a `factory` to inject one (e.g. the `ws` package on
 * Node, or a mock in tests).
 */
export declare class WebSocketTransport implements Transport {
    private socket;
    private readonly url;
    private readonly factory;
    private readonly connectTimeout;
    private readonly messageHandlers;
    private readonly closeHandlers;
    private readonly errorHandlers;
    constructor(url: string, factory?: WebSocketFactory, connectTimeout?: number);
    get state(): TransportState;
    connect(): Promise<void>;
    send(data: string): void;
    close(code?: number, reason?: string): void;
    onMessage(handler: (data: string) => void): () => void;
    onClose(handler: (info: {
        code?: number;
        reason?: string;
    }) => void): () => void;
    onError(handler: (err: unknown) => void): () => void;
}
//# sourceMappingURL=transport.d.ts.map