@whereby.com/browser-sdk 2.0.0-alpha23 → 2.0.0-alpha26

package/dist/api/organizationServiceCache/index.js

@@ -0,0 +1,20 @@
+import { assertInstanceOf, assertString } from "../parameterAssertUtils";
+import OrganizationService from "../organizationService/index";
+export default class OrganizationServiceCache {
+    constructor({ organizationService, subdomain }) {
+        assertInstanceOf(organizationService, OrganizationService);
+        assertString(subdomain, "subdomain");
+        this._organizationService = organizationService;
+        this._subdomain = subdomain;
+        this._organizationPromise = null;
+    }
+    initOrganization() {
+        return this.fetchOrganization().then(() => undefined);
+    }
+    fetchOrganization() {
+        if (!this._organizationPromise) {
+            this._organizationPromise = this._organizationService.getOrganizationBySubdomain(this._subdomain);
+        }
+        return this._organizationPromise;
+    }
+}

package/dist/api/parameterAssertUtils.d.ts

@@ -0,0 +1,13 @@
+export declare function assertTruthy(value: unknown, parameterName: string): unknown;
+export declare function assertBoolean(value: unknown, parameterName: string): boolean;
+export declare function assertNumber(value: unknown, parameterName: string): number;
+export declare function assertString(value: unknown, parameterName: string): string;
+export declare function assertInstanceOf<T>(value: unknown, type: new (any: any) => T, parameterName?: string): T;
+export declare function assertRoomName(roomName: unknown, parameterName?: string): string;
+export declare function assertArray(array: unknown, parameterName: string): Array<unknown>;
+export declare function assertOneOf<T>(value: T, allowedValues: Array<unknown>, parameterName: string): T;
+export declare function assertType(ref: unknown, type: string, name: string, message?: string): void;
+export declare function assertRecord(ref: unknown, name: string): Record<string, unknown>;
+export declare function assertNullOrType(ref: unknown, type: string, name: string, message?: string): void;
+export declare function assertNullOrBoolean(ref: unknown, name: string, message?: string): void;
+export declare function assertNullOrString(ref: unknown, name: string, message?: string): void;

package/dist/api/parameterAssertUtils.js

@@ -0,0 +1,64 @@
+import assert from "assert";
+export function assertTruthy(value, parameterName) {
+    assert.ok(value, `${parameterName} is required`);
+    return value;
+}
+export function assertBoolean(value, parameterName) {
+    assert.ok(typeof value === "boolean", `${parameterName}<boolean> is required`);
+    return value;
+}
+export function assertNumber(value, parameterName) {
+    assert.ok(typeof value === "number", `${parameterName}<number> is required`);
+    return value;
+}
+export function assertString(value, parameterName) {
+    assert.ok(typeof value === "string", `${parameterName}<string> is required`);
+    return value;
+}
+export function assertInstanceOf(value, type, parameterName) {
+    const resolvedParameterName = parameterName || type.name[0].toLowerCase() + type.name.substring(1);
+    assert.ok(value instanceof type, `${resolvedParameterName}<${type.name}> is required`);
+    return value;
+}
+export function assertRoomName(roomName, parameterName = "roomName") {
+    assertString(roomName, parameterName);
+    assert.equal(typeof roomName === "string" && roomName[0], "/", `${parameterName} must begin with a '/'`);
+    return roomName;
+}
+export function assertArray(array, parameterName) {
+    assert.ok(Array.isArray(array), `${parameterName}<array> is required`);
+    return array;
+}
+export function assertOneOf(value, allowedValues, parameterName) {
+    assertTruthy(value, "value");
+    assertArray(allowedValues, "allowedValues");
+    const isAllowed = allowedValues.includes(value);
+    if (!isAllowed) {
+        throw new Error(`${parameterName}<string> must be one of the following: ${allowedValues.join(", ")}`);
+    }
+    return value;
+}
+export function assertType(ref, type, name, message) {
+    assert.ok(typeof name === "string", "name must be of type string");
+    const errorMessage = message || `${name} must be of type ${type}`;
+    assert.ok(ref !== null && typeof ref === type, errorMessage);
+}
+export function assertRecord(ref, name) {
+    if (ref === null || ref === undefined || typeof ref !== "object" || Array.isArray(ref)) {
+        throw new Error(`${name} must be a record. ${JSON.stringify(ref)}`);
+    }
+    return ref;
+}
+export function assertNullOrType(ref, type, name, message) {
+    assertString(name, "name");
+    const errorMessage = message || `${name} must be null or of type ${type}`;
+    assert.ok(ref === null || typeof ref === type, errorMessage);
+}
+export function assertNullOrBoolean(ref, name, message) {
+    assertString(name, "name");
+    assertNullOrType(ref, "boolean", name, message);
+}
+export function assertNullOrString(ref, name, message) {
+    assertString(name, "name");
+    assertNullOrType(ref, "string", name, message);
+}

package/dist/api/roomService/index.d.ts

@@ -0,0 +1,54 @@
+import Room from "../models/Room";
+export default class RoomService {
+    constructor({ organizationApiClient }: {
+        organizationApiClient: any;
+    });
+    getRooms({ types, fields }?: {
+        types: any;
+        fields?: never[] | undefined;
+    }): any;
+    getRoom({ roomName, fields }: {
+        roomName: string;
+        fields?: Array<string>;
+    }): Promise<Room>;
+    claimRoom({ roomName, type, mode, isLocked }: {
+        roomName: any;
+        type: any;
+        mode: any;
+        isLocked: any;
+    }): any;
+    unclaimRoom(roomName: any): any;
+    renameRoom({ roomName, newRoomName }: {
+        roomName: any;
+        newRoomName: any;
+    }): any;
+    changeMode({ roomName, mode }: {
+        roomName: any;
+        mode: any;
+    }): any;
+    updatePreferences({ roomName, preferences }: {
+        roomName: any;
+        preferences: any;
+    }): any;
+    updateProtectedPreferences({ roomName, preferences }: {
+        roomName: any;
+        preferences: any;
+    }): any;
+    getRoomPermissions(roomName: any, { roomKey }?: {
+        roomKey: any;
+    }): any;
+    getRoomMetrics({ roomName, metrics, from, to }: {
+        roomName: any;
+        metrics: any;
+        from: any;
+        to: any;
+    }): any;
+    changeType({ roomName, type }: {
+        roomName: any;
+        type: any;
+    }): any;
+    getForestSocialImage({ roomName, count }: {
+        roomName: any;
+        count: any;
+    }): any;
+}

package/dist/api/roomService/index.js

@@ -0,0 +1,160 @@
+import Room from "../models/Room";
+import { assertInstanceOf, assertRoomName, assertString, assertArray, assertOneOf, assertNumber, } from "../parameterAssertUtils";
+import OrganizationApiClient from "../OrganizationApiClient";
+import Meeting from "../models/Meeting";
+function createRoomUrl(roomName, path = "") {
+    const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+    return `/room/${encodedDisplayName}${path}`;
+}
+export default class RoomService {
+    constructor({ organizationApiClient }) {
+        this._organizationApiClient = assertInstanceOf(organizationApiClient, OrganizationApiClient);
+    }
+    getRooms({ types, fields = [] } = {}) {
+        assertArray(types, "types");
+        assertArray(fields, "fields");
+        return this._organizationApiClient
+            .request("/room", {
+            method: "GET",
+            params: { types: types.join(","), fields: fields.join(","), includeOnlyLegacyRoomType: "false" },
+        })
+            .then(({ data }) => data.rooms.map((room) => new Room(room)));
+    }
+    getRoom({ roomName, fields }) {
+        assertRoomName(roomName);
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/rooms/${encodedDisplayName}`, {
+            method: "GET",
+            params: Object.assign({ includeOnlyLegacyRoomType: "false" }, (fields && { fields: fields.join(",") })),
+        })
+            .then(({ data }) => new Room(Object.assign({}, data, Object.assign({ roomName }, (data.meeting && { meeting: Meeting.fromJson(data.meeting) })))))
+            .catch((response) => {
+            if (response.status === 404) {
+                return new Room({
+                    roomName,
+                    isClaimed: false,
+                    mode: "normal",
+                    product: {
+                        categoryName: "personal_free",
+                    },
+                    type: "personal",
+                    legacyRoomType: "free",
+                });
+            }
+            if (response.status === 400 && response.data.error === "Banned room") {
+                return new Room({ roomName, isBanned: true });
+            }
+            throw new Error(response.data ? response.data.error : "Could not fetch room information");
+        });
+    }
+    claimRoom({ roomName, type, mode, isLocked }) {
+        assertRoomName(roomName);
+        assertString(type, "type");
+        return this._organizationApiClient
+            .request("/room/claim", {
+            method: "POST",
+            data: Object.assign(Object.assign({ roomName,
+                type }, (typeof mode === "string" && { mode })), (typeof isLocked === "boolean" && { isLocked })),
+        })
+            .then(() => undefined)
+            .catch((response) => {
+            throw new Error(response.data.error || "Failed to claim room");
+        });
+    }
+    unclaimRoom(roomName) {
+        assertRoomName(roomName);
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}`, {
+            method: "DELETE",
+        })
+            .then(() => undefined);
+    }
+    renameRoom({ roomName, newRoomName }) {
+        assertRoomName(roomName);
+        assertString(newRoomName, "newRoomName");
+        const encodedRoomName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedRoomName}/roomName`, {
+            method: "PUT",
+            data: { newRoomName },
+        })
+            .then(() => undefined);
+    }
+    changeMode({ roomName, mode }) {
+        assertRoomName(roomName);
+        assertString(mode, "mode");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/mode`, {
+            method: "PUT",
+            data: { mode },
+        })
+            .then(() => undefined);
+    }
+    updatePreferences({ roomName, preferences }) {
+        assertRoomName(roomName);
+        assertInstanceOf(preferences, Object, "preferences");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/preferences`, {
+            method: "PATCH",
+            data: preferences,
+        })
+            .then(() => undefined);
+    }
+    updateProtectedPreferences({ roomName, preferences }) {
+        assertRoomName(roomName);
+        assertInstanceOf(preferences, Object, "preferences");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/protected-preferences`, {
+            method: "PATCH",
+            data: preferences,
+        })
+            .then(() => undefined);
+    }
+    getRoomPermissions(roomName, { roomKey } = {}) {
+        assertRoomName(roomName);
+        return this._organizationApiClient
+            .request(createRoomUrl(roomName, "/permissions"), Object.assign({ method: "GET" }, (roomKey && { headers: { "X-Whereby-Room-Key": roomKey } })))
+            .then((response) => {
+            const { permissions, limits } = response.data;
+            return {
+                permissions,
+                limits,
+            };
+        });
+    }
+    getRoomMetrics({ roomName, metrics, from, to }) {
+        assertRoomName(roomName);
+        assertString(metrics, "metrics");
+        return this._organizationApiClient
+            .request(createRoomUrl(roomName, "/metrics"), {
+            method: "GET",
+            params: { metrics, from, to },
+        })
+            .then((response) => response.data);
+    }
+    changeType({ roomName, type }) {
+        assertRoomName(roomName);
+        assertOneOf(type, ["personal", "personal_xl"], "type");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/type`, {
+            method: "PUT",
+            data: { type },
+        })
+            .then(() => undefined);
+    }
+    getForestSocialImage({ roomName, count }) {
+        assertRoomName(roomName);
+        assertNumber(count, "count");
+        return this._organizationApiClient
+            .request(createRoomUrl(roomName, `/forest-social-image/${count}`), {
+            method: "GET",
+        })
+            .then((response) => response.data.imageUrl);
+    }
+}

package/dist/api/test/helpers.d.ts

@@ -0,0 +1,5 @@
+import { Json } from "../Response";
+export declare const itShouldThrowIfInvalid: (missingPropertyName: string, func: () => void, regexMatcher?: RegExp) => void;
+export declare const itShouldRejectIfApiClientRejects: (getApiClient: any, func: () => void) => void;
+export declare const itShouldRejectIfMultipartRequestRejects: (getApiClient: any, func: () => void) => void;
+export declare function toJson(value: unknown): Json;

package/dist/api/test/helpers.js

@@ -0,0 +1,32 @@
+import { __awaiter } from "tslib";
+export const itShouldThrowIfInvalid = (missingPropertyName, func, regexMatcher) => {
+    const testingNoArguments = !missingPropertyName;
+    const isOrAre = missingPropertyName[missingPropertyName.length - 1] === "s" ? "are" : "is";
+    const scenario = testingNoArguments ? "arguments are missing" : `${missingPropertyName} ${isOrAre} invalid`;
+    const expectedException = testingNoArguments
+        ? undefined
+        : regexMatcher || new RegExp(`${missingPropertyName}(<[\\w|]+>)? (is|are) required`);
+    it(`should throw if ${scenario}`, () => {
+        expect(() => {
+            func();
+        }).toThrowError(expectedException);
+    });
+};
+export const itShouldRejectIfApiClientRejects = (getApiClient, func) => {
+    it("should fail if the request failed", () => __awaiter(void 0, void 0, void 0, function* () {
+        const error = new Error("some error");
+        getApiClient().request.mockRejectedValue(error);
+        yield expect(func()).rejects.toThrow(error);
+    }));
+};
+export const itShouldRejectIfMultipartRequestRejects = (getApiClient, func) => {
+    it("should fail if the requestMultipart failed", () => {
+        const error = new Error("some error");
+        getApiClient().requestMultipart.rejects(error);
+        const promise = func();
+        return expect(promise).to.eventually.be.rejected().toBe(error);
+    });
+};
+export function toJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}

package/dist/api/types.d.ts

@@ -0,0 +1,5 @@
+export type UserConsentAction = "accepted" | "rejected" | null;
+export type ConsentGrantRequest = {
+    readonly consentRevisionId: string;
+    readonly action: UserConsentAction;
+};

package/dist/api/types.js

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

package/dist/embed/index.d.ts

@@ -0,0 +1,31 @@
+interface WherebyEmbedAttributes {
+    audio: string;
+    avatarUrl: string;
+    background: string;
+    cameraAccess: string;
+    chat: string;
+    displayName: string;
+    emptyRoomInvitation: string;
+    floatSelf: string;
+    help: string;
+    leaveButton: string;
+    logo: string;
+    people: string;
+    precallReview: string;
+    recording: string;
+    screenshare: string;
+    video: string;
+    virtualBackgroundUrl: string;
+    room: string;
+    style: {
+        [key: string]: string;
+    };
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            ["whereby-embed"]: Partial<WherebyEmbedAttributes>;
+        }
+    }
+}
+export {};

package/dist/embed/index.js

@@ -0,0 +1,123 @@
+import { define, ref } from "heresy";
+const boolAttrs = [
+    "audio",
+    "background",
+    "cameraaccess",
+    "chat",
+    "people",
+    "embed",
+    "emptyRoomInvitation",
+    "help",
+    "leaveButton",
+    "precallReview",
+    "screenshare",
+    "video",
+    "floatSelf",
+    "recording",
+    "logo",
+    "locking",
+    "participantCount",
+    "settingsButton",
+    "pipButton",
+    "moreButton",
+    "personality",
+    "subgridLabels",
+    "lowData",
+    "breakout",
+];
+define("WherebyEmbed", {
+    oninit() {
+        this.iframe = ref();
+    },
+    onconnected() {
+        window.addEventListener("message", this.onmessage);
+    },
+    ondisconnected() {
+        window.removeEventListener("message", this.onmessage);
+    },
+    observedAttributes: [
+        "displayName",
+        "minimal",
+        "room",
+        "subdomain",
+        "lang",
+        "metadata",
+        "groups",
+        "virtualBackgroundUrl",
+        "avatarUrl",
+        ...boolAttrs,
+    ].map((a) => a.toLowerCase()),
+    onattributechanged({ attributeName, oldValue }) {
+        if (["room", "subdomain"].includes(attributeName) && oldValue == null)
+            return;
+        this.render();
+    },
+    style(self) {
+        return `
+    ${self} {
+      display: block;
+    }
+    ${self} iframe {
+      border: none;
+      height: 100%;
+      width: 100%;
+    }
+    `;
+    },
+    _postCommand(command, args = []) {
+        if (this.iframe.current) {
+            this.iframe.current.contentWindow.postMessage({ command, args }, this.url.origin);
+        }
+    },
+    startRecording() {
+        this._postCommand("start_recording");
+    },
+    stopRecording() {
+        this._postCommand("stop_recording");
+    },
+    toggleCamera(enabled) {
+        this._postCommand("toggle_camera", [enabled]);
+    },
+    toggleMicrophone(enabled) {
+        this._postCommand("toggle_microphone", [enabled]);
+    },
+    toggleScreenshare(enabled) {
+        this._postCommand("toggle_screenshare", [enabled]);
+    },
+    onmessage({ origin, data }) {
+        var _a;
+        if (origin !== ((_a = this.url) === null || _a === void 0 ? void 0 : _a.origin))
+            return;
+        const { type, payload: detail } = data;
+        this.dispatchEvent(new CustomEvent(type, { detail }));
+    },
+    render() {
+        const { avatarurl: avatarUrl, displayname: displayName, lang, metadata, minimal, room, groups, virtualbackgroundurl: virtualBackgroundUrl, } = this;
+        if (!room)
+            return this.html `Whereby: Missing room attribute.`;
+        const m = /https:\/\/([^.]+)(\.whereby.com|-ip-\d+-\d+-\d+-\d+.hereby.dev:4443)\/.+/.exec(room);
+        const subdomain = (m && m[1]) || this.subdomain;
+        if (!subdomain)
+            return this.html `Whereby: Missing subdomain attr.`;
+        if (!m) {
+            return this.html `could not parse URL.`;
+        }
+        const baseURL = m[2] || `.whereby.com`;
+        this.url = new URL(room, `https://${subdomain}${baseURL}`);
+        const roomUrl = new URL(room);
+        if (roomUrl.searchParams.get("roomKey")) {
+            this.url.searchParams.append("roomKey", roomUrl.searchParams.get("roomKey"));
+        }
+        Object.entries(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ jsApi: true, we: "__SDK_VERSION__", iframeSource: subdomain }, (displayName && { displayName })), (lang && { lang })), (metadata && { metadata })), (groups && { groups })), (virtualBackgroundUrl && { virtualBackgroundUrl })), (avatarUrl && { avatarUrl })), (minimal != null && { embed: minimal })), boolAttrs.reduce((o, v) => (this[v.toLowerCase()] != null ? Object.assign(Object.assign({}, o), { [v]: this[v.toLowerCase()] }) : o), {}))).forEach(([k, v]) => {
+            if (!this.url.searchParams.has(k) && typeof v === "string") {
+                this.url.searchParams.set(k, v);
+            }
+        });
+        return this.html `
+        <iframe
+            ref=${this.iframe}
+            src=${this.url}
+            allow="autoplay; camera; microphone; fullscreen; speaker; display-capture" />
+        `;
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import "./embed";
+export { useLocalMedia, useRoomConnection, VideoView } from "./react";
+export { default as fakeWebcamFrame } from "./utils/fakeWebcamFrame";
+export { default as fakeAudioStream } from "./utils/fakeAudioStream";
+export declare const sdkVersion = "__SDK_VERSION__";

package/dist/index.js

@@ -0,0 +1,5 @@
+import "./embed";
+export { useLocalMedia, useRoomConnection, VideoView } from "./react";
+export { default as fakeWebcamFrame } from "./utils/fakeWebcamFrame";
+export { default as fakeAudioStream } from "./utils/fakeAudioStream";
+export const sdkVersion = "__SDK_VERSION__";

package/dist/react/VideoView.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+interface VideoViewSelfProps {
+    stream: MediaStream;
+    muted?: boolean;
+    mirror?: boolean;
+    style?: React.CSSProperties;
+    onResize?: ({ width, height, stream }: {
+        width: number;
+        height: number;
+        stream: MediaStream;
+    }) => void;
+}
+type VideoViewProps = VideoViewSelfProps & React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
+declare const _default: ({ muted, mirror, stream, onResize, ...rest }: VideoViewProps) => JSX.Element;
+export default _default;

package/dist/react/VideoView.js

@@ -0,0 +1,37 @@
+import { __rest } from "tslib";
+import React, { useEffect, useRef } from "react";
+import debounce from "../utils/debounce";
+export default (_a) => {
+    var { muted, mirror = false, stream, onResize } = _a, rest = __rest(_a, ["muted", "mirror", "stream", "onResize"]);
+    const videoEl = useRef(null);
+    useEffect(() => {
+        if (!videoEl.current || !onResize) {
+            return;
+        }
+        const resizeObserver = new ResizeObserver(debounce(() => {
+            if (videoEl.current && (stream === null || stream === void 0 ? void 0 : stream.id)) {
+                onResize({
+                    width: videoEl.current.clientWidth,
+                    height: videoEl.current.clientHeight,
+                    stream,
+                });
+            }
+        }, { delay: 1000, edges: true }));
+        resizeObserver.observe(videoEl.current);
+        return () => {
+            resizeObserver.disconnect();
+        };
+    }, [stream]);
+    useEffect(() => {
+        if (!videoEl.current) {
+            return;
+        }
+        if (videoEl.current.srcObject !== stream) {
+            videoEl.current.srcObject = stream;
+        }
+        if (videoEl.current.muted !== muted) {
+            videoEl.current.muted = Boolean(muted);
+        }
+    }, [muted, stream, videoEl]);
+    return (React.createElement("video", Object.assign({ ref: videoEl, autoPlay: true, playsInline: true }, rest, { style: Object.assign({ transform: mirror ? "scaleX(-1)" : "none" }, rest.style) })));
+};

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export { default as VideoView } from "./VideoView";
+export { default as useLocalMedia } from "./useLocalMedia";
+export { useRoomConnection } from "./useRoomConnection";

package/dist/react/index.js

@@ -0,0 +1,3 @@
+export { default as VideoView } from "./VideoView";
+export { default as useLocalMedia } from "./useLocalMedia";
+export { useRoomConnection } from "./useRoomConnection";

package/dist/react/useLocalMedia.d.ts

@@ -0,0 +1,28 @@
+import LocalMedia from "../LocalMedia";
+interface LocalMediaState {
+    currentCameraDeviceId?: string;
+    currentMicrophoneDeviceId?: string;
+    cameraDeviceError: unknown;
+    cameraDevices: MediaDeviceInfo[];
+    isSettingCameraDevice: boolean;
+    isSettingMicrophoneDevice: boolean;
+    isStarting: boolean;
+    localStream?: MediaStream;
+    microphoneDeviceError: unknown;
+    microphoneDevices: MediaDeviceInfo[];
+    speakerDevices: MediaDeviceInfo[];
+    startError: unknown;
+}
+interface LocalMediaActions {
+    setCameraDevice: InstanceType<typeof LocalMedia>["setCameraDevice"];
+    setMicrophoneDevice: InstanceType<typeof LocalMedia>["setMicrophoneDevice"];
+    toggleCameraEnabled: InstanceType<typeof LocalMedia>["toggleCameraEnabled"];
+    toggleMicrophoneEnabled: InstanceType<typeof LocalMedia>["toggleMichrophoneEnabled"];
+}
+export type LocalMediaRef = {
+    state: LocalMediaState;
+    actions: LocalMediaActions;
+    _ref: LocalMedia;
+};
+export default function useLocalMedia(constraintsOrStream?: MediaStreamConstraints | MediaStream): LocalMediaRef;
+export {};