@fails-components/webtransport/dist/lib/session.d.ts

A component to add webtransport support (server and client) to node.js using libquiche

/// <reference types="node" />
/**
 * WebTransport session events
 * @typedef {import('./types').WebTransportSessionEventHandler} WebTransportSessionEventHandler
 * @typedef {import('./types').SessionReadyEvent} SessionReadyEvent
 * @typedef {import('./types').SessionCloseEvent} SessionCloseEvent
 * @typedef {import('./types').DatagramReceivedEvent} DatagramReceivedEvent
 * @typedef {import('./types').GoawayReceivedEvent} GoawayReceivedEvent
 * @typedef {import('./types').DatagramStatsEvent} DatagramStatsEvent
 * @typedef {import('./types').SessionStatsEvent} SessionStatsEvent
 * @typedef {import('./types').NewStreamEvent} NewStreamEvent
 *
 * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
 * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
 * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
 * @typedef {import('./dom').WebTransportSendStreamOptions} WebTransportSendStreamOptions
 * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
 * @typedef {import('./dom').WebTransportDatagramDuplexStream} WebTransportDatagramDuplexStream
 * @typedef {import('./dom').WebTransportReliabilityMode} WebTransportReliabilityMode
 * @typedef {import('./dom').WebTransportCongestionControl} WebTransportCongestionControl
 * @typedef {import('./dom').WebTransportSendGroup} WebTransportSendGroup
 * @typedef {import('./dom').WebTransportStats} WebTransportStats
 * @typedef {import('./dom').WebTransportDatagramStats} WebTransportDatagramStats
 * @typedef {import('./dom').WebTransportSendOptions} WebTransportSendOptions
 * @typedef {import('./dom').WebTransportDatagramsWritable} WebTransportDatagramsWritable
 * @typedef {import('./dom').DatagramsReadableMode} DatagramsReadableMode
 *
 * @typedef {import('./types').NativeHttpWTSession} NativeHttpWTSession
 *
 * Public API
 * @typedef {import('./types').WebTransportSessionImpl} WebTransportSession
 *
 * @typedef {import('./server').HttpServer} HttpServer
 * @typedef {import('./client').HttpClient} HttpClient
 *
 * @typedef {import('stream/web').WritableStreamDefaultController} WritableStreamDefaultController
 */
/**
 * @implements {WebTransportSessionEventHandler}
 * @implements {WebTransportSession}
 */
export class HttpWTSession implements WebTransportSessionEventHandler, WebTransportSession {
    /**
     * @param {object} args
     * @param {import('./types').NativeHttpWTSession} [args.object]
     * @param {HttpServer | HttpClient} args.parentobj
     * @param {Object | undefined} [args.header= undefined]
     * @param {Object | undefined} [args.userData= undefined]
     * @param {string | undefined} [args.peerAddress= undefined]
     * @param {DatagramsReadableMode} [args.datagramsReadableMode]
     */
    constructor(args: {
        object?: import("./types").NativeHttpWTSession | undefined;
        parentobj: HttpServer | HttpClient;
        header?: Object | undefined;
        userData?: Object | undefined;
        peerAddress?: string | undefined;
        datagramsReadableMode?: "bytes" | undefined;
    });
    objint: import("./types").NativeHttpWTSession | undefined;
    parentobj: import("./client").HttpClient | import("./server").HttpServer;
    /** @type {import('./types').WebTransportSessionState} */
    state: import('./types').WebTransportSessionState;
    /** @type {((value?: any) => void) | null | undefined} */
    readyResolve: ((value?: any) => void) | null | undefined;
    /** @type {(() => void) | null | undefined} */
    closeHook: (() => void) | null | undefined;
    /** @type {(Object | null | undefined)} */
    header: (Object | null | undefined);
    /** @type {(Object | null | undefined)} */
    userData: (Object | null | undefined);
    /** @type {(string | undefined)} */
    peerAddress_: (string | undefined);
    datagramsReadableMode_: "bytes" | undefined;
    /** @type {Promise<void>} */
    ready: Promise<void>;
    readyReject: (reason?: any) => void;
    /** @type {WebTransportReliabilityMode} */
    reliability: WebTransportReliabilityMode;
    /** @type {WebTransportCongestionControl} */
    congestionControl: WebTransportCongestionControl;
    /** @type {Promise<WebTransportCloseInfo>} */
    closed: Promise<WebTransportCloseInfo>;
    closedResolve: (value: import("./dom").WebTransportCloseInfo | PromiseLike<import("./dom").WebTransportCloseInfo>) => void;
    closedReject: (reason?: any) => void;
    /** @type {Promise<undefined>} */
    draining: Promise<undefined>;
    drainingResolve: (value: PromiseLike<undefined> | undefined) => void;
    drainingReject: (reason?: any) => void;
    /** @type {ReadableStream<WebTransportBidirectionalStream>} */
    incomingBidirectionalStreams: ReadableStream<WebTransportBidirectionalStream>;
    incomBiDiController: ReadableStreamDefaultController<import("./dom").WebTransportBidirectionalStream>;
    /** @type {ReadableStream<WebTransportReceiveStream>} */
    incomingUnidirectionalStreams: ReadableStream<WebTransportReceiveStream>;
    incomUniDiController: ReadableStreamDefaultController<import("./dom").WebTransportReceiveStream>;
    /** @type {import("stream/web").ReadableByteStreamController | undefined} */
    incomDatagramControllerBytes_: import("stream/web").ReadableByteStreamController | undefined;
    /** @type {import("stream/web").ReadableStreamController<Uint8Array> | undefined} */
    incomDatagramController_: import("stream/web").ReadableStreamController<Uint8Array> | undefined;
    _lastGetMaxDatagramSize: number;
    /** @type {WebTransportDatagramDuplexStream} */
    datagrams: WebTransportDatagramDuplexStream;
    outgoDatagramController: import("stream/web").WritableStreamDefaultController;
    /** @type {Array<(stream: WebTransportBidirectionalStream) => void>} */
    resolveBiDi: ((stream: WebTransportBidirectionalStream) => void)[];
    /** @type {Array<(stream: WebTransportSendStream) => void>} */
    resolveUniDi: ((stream: WebTransportSendStream) => void)[];
    /** @type {Array<(err?: Error) => void>} */
    rejectBiDi: ((err?: Error) => void)[];
    /** @type {Array<(err?: Error) => void>} */
    rejectUniDi: ((err?: Error) => void)[];
    /** @type {Array<(stats: WebTransportStats) => void>} */
    resolveSessionStats: ((stats: WebTransportStats) => void)[];
    /** @type {Array<(err?: Error) => void>} */
    rejectSessionStats: ((err?: Error) => void)[];
    /** @type {Array<(stats: WebTransportDatagramStats) => void>} */
    resolveDatagramStats: ((stats: WebTransportDatagramStats) => void)[];
    /** @type {Array<(err?: Error) => void>} */
    rejectDatagramStats: ((err?: Error) => void)[];
    /** @type {Set<WebTransportSendStream>} */
    sendStreams: Set<WebTransportSendStream>;
    /** @type {Set<WebTransportReceiveStream>} */
    receiveStreams: Set<WebTransportReceiveStream>;
    /** @type {Set<HttpWTStream>} */
    streamObjs: Set<HttpWTStream>;
    /** @type {Set<WritableStreamDefaultController>} */
    sendStreamsController: Set<WritableStreamDefaultController>;
    /** @type {Set<ReadableStreamDefaultController>} */
    receiveStreamsController: Set<ReadableStreamDefaultController>;
    _sendGroupNum: bigint;
    /** @type {Map<bigint,WebTransportSendGroup>} */
    _sendGroupIndex: Map<bigint, WebTransportSendGroup>;
    /** @type {undefined|string} */
    _selectedProtocol: undefined | string;
    /**
     * @param {NativeHttpWTSession} object
     * @param {boolean} reliable
     */
    setSessionObj(object: NativeHttpWTSession, reliable: boolean): void;
    reliable: boolean | undefined;
    get protocol(): string | undefined;
    getStats(): Promise<any>;
    /**
     * @param {SessionStatsEvent} evt
     */
    onSessionStats({ timestamp, expiredOutgoing, lostOutgoing, minRtt, smoothedRtt, rttVariation, estimatedSendRateBps }: SessionStatsEvent): void;
    /**
     * @param {DatagramStatsEvent} evt
     */
    onDatagramStats({ timestamp, expiredOutgoing, lostOutgoing }: DatagramStatsEvent): void;
    notifySessionDraining(): void;
    /**
     * @param {HttpWTStream} stream
     */
    addStreamObj(stream: HttpWTStream): void;
    /**
     * @param {HttpWTStream} stream
     */
    removeStreamObj(stream: HttpWTStream): void;
    /**
     * @param {WebTransportSendStream} stream
     * @param {WritableStreamDefaultController} controller
     */
    addSendStream(stream: WebTransportSendStream, controller: WritableStreamDefaultController): void;
    /**
     * @param {WebTransportSendStream} stream
     * @param {WritableStreamDefaultController} controller
     */
    removeSendStream(stream: WebTransportSendStream, controller: WritableStreamDefaultController): void;
    /**
     * @param {WebTransportReceiveStream } stream
     * @param {ReadableStreamDefaultController} controller
     */
    addReceiveStream(stream: WebTransportReceiveStream, controller: ReadableStreamDefaultController): void;
    /**
     * @param {WebTransportReceiveStream } stream
     * @param {ReadableStreamDefaultController} controller
     */
    removeReceiveStream(stream: WebTransportReceiveStream, controller: ReadableStreamDefaultController): void;
    /**
     * @param {WebTransportSendStreamOptions} [opts]
     * @returns {Promise<WebTransportBidirectionalStream>}
     */
    createBidirectionalStream(opts?: import("./dom").WebTransportSendStreamOptions | undefined): Promise<WebTransportBidirectionalStream>;
    /**
     * @param {WebTransportSendStreamOptions} [opts]
     * @returns {Promise<WebTransportSendStream>}
     */
    createUnidirectionalStream(opts?: import("./dom").WebTransportSendStreamOptions | undefined): Promise<WebTransportSendStream>;
    /**
     * @param {object} [closeInfo]
     * @param {number} closeInfo.closeCode
     * @param {string} closeInfo.reason
     * @returns {void}
     */
    close(closeInfo?: {
        closeCode: number;
        reason: string;
    } | undefined): void;
    /**
     * @returns {WebTransportSendGroup}
     */
    createSendGroup(): WebTransportSendGroup;
    /**
     * @param {{protocol?: string}} arg
     **/
    onReady({ protocol }: {
        protocol?: string;
    }): void;
    /**
     * @param {SessionCloseEvent} args
     */
    onClose(args: SessionCloseEvent): void;
    /**
     * @param {NewStreamEvent} args
     */
    onStream(args: NewStreamEvent): void;
    /**
     * @param {DatagramReceivedEvent} args
     */
    onDatagramReceived(args: DatagramReceivedEvent): void;
    /**
     * @param {GoawayReceivedEvent} args
     */
    onGoAwayReceived(args: GoawayReceivedEvent): void;
    get peerAddress(): string | undefined;
}
/**
 * WebTransport session events
 */
export type WebTransportSessionEventHandler = import('./types').WebTransportSessionEventHandler;
/**
 * WebTransport session events
 */
export type SessionReadyEvent = import('./types').SessionReadyEvent;
/**
 * WebTransport session events
 */
export type SessionCloseEvent = import('./types').SessionCloseEvent;
/**
 * WebTransport session events
 */
export type DatagramReceivedEvent = import('./types').DatagramReceivedEvent;
/**
 * WebTransport session events
 */
export type GoawayReceivedEvent = import('./types').GoawayReceivedEvent;
/**
 * WebTransport session events
 */
export type DatagramStatsEvent = import('./types').DatagramStatsEvent;
/**
 * WebTransport session events
 */
export type SessionStatsEvent = import('./types').SessionStatsEvent;
/**
 * WebTransport session events
 */
export type NewStreamEvent = import('./types').NewStreamEvent;
/**
 * WebTransport session events
 */
export type WebTransportCloseInfo = import('./dom').WebTransportCloseInfo;
/**
 * WebTransport session events
 */
export type WebTransportBidirectionalStream = import('./dom').WebTransportBidirectionalStream;
/**
 * WebTransport session events
 */
export type WebTransportSendStream = import('./dom').WebTransportSendStream;
/**
 * WebTransport session events
 */
export type WebTransportSendStreamOptions = import('./dom').WebTransportSendStreamOptions;
/**
 * WebTransport session events
 */
export type WebTransportReceiveStream = import('./dom').WebTransportReceiveStream;
/**
 * WebTransport session events
 */
export type WebTransportDatagramDuplexStream = import('./dom').WebTransportDatagramDuplexStream;
/**
 * WebTransport session events
 */
export type WebTransportReliabilityMode = import('./dom').WebTransportReliabilityMode;
/**
 * WebTransport session events
 */
export type WebTransportCongestionControl = import('./dom').WebTransportCongestionControl;
/**
 * WebTransport session events
 */
export type WebTransportSendGroup = import('./dom').WebTransportSendGroup;
/**
 * WebTransport session events
 */
export type WebTransportStats = import('./dom').WebTransportStats;
/**
 * WebTransport session events
 */
export type WebTransportDatagramStats = import('./dom').WebTransportDatagramStats;
/**
 * WebTransport session events
 */
export type WebTransportSendOptions = import('./dom').WebTransportSendOptions;
/**
 * WebTransport session events
 */
export type WebTransportDatagramsWritable = import('./dom').WebTransportDatagramsWritable;
/**
 * WebTransport session events
 */
export type DatagramsReadableMode = import('./dom').DatagramsReadableMode;
/**
 * Public API
 */
export type NativeHttpWTSession = import('./types').NativeHttpWTSession;
/**
 * WebTransport session events
 */
export type WebTransportSession = import('./types').WebTransportSessionImpl;
/**
 * WebTransport session events
 */
export type HttpServer = import('./server').HttpServer;
/**
 * WebTransport session events
 */
export type HttpClient = import('./client').HttpClient;
/**
 * WebTransport session events
 */
export type WritableStreamDefaultController = import('stream/web').WritableStreamDefaultController;
import { ReadableStream } from "./webstreams.js";
import { HttpWTStream } from "./stream.js";
//# sourceMappingURL=session.d.ts.map