@whereby.com/browser-sdk 2.0.0-beta1 → 2.0.0-beta3

package/dist/api/organizationServiceCache/index.js

@@ -1,16 +0,0 @@
-export default class OrganizationServiceCache {
-    constructor({ organizationService, 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

@@ -1,13 +0,0 @@
-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: unknown) => 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

@@ -1,64 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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

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

package/dist/api/test/helpers.js

@@ -1,32 +0,0 @@
-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

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

package/dist/api/types.js

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

package/dist/react/VideoView.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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.js

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

package/dist/react/useLocalMedia.d.ts

@@ -1,28 +0,0 @@
-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 {};

package/dist/react/useLocalMedia.js

@@ -1,109 +0,0 @@
-import { __awaiter } from "tslib";
-import { useEffect, useReducer, useState } from "react";
-import LocalMedia from "../LocalMedia";
-const initialState = {
-    cameraDeviceError: null,
-    cameraDevices: [],
-    isSettingCameraDevice: false,
-    isSettingMicrophoneDevice: false,
-    isStarting: false,
-    microphoneDeviceError: null,
-    microphoneDevices: [],
-    speakerDevices: [],
-    startError: null,
-};
-function reducer(state, action) {
-    switch (action.type) {
-        case "DEVICE_LIST_UPDATED":
-            return Object.assign(Object.assign({}, state), action.payload);
-        case "LOCAL_STREAM_UPDATED":
-            return Object.assign(Object.assign({}, state), { currentCameraDeviceId: action.payload.currentCameraDeviceId, currentMicrophoneDeviceId: action.payload.currentMicrophoneDeviceId, localStream: action.payload.stream });
-        case "SET_CAMERA_DEVICE":
-            return Object.assign(Object.assign({}, state), { cameraDeviceError: null, isSettingCameraDevice: true });
-        case "SET_CAMERA_DEVICE_COMPLETE":
-            return Object.assign(Object.assign({}, state), { isSettingCameraDevice: false });
-        case "SET_CAMERA_DEVICE_ERROR":
-            return Object.assign(Object.assign({}, state), { cameraDeviceError: action.payload, isSettingCameraDevice: false });
-        case "SET_MICROPHONE_DEVICE":
-            return Object.assign(Object.assign({}, state), { isSettingMicrophoneDevice: true, microphoneDeviceError: null });
-        case "SET_MICROPHONE_DEVICE_COMPLETE":
-            return Object.assign(Object.assign({}, state), { isSettingMicrophoneDevice: false });
-        case "SET_MICROPHONE_DEVICE_ERROR":
-            return Object.assign(Object.assign({}, state), { isSettingMicrophoneDevice: false, microphoneDeviceError: action.payload });
-        case "START":
-            return Object.assign(Object.assign({}, state), { isStarting: true, startError: null });
-        case "START_COMPLETE":
-            return Object.assign(Object.assign({}, state), { isStarting: false });
-        case "START_ERROR":
-            return Object.assign(Object.assign({}, state), { isStarting: false, startError: action.payload });
-        default:
-            return state;
-    }
-}
-export default function useLocalMedia(constraintsOrStream = { audio: true, video: true }) {
-    const [localMedia] = useState(() => new LocalMedia(constraintsOrStream));
-    const [state, dispatch] = useReducer(reducer, initialState);
-    useEffect(() => {
-        localMedia.addEventListener("device_list_updated", (e) => {
-            const { cameraDevices, microphoneDevices, speakerDevices } = e.detail;
-            dispatch({ type: "DEVICE_LIST_UPDATED", payload: { cameraDevices, microphoneDevices, speakerDevices } });
-        });
-        localMedia.addEventListener("stream_updated", (e) => {
-            const { stream } = e.detail;
-            dispatch({
-                type: "LOCAL_STREAM_UPDATED",
-                payload: {
-                    stream,
-                    currentCameraDeviceId: localMedia.getCameraDeviceId(),
-                    currentMicrophoneDeviceId: localMedia.getMicrophoneDeviceId(),
-                },
-            });
-        });
-        const start = () => __awaiter(this, void 0, void 0, function* () {
-            dispatch({ type: "START" });
-            try {
-                yield localMedia.start();
-                dispatch({ type: "START_COMPLETE" });
-            }
-            catch (error) {
-                dispatch({ type: "START_ERROR", payload: error });
-            }
-        });
-        start();
-        return () => {
-            localMedia.stop();
-        };
-    }, []);
-    return {
-        state,
-        actions: {
-            setCameraDevice: (...args) => __awaiter(this, void 0, void 0, function* () {
-                dispatch({ type: "SET_CAMERA_DEVICE" });
-                try {
-                    yield localMedia.setCameraDevice(...args);
-                    dispatch({ type: "SET_CAMERA_DEVICE_COMPLETE" });
-                }
-                catch (error) {
-                    dispatch({ type: "SET_CAMERA_DEVICE_ERROR", payload: error });
-                }
-            }),
-            setMicrophoneDevice: (...args) => __awaiter(this, void 0, void 0, function* () {
-                dispatch({ type: "SET_MICROPHONE_DEVICE" });
-                try {
-                    yield localMedia.setMicrophoneDevice(...args);
-                    dispatch({ type: "SET_MICROPHONE_DEVICE_COMPLETE" });
-                }
-                catch (error) {
-                    dispatch({ type: "SET_MICROPHONE_DEVICE_ERROR", payload: error });
-                }
-            }),
-            toggleCameraEnabled: (...args) => {
-                return localMedia.toggleCameraEnabled(...args);
-            },
-            toggleMicrophoneEnabled: (...args) => {
-                return localMedia.toggleMichrophoneEnabled(...args);
-            },
-        },
-        _ref: localMedia,
-    };
-}

package/dist/react/useRoomConnection.d.ts

@@ -1,55 +0,0 @@
-import React from "react";
-import VideoView from "./VideoView";
-import { LocalMediaRef } from "./useLocalMedia";
-import RoomConnection, { ChatMessage, CloudRecordingState, RoomConnectionOptions, ConnectionStatus, LiveStreamState } from "../RoomConnection";
-import { LocalParticipant, RemoteParticipant, Screenshare } from "../RoomParticipant";
-export type RemoteParticipantState = Omit<RemoteParticipant, "updateStreamState" | "newJoiner" | "streams" | "addStream" | "removeStream">;
-export type LocalParticipantState = LocalParticipant;
-export interface WaitingParticipantState {
-    id: string;
-    displayName: string | null;
-}
-export interface ChatMessageState {
-    senderId: string;
-    timestamp: string;
-    text: string;
-}
-export type ScreenshareState = Screenshare;
-type LocalScreenshareStatus = "starting" | "active";
-export interface RoomConnectionState {
-    chatMessages: ChatMessage[];
-    cloudRecording?: CloudRecordingState;
-    localScreenshareStatus?: LocalScreenshareStatus;
-    localParticipant?: LocalParticipantState;
-    remoteParticipants: RemoteParticipantState[];
-    screenshares: Screenshare[];
-    connectionStatus: ConnectionStatus;
-    liveStream?: LiveStreamState;
-    waitingParticipants: WaitingParticipantState[];
-}
-interface UseRoomConnectionOptions extends Omit<RoomConnectionOptions, "localMedia"> {
-    localMedia?: LocalMediaRef;
-}
-interface RoomConnectionActions {
-    sendChatMessage(text: string): void;
-    knock(): void;
-    setDisplayName(displayName: string): void;
-    toggleCamera(enabled?: boolean): void;
-    toggleMicrophone(enabled?: boolean): void;
-    acceptWaitingParticipant(participantId: string): void;
-    rejectWaitingParticipant(participantId: string): void;
-    startScreenshare(): void;
-    stopScreenshare(): void;
-}
-type VideoViewComponentProps = Omit<React.ComponentProps<typeof VideoView>, "onResize">;
-interface RoomConnectionComponents {
-    VideoView: (props: VideoViewComponentProps) => ReturnType<typeof VideoView>;
-}
-export type RoomConnectionRef = {
-    state: RoomConnectionState;
-    actions: RoomConnectionActions;
-    components: RoomConnectionComponents;
-    _ref: RoomConnection;
-};
-export declare function useRoomConnection(roomUrl: string, roomConnectionOptions?: UseRoomConnectionOptions): RoomConnectionRef;
-export {};