@sbhjt-gr/react-native-webrtc 137.0.2

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;

package/lib/typescript/RTCView.d.ts

@@ -0,0 +1,117 @@
+import { ViewProps } from 'react-native';
+/**
+ * Native prop validation was removed from RN in:
+ * https://github.com/facebook/react-native/commit/8dc3ba0444c94d9bbb66295b5af885bff9b9cd34
+ *
+ * So we list them here for documentation purposes.
+ */
+export interface RTCVideoViewProps extends ViewProps {
+    /**
+     * Indicates whether the video specified by {@link #streamURL} should be
+     * mirrored during rendering. Commonly, applications choose to mirror the
+     * user-facing camera.
+     *
+     * mirror: boolean
+     */
+    mirror?: boolean;
+    /**
+     * In the fashion of
+     * https://www.w3.org/TR/html5/embedded-content-0.html#dom-video-videowidth
+     * and https://www.w3.org/TR/html5/rendering.html#video-object-fit,
+     * resembles the CSS style object-fit.
+     *
+     * objectFit: 'contain' | 'cover'
+     *
+     * Defaults to 'cover'.
+     */
+    objectFit?: 'contain' | 'cover';
+    /**
+     * URL / id of the stream that should be rendered.
+     *
+     * streamURL: string
+     */
+    streamURL?: string;
+    /**
+     * Similarly to the CSS property z-index, specifies the z-order of this
+     * RTCView in the stacking space of all RTCViews. When RTCViews overlap,
+     * zOrder determines which one covers the other. An RTCView with a larger
+     * zOrder generally covers an RTCView with a lower one.
+     *
+     * Non-overlapping RTCViews may safely share a z-order (because one does not
+     * have to cover the other).
+     *
+     * The support for zOrder is platform-dependent and/or
+     * implementation-specific. Thus, specifying a value for zOrder is to be
+     * thought of as giving a hint rather than as imposing a requirement. For
+     * example, video renderers such as RTCView are commonly implemented using
+     * OpenGL and OpenGL views may have different numbers of layers in their
+     * stacking space. Android has three: a layer bellow the window (aka
+     * default), a layer bellow the window again but above the previous layer
+     * (aka media overlay), and above the window. Consequently, it is advisable
+     * to limit the number of utilized layers in the stacking space to the
+     * minimum sufficient for the desired display. For example, a video call
+     * application usually needs a maximum of two zOrder values: 0 for the
+     * remote video(s) which appear in the background, and 1 for the local
+     * video(s) which appear above the remote video(s).
+     *
+     * zOrder: number
+     */
+    zOrder?: number;
+    /**
+     * Picture in picture options for this view. Disabled if not supplied.
+     *
+     * Note: this should only be generally only used with remote video tracks,
+     * as the local camera may stop while in the background.
+     *
+     * iOS only. Requires iOS 15.0 or above, and the PIP background mode capability.
+     */
+    iosPIP?: RTCIOSPIPOptions;
+    /**
+     * Callback function that is called when the dimensions of the video change.
+     *
+     * @param {Object} event - The event object containing the new dimensions.
+     * @param {Object} event.nativeEvent - The native event data.
+     * @param {number} event.nativeEvent.width - The width of the video.
+     * @param {number} event.nativeEvent.height - The height of the video.
+     */
+    onDimensionsChange?: (event: {
+        nativeEvent: {
+            width: number;
+            height: number;
+        };
+    }) => void;
+}
+export interface RTCIOSPIPOptions {
+    /**
+     * Whether PIP can be launched from this view.
+     *
+     * Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * The preferred size of the PIP window.
+     */
+    preferredSize?: {
+        width: number;
+        height: number;
+    };
+    /**
+     * Indicates whether Picture in Picture starts automatically
+     * when the controller embeds its content inline and the app
+     * transitions to the background.
+     *
+     * Defaults to true.
+     *
+     * See: AVPictureInPictureController.canStartPictureInPictureAutomaticallyFromInline
+     */
+    startAutomatically?: boolean;
+    /**
+     * Indicates whether Picture in Picture should stop automatically
+     * when the app returns to the foreground.
+     *
+     * Defaults to true.
+     */
+    stopAutomatically?: boolean;
+}
+declare const _default: import("react-native").HostComponent<RTCVideoViewProps>;
+export default _default;

package/lib/typescript/ScreenCapturePickerView.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("react-native").HostComponent<unknown>;
+export default _default;

package/lib/typescript/getDisplayMedia.d.ts

@@ -0,0 +1,2 @@
+import MediaStream from './MediaStream';
+export default function getDisplayMedia(): Promise<MediaStream>;

package/lib/typescript/getUserMedia.d.ts

@@ -0,0 +1,7 @@
+import { MediaTrackConstraints } from './Constraints';
+import MediaStream from './MediaStream';
+export interface Constraints {
+    audio?: boolean | MediaTrackConstraints;
+    video?: boolean | MediaTrackConstraints;
+}
+export default function getUserMedia(constraints?: Constraints): Promise<MediaStream>;

package/lib/typescript/index.d.ts

@@ -0,0 +1,22 @@
+import mediaDevices from './MediaDevices';
+import MediaStream from './MediaStream';
+import MediaStreamTrack, { type MediaTrackSettings } from './MediaStreamTrack';
+import permissions from './Permissions';
+import RTCAudioSession from './RTCAudioSession';
+import RTCDataPacketCryptor, { RTCEncryptedPacket } from './RTCDataPacketCryptor';
+import RTCDataPacketCryptorFactory from './RTCDataPacketCryptorFactory';
+import RTCErrorEvent from './RTCErrorEvent';
+import RTCFrameCryptor, { RTCFrameCryptorState } from './RTCFrameCryptor';
+import RTCFrameCryptorFactory, { RTCFrameCryptorAlgorithm, RTCKeyProviderOptions } from './RTCFrameCryptorFactory';
+import RTCIceCandidate from './RTCIceCandidate';
+import RTCKeyProvider from './RTCKeyProvider';
+import RTCPIPView, { startIOSPIP, stopIOSPIP } from './RTCPIPView';
+import RTCPeerConnection from './RTCPeerConnection';
+import RTCRtpReceiver from './RTCRtpReceiver';
+import RTCRtpSender from './RTCRtpSender';
+import RTCRtpTransceiver from './RTCRtpTransceiver';
+import RTCSessionDescription from './RTCSessionDescription';
+import RTCView, { type RTCVideoViewProps, type RTCIOSPIPOptions } from './RTCView';
+import ScreenCapturePickerView from './ScreenCapturePickerView';
+export { RTCIceCandidate, RTCPeerConnection, RTCSessionDescription, RTCView, RTCPIPView, ScreenCapturePickerView, RTCRtpTransceiver, RTCRtpReceiver, RTCRtpSender, RTCErrorEvent, RTCAudioSession, RTCDataPacketCryptor, RTCDataPacketCryptorFactory, RTCEncryptedPacket, RTCFrameCryptor, RTCFrameCryptorAlgorithm, RTCFrameCryptorState, RTCFrameCryptorFactory, RTCKeyProvider, RTCKeyProviderOptions, MediaStream, MediaStreamTrack, type MediaTrackSettings, type RTCVideoViewProps, type RTCIOSPIPOptions, mediaDevices, permissions, registerGlobals, startIOSPIP, stopIOSPIP, };
+declare function registerGlobals(): void;

package/livekit-react-native-webrtc.podspec

@@ -0,0 +1,29 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name                = 'livekit-react-native-webrtc'
+  s.version             = package['version']
+  s.summary             = package['description']
+  s.homepage            = 'https://github.com/sbhjt-gr/react-native-webrtc'
+  s.license             = package['license']
+  s.author              = 'https://github.com/sbhjt-gr/react-native-webrtc/graphs/contributors'
+  s.source              = { :git => 'git@github.com:sbhjt-gr/react-native-webrtc.git', :tag => 'release #{s.version}' }
+  s.requires_arc        = true
+
+  s.platforms           = { :ios => '12.0', :osx => '10.13', :tvos => '16.0' }
+
+  s.preserve_paths      = 'ios/**/*'
+  s.source_files        = 'ios/**/*.{h,m}'
+  s.libraries           = 'c', 'sqlite3', 'stdc++'
+  s.framework           = 'AudioToolbox','AVFoundation', 'CoreAudio', 'CoreGraphics', 'CoreVideo', 'GLKit', 'VideoToolbox'
+  s.dependency          'React-Core'
+  s.dependency          'WebRTC-SDK', '=137.7151.09'
+  
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES'
+  }
+
+end