@cloudflare/realtimekit-react-native 0.0.0 → 0.0.1-staging.3

package/lib/LocalMediaInterfaces.d.ts

@@ -0,0 +1,76 @@
+export type MediaDeviceKind = 'audioinput' | 'audiooutput' | 'videoinput';
+export interface MediaDeviceInfo {
+    readonly deviceId: string;
+    readonly groupId: string;
+    readonly kind: MediaDeviceKind;
+    readonly label: string;
+    readonly facing: string;
+    toJSON(): any;
+}
+interface ULongRange {
+    max?: number;
+    min?: number;
+}
+interface DoubleRange {
+    max?: number;
+    min?: number;
+}
+interface ConstrainDoubleRange extends DoubleRange {
+    exact?: number;
+    ideal?: number;
+}
+interface ConstrainDOMStringParameters {
+    exact?: string | string[];
+    ideal?: string | string[];
+}
+interface ConstrainULongRange extends ULongRange {
+    exact?: number;
+    ideal?: number;
+}
+interface ConstrainBooleanParameters {
+    exact?: boolean;
+    ideal?: boolean;
+}
+export type ConstrainBoolean = boolean | ConstrainBooleanParameters;
+export type ConstrainDOMString = string | string[] | ConstrainDOMStringParameters;
+export type ConstrainDouble = number | ConstrainDoubleRange;
+export type ConstrainULong = number | ConstrainULongRange;
+export interface MediaTrackConstraintSet {
+    aspectRatio?: ConstrainDouble;
+    autoGainControl?: ConstrainBoolean;
+    channelCount?: ConstrainULong;
+    deviceId?: ConstrainDOMString;
+    echoCancellation?: ConstrainBoolean;
+    facingMode?: ConstrainDOMString;
+    frameRate?: ConstrainDouble;
+    groupId?: ConstrainDOMString;
+    height?: ConstrainULong;
+    latency?: ConstrainDouble;
+    noiseSuppression?: ConstrainBoolean;
+    sampleRate?: ConstrainULong;
+    sampleSize?: ConstrainULong;
+    suppressLocalAudioPlayback?: ConstrainBoolean;
+    width?: ConstrainULong;
+}
+interface MediaStreamConstraints {
+    audio?: boolean | MediaTrackConstraints;
+    peerIdentity?: string;
+    preferCurrentTab?: boolean;
+    video?: boolean | MediaTrackConstraints;
+}
+export interface MediaTrackConstraints extends MediaTrackConstraintSet {
+    advanced?: MediaTrackConstraintSet[];
+}
+export type VideoQuality = 'qvga' | 'vga' | 'hd' | 'hd_cropped';
+export type ScreenShareQuality = 'vga' | 'hd' | 'full_hd';
+export interface RealtimeKitMediaTrackConstraints extends MediaTrackConstraints {
+    optional?: Array<object>;
+}
+export interface RealtimeKitMediaStreamConstraints extends MediaStreamConstraints {
+    audio?: boolean | RealtimeKitMediaTrackConstraints;
+}
+export interface VideoConstraints {
+    [key: string]: RealtimeKitMediaTrackConstraints;
+}
+export type MediaPermission = 'ACCEPTED' | 'DENIED' | 'SYS_DENIED' | 'UNAVAILABLE' | 'NOT_REQUESTED';
+export {};

package/lib/LocalMediaInterfaces.js

@@ -0,0 +1 @@
+export {};

package/lib/LocalMediaUtils.d.ts

@@ -0,0 +1,93 @@
+import { ConstrainDouble, RealtimeKitMediaStreamConstraints, RealtimeKitMediaTrackConstraints, MediaDeviceInfo } from './LocalMediaInterfaces';
+export interface LocalAudioOptions {
+    disableAP?: boolean;
+    disableAEC?: boolean;
+    disableNS?: boolean;
+    disableAGC?: boolean;
+    disableHPF?: boolean;
+}
+export declare const VIDEO_CONSTRAINTS: {
+    qvga: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    vga: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    hd: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    hd_cropped: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+};
+/**
+ * To initialize an instance of this class, use the
+ * `.init()` static method.
+ */
+export default class LocalMediaUtils {
+    #private;
+    private constructor();
+    static init(): Promise<LocalMediaUtils>;
+    destruct(): Promise<void>;
+    static isDeviceListAvailable(): boolean;
+    private static enumerateVideoDevices;
+    private static enumerateAudioDevices;
+    static getVideoConstraints(options?: {
+        videoDeviceId?: string;
+        videoTrackConstraints?: boolean | RealtimeKitMediaTrackConstraints;
+        facingMode?: string;
+        frameRate?: ConstrainDouble;
+    }): RealtimeKitMediaStreamConstraints;
+    private static getUserMediaWithTimeout;
+    static getAudioTrack(): Promise<import("@dyteinternals/react-native-webrtc").MediaStreamTrack>;
+    static getVideoTrack(constraints: RealtimeKitMediaStreamConstraints): Promise<import("@dyteinternals/react-native-webrtc").MediaStreamTrack>;
+    static getScreenShareTracks(): Promise<{
+        video: import("@dyteinternals/react-native-webrtc").MediaStreamTrack;
+        audio: import("@dyteinternals/react-native-webrtc").MediaStreamTrack;
+    }>;
+    static getAudioAndVideoTrack(constraints: RealtimeKitMediaStreamConstraints): Promise<{
+        audioTrack: import("@dyteinternals/react-native-webrtc").MediaStreamTrack;
+        videoTrack: import("@dyteinternals/react-native-webrtc").MediaStreamTrack;
+    }>;
+    onDeviceChange(callback: (changedDevices: {
+        added: MediaDeviceInfo[];
+        removed: MediaDeviceInfo[];
+    }, forceDeviceChange?: boolean) => void): void;
+    repopulateAvailableDevices(): Promise<void>;
+    chooseAudioRoute(route: String): Promise<any>;
+    get availableDevices(): MediaDeviceInfo[];
+    getAvailableDevicesByKind(kind: string): MediaDeviceInfo[];
+    getDeviceById(deviceId: string, kind: 'audioinput' | 'audiooutput' | 'videoinput'): MediaDeviceInfo;
+    /**
+     * Returns all audio input devices (microphone devices).
+     */
+    getAudioDevices(): MediaDeviceInfo[];
+    /**
+     * Returns all video input devices.
+     */
+    getVideoDevices(): MediaDeviceInfo[];
+    /**
+     * Returns all audio output devices (speaker devices).
+     */
+    getSpeakerDevices(): MediaDeviceInfo[];
+}

package/lib/LocalMediaUtils.js

@@ -0,0 +1,276 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LocalMediaUtils_availableDevices, _LocalMediaUtils_nativeEventEmitter;
+import { NativeEventEmitter, NativeModules, LogBox } from 'react-native';
+import { mediaDevices } from '@dyteinternals/react-native-webrtc';
+import LocalMediaError from './LocalMediaError';
+import NativeAudioManager from './NativeAudioManager';
+LogBox.ignoreLogs(['new NativeEventEmitter']);
+export const VIDEO_CONSTRAINTS = {
+    qvga: { width: { ideal: 320 }, height: { ideal: 240 } },
+    vga: { width: { ideal: 640 }, height: { ideal: 480 } },
+    hd: { width: { ideal: 1280 }, height: { ideal: 720 } },
+    hd_cropped: { width: { ideal: 900 }, height: { ideal: 720 } },
+};
+/**
+ * To initialize an instance of this class, use the
+ * `.init()` static method.
+ */
+class LocalMediaUtils {
+    constructor(availableDevices) {
+        _LocalMediaUtils_availableDevices.set(this, void 0);
+        _LocalMediaUtils_nativeEventEmitter.set(this, void 0);
+        __classPrivateFieldSet(this, _LocalMediaUtils_availableDevices, availableDevices, "f");
+        __classPrivateFieldSet(this, _LocalMediaUtils_nativeEventEmitter, new NativeEventEmitter(NativeModules.InCallManager), "f");
+    }
+    static init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableVideoDevices = yield LocalMediaUtils.enumerateVideoDevices();
+            const availableAudioDevices = yield LocalMediaUtils.enumerateAudioDevices();
+            return new LocalMediaUtils(availableAudioDevices.concat(availableVideoDevices));
+        });
+    }
+    destruct() {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldGet(this, _LocalMediaUtils_nativeEventEmitter, "f").removeAllListeners('onAudioDeviceChanged');
+        });
+    }
+    static isDeviceListAvailable() {
+        return true;
+    }
+    static enumerateVideoDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const deviceMem = {};
+                const videoDevices = (yield mediaDevices.enumerateDevices());
+                return videoDevices.filter((d) => {
+                    if (d.kind === 'videoinput' && !deviceMem[d.facing]) {
+                        deviceMem[d.facing] = true;
+                        return d;
+                    }
+                    return false;
+                });
+            }
+            catch (error) {
+                return [];
+            }
+        });
+    }
+    static enumerateAudioDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let audioDevices = {
+                earpiece: {
+                    connected: true,
+                    haveMic: true,
+                },
+                speaker: {
+                    connected: true,
+                    haveMic: true,
+                },
+                bluetooth: {
+                    connected: false,
+                    haveMic: false,
+                },
+                wired: {
+                    connected: false,
+                    haveMic: false,
+                },
+            };
+            const isWiredHeadphonesConnected = yield NativeAudioManager.getIsWiredHeadsetPluggedIn();
+            audioDevices.wired = isWiredHeadphonesConnected
+                ? {
+                    connected: true,
+                    haveMic: true,
+                }
+                : {
+                    connected: false,
+                    haveMic: false,
+                };
+            const isBluetoothHeadsetConnected = yield NativeAudioManager.isBluetoothHeadsetConnected();
+            audioDevices.bluetooth = isBluetoothHeadsetConnected
+                ? {
+                    connected: true,
+                    haveMic: true,
+                }
+                : {
+                    connected: false,
+                    haveMic: false,
+                };
+            const resp = Object.keys(audioDevices)
+                .map((audioDevice) => {
+                const audioDeviceProps = audioDevices[audioDevice];
+                return Object.assign(Object.assign({}, audioDeviceProps), { deviceId: audioDevice, label: audioDevice, kind: 'audioinput' });
+            })
+                .filter((audioDevice) => audioDevice.connected);
+            // console.log('Resp: ', JSON.stringify(resp, null, 2));
+            return resp;
+        });
+    }
+    static getVideoConstraints(options) {
+        const constraints = {};
+        const { videoDeviceId, videoTrackConstraints, facingMode = 'user', frameRate = { ideal: 24, max: 30 }, } = options;
+        constraints.video = videoTrackConstraints || VIDEO_CONSTRAINTS.vga;
+        if (typeof constraints.video === 'boolean') {
+            return constraints;
+        }
+        constraints.video.deviceId = videoDeviceId;
+        constraints.video.facingMode = facingMode;
+        constraints.video.frameRate = frameRate;
+        return constraints;
+    }
+    static getUserMediaWithTimeout() {
+        return __awaiter(this, arguments, void 0, function* (constraints = {}, timeout = 0) {
+            try {
+                if (!timeout) {
+                    return yield mediaDevices.getUserMedia(constraints);
+                }
+                // NOTE(roerohan): The await is required to catch errors (if any).
+                return yield Promise.race([
+                    mediaDevices.getUserMedia(constraints),
+                    new Promise((_resolve, reject) => {
+                        setTimeout(() => reject(new LocalMediaError('Get user media timed out', 'ERR_GUM_TIMEOUT')), timeout);
+                    }),
+                ]);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    static getAudioTrack() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mediaStream = (yield LocalMediaUtils.getUserMediaWithTimeout({
+                audio: true,
+            }));
+            return mediaStream.getAudioTracks()[0];
+        });
+    }
+    static getVideoTrack(constraints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mediaStream = (yield LocalMediaUtils.getUserMediaWithTimeout(constraints));
+            return mediaStream.getVideoTracks()[0];
+        });
+    }
+    static getScreenShareTracks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            /**
+             * getDisplayMedia is not defined on type MediaDevices.
+             * Need to update this when a fix
+             * is made: https://github.com/microsoft/TypeScript/issues/33232
+             */
+            const stream = (yield mediaDevices.getDisplayMedia());
+            // console.log('Screenshare stream: ', stream.getVideoTracks());
+            return {
+                video: stream.getVideoTracks()[0],
+                audio: stream.getAudioTracks()[0],
+            };
+        });
+    }
+    static getAudioAndVideoTrack(constraints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mediaStream = (yield LocalMediaUtils.getUserMediaWithTimeout(constraints));
+            return {
+                audioTrack: mediaStream.getAudioTracks()[0],
+                videoTrack: mediaStream.getVideoTracks()[0],
+            };
+        });
+    }
+    onDeviceChange(callback) {
+        const onChange = (deviceData) => __awaiter(this, void 0, void 0, function* () {
+            const checkDeviceId = (_id) => {
+                if (_id.toLowerCase().includes('speaker'))
+                    return 'speaker';
+                else
+                    return _id;
+            };
+            const previouslyAvailableDevices = __classPrivateFieldGet(this, _LocalMediaUtils_availableDevices, "f").filter((device) => device.kind === 'audioinput' || device.kind === 'audiooutput');
+            const previouslyAvailableDeviceIds = previouslyAvailableDevices.map((device) => checkDeviceId(device.deviceId));
+            const len = deviceData.availableAudioDeviceList.length;
+            if (len === 0) {
+                const currentlyAvailableDevices = yield LocalMediaUtils.enumerateAudioDevices();
+                const currentlyAvailableDeviceIds = currentlyAvailableDevices.map((device) => checkDeviceId(device.deviceId));
+                const changedDevices = {
+                    added: currentlyAvailableDevices.filter((device) => !previouslyAvailableDeviceIds.includes(checkDeviceId(device.deviceId))),
+                    removed: previouslyAvailableDevices.filter((device) => !currentlyAvailableDeviceIds.includes(device.deviceId)),
+                };
+                this.repopulateAvailableDevices().then(() => {
+                    callback(changedDevices, false);
+                });
+            }
+            else {
+                const currentlyAvailableDevices = yield LocalMediaUtils.enumerateAudioDevices();
+                const currentlyAvailableDeviceIds = currentlyAvailableDevices.map((device) => checkDeviceId(device.deviceId));
+                const availableAudioDevices = yield LocalMediaUtils.enumerateAudioDevices();
+                const changedDevices = {
+                    added: availableAudioDevices.filter((device) => !previouslyAvailableDeviceIds.includes(checkDeviceId(device.deviceId))),
+                    removed: previouslyAvailableDevices.filter((device) => !currentlyAvailableDeviceIds.includes(device.deviceId)),
+                };
+                this.repopulateAvailableDevices().then(() => {
+                    callback(changedDevices, false);
+                });
+            }
+        });
+        if (__classPrivateFieldGet(this, _LocalMediaUtils_nativeEventEmitter, "f").listenerCount('onAudioDeviceChanged') === 0) {
+            __classPrivateFieldGet(this, _LocalMediaUtils_nativeEventEmitter, "f").addListener('onAudioDeviceChanged', onChange);
+        }
+    }
+    repopulateAvailableDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const videoDevices = yield LocalMediaUtils.enumerateVideoDevices();
+            const audioDevices = yield LocalMediaUtils.enumerateAudioDevices();
+            __classPrivateFieldSet(this, _LocalMediaUtils_availableDevices, videoDevices.concat(audioDevices), "f");
+        });
+    }
+    chooseAudioRoute(route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield NativeAudioManager.chooseAudioRoute(route);
+        });
+    }
+    get availableDevices() {
+        return __classPrivateFieldGet(this, _LocalMediaUtils_availableDevices, "f");
+    }
+    getAvailableDevicesByKind(kind) {
+        return __classPrivateFieldGet(this, _LocalMediaUtils_availableDevices, "f").filter((device) => device.kind === kind);
+    }
+    getDeviceById(deviceId, kind) {
+        return __classPrivateFieldGet(this, _LocalMediaUtils_availableDevices, "f").find((device) => device.deviceId === deviceId && device.kind === kind);
+    }
+    /**
+     * Returns all audio input devices (microphone devices).
+     */
+    getAudioDevices() {
+        return this.getAvailableDevicesByKind('audioinput');
+    }
+    /**
+     * Returns all video input devices.
+     */
+    getVideoDevices() {
+        return this.getAvailableDevicesByKind('videoinput');
+    }
+    /**
+     * Returns all audio output devices (speaker devices).
+     */
+    getSpeakerDevices() {
+        return this.getAvailableDevicesByKind('audiooutput');
+    }
+}
+_LocalMediaUtils_availableDevices = new WeakMap(), _LocalMediaUtils_nativeEventEmitter = new WeakMap();
+export default LocalMediaUtils;

package/lib/NativeAudioManager.d.ts

@@ -0,0 +1,16 @@
+declare class InCallManager {
+    constructor();
+    start(setup: any): void;
+    stop(setup: any): void;
+    getIsWiredHeadsetPluggedIn(): Promise<any>;
+    isBluetoothHeadsetConnected(): Promise<any>;
+    setKeepScreenOn(enable: any): void;
+    setSpeakerphoneOn(enable: any): void;
+    setForceSpeakerphoneOn(_flag: any): void;
+    setMicrophoneMute(enable: any): void;
+    chooseAudioRoute(route: String): Promise<any>;
+    requestAudioFocus(): Promise<any>;
+    abandonAudioFocus(): Promise<any>;
+}
+declare const _default: InCallManager;
+export default _default;

package/lib/NativeAudioManager.js

@@ -0,0 +1,93 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// @ts-nocheck
+import { Platform, NativeModules } from 'react-native';
+const _InCallManager = NativeModules.InCallManager;
+class InCallManager {
+    constructor() {
+        this.vibrate = false;
+    }
+    start(setup) {
+        setup = setup === undefined ? {} : setup;
+        const auto = setup.auto !== false;
+        const media = setup.media === 'video' ? 'video' : 'audio';
+        const ringback = setup.ringback
+            ? typeof setup.ringback === 'string'
+                ? setup.ringback
+                : ''
+            : '';
+        _InCallManager.start(media, auto, ringback);
+    }
+    stop(setup) {
+        setup = setup === undefined ? {} : setup;
+        const busytone = setup.busytone
+            ? typeof setup.busytone === 'string'
+                ? setup.busytone
+                : ''
+            : '';
+        _InCallManager.stop(busytone);
+    }
+    getIsWiredHeadsetPluggedIn() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield _InCallManager.getIsWiredHeadsetPluggedIn();
+            }
+            catch (e) {
+                return {};
+            }
+        });
+    }
+    isBluetoothHeadsetConnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield _InCallManager.isBluetoothHeadsetConnected();
+            }
+            catch (e) {
+                return {};
+            }
+        });
+    }
+    setKeepScreenOn(enable) {
+        enable = enable === true;
+        _InCallManager.setKeepScreenOn(enable);
+    }
+    setSpeakerphoneOn(enable) {
+        enable = enable === true;
+        _InCallManager.setSpeakerphoneOn(enable);
+    }
+    setForceSpeakerphoneOn(_flag) {
+        const flag = typeof _flag === 'boolean' ? (_flag ? 1 : -1) : 0;
+        _InCallManager.setForceSpeakerphoneOn(flag);
+    }
+    setMicrophoneMute(enable) {
+        enable = enable === true;
+        _InCallManager.setMicrophoneMute(enable);
+    }
+    chooseAudioRoute(route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _InCallManager.chooseAudioRoute(route);
+        });
+    }
+    requestAudioFocus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Platform.OS === 'android') {
+                return yield _InCallManager.requestAudioFocusJS();
+            }
+        });
+    }
+    abandonAudioFocus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Platform.OS === 'android') {
+                return yield _InCallManager.abandonAudioFocusJS();
+            }
+        });
+    }
+}
+export default new InCallManager();

package/lib/PermissionHandler.d.ts

@@ -0,0 +1,34 @@
+import { MediaPermission } from './LocalMediaInterfaces';
+declare const ANDROID: Readonly<{
+    readonly CAMERA: "android.permission.CAMERA";
+    readonly BLUETOOTH: "android.permission.BLUETOOTH_CONNECT";
+    readonly RECORD_AUDIO: "android.permission.RECORD_AUDIO";
+    readonly LOCATION: "android.permission.ACCESS_FINE_LOCATION";
+}>;
+type AndroidPermissionMap = typeof ANDROID;
+declare const IOS: Readonly<{
+    readonly APP_TRACKING_TRANSPARENCY: "ios.permission.APP_TRACKING_TRANSPARENCY";
+    readonly BLUETOOTH_PERIPHERAL: "ios.permission.BLUETOOTH_PERIPHERAL";
+    readonly CAMERA: "ios.permission.CAMERA";
+    readonly MICROPHONE: "ios.permission.MICROPHONE";
+}>;
+type IOSPermissionMap = typeof IOS;
+export declare const PERMISSIONS: Readonly<{
+    readonly ANDROID: AndroidPermissionMap;
+    readonly IOS: IOSPermissionMap;
+}>;
+export declare const RESULTS: Readonly<{
+    readonly UNAVAILABLE: "unavailable";
+    readonly BLOCKED: "blocked";
+    readonly DENIED: "denied";
+    readonly GRANTED: "granted";
+    readonly LIMITED: "limited";
+    readonly PROMPTED: "prompted";
+}>;
+export declare function uniq(array: any): any;
+export type DynamicPermissions = Array<'camera' | 'microphone'>;
+export declare const setupPermissions: (audio: boolean, video: boolean) => Promise<{
+    [key: string]: MediaPermission;
+}>;
+export type ResultMap = typeof RESULTS;
+export {};