@lng2004/node-datachannel 0.31.0-20251228

package/dist/types/lib/datachannel-stream.d.ts

@@ -0,0 +1,24 @@
+import * as stream from 'stream';
+
+/**
+ * Turns a node-datachannel DataChannel into a real Node.js stream, complete with buffering,
+ * backpressure (up to a point - if the buffer fills up, messages are dropped), and
+ * support for piping data elsewhere.
+ *
+ * Read & written data may be either UTF-8 strings or Buffers - this difference exists at
+ * the protocol level, and is preserved here throughout.
+ */
+declare class DataChannelStream extends stream.Duplex {
+    private _rawChannel;
+    private _readActive;
+    constructor(rawChannel: any, streamOptions?: Omit<stream.DuplexOptions, 'objectMode'>);
+    _read(): void;
+    _write(chunk: any, _encoding: any, callback: any): void;
+    _final(callback: any): void;
+    _destroy(maybeErr: any, callback: any): void;
+    get label(): string;
+    get id(): number;
+    get protocol(): string;
+}
+
+export { DataChannelStream as default };

package/dist/types/lib/index.d.ts

@@ -0,0 +1,235 @@
+import { LogLevel, SctpSettings, Direction, Channel, DescriptionType, LocalDescriptionInit, CertificateFingerprint, DataChannelInitConfig, RTCPeerConnectionState, RTCIceConnectionState, RTCSignalingState, RTCIceGatheringState, SelectedCandidateInfo, RtcConfig, IceUdpMuxRequest, NalUnitSeparator, ObuPacketization, WebSocketServerConfiguration } from './types.js';
+export { IceServer, ProxyServer, ProxyServerType, RTCIceGathererState, RTCIceTransportState, RTCSdpType, RelayType, TransportPolicy } from './types.js';
+import DataChannelStream$1 from './datachannel-stream.js';
+import { WebSocketServer } from './websocket-server.js';
+import { WebSocket } from './websocket.js';
+
+declare function preload(): void;
+declare function initLogger(level: LogLevel): void;
+declare function cleanup(): void;
+declare function setSctpSettings(settings: SctpSettings): void;
+declare function getLibraryVersion(): string;
+interface Audio {
+    addAudioCodec(payloadType: number, codec: string, profile?: string): void;
+    addOpusCodec(payloadType: number, profile?: string): string;
+    direction(): Direction;
+    generateSdp(eol: string, addr: string, port: number): string;
+    mid(): string;
+    setDirection(dir: Direction): void;
+    description(): string;
+    removeFormat(fmt: string): void;
+    addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    removeSSRC(ssrc: number): void;
+    replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    hasSSRC(ssrc: number): boolean;
+    getSSRCs(): number[];
+    getCNameForSsrc(ssrc: number): string;
+    setBitrate(bitRate: number): void;
+    getBitrate(): number;
+    hasPayloadType(payloadType: number): boolean;
+    addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
+    addRTPMap(): void;
+    parseSdpLine(line: string): void;
+}
+declare const Audio: {
+    new (mid: string, dir: Direction): Audio;
+};
+interface Video {
+    addVideoCodec(payloadType: number, codec: string, profile?: string): void;
+    addH264Codec(payloadType: number, profile?: string): void;
+    addH265Codec(payloadType: number): void;
+    addVP8Codec(payloadType: number): void;
+    addVP9Codec(payloadType: number): void;
+    addAV1Codec(payloadType: number): void;
+    direction(): Direction;
+    generateSdp(eol: string, addr: string, port: number): string;
+    mid(): string;
+    setDirection(dir: Direction): void;
+    description(): string;
+    removeFormat(fmt: string): void;
+    addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    removeSSRC(ssrc: number): void;
+    replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    hasSSRC(ssrc: number): boolean;
+    getSSRCs(): number[];
+    getCNameForSsrc(ssrc: number): string;
+    setBitrate(bitRate: number): void;
+    getBitrate(): number;
+    hasPayloadType(payloadType: number): boolean;
+    addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
+    addRTPMap(): void;
+    parseSdpLine(line: string): void;
+}
+declare const Video: {
+    new (mid: string, dir: Direction): Video;
+};
+interface Track {
+    direction(): Direction;
+    mid(): string;
+    type(): string;
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Buffer): boolean;
+    isOpen(): boolean;
+    isClosed(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    requestBitrate(bitRate: number): boolean;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    requestKeyframe(): boolean;
+    setMediaHandler(handler: MediaHandler): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onMessage(cb: (msg: Buffer) => void): void;
+}
+declare const Track: {
+    new (): Track;
+};
+interface DataChannel extends Channel {
+    getLabel(): string;
+    getId(): number;
+    getProtocol(): string;
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Buffer | Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer | ArrayBuffer) => void): void;
+}
+declare const DataChannel: {};
+interface PeerConnection {
+    close(): void;
+    setLocalDescription(type?: DescriptionType, init?: LocalDescriptionInit): void;
+    setRemoteDescription(sdp: string, type: DescriptionType): void;
+    localDescription(): {
+        type: DescriptionType;
+        sdp: string;
+    } | null;
+    remoteDescription(): {
+        type: DescriptionType;
+        sdp: string;
+    } | null;
+    remoteFingerprint(): CertificateFingerprint;
+    addRemoteCandidate(candidate: string, mid: string): void;
+    createDataChannel(label: string, config?: DataChannelInitConfig): DataChannel;
+    addTrack(media: Video | Audio): Track;
+    hasMedia(): boolean;
+    state(): RTCPeerConnectionState;
+    iceState(): RTCIceConnectionState;
+    signalingState(): RTCSignalingState;
+    gatheringState(): RTCIceGatheringState;
+    onLocalDescription(cb: (sdp: string, type: DescriptionType) => void): void;
+    onLocalCandidate(cb: (candidate: string, mid: string) => void): void;
+    onStateChange(cb: (state: string) => void): void;
+    onIceStateChange(cb: (state: string) => void): void;
+    onSignalingStateChange(cb: (state: string) => void): void;
+    onGatheringStateChange(cb: (state: string) => void): void;
+    onDataChannel(cb: (dc: DataChannel) => void): void;
+    onTrack(cb: (track: Track) => void): void;
+    bytesSent(): number;
+    bytesReceived(): number;
+    rtt(): number;
+    getSelectedCandidatePair(): {
+        local: SelectedCandidateInfo;
+        remote: SelectedCandidateInfo;
+    } | null;
+    maxDataChannelId(): number;
+    maxMessageSize(): number;
+}
+declare const PeerConnection: {
+    new (peerName: string, config: RtcConfig): PeerConnection;
+};
+interface IceUdpMuxListener {
+    address?: string;
+    port: number;
+    stop(): void;
+    onUnhandledStunRequest(cb: (req: IceUdpMuxRequest) => void): void;
+}
+declare const IceUdpMuxListener: {
+    new (port: number, address?: string): IceUdpMuxListener;
+};
+interface RtpPacketizationConfig {
+    playoutDelayId: number;
+    playoutDelayMin: number;
+    playoutDelayMax: number;
+    timestamp: number;
+    get clockRate(): number;
+}
+declare const RtpPacketizationConfig: {
+    new (ssrc: number, cname: string, payloadType: number, clockRate: number, videoOrientationId?: number): RtpPacketizationConfig;
+};
+interface MediaHandler {
+    addToChain(handler: MediaHandler): void;
+}
+interface RtcpReceivingSession extends MediaHandler {
+}
+declare const RtcpReceivingSession: {
+    new (): RtcpReceivingSession;
+};
+interface RtcpNackResponder extends MediaHandler {
+}
+declare const RtcpNackResponder: {
+    new (maxSize?: number): RtcpNackResponder;
+};
+interface RtcpSrReporter extends MediaHandler {
+    get rtpConfig(): RtpPacketizationConfig;
+}
+declare const RtcpSrReporter: {
+    new (rtpConfig: RtpPacketizationConfig): RtcpSrReporter;
+};
+interface RtpPacketizer extends MediaHandler {
+    get rtpConfig(): RtpPacketizationConfig;
+}
+declare const RtpPacketizer: {
+    new (rtpConfig: RtpPacketizationConfig): RtpPacketizer;
+};
+interface H264RtpPacketizer extends RtpPacketizer {
+}
+declare const H264RtpPacketizer: {
+    new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H264RtpPacketizer;
+};
+interface H265RtpPacketizer extends RtpPacketizer {
+}
+declare const H265RtpPacketizer: {
+    new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H265RtpPacketizer;
+};
+interface AV1RtpPacketizer extends RtpPacketizer {
+}
+declare const AV1RtpPacketizer: {
+    new (packetization: ObuPacketization, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): AV1RtpPacketizer;
+};
+
+declare const DataChannelStream: typeof DataChannelStream$1;
+declare const _default: {
+    initLogger: typeof initLogger;
+    cleanup: typeof cleanup;
+    preload: typeof preload;
+    setSctpSettings: typeof setSctpSettings;
+    getLibraryVersion: typeof getLibraryVersion;
+    RtcpReceivingSession: new () => RtcpReceivingSession;
+    RtcpNackResponder: new (maxSize?: number) => RtcpNackResponder;
+    RtcpSrReporter: new (rtpConfig: RtpPacketizationConfig) => RtcpSrReporter;
+    RtpPacketizationConfig: new (ssrc: number, cname: string, payloadType: number, clockRate: number, videoOrientationId?: number) => RtpPacketizationConfig;
+    RtpPacketizer: new (rtpConfig: RtpPacketizationConfig) => RtpPacketizer;
+    H264RtpPacketizer: new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number) => H264RtpPacketizer;
+    H265RtpPacketizer: new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number) => H265RtpPacketizer;
+    AV1RtpPacketizer: new (packetization: ObuPacketization, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number) => AV1RtpPacketizer;
+    Track: new () => Track;
+    Video: new (mid: string, dir: Direction) => Video;
+    Audio: new (mid: string, dir: Direction) => Audio;
+    DataChannel: {};
+    PeerConnection: new (peerName: string, config: RtcConfig) => PeerConnection;
+    WebSocket: new (config?: WebSocketServerConfiguration) => WebSocket;
+    WebSocketServer: typeof WebSocketServer;
+    DataChannelStream: typeof DataChannelStream$1;
+    IceUdpMuxListener: new (port: number, address?: string) => IceUdpMuxListener;
+};
+
+export { AV1RtpPacketizer, Audio, CertificateFingerprint, Channel, DataChannel, DataChannelInitConfig, DataChannelStream, DescriptionType, Direction, H264RtpPacketizer, H265RtpPacketizer, IceUdpMuxListener, IceUdpMuxRequest, LocalDescriptionInit, LogLevel, type MediaHandler, NalUnitSeparator, ObuPacketization, PeerConnection, RTCIceConnectionState, RTCIceGatheringState, RTCPeerConnectionState, RTCSignalingState, RtcConfig, RtcpNackResponder, RtcpReceivingSession, RtcpSrReporter, RtpPacketizationConfig, RtpPacketizer, SctpSettings, SelectedCandidateInfo, Track, Video, WebSocket, WebSocketServer, WebSocketServerConfiguration, cleanup, _default as default, getLibraryVersion, initLogger, preload, setSctpSettings };

package/dist/types/lib/types.d.ts

@@ -0,0 +1,118 @@
+interface Channel {
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer | ArrayBuffer) => void): void;
+}
+interface WebSocketServerConfiguration {
+    port?: number;
+    enableTls?: boolean;
+    certificatePemFile?: string;
+    keyPemFile?: string;
+    keyPemPass?: string;
+    bindAddress?: string;
+    connectionTimeout?: number;
+    maxMessageSize?: number;
+}
+type LogLevel = 'Verbose' | 'Debug' | 'Info' | 'Warning' | 'Error' | 'Fatal';
+interface SctpSettings {
+    recvBufferSize?: number;
+    sendBufferSize?: number;
+    maxChunksOnQueue?: number;
+    initialCongestionWindow?: number;
+    congestionControlModule?: number;
+    delayedSackTime?: number;
+}
+type ProxyServerType = 'Socks5' | 'Http';
+interface ProxyServer {
+    type: ProxyServerType;
+    ip: string;
+    port: number;
+    username?: string;
+    password?: string;
+}
+type RelayType = 'TurnUdp' | 'TurnTcp' | 'TurnTls';
+interface IceServer {
+    hostname: string;
+    port: number;
+    username?: string;
+    password?: string;
+    relayType?: RelayType;
+}
+type TransportPolicy = 'all' | 'relay';
+interface RtcConfig {
+    iceServers: (string | IceServer)[];
+    proxyServer?: ProxyServer;
+    bindAddress?: string;
+    enableIceTcp?: boolean;
+    enableIceUdpMux?: boolean;
+    disableAutoNegotiation?: boolean;
+    forceMediaTransport?: boolean;
+    portRangeBegin?: number;
+    portRangeEnd?: number;
+    maxMessageSize?: number;
+    mtu?: number;
+    iceTransportPolicy?: TransportPolicy;
+    disableFingerprintVerification?: boolean;
+    disableAutoGathering?: boolean;
+    certificatePemFile?: string;
+    keyPemFile?: string;
+    keyPemPass?: string;
+}
+type DescriptionType = 'unspec' | 'offer' | 'answer' | 'pranswer' | 'rollback';
+type RTCSdpType = 'answer' | 'offer' | 'pranswer' | 'rollback';
+type RTCIceTransportState = 'checking' | 'closed' | 'completed' | 'connected' | 'disconnected' | 'failed' | 'new';
+type RTCPeerConnectionState = 'closed' | 'connected' | 'connecting' | 'disconnected' | 'failed' | 'new';
+type RTCIceConnectionState = 'checking' | 'closed' | 'completed' | 'connected' | 'disconnected' | 'failed' | 'new';
+type RTCIceGathererState = 'complete' | 'gathering' | 'new';
+type RTCIceGatheringState = 'complete' | 'gathering' | 'new';
+type RTCSignalingState = 'closed' | 'have-local-offer' | 'have-local-pranswer' | 'have-remote-offer' | 'have-remote-pranswer' | 'stable';
+interface LocalDescriptionInit {
+    iceUfrag?: string;
+    icePwd?: string;
+}
+interface DataChannelInitConfig {
+    protocol?: string;
+    negotiated?: boolean;
+    id?: number;
+    unordered?: boolean;
+    maxPacketLifeTime?: number;
+    maxRetransmits?: number;
+}
+interface CertificateFingerprint {
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/RTCCertificate/getFingerprints#value
+     */
+    value: string;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/RTCCertificate/getFingerprints#algorithm
+     */
+    algorithm: 'sha-1' | 'sha-224' | 'sha-256' | 'sha-384' | 'sha-512' | 'md5' | 'md2';
+}
+interface SelectedCandidateInfo {
+    address: string;
+    port: number;
+    type: string;
+    transportType: string;
+    candidate: string;
+    mid: string;
+    priority: number;
+}
+type Direction = 'SendOnly' | 'RecvOnly' | 'SendRecv' | 'Inactive' | 'Unknown';
+interface IceUdpMuxRequest {
+    ufrag: string;
+    host: string;
+    port: number;
+}
+type NalUnitSeparator = 'Length' | 'ShortStartSequence' | 'LongStartSequence' | 'StartSequence';
+type ObuPacketization = 'Obu' | 'TemporalUnit';
+
+export type { CertificateFingerprint, Channel, DataChannelInitConfig, DescriptionType, Direction, IceServer, IceUdpMuxRequest, LocalDescriptionInit, LogLevel, NalUnitSeparator, ObuPacketization, ProxyServer, ProxyServerType, RTCIceConnectionState, RTCIceGathererState, RTCIceGatheringState, RTCIceTransportState, RTCPeerConnectionState, RTCSdpType, RTCSignalingState, RelayType, RtcConfig, SctpSettings, SelectedCandidateInfo, TransportPolicy, WebSocketServerConfiguration };

package/dist/types/lib/websocket-server.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from 'events';
+import { WebSocketServerConfiguration } from './types.js';
+import { WebSocket } from './websocket.js';
+
+declare class WebSocketServer extends EventEmitter {
+    #private;
+    constructor(options: WebSocketServerConfiguration);
+    port(): number;
+    stop(): void;
+    onClient(cb: (clientSocket: WebSocket) => void): void;
+}
+
+export { WebSocketServer };

package/dist/types/lib/websocket.d.ts

@@ -0,0 +1,25 @@
+import { Channel, WebSocketServerConfiguration } from './types.js';
+
+interface WebSocket extends Channel {
+    open(url: string): void;
+    forceClose(): void;
+    remoteAddress(): string | undefined;
+    path(): string | undefined;
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer) => void): void;
+}
+declare const WebSocket: {
+    new (config?: WebSocketServerConfiguration): WebSocket;
+};
+
+export { WebSocket };

package/dist/types/polyfill/Events.d.ts

@@ -0,0 +1,15 @@
+import RTCDataChannel from './RTCDataChannel.js';
+
+declare class RTCPeerConnectionIceEvent extends Event implements globalThis.RTCPeerConnectionIceEvent {
+    #private;
+    constructor(candidate: globalThis.RTCIceCandidate);
+    get candidate(): globalThis.RTCIceCandidate;
+    get url(): string;
+}
+declare class RTCDataChannelEvent extends Event implements globalThis.RTCDataChannelEvent {
+    #private;
+    constructor(type: string, eventInitDict: globalThis.RTCDataChannelEventInit);
+    get channel(): RTCDataChannel;
+}
+
+export { RTCDataChannelEvent, RTCPeerConnectionIceEvent };

package/dist/types/polyfill/RTCCertificate.d.ts

@@ -0,0 +1,9 @@
+declare class RTCCertificate implements globalThis.RTCCertificate {
+    #private;
+    constructor();
+    get expires(): number;
+    getFingerprints(): globalThis.RTCDtlsFingerprint[];
+    getAlgorithm(): string;
+}
+
+export { RTCCertificate as default };

package/dist/types/polyfill/RTCDataChannel.d.ts

@@ -0,0 +1,29 @@
+import { DataChannel } from '../lib/index';
+
+declare class RTCDataChannel extends EventTarget implements globalThis.RTCDataChannel {
+    #private;
+    onbufferedamountlow: globalThis.RTCDataChannel['onbufferedamountlow'];
+    onclose: globalThis.RTCDataChannel['onclose'];
+    onclosing: globalThis.RTCDataChannel['onclosing'];
+    onerror: globalThis.RTCDataChannel['onerror'];
+    onmessage: globalThis.RTCDataChannel['onmessage'];
+    onopen: globalThis.RTCDataChannel['onopen'];
+    constructor(dataChannel: DataChannel, opts?: globalThis.RTCDataChannelInit);
+    set binaryType(type: BinaryType);
+    get binaryType(): BinaryType;
+    get bufferedAmount(): number;
+    get bufferedAmountLowThreshold(): number;
+    set bufferedAmountLowThreshold(value: number);
+    get id(): number | null;
+    get label(): string;
+    get maxPacketLifeTime(): number | null;
+    get maxRetransmits(): number | null;
+    get negotiated(): boolean;
+    get ordered(): boolean;
+    get protocol(): string;
+    get readyState(): globalThis.RTCDataChannelState;
+    send(data: any): void;
+    close(): void;
+}
+
+export { RTCDataChannel as default };

package/dist/types/polyfill/RTCDtlsTransport.d.ts

@@ -0,0 +1,15 @@
+import RTCPeerConnection from './RTCPeerConnection.js';
+
+declare class RTCDtlsTransport extends EventTarget implements globalThis.RTCDtlsTransport {
+    #private;
+    onstatechange: globalThis.RTCDtlsTransport['onstatechange'];
+    onerror: globalThis.RTCDtlsTransport['onstatechange'];
+    constructor(init: {
+        pc: RTCPeerConnection;
+    });
+    get iceTransport(): globalThis.RTCIceTransport;
+    get state(): globalThis.RTCDtlsTransportState;
+    getRemoteCertificates(): ArrayBuffer[];
+}
+
+export { RTCDtlsTransport as default };

package/dist/types/polyfill/RTCError.d.ts

@@ -0,0 +1,17 @@
+declare class RTCError extends DOMException implements globalThis.RTCError {
+    #private;
+    constructor(init: globalThis.RTCErrorInit, message?: string);
+    get errorDetail(): globalThis.RTCErrorDetailType;
+    set errorDetail(_value: globalThis.RTCErrorDetailType);
+    get receivedAlert(): number | null;
+    set receivedAlert(_value: number | null);
+    get sctpCauseCode(): number | null;
+    set sctpCauseCode(_value: number | null);
+    get httpRequestStatusCode(): number | null;
+    get sdpLineNumber(): number | null;
+    set sdpLineNumber(_value: number | null);
+    get sentAlert(): number | null;
+    set sentAlert(_value: number | null);
+}
+
+export { RTCError as default };

package/dist/types/polyfill/RTCIceCandidate.d.ts

@@ -0,0 +1,21 @@
+declare class RTCIceCandidate implements globalThis.RTCIceCandidate {
+    #private;
+    constructor({ candidate, sdpMLineIndex, sdpMid, usernameFragment, }: globalThis.RTCIceCandidateInit);
+    get address(): string | null;
+    get candidate(): string;
+    get component(): globalThis.RTCIceComponent | null;
+    get foundation(): string | null;
+    get port(): number | null;
+    get priority(): number | null;
+    get protocol(): globalThis.RTCIceProtocol | null;
+    get relatedAddress(): string | null;
+    get relatedPort(): number | null;
+    get sdpMLineIndex(): number | null;
+    get sdpMid(): string | null;
+    get tcpType(): globalThis.RTCIceTcpCandidateType | null;
+    get type(): globalThis.RTCIceCandidateType | null;
+    get usernameFragment(): string | null;
+    toJSON(): globalThis.RTCIceCandidateInit;
+}
+
+export { RTCIceCandidate as default };

package/dist/types/polyfill/RTCIceTransport.d.ts

@@ -0,0 +1,30 @@
+import RTCPeerConnection from './RTCPeerConnection.js';
+
+declare class RTCIceTransport extends EventTarget implements globalThis.RTCIceTransport {
+    #private;
+    ongatheringstatechange: globalThis.RTCIceTransport['ongatheringstatechange'];
+    onselectedcandidatepairchange: globalThis.RTCIceTransport['onselectedcandidatepairchange'];
+    onstatechange: globalThis.RTCIceTransport['onstatechange'];
+    constructor(init: {
+        pc: RTCPeerConnection;
+    });
+    get component(): globalThis.RTCIceComponent;
+    get gatheringState(): globalThis.RTCIceGatheringState;
+    get role(): globalThis.RTCIceRole;
+    get state(): globalThis.RTCIceTransportState;
+    getLocalCandidates(): globalThis.RTCIceCandidate[];
+    getLocalParameters(): RTCIceParameters | null;
+    getRemoteCandidates(): globalThis.RTCIceCandidate[];
+    getRemoteParameters(): any;
+    getSelectedCandidatePair(): globalThis.RTCIceCandidatePair | null;
+}
+declare class RTCIceParameters implements globalThis.RTCIceParameters {
+    usernameFragment: string;
+    password: string;
+    constructor({ usernameFragment, password }: {
+        usernameFragment: any;
+        password?: string;
+    });
+}
+
+export { RTCIceParameters, RTCIceTransport as default };

package/dist/types/polyfill/RTCPeerConnection.d.ts

@@ -0,0 +1,64 @@
+import { SelectedCandidateInfo } from '../lib/types';
+import { PeerConnection } from '../lib/index';
+import RTCDataChannel from './RTCDataChannel.js';
+import { RTCDataChannelEvent } from './Events.js';
+import RTCCertificate from './RTCCertificate.js';
+
+interface RTCConfiguration extends globalThis.RTCConfiguration {
+    peerIdentity?: string;
+    peerConnection?: PeerConnection;
+}
+declare class RTCPeerConnection extends EventTarget implements globalThis.RTCPeerConnection {
+    #private;
+    static generateCertificate(): Promise<RTCCertificate>;
+    onconnectionstatechange: globalThis.RTCPeerConnection['onconnectionstatechange'];
+    ondatachannel: ((this: globalThis.RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
+    onicecandidate: globalThis.RTCPeerConnection['onicecandidate'];
+    onicecandidateerror: globalThis.RTCPeerConnection['onicecandidateerror'];
+    oniceconnectionstatechange: globalThis.RTCPeerConnection['oniceconnectionstatechange'];
+    onicegatheringstatechange: globalThis.RTCPeerConnection['onicegatheringstatechange'];
+    onnegotiationneeded: globalThis.RTCPeerConnection['onnegotiationneeded'];
+    onsignalingstatechange: globalThis.RTCPeerConnection['onsignalingstatechange'];
+    ontrack: globalThis.RTCPeerConnection['ontrack'];
+    private _checkConfiguration;
+    setConfiguration(config: globalThis.RTCConfiguration): void;
+    constructor(config?: RTCConfiguration);
+    get ext_maxDataChannelId(): number;
+    get ext_maxMessageSize(): number;
+    get ext_localCandidates(): globalThis.RTCIceCandidate[];
+    get ext_remoteCandidates(): globalThis.RTCIceCandidate[];
+    selectedCandidatePair(): {
+        local: SelectedCandidateInfo;
+        remote: SelectedCandidateInfo;
+    } | null;
+    get canTrickleIceCandidates(): boolean | null;
+    get connectionState(): globalThis.RTCPeerConnectionState;
+    get iceConnectionState(): globalThis.RTCIceConnectionState;
+    get iceGatheringState(): globalThis.RTCIceGatheringState;
+    get currentLocalDescription(): globalThis.RTCSessionDescription;
+    get currentRemoteDescription(): globalThis.RTCSessionDescription;
+    get localDescription(): globalThis.RTCSessionDescription;
+    get pendingLocalDescription(): globalThis.RTCSessionDescription;
+    get pendingRemoteDescription(): globalThis.RTCSessionDescription;
+    get remoteDescription(): globalThis.RTCSessionDescription;
+    get sctp(): globalThis.RTCSctpTransport;
+    get signalingState(): globalThis.RTCSignalingState;
+    addIceCandidate(candidate?: globalThis.RTCIceCandidateInit | null): Promise<void>;
+    addTrack(_track: any, ..._streams: any[]): globalThis.RTCRtpSender;
+    addTransceiver(_trackOrKind: any, _init: any): globalThis.RTCRtpTransceiver;
+    close(): void;
+    createAnswer(): Promise<globalThis.RTCSessionDescriptionInit | any>;
+    createDataChannel(label: string, opts?: globalThis.RTCDataChannelInit): RTCDataChannel;
+    createOffer(): Promise<globalThis.RTCSessionDescriptionInit | any>;
+    getConfiguration(): globalThis.RTCConfiguration;
+    getReceivers(): globalThis.RTCRtpReceiver[];
+    getSenders(): globalThis.RTCRtpSender[];
+    getStats(): Promise<globalThis.RTCStatsReport> | any;
+    getTransceivers(): globalThis.RTCRtpTransceiver[];
+    removeTrack(): void;
+    restartIce(): Promise<void>;
+    setLocalDescription(description: globalThis.RTCSessionDescriptionInit): Promise<void>;
+    setRemoteDescription(description: globalThis.RTCSessionDescriptionInit): Promise<void>;
+}
+
+export { RTCPeerConnection as default };

package/dist/types/polyfill/RTCSctpTransport.d.ts

@@ -0,0 +1,15 @@
+import RTCPeerConnection from './RTCPeerConnection.js';
+
+declare class RTCSctpTransport extends EventTarget implements globalThis.RTCSctpTransport {
+    #private;
+    onstatechange: globalThis.RTCSctpTransport['onstatechange'];
+    constructor(initial: {
+        pc: RTCPeerConnection;
+    });
+    get maxChannels(): number | null;
+    get maxMessageSize(): number;
+    get state(): globalThis.RTCSctpTransportState;
+    get transport(): globalThis.RTCDtlsTransport;
+}
+
+export { RTCSctpTransport as default };

package/dist/types/polyfill/RTCSessionDescription.d.ts

@@ -0,0 +1,10 @@
+declare class RTCSessionDescription implements globalThis.RTCSessionDescriptionInit {
+    #private;
+    constructor(init: globalThis.RTCSessionDescriptionInit);
+    get type(): globalThis.RTCSdpType;
+    set type(type: globalThis.RTCSdpType);
+    get sdp(): string;
+    toJSON(): globalThis.RTCSessionDescriptionInit;
+}
+
+export { RTCSessionDescription as default };