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

package/README.md

@@ -102,20 +102,6 @@ function MyCallUX( { roomUrl, localStream }) {
 
 ```
 
-#### Usage with Vite development environment
-
-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': {}
-    },
-});
-```
-
 #### Usage with Next.js
 
 If you are integrating these React hooks with Next.js, you need to ensure your

package/dist/embed/index.d.ts

@@ -1,4 +1,5 @@
-export { sdkVersion } from "../version";
+declare const sdkVersion = "__SDK_VERSION__";
+
 interface WherebyEmbedAttributes {
     audio: string;
     avatarUrl: string;
@@ -30,3 +31,5 @@ declare global {
         }
     }
 }
+
+export { sdkVersion };

package/dist/embed/{index.js → index.esm.js}

@@ -1,60 +1,62 @@
-import { define, ref } from "heresy";
-export { sdkVersion } from "../version";
-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.bind(this));
-    },
-    ondisconnected() {
-        window.removeEventListener("message", this.onmessage.bind(this));
-    },
-    observedAttributes: [
-        "displayName",
-        "minimal",
-        "room",
-        "subdomain",
-        "lang",
-        "metadata",
-        "groups",
-        "virtualBackgroundUrl",
-        "avatarUrl",
-        "externalId",
-        ...boolAttrs,
-    ].map((a) => a.toLowerCase()),
-    onattributechanged({ attributeName, oldValue }) {
-        if (["room", "subdomain"].includes(attributeName) && oldValue == null)
-            return;
-        this.render();
-    },
-    style(self) {
+import { define, ref } from 'heresy';
+
+const sdkVersion = "2.0.0-beta3";
+
+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.bind(this));
+    },
+    ondisconnected() {
+        window.removeEventListener("message", this.onmessage.bind(this));
+    },
+    observedAttributes: [
+        "displayName",
+        "minimal",
+        "room",
+        "subdomain",
+        "lang",
+        "metadata",
+        "groups",
+        "virtualBackgroundUrl",
+        "avatarUrl",
+        "externalId",
+        ...boolAttrs,
+    ].map((a) => a.toLowerCase()),
+    onattributechanged({ attributeName, oldValue }) {
+        if (["room", "subdomain"].includes(attributeName) && oldValue == null)
+            return;
+        this.render();
+    },
+    style(self) {
         return `
     ${self} {
       display: block;
@@ -64,61 +66,67 @@ define("WherebyEmbed", {
       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 }) {
-        if (origin !== this.url.origin)
-            return;
-        const { type, payload: detail } = data;
-        this.dispatchEvent(new CustomEvent(type, { detail }));
-    },
-    render() {
-        const { avatarurl: avatarUrl, displayname: displayName, externalId: externalId, 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(Object.assign({ jsApi: true, we: "__SDK_VERSION__", iframeSource: subdomain }, (displayName && { displayName })), (lang && { lang })), (metadata && { metadata })), (externalId && { externalId })), (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);
-            }
-        });
+    `;
+    },
+    // Commands
+    _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 }) {
+        if (origin !== this.url.origin)
+            return;
+        const { type, payload: detail } = data;
+        this.dispatchEvent(new CustomEvent(type, { detail }));
+    },
+    render() {
+        const { avatarurl: avatarUrl, displayname: displayName, externalId: externalId, lang, metadata, minimal, room, groups, virtualbackgroundurl: virtualBackgroundUrl, } = this;
+        if (!room)
+            return this.html `Whereby: Missing room attribute.`;
+        // Get subdomain from room URL, or use it specified
+        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(Object.assign({ jsApi: true, we: "2.0.0-beta3", iframeSource: subdomain }, (displayName && { displayName })), (lang && { lang })), (metadata && { metadata })), (externalId && { externalId })), (groups && { groups })), (virtualBackgroundUrl && { virtualBackgroundUrl })), (avatarUrl && { avatarUrl })), (minimal != null && { embed: minimal })), boolAttrs.reduce(
+        // add to URL if set in any way
+        (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" />
-        `;
-    },
+        `;
+    },
 });
+
+export { sdkVersion };

package/dist/react/index.d.ts

@@ -1,6 +1,397 @@
-export { default as VideoView } from "./VideoView";
-export { default as useLocalMedia } from "./useLocalMedia";
-export { useRoomConnection } from "./useRoomConnection";
-export type { LocalMediaRef as UseLocalMediaResult } from "./useLocalMedia";
-export type { ChatMessageState as ChatMessage, LocalParticipantState as LocalParticipant, RemoteParticipantState as RemoteParticipant, RoomConnectionState as RoomConnection, ScreenshareState as Screenshare, WaitingParticipantState as WaitingParticipant, } from "./useRoomConnection";
-export { sdkVersion } from "../version";
+import React from 'react';
+import RtcManager from '@whereby/jslib-media/src/webrtc/RtcManager';
+import { ChatMessage as ChatMessage$1 } from '@whereby/jslib-media/src/utils/ServerSocket';
+
+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) => React.JSX.Element;
+
+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;
+interface LocalMediaOptions {
+    audio: boolean;
+    video: boolean;
+}
+declare 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;
+}
+
+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"];
+}
+type LocalMediaRef = {
+    state: LocalMediaState;
+    actions: LocalMediaActions;
+    _ref: LocalMedia;
+};
+type UseLocalMediaOptions = LocalMediaOptions;
+declare function useLocalMedia(optionsOrStream?: UseLocalMediaOptions | MediaStream): LocalMediaRef;
+
+interface RoomParticipantData {
+    displayName: string;
+    id: string;
+    stream?: MediaStream;
+    isAudioEnabled: boolean;
+    isVideoEnabled: boolean;
+}
+declare class RoomParticipant {
+    readonly displayName: string;
+    readonly id: string;
+    readonly stream?: MediaStream;
+    readonly isAudioEnabled: boolean;
+    readonly isLocalParticipant: boolean;
+    readonly isVideoEnabled: boolean;
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }: RoomParticipantData);
+}
+interface RemoteParticipantData {
+    newJoiner: boolean;
+    streams: string[];
+}
+type StreamState = "new_accept" | "to_accept" | "old_accept" | "done_accept" | "to_unaccept" | "done_unaccept" | "auto";
+interface Stream {
+    id: string;
+    state: StreamState;
+}
+declare class RemoteParticipant extends RoomParticipant {
+    readonly newJoiner: boolean;
+    readonly streams: Stream[];
+    constructor({ displayName, id, newJoiner, streams, isAudioEnabled, isVideoEnabled, }: RoomParticipantData & RemoteParticipantData);
+    addStream(streamId: string, state: StreamState): void;
+    removeStream(streamId: string): void;
+    updateStreamState(streamId: string, state: StreamState): void;
+}
+declare class LocalParticipant extends RoomParticipant {
+    readonly isLocalParticipant = true;
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }: RoomParticipantData);
+}
+interface WaitingParticipant {
+    id: string;
+    displayName: string | null;
+}
+declare class Screenshare {
+    readonly participantId: string;
+    readonly id: string;
+    readonly hasAudioTrack: boolean;
+    readonly stream?: MediaStream;
+    readonly isLocal: boolean;
+    constructor({ participantId, id, hasAudioTrack, stream, isLocal }: Screenshare);
+}
+
+type Logger = Pick<Console, "debug" | "error" | "log" | "warn" | "info">;
+interface RoomConnectionOptions {
+    displayName?: string;
+    localMediaOptions?: LocalMediaOptions;
+    roomKey?: string;
+    logger?: Logger;
+    localMedia?: LocalMedia;
+    externalId?: string;
+}
+type ChatMessage = Pick<ChatMessage$1, "senderId" | "timestamp" | "text">;
+type ConnectionStatus = "initializing" | "connecting" | "connected" | "room_locked" | "knocking" | "disconnecting" | "disconnected" | "knock_rejected";
+type CloudRecordingState = {
+    error?: string;
+    status: "recording" | "requested" | "error";
+    startedAt?: number;
+};
+type LiveStreamState = {
+    status: "streaming";
+    startedAt: number;
+};
+type RoomJoinedEvent = {
+    localParticipant: LocalParticipant;
+    remoteParticipants: RemoteParticipant[];
+    waitingParticipants: WaitingParticipant[];
+};
+type ConnectionStatusChangedEvent = {
+    connectionStatus: ConnectionStatus;
+};
+type ParticipantJoinedEvent = {
+    remoteParticipant: RemoteParticipant;
+};
+type ParticipantLeftEvent = {
+    participantId: string;
+};
+type ParticipantStreamAddedEvent = {
+    participantId: string;
+    stream: MediaStream;
+    streamId: string;
+};
+type ParticipantAudioEnabledEvent = {
+    participantId: string;
+    isAudioEnabled: boolean;
+};
+type ParticipantVideoEnabledEvent = {
+    participantId: string;
+    isVideoEnabled: boolean;
+};
+type ParticipantMetadataChangedEvent = {
+    participantId: string;
+    displayName: string;
+};
+type ScreenshareStartedEvent = {
+    participantId: string;
+    id: string;
+    hasAudioTrack: boolean;
+    stream: MediaStream;
+    isLocal: boolean;
+};
+type ScreenshareStoppedEvent = {
+    participantId: string;
+    id: string;
+};
+type WaitingParticipantJoinedEvent = {
+    participantId: string;
+    displayName: string | null;
+};
+type WaitingParticipantLeftEvent = {
+    participantId: string;
+};
+type LocalCameraEnabledEvent = {
+    enabled: boolean;
+};
+type LocalMicrophoneEnabledEvent = {
+    enabled: boolean;
+};
+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;
+}
+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;
+declare 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;
+}
+
+type RemoteParticipantState = Omit<RemoteParticipant, "updateStreamState" | "newJoiner" | "streams" | "addStream" | "removeStream">;
+type LocalParticipantState = LocalParticipant;
+interface WaitingParticipantState {
+    id: string;
+    displayName: string | null;
+}
+interface ChatMessageState {
+    senderId: string;
+    timestamp: string;
+    text: string;
+}
+type ScreenshareState = Screenshare;
+type LocalScreenshareStatus = "starting" | "active";
+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;
+    startCloudRecording(): void;
+    startScreenshare(): void;
+    stopCloudRecording(): void;
+    stopScreenshare(): void;
+}
+type VideoViewComponentProps = Omit<React.ComponentProps<typeof _default>, "onResize">;
+interface RoomConnectionComponents {
+    VideoView: (props: VideoViewComponentProps) => ReturnType<typeof _default>;
+}
+type RoomConnectionRef = {
+    state: RoomConnectionState;
+    actions: RoomConnectionActions;
+    components: RoomConnectionComponents;
+    _ref: RoomConnection;
+};
+declare function useRoomConnection(roomUrl: string, roomConnectionOptions?: UseRoomConnectionOptions): RoomConnectionRef;
+
+declare const sdkVersion = "__SDK_VERSION__";
+
+export { type ChatMessageState as ChatMessage, type LocalParticipantState as LocalParticipant, type RemoteParticipantState as RemoteParticipant, type RoomConnectionState as RoomConnection, type ScreenshareState as Screenshare, type LocalMediaRef as UseLocalMediaResult, _default as VideoView, type WaitingParticipantState as WaitingParticipant, sdkVersion, useLocalMedia, useRoomConnection };