/**
 * A {@link SerialTransport} that talks to a remote serial port over a WebSocket
 * bridge (run `expose-serial-websocket` on the host — see `bin/expose-serial.js`).
 *
 * Because it implements the same transport contract as the native `UsbSerialModule` and the
 * in-memory `InMemorySerialTransport`, it's a drop-in: the whole `Serial` /
 * `SerialPort` polyfill (streams, signals, reconnect, the conformance suite)
 * works on top of it unchanged.
 *
 * **Resilience.** The socket is supervised: an unexpected drop (server restart,
 * network blip) is handled transparently — the transport reconnects with
 * exponential backoff and *restores the session* (line coding, control signals,
 * and read state) so the app's open `SerialPort` keeps working. A transient
 * drop is therefore invisible to the polyfill (reads pause and resume; writes
 * issued during the gap wait for the reconnection). Only a real remote
 * disconnect (the host's serial port going away) or giving up after
 * `maxReconnectAttempts` surfaces as a serial disconnect.
 *
 * @example
 * import {Serial} from 'react-native-web-serial-api';
 * import {WebSocketSerialTransport} from 'react-native-web-serial-api/websocket';
 *
 * const serial = new Serial(new WebSocketSerialTransport('ws://localhost:8080'));
 * const [port] = await serial.getPorts();
 * await port.open({baudRate: 115200});
 */
import type { ConnectEvent, ControlLine, DataEvent, ErrorEvent, FlowControl, OpenOptions, PortFilter, PortId, PortPickerLabels, SerialTransport, Subscription } from '../transport';
/** Minimal structural WebSocket shape (browser & React Native both provide it). */
export interface WebSocketLike {
    binaryType: string;
    send(data: string | ArrayBufferLike | ArrayBufferView): void;
    close(): void;
    addEventListener(type: string, listener: (event: {
        data?: unknown;
    }) => void): void;
}
export type WebSocketCtor = new (url: string) => WebSocketLike;
export type WebSocketConnectionState = 'connecting' | 'open' | 'reconnecting' | 'suspended' | 'closed';
export type WebSocketSerialOptions = {
    /** USB identity to report from getInfo() (cosmetic; default 0/0). */
    usbVendorId?: number;
    usbProductId?: number;
    /** Serial number returned by getSerial(). */
    serialNumber?: string;
    /** WebSocket implementation (defaults to the global). Injectable for tests. */
    WebSocket?: WebSocketCtor;
    /** Auto-reconnect when the socket drops unexpectedly. Default `true`. */
    reconnect?: boolean;
    /** Initial reconnect backoff in ms; doubles each attempt. Default 250. */
    reconnectInitialDelayMs?: number;
    /** Cap on the reconnect backoff in ms. Default 10000. */
    reconnectMaxDelayMs?: number;
    /** Give up (surface a disconnect) after this many consecutive failures. Default Infinity. */
    maxReconnectAttempts?: number;
    /** How long write()/commands wait for a (re)connection before failing. Default 10000. */
    connectTimeoutMs?: number;
    /** How long a control command waits for its response before failing. Default 10000. */
    commandTimeoutMs?: number;
    /** Notified before each reconnect attempt (1-based attempt + the chosen delay). */
    onReconnecting?: (attempt: number, delayMs: number) => void;
    /** Notified once (re)connected; `reconnected` is false only for the first connect. */
    onConnected?: (info: {
        reconnected: boolean;
    }) => void;
    /** Notified when the transport is permanently closed (gave up, or `disconnect()`). */
    onClosed?: (reason: string) => void;
};
type Listener<E> = (event: E) => void;
export declare class WebSocketSerialTransport implements SerialTransport {
    #private;
    constructor(url: string, options?: WebSocketSerialOptions);
    /** Current connection state (advisory; the polyfill keeps working across reconnects). */
    get connectionState(): WebSocketConnectionState;
    findAllDrivers(): Promise<ReadonlyArray<PortId>>;
    showPortPicker(_filter: ReadonlyArray<PortFilter>, _labels?: PortPickerLabels): Promise<PortId>;
    requestPermission(_deviceId: number): Promise<boolean>;
    open(_deviceId: number, _portNumber: number, options: OpenOptions): Promise<void>;
    close(_deviceId: number, _portNumber: number): Promise<void>;
    isOpen(_deviceId: number, _portNumber: number): boolean;
    write(_deviceId: number, _portNumber: number, data: number[], _timeout?: number): Promise<void>;
    startReading(_deviceId: number, _portNumber: number): Promise<void>;
    stopReading(_deviceId: number, _portNumber: number): Promise<void>;
    setParameters(_deviceId: number, _portNumber: number, options: OpenOptions): Promise<void>;
    setDTR(_d: number, _p: number, value: boolean): Promise<void>;
    setRTS(_d: number, _p: number, value: boolean): Promise<void>;
    getDTR(_d: number, _p: number): Promise<boolean>;
    getRTS(_d: number, _p: number): Promise<boolean>;
    getCD(_d: number, _p: number): Promise<boolean>;
    getCTS(_d: number, _p: number): Promise<boolean>;
    getDSR(_d: number, _p: number): Promise<boolean>;
    getRI(_d: number, _p: number): Promise<boolean>;
    getControlLines(_d: number, _p: number): Promise<ControlLine[]>;
    getSupportedControlLines(_d: number, _p: number): Promise<ControlLine[]>;
    setFlowControl(_d: number, _p: number, _flowControl: FlowControl): Promise<void>;
    getFlowControl(_d: number, _p: number): Promise<FlowControl>;
    getSupportedFlowControl(_d: number, _p: number): Promise<FlowControl[]>;
    setBreak(_d: number, _p: number, value: boolean): Promise<void>;
    purgeHwBuffers(_d: number, _p: number, _purgeWrite: boolean, _purgeRead: boolean): Promise<void>;
    getSerial(_d: number, _p: number): Promise<string>;
    onData(listener: Listener<DataEvent>): Subscription;
    onError(listener: Listener<ErrorEvent>): Subscription;
    onConnect(listener: Listener<ConnectEvent>): Subscription;
    onDisconnect(listener: Listener<ConnectEvent>): Subscription;
    /**
     * Permanently close the transport (and the remote port session). Cancels any
     * pending reconnect and stops auto-reconnecting.
     */
    disconnect(): void;
}
export {};
//# sourceMappingURL=WebSocketSerialTransport.d.ts.map