import type { ITransport, ITransportEventMap } from "./ITransport.ts";
type Channel = 'reliable' | 'unreliable';
/**
 * Reassembles length-prefixed frames from arbitrary byte chunks.
 *
 * A single WebTransport `reader.read()` may:
 *   - deliver multiple whole frames in one chunk
 *   - split a frame (or its length prefix) across multiple chunks
 *
 * This reassembler buffers partial data across reads so each dispatched
 * frame is exactly one complete message.
 */
export declare class FrameReassembler {
    private pending;
    push(chunk: Uint8Array | undefined): Uint8Array[];
}
export declare class H3TransportTransport implements ITransport {
    wt: WebTransport;
    /** Connect URL — exposed so tooling (e.g. the debug panel) can show the
     *  endpoint, mirroring `WebSocketTransport.ws.url`. */
    url?: string;
    isOpen: boolean;
    events: ITransportEventMap;
    reader: ReadableStreamDefaultReader;
    writer: WritableStreamDefaultWriter;
    unreliableReader: ReadableStreamDefaultReader<Uint8Array>;
    unreliableWriter: WritableStreamDefaultWriter<Uint8Array>;
    private lengthPrefixBuffer;
    private reliableReassembler;
    private unreliableReassembler;
    constructor(events: ITransportEventMap);
    connect(url: string, options?: any): void;
    send(data: Buffer | Uint8Array): void;
    sendUnreliable(data: Buffer | Uint8Array): void;
    /**
     * Length-prefix a payload for the wire. Normalizes the input to a typed array
     * first: unlike `ws.send()` (which accepts an ArrayBuffer directly), we frame
     * manually — reading `.length` and copying via `.set()` — so a bare ArrayBuffer
     * (e.g. the debug panel's latency-sim clone) must be wrapped, or `.length` is
     * `undefined` and the allocation/copy goes out of bounds.
     */
    protected frame(data: Buffer | Uint8Array | ArrayBuffer): Uint8Array;
    close(code?: number, reason?: string): void;
    protected readIncomingData(): Promise<void>;
    protected readIncomingUnreliableData(): Promise<void>;
    protected readLoop(reader: ReadableStreamDefaultReader<Uint8Array>, reassembler: FrameReassembler, channel: Channel): Promise<void>;
    /**
     * Drops the connection after a read loop failed.
     *
     * A rejected `read()` is the end of that channel, never a hiccup: an errored
     * ReadableStream stays errored, so retrying re-raises the same rejection (a
     * busy loop) and a fresh reader taken off the same stream is born errored.
     * With nothing to recover, the only alternative to closing is a transport
     * that reports itself open but can never deliver another frame.
     */
    protected onChannelFailure(channel: Channel, e: any): Promise<void>;
    protected sendSeatReservation(roomId: string, sessionId: string, reconnectionToken?: string, skipHandshake?: boolean): void;
    protected _close(): void;
}
export {};