@sbhjt-gr/react-native-webrtc 137.0.2

package/lib/typescript/EventEmitter.d.ts

@@ -0,0 +1,7 @@
+export declare function setupNativeEvents(): void;
+declare type EventHandler = (event: unknown) => void;
+declare type Listener = unknown;
+export declare function addListener(listener: Listener, eventName: string, eventHandler: EventHandler): void;
+export declare function removeListener(listener: Listener): void;
+export declare function removeListenerForEvent(listener: Listener, eventName: string): void;
+export {};

package/lib/typescript/Logger.d.ts

@@ -0,0 +1,13 @@
+export default class Logger {
+    static ROOT_PREFIX: string;
+    private _debug;
+    private _info;
+    private _warn;
+    private _error;
+    static enable(ns: string): void;
+    constructor(prefix: string);
+    debug(msg: string): void;
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string, err?: Error): void;
+}

package/lib/typescript/MediaDevices.d.ts

@@ -0,0 +1,30 @@
+import { EventTarget, Event } from 'event-target-shim/index';
+import { Constraints } from './getUserMedia';
+declare type MediaDevicesEventMap = {
+    devicechange: Event<'devicechange'>;
+};
+declare class MediaDevices extends EventTarget<MediaDevicesEventMap> {
+    /**
+     * W3C "Media Capture and Streams" compatible {@code enumerateDevices}
+     * implementation.
+     */
+    enumerateDevices(): Promise<unknown>;
+    /**
+     * W3C "Screen Capture" compatible {@code getDisplayMedia} implementation.
+     * See: https://w3c.github.io/mediacapture-screen-share/
+     *
+     * @returns {Promise}
+     */
+    getDisplayMedia(): Promise<import("./MediaStream").default>;
+    /**
+     * W3C "Media Capture and Streams" compatible {@code getUserMedia}
+     * implementation.
+     * See: https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-enumeratedevices
+     *
+     * @param {*} constraints
+     * @returns {Promise}
+     */
+    getUserMedia(constraints: Constraints): Promise<import("./MediaStream").default>;
+}
+declare const _default: MediaDevices;
+export default _default;

package/lib/typescript/MediaStream.d.ts

@@ -0,0 +1,48 @@
+import { EventTarget } from 'event-target-shim/index';
+import MediaStreamTrack, { MediaStreamTrackInfo } from './MediaStreamTrack';
+import MediaStreamTrackEvent from './MediaStreamTrackEvent';
+declare type MediaStreamEventMap = {
+    addtrack: MediaStreamTrackEvent<'addtrack'>;
+    removetrack: MediaStreamTrackEvent<'removetrack'>;
+};
+export default class MediaStream extends EventTarget<MediaStreamEventMap> {
+    _tracks: MediaStreamTrack[];
+    _id: string;
+    /**
+     * The identifier of this MediaStream unique within the associated
+     * WebRTCModule instance. As the id of a remote MediaStream instance is unique
+     * only within the associated RTCPeerConnection, it is not sufficiently unique
+     * to identify this MediaStream across multiple RTCPeerConnections and to
+     * unambiguously differentiate it from a local MediaStream instance not added
+     * to an RTCPeerConnection.
+     */
+    _reactTag: string;
+    /**
+     * A MediaStream can be constructed in several ways, depending on the parameters
+     * that are passed here.
+     *
+     * - undefined: just a new stream, with no tracks.
+     * - MediaStream instance: a new stream, with a copy of the tracks of the passed stream.
+     * - Array of MediaStreamTrack: a new stream with a copy of the tracks in the array.
+     * - object: a new stream instance, represented by the passed info object, this is always
+     *   done internally, when the stream is first created in native and the JS wrapper is
+     *   built afterwards.
+     */
+    constructor(arg?: MediaStream | MediaStreamTrack[] | {
+        streamId: string;
+        streamReactTag: string;
+        tracks: MediaStreamTrackInfo[];
+    });
+    get id(): string;
+    get active(): boolean;
+    addTrack(track: MediaStreamTrack): void;
+    removeTrack(track: MediaStreamTrack): void;
+    getTracks(): MediaStreamTrack[];
+    getTrackById(trackId: any): MediaStreamTrack | undefined;
+    getAudioTracks(): MediaStreamTrack[];
+    getVideoTracks(): MediaStreamTrack[];
+    clone(): never;
+    toURL(): string;
+    release(releaseTracks?: boolean): void;
+}
+export {};

package/lib/typescript/MediaStreamError.d.ts

@@ -0,0 +1,6 @@
+export default class MediaStreamError {
+    name: string;
+    message?: string;
+    constraintName?: string;
+    constructor(error: any);
+}

package/lib/typescript/MediaStreamErrorEvent.d.ts

@@ -0,0 +1,6 @@
+import type MediaStreamError from './MediaStreamError';
+export default class MediaStreamErrorEvent {
+    type: string;
+    error?: MediaStreamError;
+    constructor(type: any, eventInitDict: any);
+}

package/lib/typescript/MediaStreamTrack.d.ts

@@ -0,0 +1,103 @@
+import { EventTarget, Event } from 'event-target-shim/index';
+import { MediaTrackConstraints } from './Constraints';
+export declare type AudioSampleData = {
+    trackId: string;
+    samples: number[];
+    sampleRate: number;
+    channels: number;
+    timestamp: number;
+};
+export declare type AudioSinkCallback = (data: AudioSampleData) => void;
+declare type MediaStreamTrackState = 'live' | 'ended';
+export declare type MediaStreamTrackInfo = {
+    id: string;
+    kind: string;
+    remote: boolean;
+    constraints: object;
+    enabled: boolean;
+    settings: object;
+    peerConnectionId: number;
+    readyState: MediaStreamTrackState;
+};
+export declare type MediaTrackSettings = {
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    facingMode?: string;
+    deviceId?: string;
+    groupId?: string;
+};
+declare type MediaStreamTrackEventMap = {
+    ended: Event<'ended'>;
+    mute: Event<'mute'>;
+    unmute: Event<'unmute'>;
+};
+export default class MediaStreamTrack extends EventTarget<MediaStreamTrackEventMap> {
+    _constraints: MediaTrackConstraints;
+    _enabled: boolean;
+    _settings: MediaTrackSettings;
+    _muted: boolean;
+    _peerConnectionId: number;
+    _readyState: MediaStreamTrackState;
+    readonly id: string;
+    readonly kind: string;
+    readonly label: string;
+    readonly remote: boolean;
+    constructor(info: MediaStreamTrackInfo);
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    get muted(): boolean;
+    get readyState(): string;
+    stop(): void;
+    /**
+     * Private / custom API for switching the cameras on the fly, without the
+     * need for adding / removing tracks or doing any SDP renegotiation.
+     *
+     * This is how the reference application (AppRTCMobile) implements camera
+     * switching.
+     *
+     * @deprecated Use applyConstraints instead.
+     */
+    _switchCamera(): void;
+    _setVideoEffects(names: string[]): void;
+    _setVideoEffect(name: string): void;
+    /**
+     * Internal function which is used to set the muted state on remote tracks and
+     * emit the mute / unmute event.
+     *
+     * @param muted Whether the track should be marked as muted / unmuted.
+     */
+    _setMutedInternal(muted: boolean): void;
+    /**
+     * Custom API for setting the volume on an individual audio track.
+     *
+     * @param volume a gain value in the range of 0-10. defaults to 1.0
+     */
+    _setVolume(volume: number): void;
+    /**
+     * Applies a new set of constraints to the track.
+     *
+     * @param constraints An object listing the constraints
+     * to apply to the track's constrainable properties; any existing
+     * constraints are replaced with the new values specified, and any
+     * constrainable properties not included are restored to their default
+     * constraints. If this parameter is omitted, all currently set custom
+     * constraints are cleared.
+     */
+    applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
+    clone(): never;
+    getCapabilities(): never;
+    getConstraints(): MediaTrackConstraints;
+    getSettings(): MediaTrackSettings;
+    _registerEvents(): void;
+    private _audioSinkCallback;
+    private _audioSinkListenerActive;
+    private _playbackEnabled;
+    _setAudioSinkCallback(callback: AudioSinkCallback | null): void;
+    _handleAudioSamples(data: AudioSampleData): void;
+    setAudioSink(callback: AudioSinkCallback | null): void;
+    setPlaybackEnabled(enabled: boolean): void;
+    isPlaybackEnabled(): boolean;
+    release(): void;
+}
+export {};

package/lib/typescript/MediaStreamTrackEvent.d.ts

@@ -0,0 +1,19 @@
+import { Event } from 'event-target-shim/index';
+import type MediaStreamTrack from './MediaStreamTrack';
+declare type MEDIA_STREAM_EVENTS = 'addtrack' | 'removetrack';
+interface IMediaStreamTrackEventInitDict extends Event.EventInit {
+    track: MediaStreamTrack;
+}
+/**
+ * @eventClass
+ * This event is fired whenever the MediaStreamTrack has changed in any way.
+ * @param {MEDIA_STREAM_EVENTS} type - The type of event.
+ * @param {IMediaStreamTrackEventInitDict} eventInitDict - The event init properties.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaStream#events MDN} for details.
+ */
+export default class MediaStreamTrackEvent<TEventType extends MEDIA_STREAM_EVENTS> extends Event<TEventType> {
+    /** @eventProperty */
+    track: MediaStreamTrack;
+    constructor(type: TEventType, eventInitDict: IMediaStreamTrackEventInitDict);
+}
+export {};

package/lib/typescript/MessageEvent.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react-native" />
+import { Event } from 'event-target-shim/index';
+export declare type MessageEventData = string | ArrayBuffer | Blob;
+declare type MESSAGE_EVENTS = 'message' | 'messageerror';
+interface IMessageEventInitDict extends Event.EventInit {
+    data: MessageEventData;
+}
+/**
+ * @eventClass
+ * This event is fired whenever the RTCDataChannel send message.
+ * @param {MESSAGE_EVENTS} type - The type of event.
+ * @param {IMessageEventInitDict} eventInitDict - The event init properties.
+ * @see
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/message_event#event_type MDN} for details.
+ */
+export default class MessageEvent<TEventType extends MESSAGE_EVENTS> extends Event<TEventType> {
+    /** @eventProperty */
+    data: MessageEventData;
+    constructor(type: TEventType, eventInitDict: IMessageEventInitDict);
+}
+export {};

package/lib/typescript/Permissions.d.ts

@@ -0,0 +1,55 @@
+import { Permission } from 'react-native';
+/**
+ * Type declaration for a permissions descriptor.
+ */
+declare type PermissionDescriptor = {
+    name: string;
+};
+/**
+ * Class implementing a subset of W3C's Permissions API as defined by:
+ * https://www.w3.org/TR/permissions/
+ */
+declare class Permissions {
+    /**
+     * Possible result values for {@link query}, in accordance with:
+     * https://www.w3.org/TR/permissions/#status-of-a-permission
+     */
+    RESULT: {
+        DENIED: string;
+        GRANTED: string;
+        PROMPT: string;
+    };
+    /**
+     * This implementation only supports requesting these permissions, a subset
+     * of: https://www.w3.org/TR/permissions/#permission-registry
+     */
+    VALID_PERMISSIONS: string[];
+    _lastReq: Promise<unknown>;
+    /**
+     * Helper for requesting Android permissions. On Android only one permission
+     * can be requested at a time (unless the multi-permission API is used,
+     * but we are not using that for symmetry with the W3C API for querying)
+     * so we'll queue them up.
+     *
+     * @param perm - The requested permission from
+     * {@link PermissionsAndroid.PERMISSIONS}
+     * https://facebook.github.io/react-native/docs/permissionsandroid#permissions-that-require-prompting-the-user
+     */
+    _requestPermissionAndroid(perm: Permission): Promise<unknown>;
+    /**
+     * Validates the given permission descriptor.
+     */
+    _validatePermissionDescriptior(permissionDesc: any): void;
+    /**
+     * Method for querying the status of a permission, according to:
+     * https://www.w3.org/TR/permissions/#permissions-interface
+     */
+    query(permissionDesc: PermissionDescriptor): any;
+    /**
+     * Custom method NOT defined by W3C's permissions API, which allows the
+     * caller to request a permission.
+     */
+    request(permissionDesc: PermissionDescriptor): any;
+}
+declare const _default: Permissions;
+export default _default;

package/lib/typescript/RTCAudioSession.d.ts

@@ -0,0 +1,10 @@
+export default class RTCAudioSession {
+    /**
+     * To be called when CallKit activates the audio session.
+     */
+    static audioSessionDidActivate(): void;
+    /**
+     * To be called when CallKit deactivates the audio session.
+     */
+    static audioSessionDidDeactivate(): void;
+}

package/lib/typescript/RTCDataChannel.d.ts

@@ -0,0 +1,43 @@
+import { EventTarget } from 'event-target-shim/index';
+import MessageEvent from './MessageEvent';
+import RTCDataChannelEvent from './RTCDataChannelEvent';
+declare type RTCDataChannelState = 'connecting' | 'open' | 'closing' | 'closed';
+declare type DataChannelEventMap = {
+    bufferedamountlow: RTCDataChannelEvent<'bufferedamountlow'>;
+    close: RTCDataChannelEvent<'close'>;
+    closing: RTCDataChannelEvent<'closing'>;
+    error: RTCDataChannelEvent<'error'>;
+    message: MessageEvent<'message'>;
+    open: RTCDataChannelEvent<'open'>;
+};
+export default class RTCDataChannel extends EventTarget<DataChannelEventMap> {
+    _peerConnectionId: number;
+    _reactTag: string;
+    _bufferedAmount: number;
+    _id: number;
+    _label: string;
+    _maxPacketLifeTime?: number;
+    _maxRetransmits?: number;
+    _negotiated: boolean;
+    _ordered: boolean;
+    _protocol: string;
+    _readyState: RTCDataChannelState;
+    binaryType: string;
+    bufferedAmountLowThreshold: number;
+    constructor(info: any);
+    get bufferedAmount(): number;
+    get label(): string;
+    get id(): number;
+    get ordered(): boolean;
+    get maxPacketLifeTime(): number | undefined;
+    get maxRetransmits(): number | undefined;
+    get protocol(): string;
+    get negotiated(): boolean;
+    get readyState(): string;
+    send(data: string): void;
+    send(data: ArrayBuffer): void;
+    send(data: ArrayBufferView): void;
+    close(): void;
+    _registerEvents(): void;
+}
+export {};

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;