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

package/dist/react/index.d.ts

@@ -1,117 +1,27 @@
-import React from 'react';
+import * as React from 'react';
+import React__default from 'react';
+import _whereby_jslib_media_src_utils_ServerSocket, { ChatMessage as ChatMessage$2 } from '@whereby/jslib-media/src/utils/ServerSocket';
+import * as redux_thunk from 'redux-thunk';
+import { AxiosRequestConfig } from 'axios';
+import EventEmitter from 'events';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as redux from 'redux';
+import RtcManagerDispatcher from '@whereby/jslib-media/src/webrtc/RtcManagerDispatcher';
 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;
+    style?: React__default.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;
+type VideoViewProps = VideoViewSelfProps & React__default.DetailedHTMLProps<React__default.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
+declare const _default: ({ muted, mirror, stream, onResize, ...rest }: VideoViewProps) => React__default.JSX.Element;
 
 interface RoomParticipantData {
     displayName: string;
@@ -129,22 +39,25 @@ declare class RoomParticipant {
     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;
+interface RemoteParticipant {
+    id: string;
+    displayName: string;
+    isAudioEnabled: boolean;
+    isVideoEnabled: boolean;
+    isLocalParticipant: boolean;
+    stream: (MediaStream & {
+        inboundId?: string;
+    }) | null;
+    streams: Stream[];
+    newJoiner: boolean;
+    presentationStream: (MediaStream & {
+        inboundId?: string;
+    }) | null;
 }
 declare class LocalParticipant extends RoomParticipant {
     readonly isLocalParticipant = true;
@@ -154,193 +67,691 @@ 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 = {
+interface Screenshare {
     participantId: string;
     id: string;
     hasAudioTrack: boolean;
-    stream: MediaStream;
+    stream?: MediaStream;
     isLocal: boolean;
+}
+
+type Json = string | number | boolean | null | Array<Json> | {
+    [key: string]: Json;
 };
-type ScreenshareStoppedEvent = {
-    participantId: string;
-    id: string;
-};
-type WaitingParticipantJoinedEvent = {
-    participantId: string;
-    displayName: string | null;
+interface ResponseOptions {
+    data?: Json;
+    headers?: Record<string, unknown>;
+    status?: number;
+    statusText?: string;
+    url?: string | null;
+}
+declare class Response {
+    data: Json;
+    headers: Record<string, unknown>;
+    status: number;
+    statusText: string;
+    url: string | null;
+    constructor(initialValues?: ResponseOptions);
+}
+
+declare class EmbeddedFreeTierStatus {
+    isExhausted: boolean;
+    renewsAt: Date;
+    totalMinutesLimit: number;
+    totalMinutesUsed: number;
+    constructor({ isExhausted, renewsAt, totalMinutesLimit, totalMinutesUsed, }: {
+        isExhausted: boolean;
+        renewsAt: Date;
+        totalMinutesLimit: number;
+        totalMinutesUsed: number;
+    });
+    static fromJson(data: Record<string, unknown>): EmbeddedFreeTierStatus;
+}
+
+interface AccountProps {
+    basePlanId: string | null;
+    isDeactivated: boolean;
+    isOnTrial: boolean;
+    onTrialUntil: Date | null;
+    trialStatus: string | null;
+    embeddedFreeTierStatus: EmbeddedFreeTierStatus | null;
+}
+declare class Account {
+    basePlanId: string | null;
+    embeddedFreeTierStatus: EmbeddedFreeTierStatus | null;
+    isDeactivated: boolean;
+    isOnTrial: boolean;
+    onTrialUntil: Date | null;
+    trialStatus: string | null;
+    constructor({ basePlanId, embeddedFreeTierStatus, isDeactivated, isOnTrial, onTrialUntil, trialStatus, }: AccountProps);
+    static fromJson(data: Record<string, unknown>): Account;
+}
+
+interface OrganizationPermissionAction {
+    isAllowed: boolean;
+    isSupported: boolean;
+}
+interface FullOrganizationPermissions {
+    images: {
+        logoImageUrl: {
+            set: OrganizationPermissionAction;
+            reset: OrganizationPermissionAction;
+        };
+        roomBackgroundImageUrl: {
+            set: OrganizationPermissionAction;
+            reset: OrganizationPermissionAction;
+        };
+        roomKnockPageBackgroundImageUrl: {
+            set: OrganizationPermissionAction;
+            reset: OrganizationPermissionAction;
+        };
+    };
+    invitations: {
+        add: OrganizationPermissionAction;
+        delete: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+    };
+    roles: {
+        set: OrganizationPermissionAction;
+        remove: OrganizationPermissionAction;
+        removeSelf: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+    };
+    users: {
+        signUpWithoutInvitation: OrganizationPermissionAction;
+    };
+    rooms: {
+        customize: OrganizationPermissionAction;
+        customizeSelf: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+        lock: OrganizationPermissionAction;
+        unclaim: OrganizationPermissionAction;
+        unclaimSelf: OrganizationPermissionAction;
+    };
+    subscriptions: {
+        add: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+        payLatestInvoice: OrganizationPermissionAction;
+        updatePlan: OrganizationPermissionAction;
+    };
+    browserExtension: {
+        install: OrganizationPermissionAction;
+    };
+}
+type OrganizationPermissions = Partial<FullOrganizationPermissions>;
+interface OrganizationLimits {
+    maxNumberOfInvitationsAndUsers: number | null;
+    maxNumberOfClaimedRooms: number | null;
+    maxRoomLimitPerOrganization: number | null;
+    trialMinutesLimit: number | null;
+    includedUnits: number | null;
+}
+interface OrganizationOnboardingSurvey {
+    name: string;
+    value: unknown;
+}
+type OrganizationPreferences = Record<string, boolean | string | null | number>;
+declare class Organization {
+    static GLOBAL_ORGANIZATION_ID: string;
+    organizationId: string;
+    organizationName: string;
+    subdomain: string;
+    permissions: OrganizationPermissions;
+    limits: OrganizationLimits;
+    account: Account | null;
+    logoImageUrl: string | null;
+    roomBackgroundImageUrl: string | null;
+    roomBackgroundThumbnailUrl: string | null;
+    roomKnockPageBackgroundImageUrl: string | null;
+    roomKnockPageBackgroundThumbnailUrl: string | null;
+    preferences: OrganizationPreferences | null;
+    onboardingSurvey: OrganizationOnboardingSurvey | null;
+    type: string | null;
+    constructor(properties: {
+        account: Account | null;
+        organizationId: string;
+        organizationName: string;
+        subdomain: string;
+        permissions: OrganizationPermissions;
+        limits: OrganizationLimits;
+        logoImageUrl: string | null;
+        roomBackgroundImageUrl: string | null;
+        roomBackgroundThumbnailUrl: string | null;
+        roomKnockPageBackgroundImageUrl: string | null;
+        roomKnockPageBackgroundThumbnailUrl: string | null;
+        preferences: OrganizationPreferences | null;
+        onboardingSurvey: OrganizationOnboardingSurvey | null;
+        type: string | null;
+    });
+    static fromJson(data: Json): Organization;
+}
+
+type HttpClientRequestConfig = AxiosRequestConfig | {
+    [key: string]: unknown;
 };
-type WaitingParticipantLeftEvent = {
-    participantId: string;
+interface IHttpClient {
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+/**
+ * Class used for making http calls. This is just a pure
+ * wrapper around the http lib that we decide to use,
+ * so that we can switch implementations.
+ */
+declare class HttpClient implements IHttpClient {
+    _baseUrl: string;
+    /**
+     * Creates an HttpClient instance.
+     *
+     * @param {string} [baseUrl] - The base URL where all requests are made.
+     */
+    constructor({ baseUrl }: {
+        baseUrl: string;
+    });
+    private _requestAxios;
+    /**
+     * Wrapper for the axios API
+     *
+     * @param {string} url - Required. URL (appended to base URL) where API call will be made
+     * @param {object} options - Required. Contains the data needed for the fetch API
+     * @return {Promise<Response>} - A promise which will return a Response object (https://developer.mozilla.org/en-US/docs/Web/API/Response)
+     */
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+
+/**
+ * ApiClient for doing multipart/form-data requests.
+ */
+declare class MultipartHttpClient implements IHttpClient {
+    _httpClient: IHttpClient;
+    constructor({ httpClient }: {
+        httpClient: IHttpClient;
+    });
+    /**
+     * Convert the provided object to a FormData object containing the same keys and values.
+     * @param {object} data - the data to convert.
+     * @returns {FormData}
+     */
+    static dataToFormData(data: Record<string, string>): FormData;
+    /**
+     * Request a resource using multipart/form-data encoding.
+     *
+     * @param {string} url - the url to request
+     * @param {object} options - Required. Contains the data needed for the fetch API
+     * @return {Promise<Response>} - A promise which will return a Response object (https://developer.mozilla.org/en-US/docs/Web/API/Response)
+     */
+    request(url: string, options?: HttpClientRequestConfig): Promise<Response>;
+}
+
+interface CredentialsOptions {
+    uuid: string;
+    hmac: string;
+    userId?: string;
+}
+declare class Credentials {
+    credentials: {
+        uuid: CredentialsOptions["uuid"];
+    };
+    hmac: CredentialsOptions["hmac"];
+    userId: CredentialsOptions["userId"];
+    constructor(uuid: CredentialsOptions["uuid"], hmac: CredentialsOptions["hmac"], userId?: CredentialsOptions["userId"]);
+    toJson(): Json;
+    static fromJson(json: Json): Credentials;
+}
+
+interface AuthenticatedHttpClientOptions {
+    httpClient: HttpClient;
+    fetchDeviceCredentials: () => Promise<Credentials | null>;
+}
+declare class AuthenticatedHttpClient {
+    private _httpClient;
+    private _fetchDeviceCredentials;
+    constructor({ httpClient, fetchDeviceCredentials }: AuthenticatedHttpClientOptions);
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+interface ApiClientOptions {
+    baseUrl?: string;
+    fetchDeviceCredentials?: AuthenticatedHttpClientOptions["fetchDeviceCredentials"];
+}
+/**
+ * Class used for all Whereby API calls.
+ */
+declare class ApiClient {
+    authenticatedHttpClient: AuthenticatedHttpClient;
+    authenticatedFormDataHttpClient: MultipartHttpClient;
+    /**
+     * Create an ApiClient instance.
+     */
+    constructor({ baseUrl, fetchDeviceCredentials, }?: ApiClientOptions);
+    /**
+     * Wrapper for the fetch API
+     */
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+    /**
+     * Performs a multipart request where data is multipart/form-data encoded.
+     */
+    requestMultipart(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+
+/**
+ * Related to device calls needed to obtain credentials
+ */
+declare class DeviceService {
+    _apiClient: ApiClient;
+    constructor({ apiClient }: {
+        apiClient: ApiClient;
+    });
+    /**
+     * Get's the device credentials needed for most of the other API services
+     *
+     * @return {Promise} A promise which is fulfilled or failed based on the
+     * response.
+     */
+    getCredentials(): Promise<Credentials | null>;
+}
+
+interface AbstractStore {
+    loadOrDefault(defaultValue: Json): Promise<Json>;
+    save(value: Json): Promise<void>;
+}
+
+declare class CredentialsService extends EventEmitter {
+    _deviceService: DeviceService;
+    _credentialsStore: AbstractStore;
+    credentialsPromise?: Promise<Credentials | null>;
+    /**
+     * Service to manage Whereby's Rest API credentials.
+     *
+     * @param {ObjectStore} credentialsStore - Store to manage the credentials.
+     */
+    constructor({ deviceService, credentialsStore, }: {
+        deviceService: DeviceService;
+        credentialsStore: AbstractStore;
+    });
+    static create({ baseUrl, storeName, storeType, }: {
+        baseUrl: string;
+        storeName?: string;
+        storeType?: "localStorage" | "chromeStorage";
+    }): CredentialsService;
+    /**
+     * Contacts the REST API to get new credentials. DO NOT USE directly, call getCredentials() instead.
+     *
+     * @see getCredentials
+     * @returns {Promise.<Credentials>} - Promise that resolves with the credentials.
+     */
+    _fetchNewCredentialsFromApi(): Promise<Credentials | null>;
+    /**
+     * Returns the current credentials without triggering an API request to get new ones.
+     * If no credentials are currently available it will return null.
+     *
+     * @returns {?Credentials} - The credentials currently in use, null otherwise.
+     */
+    getCurrentCredentials(): Promise<Credentials | null>;
+    /**
+     * Returns a promise that will contain the credentials for this client.
+     * If no credentials are available in local storage, new ones will be fetched from the server.
+     *
+     * @returns {Promise.<Credentials>} - Promise that resolves with the credentials.
+     */
+    getCredentials(): Promise<Credentials | null>;
+    /**
+     * Saves new credentials which replace the existing ones and abort any pending request to get new ones.
+     *
+     * @param {Credentials} credentials - New credentials to store.
+     */
+    saveCredentials(credentials: Credentials): Promise<Credentials>;
+    /**
+     * It will set the userId for the current credentials.
+     *
+     * @param userId - The user id to set.
+     */
+    setUserId(userId: string | null): Promise<void>;
+}
+
+type UserConsentAction = "accepted" | "rejected" | null;
+type ConsentGrantRequest = {
+    readonly consentRevisionId: string;
+    readonly action: UserConsentAction;
 };
-type LocalCameraEnabledEvent = {
-    enabled: boolean;
+
+declare class OrganizationService {
+    _apiClient: ApiClient;
+    constructor({ apiClient }: {
+        apiClient: ApiClient;
+    });
+    /**
+     * Creates an organization.
+     */
+    createOrganization({ organizationName, subdomain, owner, }: {
+        organizationName: string;
+        subdomain: string;
+        owner: {
+            email: string;
+            displayName: string;
+            verificationCode: string;
+            consents?: ReadonlyArray<ConsentGrantRequest>;
+        } | {
+            idToken: string;
+            displayName: string;
+            consents?: ReadonlyArray<ConsentGrantRequest>;
+        };
+    }): Promise<string>;
+    /**
+     * Retrieves the organization based on the subdomain.
+     */
+    getOrganizationBySubdomain(subdomain: string): Promise<Organization | null>;
+    /**
+     * Retrieves the organization based on the organizationId.
+     *
+     * Note: This endpoint should only be used to retrieve an organization when the device is linked
+     * to a user in that organization. Use getOrganizationBySubdomain instead if you just want the information
+     * about an organization that is mapped to a given subdomain.
+     */
+    getOrganizationByOrganizationId(organizationId: string): Promise<Organization | null>;
+    /**
+     * Retrieves the organizations that contain a user
+     * matching provided the email+code or phoneNumber+code
+     * combination.
+     */
+    getOrganizationsByContactPoint(options: {
+        email: string;
+        code: string;
+    } | {
+        phoneNumber: string;
+        code: string;
+    }): Promise<ReadonlyArray<Organization>>;
+    /**
+     * Retrieves the organizations that contain a user
+     * matching provided the idToken
+     */
+    getOrganizationsByIdToken({ idToken }: {
+        idToken: string;
+    }): Promise<ReadonlyArray<Organization>>;
+    /**
+     * Retrieves the organizations containing a user
+     * with either the email or phoneNumber matching the logged in user.
+     *
+     * This is useful for showing the possible organization that the current
+     * user could log in to.
+     */
+    getOrganizationsByLoggedInUser(): Promise<ReadonlyArray<Organization>>;
+    /**
+     * Checks if a subdomain is available and verifies its format.
+     */
+    getSubdomainAvailability(subdomain: string): Promise<{
+        status: string;
+    }>;
+    /**
+     * Updates preferences of the organization.
+     */
+    updatePreferences({ organizationId, preferences, }: {
+        organizationId: string;
+        preferences: OrganizationPreferences;
+    }): Promise<undefined>;
+    /**
+     * Delete organization
+     */
+    deleteOrganization({ organizationId }: {
+        organizationId: string;
+    }): Promise<undefined>;
+}
+
+/**
+ * Reducer
+ */
+interface StreamingState {
+    isStreaming: boolean;
+    error: unknown;
+    startedAt?: number;
+}
+
+/**
+ * Reducer
+ */
+interface rtcAnalyticsState {
+    reportedValues: {
+        [key: string]: unknown;
+    };
+}
+
+interface LocalScreenshareState {
+    status: "" | "starting" | "active";
+    stream: MediaStream | null;
+    error: unknown | null;
+}
+
+interface LocalParticipantState$1 extends LocalParticipantState {
+    isScreenSharing: boolean;
+    roleName: string;
+}
+
+/**
+ * Reducer
+ */
+interface CloudRecordingState$1 {
+    isRecording: boolean;
+    error: unknown;
+    status?: "recording" | "requested" | "error";
+    startedAt?: number;
+}
+
+type ChatMessage$1 = Pick<ChatMessage$2, "senderId" | "timestamp" | "text">;
+/**
+ * Reducer
+ */
+interface ChatState {
+    chatMessages: ChatMessage$1[];
+}
+
+/**
+ * Reducer
+ */
+interface AppState {
+    wantsToJoin: boolean;
+    roomUrl: string | null;
+    roomName: string | null;
+    roomKey: string | null;
+    displayName: string | null;
+    sdkVersion: string | null;
+    externalId: string | null;
+}
+
+/**
+ * Reducer
+ */
+interface DeviceCredentialsState {
+    isFetching: boolean;
+    data?: Credentials | null;
+}
+
+/**
+ * Reducer
+ */
+interface OrganizationState {
+    data: Organization | null | undefined;
+    isFetching: boolean;
+    error: unknown;
+}
+
+/**
+ * Reducer
+ */
+interface RemoteParticipantState$1 {
+    remoteParticipants: RemoteParticipant[];
+}
+
+type ConnectionStatus$1 = "initializing" | "connecting" | "connected" | "reconnect" | "room_locked" | "knocking" | "disconnecting" | "disconnected" | "knock_rejected";
+/**
+ * Reducer
+ */
+interface RoomConnectionState$1 {
+    status: ConnectionStatus$1;
+    error: unknown;
+}
+
+/**
+ * Reducer
+ */
+interface StreamResolutionUpdate {
+    streamId: string;
+    width: number;
+    height: number;
+}
+interface RtcConnectionState {
+    dispatcherCreated: boolean;
+    error: unknown;
+    isCreatingDispatcher: boolean;
+    reportedStreamResolutions: {
+        [streamId: string]: Omit<StreamResolutionUpdate, "streamId">;
+    };
+    rtcManager: RtcManager | null;
+    rtcManagerDispatcher: RtcManagerDispatcher | null;
+    rtcManagerInitialized: boolean;
+    status: "" | "ready" | "reconnect";
+    isAcceptingStreams: boolean;
+}
+
+/**
+ * Reducer
+ */
+interface SignalConnectionState {
+    deviceIdentified: boolean;
+    isIdentifyingDevice: boolean;
+    status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+    socket: _whereby_jslib_media_src_utils_ServerSocket | null;
+}
+
+declare function createServices(): {
+    credentialsService: CredentialsService;
+    apiClient: ApiClient;
+    organizationService: OrganizationService;
+    fetchOrganizationFromRoomUrl: (roomUrl: string) => Promise<Organization | null>;
 };
-type LocalMicrophoneEnabledEvent = {
-    enabled: boolean;
+
+declare const createStore: ({ preloadedState, injectServices, }: {
+    preloadedState?: Partial<{
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState$1;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState$1;
+        localParticipant: LocalParticipantState$1;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState$1;
+        roomConnection: RoomConnectionState$1;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }> | undefined;
+    injectServices: ReturnType<typeof createServices>;
+}) => _reduxjs_toolkit.EnhancedStore<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState$1;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState$1;
+    localParticipant: LocalParticipantState$1;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState$1;
+    roomConnection: RoomConnectionState$1;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, redux.UnknownAction, _reduxjs_toolkit.Tuple<[redux.StoreEnhancer<{
+    dispatch: ((action: redux.Action<"listenerMiddleware/add">) => _reduxjs_toolkit.UnsubscribeListener) & redux_thunk.ThunkDispatch<{
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState$1;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState$1;
+        localParticipant: LocalParticipantState$1;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState$1;
+        roomConnection: RoomConnectionState$1;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }, {
+        services: {
+            credentialsService: CredentialsService;
+            apiClient: ApiClient;
+            organizationService: OrganizationService;
+            fetchOrganizationFromRoomUrl: (roomUrl: string) => Promise<Organization | null>;
+        };
+    }, redux.UnknownAction>;
+}, {}>, redux.StoreEnhancer<{}, {}>]>>;
+type Store = ReturnType<typeof createStore>;
+
+/**
+ * Reducer
+ */
+interface WaitingParticipantsState {
+    waitingParticipants: WaitingParticipant[];
+}
+
+type LocalMediaOptions = {
+    audio: boolean;
+    video: 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;
+/**
+ * Reducer
+ */
+interface LocalMediaState$1 {
+    busyDeviceIds: string[];
+    cameraDeviceError?: unknown;
+    cameraEnabled: boolean;
+    currentCameraDeviceId?: string;
+    currentMicrophoneDeviceId?: string;
+    devices: MediaDeviceInfo[];
+    isSettingCameraDevice: boolean;
+    isSettingMicrophoneDevice: boolean;
+    isTogglingCamera: boolean;
+    microphoneDeviceError?: unknown;
+    microphoneEnabled: boolean;
+    options?: LocalMediaOptions;
+    status: "" | "stopped" | "starting" | "started" | "error";
+    startError?: unknown;
+    stream?: MediaStream;
+    isSwitchingStream: boolean;
+    onDeviceChange?: () => void;
 }
 
-type RemoteParticipantState = Omit<RemoteParticipant, "updateStreamState" | "newJoiner" | "streams" | "addStream" | "removeStream">;
+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: (deviceId: string) => void;
+    setMicrophoneDevice: (deviceId: string) => void;
+    toggleCameraEnabled: (enabled?: boolean) => void;
+    toggleMicrophoneEnabled: (enabled?: boolean) => void;
+}
+type UseLocalMediaResult = {
+    state: LocalMediaState;
+    actions: LocalMediaActions;
+    store: Store;
+};
+type UseLocalMediaOptions = LocalMediaOptions;
+
+type RemoteParticipantState = Omit<RemoteParticipant, "newJoiner" | "streams">;
 type LocalParticipantState = LocalParticipant;
 interface WaitingParticipantState {
     id: string;
@@ -353,6 +764,17 @@ interface ChatMessageState {
 }
 type ScreenshareState = Screenshare;
 type LocalScreenshareStatus = "starting" | "active";
+type ChatMessage = Pick<ChatMessage$2, "senderId" | "timestamp" | "text">;
+type ConnectionStatus = "initializing" | "connecting" | "connected" | "reconnect" | "room_locked" | "knocking" | "disconnecting" | "disconnected" | "knock_rejected";
+type CloudRecordingState = {
+    error?: string;
+    status: "recording" | "requested" | "error";
+    startedAt?: number;
+};
+type LiveStreamState = {
+    status: "streaming";
+    startedAt?: number;
+};
 interface RoomConnectionState {
     chatMessages: ChatMessage[];
     cloudRecording?: CloudRecordingState;
@@ -364,8 +786,15 @@ interface RoomConnectionState {
     liveStream?: LiveStreamState;
     waitingParticipants: WaitingParticipantState[];
 }
+interface RoomConnectionOptions {
+    displayName?: string;
+    localMediaOptions?: LocalMediaOptions;
+    roomKey?: string;
+    localMedia?: UseLocalMediaResult;
+    externalId?: string;
+}
 interface UseRoomConnectionOptions extends Omit<RoomConnectionOptions, "localMedia"> {
-    localMedia?: LocalMediaRef;
+    localMedia?: UseLocalMediaResult;
 }
 interface RoomConnectionActions {
     sendChatMessage(text: string): void;
@@ -380,6 +809,7 @@ interface RoomConnectionActions {
     stopCloudRecording(): void;
     stopScreenshare(): void;
 }
+
 type VideoViewComponentProps = Omit<React.ComponentProps<typeof _default>, "onResize">;
 interface RoomConnectionComponents {
     VideoView: (props: VideoViewComponentProps) => ReturnType<typeof _default>;
@@ -388,10 +818,12 @@ type RoomConnectionRef = {
     state: RoomConnectionState;
     actions: RoomConnectionActions;
     components: RoomConnectionComponents;
-    _ref: RoomConnection;
+    _ref: Store;
 };
 declare function useRoomConnection(roomUrl: string, roomConnectionOptions?: UseRoomConnectionOptions): RoomConnectionRef;
 
+declare function useLocalMedia(optionsOrStream?: UseLocalMediaOptions | MediaStream): UseLocalMediaResult;
+
 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 };
+export { type ChatMessageState as ChatMessage, type LocalParticipantState as LocalParticipant, type RemoteParticipantState as RemoteParticipant, type RoomConnectionState as RoomConnection, type ScreenshareState as Screenshare, type UseLocalMediaResult, _default as VideoView, type WaitingParticipantState as WaitingParticipant, sdkVersion, useLocalMedia, useRoomConnection };