@whereby.com/browser-sdk 2.0.0-alpha9 → 2.0.0-beta2

package/README.md

@@ -1,38 +1,51 @@
 # `@whereby.com/browser-sdk`
 
-> This is a pre-release of the v2 version of this library, adding support for more custom integration using React hooks and plain JavaScript classes in addition to the web component for embedding.
+> [!WARNING]
+> This is a pre-release of the v2 version of this library, adding support for
+> more custom integration using React hooks and plain JavaScript classes in
+> addition to the web component for embedding.
 
-Whereby browser SDK is a library for seamless integration of Whereby (https://whereby.com) video calls into your web application.
+Whereby browser SDK is a library for seamless integration of Whereby
+(https://whereby.com) video calls into your web application.
+
+**For a more detailed set of instructions, including the building of a [simple telehealth app](https://docs.whereby.com/whereby-101/create-your-video-experience/in-a-web-page/using-whereby-react-hooks-build-a-telehealth-app), please see our [documentation](https://docs.whereby.com/reference/react-hooks-reference).**
 
 ## Installation
 
-```
+```shell
 npm install @whereby.com/browser-sdk
 ```
+
 or
-```
+
+```shell
 yarn add @whereby.com/browser-sdk
 ```
 
 ## Usage
-
-> In order to make use of this functionality, you must have a Whereby account from which you can create room urls, either [manually or through our API](https://docs.whereby.com/creating-and-deleting-rooms).
+> [!IMPORTANT]
+> In order to make use of this functionality, you must have a Whereby account
+> from which you can create room urls, either [manually or through our
+> API](https://docs.whereby.com/creating-and-deleting-rooms).
 
 ### React hooks
 
 #### useLocalMedia
-The `useLocalMedia` hook enables preview and selection of local devices (camera & microphone) prior to establishing a connection within a Whereby room. Use this hook to build rich pre-call
-experiences, allowing end users to confirm their device selection up-front. This hook works seamlessly with the `useRoomConnection` hook described below.
 
-```
-import { useLocalMedia, VideoView } from “@whereby.com/browser-sdk”;
+The `useLocalMedia` hook enables preview and selection of local devices (camera
+& microphone) prior to establishing a connection within a Whereby room. Use
+this hook to build rich pre-call experiences, allowing end users to confirm
+their device selection up-front. This hook works seamlessly with the
+`useRoomConnection` hook described below.
+
+```js
+import { useLocalMedia, VideoView } from "@whereby.com/browser-sdk/react";
 
 function MyPreCallUX() {
     const localMedia = useLocalMedia({ audio: false, video: true });
 
     const { currentCameraDeviceId, cameraDevices, localStream } = localMedia.state;
     const { setCameraDevice, toggleCameraEnabled } = localMedia.actions;
-    const { VideoView } = components;
 
     return <div className="preCallView">
         { /* Render any UI, making use of state */ }
@@ -54,18 +67,20 @@ function MyPreCallUX() {
 
 ```
 
-
 #### useRoomConnection
-The `useRoomConnection` hook provides a way to connect participants in a given room, subscribe to state updates, and perform actions on the connection, like toggling camera or microphone.
 
-```
-import { useRoomConnection } from “@whereby.com/browser-sdk”;
+The `useRoomConnection` hook provides a way to connect participants in a given
+room, subscribe to state updates, and perform actions on the connection, like
+toggling camera or microphone.
+
+```js
+import { useRoomConnection } from "@whereby.com/browser-sdk/react";
 
 function MyCallUX( { roomUrl, localStream }) {
-    const [state, actions, components ] = useRoomConnection(
+    const { state, actions, components } = useRoomConnection(
         "<room_url>"
         {
-            localMedia: null, // Supply localMedia from `useLocalMedia` hook, or constraints below
+            localMedia: null, // Supply localMedia from `useLocalMedia` hook, or constraints
             localMediaConstraints: {
                 audio: true,
                 video: true,
@@ -87,27 +102,64 @@ function MyCallUX( { roomUrl, localStream }) {
 
 ```
 
-### Web component for embedding
+#### Usage with Vite development environment
 
-Use the `<whereby-embed />` web component to make use of Whereby's pre-built responsive UI. Refer to our [documentation](https://docs.whereby.com/embedding-rooms/in-a-web-page/using-the-whereby-embed-element) to learn which attributes are supported.
+There is a [known Vite issue](https://github.com/vitejs/vite/issues/1973) where modules trying to access `process.env` throw `Uncaught ReferenceError: process is not defined`.
+This can be solved in `vite.config.js` with the following line:
 
+``` javascript
+export default defineConfig({
+    ...rest,
+    define: {
+        'process.env': {}
+    },
+});
+```
 
-#### React
+#### Usage with Next.js
 
-```
-import "@whereby.com/browser-sdk"
+If you are integrating these React hooks with Next.js, you need to ensure your
+custom video experience components are rendered client side, as the underlying
+APIs we use are only available in the browser context. Simply add `"use
+client";` to the top of component, like in the following example:
 
-const MyComponent = ({ roomUrl }) => {
-    return <whereby-embed chat="off" room={roomUrl} />
+```js
+"use client";
+
+import { VideoView, useLocalMedia } from "@whereby.com/browser-sdk/react";
+
+export default function MyNextVideoExperience() {
+  const { state, actions } = useLocalMedia({ audio: false, video: true });
+
+  return (
+    <p>{ state.localStream && <VideoView muted stream={state.localStream} /> }</p>
+  );
 }
 
-export default MyComponent
+```
+
+### Web component for embedding
+
+Use the `<whereby-embed />` web component to make use of Whereby's pre-built
+responsive UI. Refer to our
+[documentation](https://docs.whereby.com/embedding-rooms/in-a-web-page/using-the-whereby-embed-element)
+to learn which attributes are supported.
 
+#### React
+
+```js
+import "@whereby.com/browser-sdk/embed";
+
+const MyComponent = ({ roomUrl }) => {
+    return <whereby-embed chat="off" room={roomUrl} />;
+};
+
+export default MyComponent;
 ```
 
 #### In plain HTML
 
-```
+```html
 <html>
     <head>
         <script src="...."></script>
@@ -120,6 +172,7 @@ export default MyComponent
 </html>
 ```
 
-**Note**
-
-Although we have just higlighted two combinations of how to load and use the web component, it should be possible to use this library with all the major frontend frameworks.
+> [!NOTE]
+> Although we have just higlighted two combinations of how to load and use the
+> web component, it should be possible to use this library with all the major
+> frontend frameworks.

package/dist/LocalMedia.d.ts

@@ -0,0 +1,70 @@
+import RtcManager from "@whereby/jslib-media/src/webrtc/RtcManager";
+type CameraEnabledEvent = {
+    enabled: boolean;
+};
+type MicrophoneEnabledEvent = {
+    enabled: boolean;
+};
+type DeviceListUpdatedEvent = {
+    cameraDevices: MediaDeviceInfo[];
+    microphoneDevices: MediaDeviceInfo[];
+    speakerDevices: MediaDeviceInfo[];
+};
+type DeviceListUpdateErrorEvent = {
+    error: unknown;
+};
+type StreamUpdatedEvent = {
+    stream: MediaStream;
+};
+type StopResumeVideoEvent = {
+    track: MediaStreamTrack;
+    enable: boolean;
+};
+interface LocalMediaEventsMap {
+    camera_enabled: CustomEvent<CameraEnabledEvent>;
+    device_list_updated: CustomEvent<DeviceListUpdatedEvent>;
+    device_list_update_error: CustomEvent<DeviceListUpdateErrorEvent>;
+    microphone_enabled: CustomEvent<MicrophoneEnabledEvent>;
+    stream_updated: CustomEvent<StreamUpdatedEvent>;
+    stopresumevideo: CustomEvent<StopResumeVideoEvent>;
+}
+interface LocalMediaEventTarget extends EventTarget {
+    addEventListener<K extends keyof LocalMediaEventsMap>(type: K, listener: (ev: LocalMediaEventsMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}
+declare const TypedLocalMediaEventTarget: new () => LocalMediaEventTarget;
+export interface LocalMediaOptions {
+    audio: boolean;
+    video: boolean;
+}
+export default class LocalMedia extends TypedLocalMediaEventTarget {
+    private _options;
+    _rtcManagers: RtcManager[];
+    private _devices;
+    stream: MediaStream;
+    screenshareStream?: MediaStream;
+    private _cameraEnabled;
+    private _currentCameraDeviceId;
+    private _isTogglingCameraEnabled;
+    private _microphoneEnabled;
+    private _currentMicrophoneDeviceId;
+    constructor(optionsOrStream: LocalMediaOptions | MediaStream);
+    addRtcManager(rtcManager: RtcManager): void;
+    removeRtcManager(rtcManager: RtcManager): void;
+    getCameraDeviceId(): string | undefined;
+    getMicrophoneDeviceId(): string | undefined;
+    isCameraEnabled(): boolean;
+    isMicrophoneEnabled(): boolean;
+    toggleCameraEnabled(enabled?: boolean): Promise<void>;
+    toggleMichrophoneEnabled(enabled?: boolean): void;
+    startScreenshare(): Promise<MediaStream>;
+    stopScreenshare(): void;
+    private _getConstraintsOptions;
+    private _setDevice;
+    setCameraDevice(deviceId: string): Promise<void>;
+    setMicrophoneDevice(deviceId: string): Promise<void>;
+    private _updateDeviceList;
+    start(): Promise<MediaStream>;
+    stop(): void;
+}
+export {};

package/dist/LocalMedia.js

@@ -0,0 +1,208 @@
+import { __awaiter } from "tslib";
+import { getStream } from "@whereby/jslib-media/src/webrtc/MediaDevices";
+class LocalMediaEvent extends CustomEvent {
+    constructor(eventType, eventInitDict) {
+        super(eventType, eventInitDict);
+    }
+}
+const TypedLocalMediaEventTarget = EventTarget;
+export default class LocalMedia extends TypedLocalMediaEventTarget {
+    constructor(optionsOrStream) {
+        var _a, _b;
+        super();
+        this._options = null;
+        this._devices = [];
+        this._isTogglingCameraEnabled = false;
+        if (optionsOrStream instanceof MediaStream) {
+            this.stream = optionsOrStream;
+        }
+        else {
+            this._options = optionsOrStream;
+            this.stream = new MediaStream();
+        }
+        this._cameraEnabled = ((_a = this.stream.getVideoTracks()[0]) === null || _a === void 0 ? void 0 : _a.enabled) || false;
+        this._microphoneEnabled = ((_b = this.stream.getAudioTracks()[0]) === null || _b === void 0 ? void 0 : _b.enabled) || false;
+        this._rtcManagers = [];
+        this.screenshareStream = undefined;
+        navigator.mediaDevices.addEventListener("devicechange", this._updateDeviceList.bind(this));
+    }
+    addRtcManager(rtcManager) {
+        this._rtcManagers.push(rtcManager);
+    }
+    removeRtcManager(rtcManager) {
+        this._rtcManagers = this._rtcManagers.filter((r) => r !== rtcManager);
+    }
+    getCameraDeviceId() {
+        return this._currentCameraDeviceId;
+    }
+    getMicrophoneDeviceId() {
+        return this._currentMicrophoneDeviceId;
+    }
+    isCameraEnabled() {
+        return this._cameraEnabled;
+    }
+    isMicrophoneEnabled() {
+        return this._microphoneEnabled;
+    }
+    toggleCameraEnabled(enabled) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._isTogglingCameraEnabled) {
+                return;
+            }
+            let track = this.stream.getVideoTracks()[0];
+            const newValue = enabled !== null && enabled !== void 0 ? enabled : !(track === null || track === void 0 ? void 0 : track.enabled);
+            if (this._cameraEnabled === newValue) {
+                return;
+            }
+            this._cameraEnabled = newValue;
+            this.dispatchEvent(new LocalMediaEvent("camera_enabled", { detail: { enabled: this._cameraEnabled } }));
+            const shouldStopTrack = !!this._options;
+            this._isTogglingCameraEnabled = true;
+            try {
+                if (this._cameraEnabled) {
+                    if (track) {
+                        track.enabled = true;
+                    }
+                    else {
+                        yield getStream(Object.assign(Object.assign({}, this._getConstraintsOptions()), { audioId: false, videoId: this._currentCameraDeviceId, type: "exact" }), { replaceStream: this.stream });
+                        track = this.stream.getVideoTracks()[0];
+                    }
+                }
+                else {
+                    if (!track) {
+                        return;
+                    }
+                    track.enabled = false;
+                    if (shouldStopTrack) {
+                        track.stop();
+                        this.stream.removeTrack(track);
+                    }
+                }
+                this.stream.dispatchEvent(new LocalMediaEvent("stopresumevideo", { detail: { track, enable: this._cameraEnabled } }));
+            }
+            catch (error) {
+            }
+            this._isTogglingCameraEnabled = false;
+        });
+    }
+    toggleMichrophoneEnabled(enabled) {
+        const audioTrack = this.stream.getAudioTracks()[0];
+        if (!audioTrack) {
+            return;
+        }
+        this._microphoneEnabled = enabled !== null && enabled !== void 0 ? enabled : !audioTrack.enabled;
+        this.dispatchEvent(new LocalMediaEvent("microphone_enabled", { detail: { enabled: this._microphoneEnabled } }));
+        audioTrack.enabled = this._microphoneEnabled;
+    }
+    startScreenshare() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.screenshareStream) {
+                return this.screenshareStream;
+            }
+            const screenshareStream = yield navigator.mediaDevices.getDisplayMedia();
+            this.screenshareStream = screenshareStream;
+            return this.screenshareStream;
+        });
+    }
+    stopScreenshare() {
+        var _a;
+        (_a = this.screenshareStream) === null || _a === void 0 ? void 0 : _a.getTracks().forEach((track) => track.stop());
+        this.screenshareStream = undefined;
+    }
+    _getConstraintsOptions() {
+        return {
+            devices: this._devices,
+            options: {
+                disableAEC: false,
+                disableAGC: false,
+                hd: true,
+                lax: false,
+                lowDataMode: false,
+                simulcast: true,
+                widescreen: true,
+            },
+        };
+    }
+    _setDevice({ audioId, videoId }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { replacedTracks } = yield getStream(Object.assign(Object.assign({}, this._getConstraintsOptions()), { audioId,
+                videoId, type: "exact" }), { replaceStream: this.stream });
+            if (replacedTracks) {
+                replacedTracks.forEach((oldTrack) => {
+                    const newTrack = oldTrack.kind === "audio" ? this.stream.getAudioTracks()[0] : this.stream.getVideoTracks()[0];
+                    this._rtcManagers.forEach((rtcManager) => {
+                        rtcManager.replaceTrack(oldTrack, newTrack);
+                    });
+                });
+            }
+            this.dispatchEvent(new LocalMediaEvent("stream_updated", {
+                detail: { stream: this.stream },
+            }));
+        });
+    }
+    setCameraDevice(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._currentCameraDeviceId = deviceId;
+            yield this._setDevice({ videoId: this._currentCameraDeviceId, audioId: false });
+        });
+    }
+    setMicrophoneDevice(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._currentMicrophoneDeviceId = deviceId;
+            yield this._setDevice({ audioId: this._currentMicrophoneDeviceId, videoId: false });
+        });
+    }
+    _updateDeviceList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const devices = yield navigator.mediaDevices.enumerateDevices();
+                this.dispatchEvent(new LocalMediaEvent("device_list_updated", {
+                    detail: {
+                        cameraDevices: devices.filter((d) => d.kind === "videoinput"),
+                        microphoneDevices: devices.filter((d) => d.kind === "audioinput"),
+                        speakerDevices: devices.filter((d) => d.kind === "audiooutput"),
+                    },
+                }));
+                this._devices = devices;
+            }
+            catch (error) {
+                this.dispatchEvent(new LocalMediaEvent("device_list_update_error", {
+                    detail: {
+                        error,
+                    },
+                }));
+                throw error;
+            }
+        });
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._updateDeviceList();
+            if (this._options) {
+                yield getStream(Object.assign(Object.assign({}, this._getConstraintsOptions()), { audioId: this._options.audio, videoId: this._options.video }), { replaceStream: this.stream });
+                const cameraTrack = this.stream.getVideoTracks()[0];
+                if (cameraTrack) {
+                    this._cameraEnabled = cameraTrack.enabled;
+                    this._currentCameraDeviceId = cameraTrack.getSettings().deviceId;
+                }
+                const microphoneTrack = this.stream.getAudioTracks()[0];
+                if (microphoneTrack) {
+                    this._microphoneEnabled = microphoneTrack.enabled;
+                    this._currentMicrophoneDeviceId = microphoneTrack.getSettings().deviceId;
+                }
+            }
+            this.dispatchEvent(new LocalMediaEvent("stream_updated", {
+                detail: { stream: this.stream },
+            }));
+            return this.stream;
+        });
+    }
+    stop() {
+        var _a;
+        if (this._options) {
+            (_a = this.stream) === null || _a === void 0 ? void 0 : _a.getTracks().forEach((t) => {
+                t.stop();
+            });
+        }
+    }
+}

package/dist/RoomConnection.d.ts

@@ -0,0 +1,190 @@
+import { RtcStreamAddedPayload } from "@whereby/jslib-media/src/webrtc/RtcManagerDispatcher";
+import { LocalParticipant, RemoteParticipant, Screenshare, WaitingParticipant } from "./RoomParticipant";
+import { ChatMessage as SignalChatMessage } from "@whereby/jslib-media/src/utils/ServerSocket";
+import LocalMedia, { LocalMediaOptions } from "./LocalMedia";
+type Logger = Pick<Console, "debug" | "error" | "log" | "warn" | "info">;
+export interface RoomConnectionOptions {
+    displayName?: string;
+    localMediaOptions?: LocalMediaOptions;
+    roomKey?: string;
+    logger?: Logger;
+    localMedia?: LocalMedia;
+    externalId?: string;
+}
+export type ChatMessage = Pick<SignalChatMessage, "senderId" | "timestamp" | "text">;
+export type ConnectionStatus = "initializing" | "connecting" | "connected" | "room_locked" | "knocking" | "disconnecting" | "disconnected" | "knock_rejected";
+export type CloudRecordingState = {
+    error?: string;
+    status: "recording" | "requested" | "error";
+    startedAt?: number;
+};
+export type LiveStreamState = {
+    status: "streaming";
+    startedAt: number;
+};
+export type RoomJoinedEvent = {
+    localParticipant: LocalParticipant;
+    remoteParticipants: RemoteParticipant[];
+    waitingParticipants: WaitingParticipant[];
+};
+export type ConnectionStatusChangedEvent = {
+    connectionStatus: ConnectionStatus;
+};
+export type ParticipantJoinedEvent = {
+    remoteParticipant: RemoteParticipant;
+};
+export type ParticipantLeftEvent = {
+    participantId: string;
+};
+export type ParticipantStreamAddedEvent = {
+    participantId: string;
+    stream: MediaStream;
+    streamId: string;
+};
+export type ParticipantAudioEnabledEvent = {
+    participantId: string;
+    isAudioEnabled: boolean;
+};
+export type ParticipantVideoEnabledEvent = {
+    participantId: string;
+    isVideoEnabled: boolean;
+};
+export type ParticipantMetadataChangedEvent = {
+    participantId: string;
+    displayName: string;
+};
+export type ScreenshareStartedEvent = {
+    participantId: string;
+    id: string;
+    hasAudioTrack: boolean;
+    stream: MediaStream;
+    isLocal: boolean;
+};
+export type ScreenshareStoppedEvent = {
+    participantId: string;
+    id: string;
+};
+export type WaitingParticipantJoinedEvent = {
+    participantId: string;
+    displayName: string | null;
+};
+export type WaitingParticipantLeftEvent = {
+    participantId: string;
+};
+export type LocalCameraEnabledEvent = {
+    enabled: boolean;
+};
+export type LocalMicrophoneEnabledEvent = {
+    enabled: boolean;
+};
+export interface RoomEventsMap {
+    chat_message: (e: CustomEvent<ChatMessage>) => void;
+    cloud_recording_request_started: (e: CustomEvent<CloudRecordingState>) => void;
+    cloud_recording_started: (e: CustomEvent<CloudRecordingState>) => void;
+    cloud_recording_started_error: (e: CustomEvent<CloudRecordingState>) => void;
+    cloud_recording_stopped: (e: CustomEvent<CloudRecordingState>) => void;
+    local_camera_enabled: (e: CustomEvent<LocalCameraEnabledEvent>) => void;
+    local_microphone_enabled: (e: CustomEvent<LocalMicrophoneEnabledEvent>) => void;
+    participant_audio_enabled: (e: CustomEvent<ParticipantAudioEnabledEvent>) => void;
+    participant_joined: (e: CustomEvent<ParticipantJoinedEvent>) => void;
+    participant_left: (e: CustomEvent<ParticipantLeftEvent>) => void;
+    participant_metadata_changed: (e: CustomEvent<ParticipantMetadataChangedEvent>) => void;
+    participant_stream_added: (e: CustomEvent<ParticipantStreamAddedEvent>) => void;
+    participant_video_enabled: (e: CustomEvent<ParticipantVideoEnabledEvent>) => void;
+    connection_status_changed: (e: CustomEvent<ConnectionStatusChangedEvent>) => void;
+    room_joined: (e: CustomEvent<RoomJoinedEvent>) => void;
+    screenshare_started: (e: CustomEvent<ScreenshareStartedEvent>) => void;
+    screenshare_stopped: (e: CustomEvent<ScreenshareStoppedEvent>) => void;
+    streaming_started: (e: CustomEvent<LiveStreamState>) => void;
+    streaming_stopped: (e: CustomEvent<LiveStreamState>) => void;
+    waiting_participant_joined: (e: CustomEvent<WaitingParticipantJoinedEvent>) => void;
+    waiting_participant_left: (e: CustomEvent<WaitingParticipantLeftEvent>) => void;
+}
+type ArgType<T> = T extends (arg: infer U) => unknown ? U : never;
+type RoomEventKey = keyof RoomEventsMap;
+type RoomEventHandler<T extends RoomEventKey> = RoomEventsMap[T];
+type RoomEventType<T extends RoomEventKey> = ArgType<RoomEventHandler<T>>;
+type RoomEventPayload<T extends RoomEventKey> = RoomEventType<T> extends CustomEvent<infer U> ? U : never;
+declare class RoomConnectionEvent<T extends RoomEventKey> extends CustomEvent<RoomEventPayload<T>> {
+    constructor(eventType: T, eventInitDict?: CustomEventInit<RoomEventPayload<T>>);
+}
+export declare function handleStreamAdded(remoteParticipants: RemoteParticipant[], { clientId, stream, streamId, streamType }: RtcStreamAddedPayload): RoomConnectionEvent<"participant_stream_added"> | RoomConnectionEvent<"screenshare_started"> | undefined;
+interface RoomEventTarget extends EventTarget {
+    addEventListener<K extends keyof RoomEventsMap>(type: K, listener: RoomEventsMap[K], options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    removeEventListener<K extends keyof RoomEventsMap>(type: K, listener: RoomEventsMap[K], options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}
+declare const TypedEventTarget: new () => RoomEventTarget;
+export default class RoomConnection extends TypedEventTarget {
+    localMedia: LocalMedia;
+    localParticipant?: LocalParticipant;
+    roomUrl: URL;
+    remoteParticipants: RemoteParticipant[];
+    screenshares: Screenshare[];
+    readonly localMediaConstraints?: MediaStreamConstraints;
+    readonly roomName: string;
+    private organizationId;
+    private credentialsService;
+    private apiClient;
+    private organizationService;
+    private organizationServiceCache;
+    private organizationApiClient;
+    private roomService;
+    private _deviceCredentials;
+    private signalSocket;
+    private signalSocketManager;
+    private rtcManagerDispatcher?;
+    private rtcManager?;
+    private connectionStatus;
+    private selfId;
+    private logger;
+    private _ownsLocalMedia;
+    private displayName?;
+    private externalId?;
+    private _roomKey;
+    constructor(roomUrl: string, { displayName, localMedia, localMediaOptions: localMediaConstraints, logger, roomKey, externalId, }: RoomConnectionOptions);
+    get roomKey(): string | null;
+    private _handleNewChatMessage;
+    private _handleCloudRecordingStarted;
+    private _handleRecorderClientJoined;
+    private _handleStreamingStarted;
+    private _handleNewClient;
+    private _handleClientLeft;
+    private _handleClientAudioEnabled;
+    private _handleClientVideoEnabled;
+    private _handleClientMetadataReceived;
+    private _handleKnockHandled;
+    private _handleKnockerLeft;
+    private _handleRoomJoined;
+    private _handleRoomKnocked;
+    private _handleReconnect;
+    private _handleDisconnect;
+    private _handleCloudRecordingStopped;
+    private _handleStreamingStopped;
+    private _handleScreenshareStarted;
+    private _handleScreenshareStopped;
+    private _handleRtcEvent;
+    private _handleRtcManagerCreated;
+    private _handleRtcManagerDestroyed;
+    private _handleAcceptStreams;
+    private _handleStreamAdded;
+    private _joinRoom;
+    join(): Promise<void>;
+    knock(): void;
+    leave(): void;
+    sendChatMessage(text: string): void;
+    setDisplayName(displayName: string): void;
+    acceptWaitingParticipant(participantId: string): void;
+    rejectWaitingParticipant(participantId: string): void;
+    updateStreamResolution({ streamId, width, height }: {
+        streamId?: string;
+        width: number;
+        height: number;
+    }): void;
+    startScreenshare(): Promise<void>;
+    stopScreenshare(): void;
+    startCloudRecording(): void;
+    stopCloudRecording(): void;
+}
+export {};