@sbhjt-gr/react-native-webrtc 124.0.0

package/lib/typescript/RTCDataChannelEvent.d.ts

@@ -0,0 +1,19 @@
+import { Event } from 'event-target-shim/index';
+import type RTCDataChannel from './RTCDataChannel';
+declare type DATA_CHANNEL_EVENTS = 'open' | 'message' | 'bufferedamountlow' | 'closing' | 'close' | 'error' | 'datachannel';
+interface IRTCDataChannelEventInitDict extends Event.EventInit {
+    channel: RTCDataChannel;
+}
+/**
+ * @eventClass
+ * This event is fired whenever the RTCDataChannel has changed in any way.
+ * @param {DATA_CHANNEL_EVENTS} type - The type of event.
+ * @param {IRTCDataChannelEventInitDict} eventInitDict - The event init properties.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel#events MDN} for details.
+ */
+export default class RTCDataChannelEvent<TEventType extends DATA_CHANNEL_EVENTS> extends Event<TEventType> {
+    /** @eventProperty */
+    channel: RTCDataChannel;
+    constructor(type: TEventType, eventInitDict: IRTCDataChannelEventInitDict);
+}
+export {};

package/lib/typescript/RTCDataPacketCryptor.d.ts

@@ -0,0 +1,12 @@
+export interface RTCEncryptedPacket {
+    payload: Uint8Array;
+    iv: Uint8Array;
+    keyIndex: number;
+}
+export default class RTCDataPacketCryptor {
+    _id: string;
+    constructor(dataPacketCryptorId: string);
+    encrypt(participantId: string, keyIndex: number, data: Uint8Array): Promise<RTCEncryptedPacket | null>;
+    decrypt(participantId: string, packet: RTCEncryptedPacket): Promise<Uint8Array | null>;
+    dispose(): Promise<void>;
+}

package/lib/typescript/RTCDataPacketCryptorFactory.d.ts

@@ -0,0 +1,6 @@
+import RTCDataPacketCryptor from './RTCDataPacketCryptor';
+import RTCFrameCryptorAlgorithm from './RTCFrameCryptorFactory';
+import RTCKeyProvider from './RTCKeyProvider';
+export default class RTCDataPacketCryptorFactory {
+    static createDataPacketCryptor(algorithm: RTCFrameCryptorAlgorithm, keyProvider: RTCKeyProvider): Promise<RTCDataPacketCryptor>;
+}

package/lib/typescript/RTCErrorEvent.d.ts

@@ -0,0 +1,12 @@
+import { Event } from 'event-target-shim/index';
+declare type RTCPeerConnectionErrorFunc = 'addTransceiver' | 'getTransceivers' | 'addTrack' | 'removeTrack';
+/**
+ * @brief This class Represents internal error happening on the native side as
+ * part of asynchronous invocations to synchronous web APIs.
+ */
+export default class RTCErrorEvent<TEventType extends RTCPeerConnectionErrorFunc> extends Event<TEventType> {
+    readonly func: RTCPeerConnectionErrorFunc;
+    readonly message: string;
+    constructor(type: TEventType, func: RTCPeerConnectionErrorFunc, message: string);
+}
+export {};

package/lib/typescript/RTCFrameCryptor.d.ts

@@ -0,0 +1,47 @@
+import { Event, EventTarget } from 'event-target-shim/index';
+declare type FRAME_CRYPTOR_EVENTS = 'onframecryptorstatechanged';
+interface IRTCDataChannelEventInitDict extends Event.EventInit {
+    frameCryptor: RTCFrameCryptor;
+    state: RTCFrameCryptorState;
+}
+/**
+ * @eventClass
+ * This event is fired whenever the RTCDataChannel has changed in any way.
+ * @param {FRAME_CRYPTOR_EVENTS} type - The type of event.
+ * @param {IRTCDataChannelEventInitDict} eventInitDict - The event init properties.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel#events MDN} for details.
+ */
+export declare class RTCFrameCryptorStateEvent<TEventType extends FRAME_CRYPTOR_EVENTS> extends Event<TEventType> {
+    /** @eventProperty */
+    frameCryptor: RTCFrameCryptor;
+    /** @eventProperty */
+    state: RTCFrameCryptorState;
+    constructor(type: TEventType, eventInitDict: IRTCDataChannelEventInitDict);
+}
+declare type RTCFrameCryptorEventMap = {
+    onframecryptorstatechanged: RTCFrameCryptorStateEvent<'onframecryptorstatechanged'>;
+};
+export declare enum RTCFrameCryptorState {
+    FrameCryptorStateNew = 0,
+    FrameCryptorStateOk = 1,
+    FrameCryptorStateEncryptionFailed = 2,
+    FrameCryptorStateDecryptionFailed = 3,
+    FrameCryptorStateMissingKey = 4,
+    FrameCryptorStateKeyRatcheted = 5,
+    FrameCryptorStateInternalError = 6
+}
+export default class RTCFrameCryptor extends EventTarget<RTCFrameCryptorEventMap> {
+    private _frameCryptorId;
+    private _participantId;
+    constructor(frameCryptorId: string, participantId: string);
+    get id(): string;
+    get participantId(): string;
+    _cryptorStateFromString(str: string): RTCFrameCryptorState;
+    setKeyIndex(keyIndex: number): Promise<boolean>;
+    getKeyIndex(): Promise<number>;
+    setEnabled(enabled: boolean): Promise<boolean>;
+    getEnabled(): Promise<boolean>;
+    dispose(): Promise<void>;
+    _registerEvents(): void;
+}
+export {};

package/lib/typescript/RTCFrameCryptorFactory.d.ts

@@ -0,0 +1,21 @@
+import RTCFrameCryptor from './RTCFrameCryptor';
+import RTCKeyProvider from './RTCKeyProvider';
+import RTCRtpReceiver from './RTCRtpReceiver';
+import RTCRtpSender from './RTCRtpSender';
+export declare enum RTCFrameCryptorAlgorithm {
+    kAesGcm = 0
+}
+export declare type RTCKeyProviderOptions = {
+    sharedKey: boolean;
+    ratchetSalt: string | Uint8Array;
+    ratchetWindowSize: number;
+    uncryptedMagicBytes?: Uint8Array;
+    failureTolerance?: number;
+    keyRingSize?: number;
+    discardFrameWhenCryptorNotReady?: boolean;
+};
+export default class RTCFrameCryptorFactory {
+    static createFrameCryptorForRtpSender(participantId: string, sender: RTCRtpSender, algorithm: RTCFrameCryptorAlgorithm, keyProvider: RTCKeyProvider): RTCFrameCryptor;
+    static createFrameCryptorForRtpReceiver(participantId: string, receiver: RTCRtpReceiver, algorithm: RTCFrameCryptorAlgorithm, keyProvider: RTCKeyProvider): RTCFrameCryptor;
+    static createDefaultKeyProvider(options: RTCKeyProviderOptions): RTCKeyProvider;
+}

package/lib/typescript/RTCIceCandidate.d.ts

@@ -0,0 +1,17 @@
+interface RTCIceCandidateInfo {
+    candidate?: string;
+    sdpMLineIndex?: number | null;
+    sdpMid?: string | null;
+}
+export default class RTCIceCandidate {
+    candidate: string;
+    sdpMLineIndex?: number | null;
+    sdpMid?: string | null;
+    constructor({ candidate, sdpMLineIndex, sdpMid }: RTCIceCandidateInfo);
+    toJSON(): {
+        candidate: string;
+        sdpMLineIndex: number | null | undefined;
+        sdpMid: string | null | undefined;
+    };
+}
+export {};

package/lib/typescript/RTCIceCandidateEvent.d.ts

@@ -0,0 +1,20 @@
+import { Event } from 'event-target-shim/index';
+import type RTCIceCandidate from './RTCIceCandidate';
+declare type RTC_ICECANDIDATE_EVENTS = 'icecandidate' | 'icecandidateerror';
+interface IRTCDataChannelEventInitDict extends Event.EventInit {
+    candidate: RTCIceCandidate | null;
+}
+/**
+ * @eventClass
+ * This event is fired whenever the icecandidate related RTC_EVENTS changed.
+ * @type {RTCIceCandidateEvent} for icecandidate related.
+ * @param {RTC_ICECANDIDATE_EVENTS} type - The type of event.
+ * @param {IRTCDataChannelEventInitDict} eventInitDict - The event init properties.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection#events MDN} for details.
+ */
+export default class RTCIceCandidateEvent<TEventType extends RTC_ICECANDIDATE_EVENTS> extends Event<TEventType> {
+    /** @eventProperty */
+    candidate: RTCIceCandidate | null;
+    constructor(type: TEventType, eventInitDict: IRTCDataChannelEventInitDict);
+}
+export {};

package/lib/typescript/RTCKeyProvider.d.ts

@@ -0,0 +1,21 @@
+export declare enum FrameCryptorState {
+    FrameCryptorStateNew = 0,
+    FrameCryptorStateOk = 1,
+    FrameCryptorStateEncryptionFailed = 2,
+    FrameCryptorStateDecryptionFailed = 3,
+    FrameCryptorStateMissingKey = 4,
+    FrameCryptorStateKeyRatcheted = 5,
+    FrameCryptorStateInternalError = 6
+}
+export default class RTCKeyProvider {
+    _id: string;
+    constructor(keyProviderId: string);
+    setSharedKey(key: string | Uint8Array, keyIndex?: number): Promise<any>;
+    ratchetSharedKey(keyIndex?: number): Promise<Uint8Array>;
+    exportSharedKey(keyIndex?: number): Promise<Uint8Array>;
+    setKey(participantId: string, key: string | Uint8Array, keyIndex?: number): Promise<boolean>;
+    ratchetKey(participantId: string, keyIndex?: number): Promise<Uint8Array>;
+    exportKey(participantId: string, keyIndex?: number): Promise<Uint8Array>;
+    setSifTrailer(trailer: Uint8Array): Promise<any>;
+    dispose(): Promise<any>;
+}

package/lib/typescript/RTCPIPView.d.ts

@@ -0,0 +1,15 @@
+import { Component } from 'react';
+import ReactNative from 'react-native';
+import { RTCIOSPIPOptions, RTCVideoViewProps } from './RTCView';
+export interface RTCPIPViewProps extends RTCVideoViewProps {
+    iosPIP?: RTCIOSPIPOptions & {
+        fallbackView?: Component;
+    };
+}
+/**
+ * A convenience wrapper around RTCView to handle the fallback view as a prop.
+ */
+declare const RTCPIPView: import("react").ForwardRefExoticComponent<RTCPIPViewProps & import("react").RefAttributes<Component<RTCVideoViewProps, {}, any> & Readonly<ReactNative.NativeMethods>>>;
+export declare function startIOSPIP(ref: any): void;
+export declare function stopIOSPIP(ref: any): void;
+export default RTCPIPView;

package/lib/typescript/RTCPIPView.web.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { RTCIOSPIPOptions, RTCVideoViewProps } from './RTCView.web';
+export declare type RTCPIPViewProps = RTCVideoViewProps & {
+    fallbackView?: React.ReactNode;
+    iosPIP?: RTCIOSPIPOptions;
+};
+declare const RTCPIPView: React.ForwardRefExoticComponent<RTCVideoViewProps & {
+    fallbackView?: React.ReactNode;
+    iosPIP?: RTCIOSPIPOptions | undefined;
+} & React.RefAttributes<unknown>>;
+export declare function startIOSPIP(): void;
+export declare function stopIOSPIP(): void;
+export default RTCPIPView;

package/lib/typescript/RTCPeerConnection.d.ts

@@ -0,0 +1,117 @@
+import { EventTarget, Event } from 'event-target-shim/index';
+import MediaStream from './MediaStream';
+import MediaStreamTrack from './MediaStreamTrack';
+import RTCDataChannel from './RTCDataChannel';
+import RTCDataChannelEvent from './RTCDataChannelEvent';
+import RTCIceCandidateEvent from './RTCIceCandidateEvent';
+import RTCRtpReceiver from './RTCRtpReceiver';
+import RTCRtpSender from './RTCRtpSender';
+import RTCRtpTransceiver from './RTCRtpTransceiver';
+import RTCSessionDescription, { RTCSessionDescriptionInit } from './RTCSessionDescription';
+import RTCTrackEvent from './RTCTrackEvent';
+import { RTCOfferOptions } from './RTCUtil';
+declare type RTCSignalingState = 'stable' | 'have-local-offer' | 'have-remote-offer' | 'have-local-pranswer' | 'have-remote-pranswer' | 'closed';
+declare type RTCIceGatheringState = 'new' | 'gathering' | 'complete';
+declare type RTCPeerConnectionState = 'new' | 'connecting' | 'connected' | 'disconnected' | 'failed' | 'closed';
+declare type RTCIceConnectionState = 'new' | 'checking' | 'connected' | 'completed' | 'failed' | 'disconnected' | 'closed';
+declare type RTCDataChannelInit = {
+    ordered?: boolean;
+    maxPacketLifeTime?: number;
+    maxRetransmits?: number;
+    protocol?: string;
+    negotiated?: boolean;
+    id?: number;
+};
+declare type RTCIceServer = {
+    credential?: string;
+    url?: string;
+    urls?: string | string[];
+    username?: string;
+};
+declare type RTCConfiguration = {
+    bundlePolicy?: 'balanced' | 'max-compat' | 'max-bundle';
+    iceCandidatePoolSize?: number;
+    iceServers?: RTCIceServer[];
+    iceTransportPolicy?: 'all' | 'relay';
+    rtcpMuxPolicy?: 'negotiate' | 'require';
+};
+declare type RTCPeerConnectionEventMap = {
+    connectionstatechange: Event<'connectionstatechange'>;
+    icecandidate: RTCIceCandidateEvent<'icecandidate'>;
+    icecandidateerror: RTCIceCandidateEvent<'icecandidateerror'>;
+    iceconnectionstatechange: Event<'iceconnectionstatechange'>;
+    icegatheringstatechange: Event<'icegatheringstatechange'>;
+    negotiationneeded: Event<'negotiationneeded'>;
+    signalingstatechange: Event<'signalingstatechange'>;
+    datachannel: RTCDataChannelEvent<'datachannel'>;
+    track: RTCTrackEvent<'track'>;
+    error: Event<'error'>;
+};
+export default class RTCPeerConnection extends EventTarget<RTCPeerConnectionEventMap> {
+    localDescription: RTCSessionDescription | null;
+    remoteDescription: RTCSessionDescription | null;
+    signalingState: RTCSignalingState;
+    iceGatheringState: RTCIceGatheringState;
+    connectionState: RTCPeerConnectionState;
+    iceConnectionState: RTCIceConnectionState;
+    _pcId: number;
+    _transceivers: {
+        order: number;
+        transceiver: RTCRtpTransceiver;
+    }[];
+    _remoteStreams: Map<string, MediaStream>;
+    _pendingTrackEvents: any[];
+    constructor(configuration?: RTCConfiguration);
+    createOffer(options?: RTCOfferOptions): Promise<any>;
+    createAnswer(): Promise<any>;
+    setConfiguration(configuration: any): void;
+    setLocalDescription(sessionDescription?: RTCSessionDescription | RTCSessionDescriptionInit): Promise<void>;
+    setRemoteDescription(sessionDescription: RTCSessionDescription | RTCSessionDescriptionInit): Promise<void>;
+    addIceCandidate(candidate: any): Promise<void>;
+    /**
+     * @brief Adds a new track to the {@link RTCPeerConnection},
+     * and indicates that it is contained in the specified {@link MediaStream}s.
+     * This method has to be synchronous as the W3C API expects a track to be returned
+     * @param {MediaStreamTrack} track The track to be added
+     * @param {...MediaStream} streams One or more {@link MediaStream}s the track needs to be added to
+     * https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-addtrack
+     */
+    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
+    addTransceiver(source: 'audio' | 'video' | MediaStreamTrack, init: any): RTCRtpTransceiver;
+    removeTrack(sender: RTCRtpSender): void;
+    getStats(selector?: MediaStreamTrack): Promise<any>;
+    getTransceivers(): RTCRtpTransceiver[];
+    getSenders(): RTCRtpSender[];
+    getReceivers(): RTCRtpReceiver[];
+    close(): void;
+    restartIce(): void;
+    _registerEvents(): void;
+    /**
+     * Creates a new RTCDataChannel object with the given label. The
+     * RTCDataChannelInit dictionary can be used to configure properties of the
+     * underlying channel such as data reliability.
+     *
+     * @param {string} label - the value with which the label attribute of the new
+     * instance is to be initialized
+     * @param {RTCDataChannelInit} dataChannelDict - an optional dictionary of
+     * values with which to initialize corresponding attributes of the new
+     * instance such as id
+     */
+    createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
+    /**
+     * Check whether a media stream track exists already in a sender.
+     * See https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-addtrack for more information
+     */
+    _trackExists(track: MediaStreamTrack): boolean;
+    /**
+     * Updates transceivers after offer/answer updates if necessary.
+     */
+    _updateTransceivers(transceiverUpdates: any, removeStopped?: boolean): void;
+    /**
+     * Inserts transceiver into the transceiver array in the order they are created (timestamp).
+     * @param order an index that refers to when it it was created relatively.
+     * @param transceiver the transceiver object to be inserted.
+     */
+    _insertTransceiverSorted(order: number, transceiver: RTCRtpTransceiver): void;
+}
+export {};

package/lib/typescript/RTCRtcpParameters.d.ts

@@ -0,0 +1,10 @@
+export interface RTCRtcpParametersInit {
+    cname: string;
+    reducedSize: boolean;
+}
+export default class RTCRtcpParameters {
+    readonly cname: string;
+    readonly reducedSize: boolean;
+    constructor(init: RTCRtcpParametersInit);
+    toJSON(): RTCRtcpParametersInit;
+}

package/lib/typescript/RTCRtpCapabilities.d.ts

@@ -0,0 +1,9 @@
+import RTCRtpCodecCapability from './RTCRtpCodecCapability';
+/**
+ * @brief represents codec capabilities for senders and receivers.
+ */
+export default class RTCRtpCapabilities {
+    _codecs: RTCRtpCodecCapability[];
+    constructor(codecs: RTCRtpCodecCapability[]);
+    get codecs(): RTCRtpCodecCapability[];
+}

package/lib/typescript/RTCRtpCodecCapability.d.ts

@@ -0,0 +1,7 @@
+export default class RTCRtpCodecCapability {
+    _mimeType: string;
+    constructor(init: {
+        mimeType: string;
+    });
+    get mimeType(): string;
+}

package/lib/typescript/RTCRtpCodecParameters.d.ts

@@ -0,0 +1,16 @@
+export interface RTCRtpCodecParametersInit {
+    payloadType: number;
+    clockRate: number;
+    mimeType: string;
+    channels?: number;
+    sdpFmtpLine?: string;
+}
+export default class RTCRtpCodecParameters {
+    readonly payloadType: number;
+    readonly clockRate: number;
+    readonly mimeType: string;
+    readonly channels: number | null;
+    readonly sdpFmtpLine: string | null;
+    constructor(init: RTCRtpCodecParametersInit);
+    toJSON(): RTCRtpCodecParametersInit;
+}

package/lib/typescript/RTCRtpEncodingParameters.d.ts

@@ -0,0 +1,23 @@
+export interface RTCRtpEncodingParametersInit {
+    active: boolean;
+    rid?: string;
+    maxFramerate?: number;
+    maxBitrate?: number;
+    scaleResolutionDownBy?: number;
+}
+export default class RTCRtpEncodingParameters {
+    active: boolean;
+    _rid: string | null;
+    _maxFramerate: number | null;
+    _maxBitrate: number | null;
+    _scaleResolutionDownBy: number | null;
+    constructor(init: RTCRtpEncodingParametersInit);
+    get rid(): string | null;
+    get maxFramerate(): number | null;
+    set maxFramerate(framerate: number | null);
+    get maxBitrate(): number | null;
+    set maxBitrate(bitrate: number | null);
+    get scaleResolutionDownBy(): number | null;
+    set scaleResolutionDownBy(resolutionScale: number | null);
+    toJSON(): RTCRtpEncodingParametersInit;
+}

package/lib/typescript/RTCRtpHeaderExtension.d.ts

@@ -0,0 +1,12 @@
+export interface RTCRtpHeaderExtensionInit {
+    id: number;
+    uri: string;
+    encrypted: boolean;
+}
+export default class RTCRtpHeaderExtension {
+    readonly id: number;
+    readonly uri: string;
+    readonly encrypted: boolean;
+    constructor(init: RTCRtpHeaderExtensionInit);
+    toJSON(): RTCRtpHeaderExtensionInit;
+}

package/lib/typescript/RTCRtpParameters.d.ts

@@ -0,0 +1,19 @@
+import RTCRtcpParameters, { RTCRtcpParametersInit } from './RTCRtcpParameters';
+import RTCRtpCodecParameters, { RTCRtpCodecParametersInit } from './RTCRtpCodecParameters';
+import RTCRtpHeaderExtension, { RTCRtpHeaderExtensionInit } from './RTCRtpHeaderExtension';
+export interface RTCRtpParametersInit {
+    codecs: RTCRtpCodecParametersInit[];
+    headerExtensions: RTCRtpHeaderExtensionInit[];
+    rtcp: RTCRtcpParametersInit;
+}
+export default class RTCRtpParameters {
+    codecs: (RTCRtpCodecParameters | RTCRtpCodecParametersInit)[];
+    readonly headerExtensions: RTCRtpHeaderExtension[];
+    readonly rtcp: RTCRtcpParameters;
+    constructor(init: RTCRtpParametersInit);
+    toJSON(): {
+        codecs: (RTCRtpCodecParametersInit | RTCRtpCodecParameters)[];
+        headerExtensions: RTCRtpHeaderExtension[];
+        rtcp: RTCRtcpParameters;
+    };
+}

package/lib/typescript/RTCRtpReceiveParameters.d.ts

@@ -0,0 +1,4 @@
+import RTCRtpParameters, { RTCRtpParametersInit } from './RTCRtpParameters';
+export default class RTCRtpReceiveParameters extends RTCRtpParameters {
+    constructor(init: RTCRtpParametersInit);
+}

package/lib/typescript/RTCRtpReceiver.d.ts

@@ -0,0 +1,21 @@
+import MediaStreamTrack from './MediaStreamTrack';
+import RTCRtpCapabilities from './RTCRtpCapabilities';
+import { RTCRtpParametersInit } from './RTCRtpParameters';
+import RTCRtpReceiveParameters from './RTCRtpReceiveParameters';
+export default class RTCRtpReceiver {
+    _id: string;
+    _peerConnectionId: number;
+    _track: MediaStreamTrack | null;
+    _rtpParameters: RTCRtpReceiveParameters;
+    constructor(info: {
+        peerConnectionId: number;
+        id: string;
+        track?: MediaStreamTrack;
+        rtpParameters: RTCRtpParametersInit;
+    });
+    static getCapabilities(kind: 'audio' | 'video'): RTCRtpCapabilities;
+    getStats(): any;
+    getParameters(): RTCRtpReceiveParameters;
+    get id(): string;
+    get track(): MediaStreamTrack | null;
+}

package/lib/typescript/RTCRtpSendParameters.d.ts

@@ -0,0 +1,20 @@
+import RTCRtpEncodingParameters, { RTCRtpEncodingParametersInit } from './RTCRtpEncodingParameters';
+import RTCRtpParameters, { RTCRtpParametersInit } from './RTCRtpParameters';
+declare type DegradationPreferenceType = 'maintain-framerate' | 'maintain-resolution' | 'balanced' | 'disabled';
+export interface RTCRtpSendParametersInit extends RTCRtpParametersInit {
+    transactionId: string;
+    encodings: RTCRtpEncodingParametersInit[];
+    degradationPreference?: string;
+}
+export default class RTCRtpSendParameters extends RTCRtpParameters {
+    readonly transactionId: string;
+    encodings: (RTCRtpEncodingParameters | RTCRtpEncodingParametersInit)[];
+    degradationPreference: DegradationPreferenceType | null;
+    constructor(init: RTCRtpSendParametersInit);
+    toJSON(): {
+        codecs: (import("./RTCRtpCodecParameters").RTCRtpCodecParametersInit | import("./RTCRtpCodecParameters").default)[];
+        headerExtensions: import("./RTCRtpHeaderExtension").default[];
+        rtcp: import("./RTCRtcpParameters").default;
+    };
+}
+export {};

package/lib/typescript/RTCRtpSender.d.ts

@@ -0,0 +1,22 @@
+import MediaStreamTrack from './MediaStreamTrack';
+import RTCRtpCapabilities from './RTCRtpCapabilities';
+import RTCRtpSendParameters, { RTCRtpSendParametersInit } from './RTCRtpSendParameters';
+export default class RTCRtpSender {
+    _id: string;
+    _track: MediaStreamTrack | null;
+    _peerConnectionId: number;
+    _rtpParameters: RTCRtpSendParameters;
+    constructor(info: {
+        peerConnectionId: number;
+        id: string;
+        track?: MediaStreamTrack;
+        rtpParameters: RTCRtpSendParametersInit;
+    });
+    replaceTrack(track: MediaStreamTrack | null): Promise<void>;
+    static getCapabilities(kind: 'audio' | 'video'): RTCRtpCapabilities;
+    getParameters(): RTCRtpSendParameters;
+    setParameters(parameters: RTCRtpSendParameters): Promise<void>;
+    getStats(): any;
+    get track(): MediaStreamTrack | null;
+    get id(): string;
+}

package/lib/typescript/RTCRtpTransceiver.d.ts

@@ -0,0 +1,31 @@
+import RTCRtpCodecCapability from './RTCRtpCodecCapability';
+import RTCRtpReceiver from './RTCRtpReceiver';
+import RTCRtpSender from './RTCRtpSender';
+export default class RTCRtpTransceiver {
+    _peerConnectionId: number;
+    _sender: RTCRtpSender;
+    _receiver: RTCRtpReceiver;
+    _mid: string | null;
+    _direction: string;
+    _currentDirection: string;
+    _stopped: boolean;
+    constructor(args: {
+        peerConnectionId: number;
+        isStopped: boolean;
+        direction: string;
+        currentDirection: string;
+        mid?: string;
+        sender: RTCRtpSender;
+        receiver: RTCRtpReceiver;
+    });
+    get mid(): string | null;
+    get stopped(): boolean;
+    get direction(): string;
+    set direction(val: string);
+    get currentDirection(): string;
+    get sender(): RTCRtpSender;
+    get receiver(): RTCRtpReceiver;
+    stop(): void;
+    setCodecPreferences(codecs: RTCRtpCodecCapability[]): void;
+    _setStopped(): void;
+}

package/lib/typescript/RTCSessionDescription.d.ts

@@ -0,0 +1,12 @@
+export interface RTCSessionDescriptionInit {
+    sdp: string;
+    type: string | null;
+}
+export default class RTCSessionDescription {
+    _sdp: string;
+    _type: string | null;
+    constructor(info?: RTCSessionDescriptionInit);
+    get sdp(): string;
+    get type(): string | null;
+    toJSON(): RTCSessionDescriptionInit;
+}

package/lib/typescript/RTCTrackEvent.d.ts

@@ -0,0 +1,29 @@
+import { Event } from 'event-target-shim/index';
+import MediaStream from './MediaStream';
+import type MediaStreamTrack from './MediaStreamTrack';
+import RTCRtpReceiver from './RTCRtpReceiver';
+import RTCRtpTransceiver from './RTCRtpTransceiver';
+declare type TRACK_EVENTS = 'track';
+interface IRTCTrackEventInitDict extends Event.EventInit {
+    streams: MediaStream[];
+    transceiver: RTCRtpTransceiver;
+}
+/**
+ * @eventClass
+ * This event is fired whenever the Track is changed in PeerConnection.
+ * @param {TRACK_EVENTS} type - The type of event.
+ * @param {IRTCTrackEventInitDict} eventInitDict - The event init properties.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/track_event MDN} for details.
+ */
+export default class RTCTrackEvent<TEventType extends TRACK_EVENTS> extends Event<TEventType> {
+    /** @eventProperty */
+    readonly streams: MediaStream[];
+    /** @eventProperty */
+    readonly transceiver: RTCRtpTransceiver;
+    /** @eventProperty */
+    readonly receiver: RTCRtpReceiver | null;
+    /** @eventProperty */
+    readonly track: MediaStreamTrack | null;
+    constructor(type: TEventType, eventInitDict: IRTCTrackEventInitDict);
+}
+export {};

package/lib/typescript/RTCUtil.d.ts

@@ -0,0 +1,37 @@
+export declare type RTCOfferOptions = {
+    iceRestart?: boolean;
+    offerToReceiveAudio?: boolean;
+    offerToReceiveVideo?: boolean;
+    voiceActivityDetection?: boolean;
+};
+/**
+ * Put together a random string in UUIDv4 format {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
+ *
+ * @return {String} uuidv4
+ */
+export declare function uniqueID(): string;
+/**
+ * Utility for deep cloning an object. Object.assign() only does a shallow copy.
+ *
+ * @param {Object} obj - object to be cloned
+ * @return {Object} cloned obj
+ */
+export declare function deepClone<T>(obj: T): T;
+/**
+ * Checks whether an SDP type is valid or not.
+ *
+ * @param type SDP type to check.
+ * @returns Whether the SDP type is valid or not.
+ */
+export declare function isSdpTypeValid(type: string): boolean;
+/**
+ * Normalize options passed to createOffer().
+ *
+ * @param options - user supplied options
+ * @return Normalized options
+ */
+export declare function normalizeOfferOptions(options?: RTCOfferOptions): Record<string, string>;
+/**
+ * Normalize the given constraints in something we can work with.
+ */
+export declare function normalizeConstraints(constraints: any): any;