node-datachannel 0.12.0 → 0.20.0-alpha.2

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,164 @@
+import { LogLevel, SctpSettings, Direction, Channel, DescriptionType, RTCSdpType, DataChannelInitConfig, RTCPeerConnectionState, RTCIceConnectionState, RTCSignalingState, RTCIceGatheringState, SelectedCandidateInfo, RtcConfig, WebSocketServerConfiguration } 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;
+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;
+    addVP8Codec(payloadType: number): void;
+    addVP9Codec(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: RtcpReceivingSession): 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: 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 DataChannel: {};
+interface PeerConnection {
+    close(): void;
+    setLocalDescription(type?: DescriptionType): void;
+    setRemoteDescription(sdp: string, type: DescriptionType): void;
+    localDescription(): {
+        type: DescriptionType;
+        sdp: RTCSdpType;
+    } | null;
+    remoteDescription(): {
+        type: DescriptionType;
+        sdp: string;
+    } | null;
+    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;
+};
+declare class RtcpReceivingSession {
+}
+
+declare const DataChannelStream: typeof DataChannelStream$1;
+declare const _default: {
+    initLogger: typeof initLogger;
+    cleanup: typeof cleanup;
+    preload: typeof preload;
+    setSctpSettings: typeof setSctpSettings;
+    RtcpReceivingSession: typeof RtcpReceivingSession;
+    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;
+};
+
+export { Audio, DataChannel, DataChannelStream, PeerConnection, RtcpReceivingSession, Track, Video, WebSocket, WebSocketServer, cleanup, _default as default, initLogger, preload, setSctpSettings };

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

@@ -0,0 +1,106 @@
+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) => 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;
+}
+declare const enum RelayType {
+    TurnUdp = "TurnUdp",
+    TurnTcp = "TurnTcp",
+    TurnTls = "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;
+}
+declare enum DescriptionType {
+    Unspec = "unspec",
+    Offer = "offer",
+    Answer = "answer",
+    Pranswer = "pranswer",
+    Rollback = "rollback"
+}
+type RTCSdpType = 'answer' | 'offer' | 'pranswer' | 'rollback';
+type RTCPeerConnectionState = "closed" | "connected" | "connecting" | "disconnected" | "failed" | "new";
+type RTCIceConnectionState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
+type RTCIceGatheringState = "complete" | "gathering" | "new";
+type RTCSignalingState = "closed" | "have-local-offer" | "have-local-pranswer" | "have-remote-offer" | "have-remote-pranswer" | "stable";
+interface DataChannelInitConfig {
+    protocol?: string;
+    negotiated?: boolean;
+    id?: number;
+    unordered?: boolean;
+    maxPacketLifeTime?: number;
+    maxRetransmits?: number;
+}
+interface SelectedCandidateInfo {
+    address: string;
+    port: number;
+    type: string;
+    transportType: string;
+    candidate: string;
+    mid: string;
+    priority: number;
+}
+declare const enum Direction {
+    SendOnly = "SendOnly",
+    RecvOnly = "RecvOnly",
+    SendRecv = "SendRecv",
+    Inactive = "Inactive",
+    Unknown = "Unknown"
+}
+
+export { type Channel, type DataChannelInitConfig, DescriptionType, Direction, type IceServer, type LogLevel, type ProxyServer, type ProxyServerType, type RTCIceConnectionState, type RTCIceGatheringState, type RTCPeerConnectionState, type RTCSdpType, type RTCSignalingState, RelayType, type RtcConfig, type SctpSettings, type SelectedCandidateInfo, type TransportPolicy, type 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';
+import RTCIceCandidate from './RTCIceCandidate.js';
+
+declare class RTCPeerConnectionIceEvent extends Event implements globalThis.RTCPeerConnectionIceEvent {
+    #private;
+    constructor(candidate: RTCIceCandidate);
+    get candidate(): RTCIceCandidate;
+}
+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,8 @@
+declare class RTCCertificate implements globalThis.RTCCertificate {
+    #private;
+    constructor();
+    get expires(): number;
+    getFingerprints(): globalThis.RTCDtlsFingerprint[];
+}
+
+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: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onclosing: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onerror: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null;
+    onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
+    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,17 @@
+import RTCIceTransport from './RTCIceTransport.js';
+import RTCPeerConnection from './RTCPeerConnection.js';
+
+declare class RTCDtlsTransport extends EventTarget implements globalThis.RTCDtlsTransport {
+    #private;
+    onstatechange: ((this: RTCDtlsTransport, ev: Event) => any) | null;
+    onerror: ((this: RTCDtlsTransport, ev: Event) => any) | null;
+    constructor(init: {
+        pc: RTCPeerConnection;
+        extraFunctions: any;
+    });
+    get iceTransport(): RTCIceTransport;
+    get state(): RTCDtlsTransportState;
+    getRemoteCertificates(): ArrayBuffer[];
+}
+
+export { RTCDtlsTransport as default };

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

@@ -0,0 +1,16 @@
+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 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,24 @@
+import RTCIceCandidate from './RTCIceCandidate.js';
+import RTCPeerConnection from './RTCPeerConnection.js';
+
+declare class RTCIceTransport extends EventTarget implements globalThis.RTCIceTransport {
+    #private;
+    ongatheringstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
+    onselectedcandidatepairchange: ((this: RTCIceTransport, ev: Event) => any) | null;
+    onstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
+    constructor(init: {
+        pc: RTCPeerConnection;
+        extraFunctions: any;
+    });
+    get component(): globalThis.RTCIceComponent;
+    get gatheringState(): globalThis.RTCIceGatheringState;
+    get role(): string;
+    get state(): globalThis.RTCIceTransportState;
+    getLocalCandidates(): RTCIceCandidate[];
+    getLocalParameters(): any;
+    getRemoteCandidates(): RTCIceCandidate[];
+    getRemoteParameters(): any;
+    getSelectedCandidatePair(): globalThis.RTCIceCandidatePair | null;
+}
+
+export { RTCIceTransport as default };

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

@@ -0,0 +1,56 @@
+import RTCSessionDescription from './RTCSessionDescription.js';
+import RTCDataChannel from './RTCDataChannel.js';
+import RTCIceCandidate from './RTCIceCandidate.js';
+import { RTCDataChannelEvent, RTCPeerConnectionIceEvent } from './Events.js';
+import RTCSctpTransport from './RTCSctpTransport.js';
+import RTCCertificate from './RTCCertificate.js';
+
+interface RTCConfiguration extends globalThis.RTCConfiguration {
+    peerIdentity?: string;
+}
+declare class RTCPeerConnection extends EventTarget implements globalThis.RTCPeerConnection {
+    #private;
+    static generateCertificate(): Promise<RTCCertificate>;
+    onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    ondatachannel: ((this: RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
+    onicecandidate: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any) | null;
+    onicecandidateerror: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    oniceconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    onicegatheringstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    onnegotiationneeded: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    onsignalingstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    ontrack: ((this: RTCPeerConnection, ev: globalThis.RTCTrackEvent) => any) | null;
+    private _checkConfiguration;
+    setConfiguration(config: RTCConfiguration): void;
+    constructor(config?: RTCConfiguration);
+    get canTrickleIceCandidates(): boolean | null;
+    get connectionState(): globalThis.RTCPeerConnectionState;
+    get iceConnectionState(): globalThis.RTCIceConnectionState;
+    get iceGatheringState(): globalThis.RTCIceGatheringState;
+    get currentLocalDescription(): RTCSessionDescription;
+    get currentRemoteDescription(): RTCSessionDescription;
+    get localDescription(): RTCSessionDescription;
+    get pendingLocalDescription(): RTCSessionDescription;
+    get pendingRemoteDescription(): RTCSessionDescription;
+    get remoteDescription(): RTCSessionDescription;
+    get sctp(): RTCSctpTransport;
+    get signalingState(): globalThis.RTCSignalingState;
+    addIceCandidate(candidate?: globalThis.RTCIceCandidateInit | RTCIceCandidate): 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: any, opts?: {}): RTCDataChannel;
+    createOffer(): Promise<globalThis.RTCSessionDescriptionInit | any>;
+    getConfiguration(): globalThis.RTCConfiguration;
+    getReceivers(): globalThis.RTCRtpReceiver[];
+    getSenders(): globalThis.RTCRtpSender[];
+    getStats(): Promise<globalThis.RTCStatsReport>;
+    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,17 @@
+import RTCDtlsTransport from './RTCDtlsTransport.js';
+import RTCPeerConnection from './RTCPeerConnection.js';
+
+declare class RTCSctpTransport extends EventTarget implements globalThis.RTCSctpTransport {
+    #private;
+    onstatechange: ((this: RTCSctpTransport, ev: Event) => any) | null;
+    constructor(initial: {
+        pc: RTCPeerConnection;
+        extraFunctions: any;
+    });
+    get maxChannels(): number | null;
+    get maxMessageSize(): number;
+    get state(): globalThis.RTCSctpTransportState;
+    get transport(): RTCDtlsTransport;
+}
+
+export { RTCSctpTransport as default };

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

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

package/{polyfill → dist/types/polyfill}/index.d.ts

@@ -7,19 +7,7 @@ import RTCPeerConnection from './RTCPeerConnection.js';
 import RTCSctpTransport from './RTCSctpTransport.js';
 import RTCSessionDescription from './RTCSessionDescription.js';
 import { RTCDataChannelEvent, RTCPeerConnectionIceEvent } from './Events.js';
-
-export {
-    RTCCertificate,
-    RTCDataChannel,
-    RTCDtlsTransport,
-    RTCIceCandidate,
-    RTCIceTransport,
-    RTCPeerConnection,
-    RTCSctpTransport,
-    RTCSessionDescription,
-    RTCDataChannelEvent,
-    RTCPeerConnectionIceEvent,
-};
+import RTCError from './RTCError.js';
 
 declare const _default: {
     RTCCertificate: typeof RTCCertificate;
@@ -32,6 +20,7 @@ declare const _default: {
     RTCSessionDescription: typeof RTCSessionDescription;
     RTCDataChannelEvent: typeof RTCDataChannelEvent;
     RTCPeerConnectionIceEvent: typeof RTCPeerConnectionIceEvent;
+    RTCError: typeof RTCError;
 };
 
-export default _default;
+export { RTCCertificate, RTCDataChannel, RTCDataChannelEvent, RTCDtlsTransport, RTCError, RTCIceCandidate, RTCIceTransport, RTCPeerConnection, RTCPeerConnectionIceEvent, RTCSctpTransport, RTCSessionDescription, _default as default };

package/jest.config.ts

@@ -0,0 +1,14 @@
+import type { Config } from 'jest';
+
+const config: Config = {
+    clearMocks: true,
+    collectCoverage: false,
+    coverageDirectory: "coverage",
+    coverageProvider: "v8",
+    preset: 'ts-jest',
+    testEnvironment: "jest-environment-node",
+    testRegex: '(/test/jest-tests/.*|(\\.|/)(test|spec))\\.(m)?ts$',
+    testPathIgnorePatterns: ['node_modules', 'multiple-run.test'],
+};
+
+export default config;