@whereby.com/core 0.2.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,4252 @@
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import { PayloadAction, ActionCreatorWithPayload, AsyncThunkPayloadCreator, AsyncThunk, TypedStartListening, TypedAddListener, Selector } from '@reduxjs/toolkit';
+import * as redux_thunk from 'redux-thunk';
+import * as redux from 'redux';
+import * as reselect from 'reselect';
+import * as _whereby_jslib_media_src_utils_ServerSocket from '@whereby/jslib-media/src/utils/ServerSocket';
+import _whereby_jslib_media_src_utils_ServerSocket__default, { ChatMessage as ChatMessage$1 } from '@whereby/jslib-media/src/utils/ServerSocket';
+import { AsyncThunkFulfilledActionCreator } from '@reduxjs/toolkit/dist/createAsyncThunk';
+import { getDeviceData } from '@whereby/jslib-media/src/webrtc/MediaDevices';
+import RtcManagerDispatcher, { RtcStreamAddedPayload, RtcEvents, RtcManagerCreatedPayload } from '@whereby/jslib-media/src/webrtc/RtcManagerDispatcher';
+import RtcManager from '@whereby/jslib-media/src/webrtc/RtcManager';
+import { AxiosRequestConfig } from 'axios';
+import EventEmitter from 'events';
+
+type Json = string | number | boolean | null | Array<Json> | {
+    [key: string]: Json;
+};
+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;
+}
+
+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;
+}
+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;
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }: RoomParticipantData);
+}
+interface WaitingParticipant {
+    id: string;
+    displayName: string | null;
+}
+interface Screenshare {
+    participantId: string;
+    id: string;
+    hasAudioTrack: boolean;
+    stream?: MediaStream;
+    isLocal: boolean;
+}
+
+/**
+ * Reducer
+ */
+interface WaitingParticipantsState {
+    waitingParticipants: WaitingParticipant[];
+}
+declare const waitingParticipantsSlice: _reduxjs_toolkit.Slice<WaitingParticipantsState, {}, "waitingParticipants", "waitingParticipants", _reduxjs_toolkit.SliceSelectors<WaitingParticipantsState>>;
+/**
+ * Action creators
+ */
+declare const doAcceptWaitingParticipant: (args: {
+    participantId: string;
+}) => AppThunk<void>;
+declare const doRejectWaitingParticipant: (args: {
+    participantId: string;
+}) => AppThunk<void>;
+/**
+ * Selectors
+ */
+declare const selectWaitingParticipantsRaw: (state: RootState) => WaitingParticipantsState;
+declare const selectWaitingParticipants: (state: RootState) => WaitingParticipant[];
+
+/**
+ * Reducer
+ */
+interface StreamingState {
+    isStreaming: boolean;
+    error: unknown;
+    startedAt?: number;
+}
+declare const streamingSlice: _reduxjs_toolkit.Slice<StreamingState, {
+    doHandleStreamingStarted: (state: {
+        isStreaming: boolean;
+        error: unknown;
+        startedAt?: number | undefined;
+    }) => {
+        isStreaming: true;
+        error: null;
+        startedAt: number;
+    };
+    doHandleStreamingStopped: (state: {
+        isStreaming: boolean;
+        error: unknown;
+        startedAt?: number | undefined;
+    }) => {
+        isStreaming: false;
+        error: unknown;
+        startedAt?: number | undefined;
+    };
+}, "streaming", "streaming", _reduxjs_toolkit.SliceSelectors<StreamingState>>;
+/**
+ * Action creators
+ */
+declare const doHandleStreamingStarted: _reduxjs_toolkit.ActionCreatorWithoutPayload<"streaming/doHandleStreamingStarted">;
+declare const doHandleStreamingStopped: _reduxjs_toolkit.ActionCreatorWithoutPayload<"streaming/doHandleStreamingStopped">;
+/**
+ * Selectors
+ */
+declare const selectStreamingRaw: (state: RootState) => StreamingState;
+
+type RtcAnalyticsCustomEvent = {
+    actions: Array<ActionCreatorWithPayload<any> | AsyncThunkFulfilledActionCreator<any, any, ThunkConfig>> | null;
+    rtcEventName: string;
+    getValue: (state: RootState) => unknown;
+    getOutput: (value: unknown) => unknown;
+};
+declare const rtcAnalyticsCustomEvents: {
+    [key: string]: RtcAnalyticsCustomEvent;
+};
+/**
+ * Reducer
+ */
+interface rtcAnalyticsState {
+    reportedValues: {
+        [key: string]: unknown;
+    };
+}
+declare const rtcAnalyticsSlice: _reduxjs_toolkit.Slice<rtcAnalyticsState, {
+    updateReportedValues(state: {
+        reportedValues: {
+            [x: string]: unknown;
+        };
+    }, action: PayloadAction<{
+        rtcEventName: string;
+        value: unknown;
+    }>): {
+        reportedValues: {
+            [x: string]: unknown;
+        };
+    };
+}, "rtcAnalytics", "rtcAnalytics", _reduxjs_toolkit.SliceSelectors<rtcAnalyticsState>>;
+declare const doRtcAnalyticsCustomEventsInitialize: (args: void) => AppThunk<void>;
+/**
+ * Action creators
+ */
+declare const updateReportedValues: ActionCreatorWithPayload<{
+    rtcEventName: string;
+    value: unknown;
+}, "rtcAnalytics/updateReportedValues">;
+
+interface LocalScreenshareState {
+    status: "" | "starting" | "active";
+    stream: MediaStream | null;
+    error: unknown | null;
+}
+/**
+ * Reducer
+ */
+declare const localScreenshareSlice: _reduxjs_toolkit.Slice<LocalScreenshareState, {
+    stopScreenshare(state: {
+        status: "" | "starting" | "active";
+        stream: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null;
+        error: unknown | null;
+    }, action: PayloadAction<{
+        stream: MediaStream;
+    }>): {
+        status: "";
+        stream: null;
+        error: unknown | null;
+    };
+}, "localScreenshare", "localScreenshare", _reduxjs_toolkit.SliceSelectors<LocalScreenshareState>>;
+/**
+ * Action creators
+ */
+declare const stopScreenshare: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    stream: MediaStream;
+}, "localScreenshare/stopScreenshare">;
+declare const doStartScreenshare: _reduxjs_toolkit.AsyncThunk<{
+    stream: MediaStream;
+}, undefined, ThunkConfig>;
+declare const doStopScreenshare: (args: void) => AppThunk<void>;
+/**
+ * Selectors
+ */
+declare const selectLocalScreenshareRaw: (state: RootState) => LocalScreenshareState;
+declare const selectLocalScreenshareStatus: (state: RootState) => "" | "starting" | "active";
+declare const selectLocalScreenshareStream: (state: RootState) => MediaStream | null;
+
+interface LocalParticipantState extends LocalParticipant {
+    isScreenSharing: boolean;
+    roleName: string;
+}
+declare const doEnableAudio: _reduxjs_toolkit.AsyncThunk<boolean, {
+    enabled: boolean;
+}, ThunkConfig>;
+declare const doEnableVideo: _reduxjs_toolkit.AsyncThunk<boolean, {
+    enabled: boolean;
+}, ThunkConfig>;
+declare const doSetDisplayName: _reduxjs_toolkit.AsyncThunk<string, {
+    displayName: string;
+}, ThunkConfig>;
+declare const localParticipantSlice: _reduxjs_toolkit.Slice<LocalParticipantState, {
+    doSetLocalParticipant: (state: {
+        isScreenSharing: boolean;
+        roleName: string;
+        isLocalParticipant: true;
+        displayName: string;
+        id: string;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isAudioEnabled: boolean;
+        isVideoEnabled: boolean;
+    }, action: PayloadAction<LocalParticipant>) => {
+        isLocalParticipant: true;
+        displayName: string;
+        id: string;
+        stream?: MediaStream | undefined;
+        isAudioEnabled: boolean;
+        isVideoEnabled: boolean;
+        isScreenSharing: boolean;
+        roleName: string;
+    };
+}, "localParticipant", "localParticipant", _reduxjs_toolkit.SliceSelectors<LocalParticipantState>>;
+declare const doSetLocalParticipant: _reduxjs_toolkit.ActionCreatorWithPayload<LocalParticipant, "localParticipant/doSetLocalParticipant">;
+declare const selectLocalParticipantRaw: (state: RootState) => LocalParticipantState;
+declare const selectSelfId: (state: RootState) => string;
+declare const selectLocalParticipantRole: (state: RootState) => string;
+declare const selectLocalParticipantIsScreenSharing: (state: RootState) => boolean;
+
+/**
+ * Reducer
+ */
+interface CloudRecordingState {
+    isRecording: boolean;
+    error: unknown;
+    status?: "recording" | "requested" | "error";
+    startedAt?: number;
+}
+declare const initialCloudRecordingState: CloudRecordingState;
+declare const cloudRecordingSlice: _reduxjs_toolkit.Slice<CloudRecordingState, {
+    recordingRequestStarted: (state: {
+        isRecording: boolean;
+        error: unknown;
+        status?: "error" | "recording" | "requested" | undefined;
+        startedAt?: number | undefined;
+    }) => {
+        status: "requested";
+        isRecording: boolean;
+        error: unknown;
+        startedAt?: number | undefined;
+    };
+}, "cloudRecording", "cloudRecording", _reduxjs_toolkit.SliceSelectors<CloudRecordingState>>;
+/**
+ * Action creators
+ */
+declare const recordingRequestStarted: _reduxjs_toolkit.ActionCreatorWithoutPayload<"cloudRecording/recordingRequestStarted">;
+declare const doStartCloudRecording: (args: void) => AppThunk<void>;
+declare const doStopCloudRecording: (args: void) => AppThunk<void>;
+/**
+ * Selectors
+ */
+declare const selectCloudRecordingRaw: (state: RootState) => CloudRecordingState;
+declare const selectCloudRecordingStatus: (state: RootState) => "error" | "recording" | "requested" | undefined;
+declare const selectCloudRecordingStartedAt: (state: RootState) => number | undefined;
+declare const selectCloudRecordingError: (state: RootState) => unknown;
+declare const selectIsCloudRecording: (state: RootState) => boolean;
+
+type ChatMessage = Pick<ChatMessage$1, "senderId" | "timestamp" | "text">;
+/**
+ * Reducer
+ */
+interface ChatState {
+    chatMessages: ChatMessage[];
+}
+declare const chatSlice: _reduxjs_toolkit.Slice<ChatState, {}, "chat", "chat", _reduxjs_toolkit.SliceSelectors<ChatState>>;
+/**
+ * Action creators
+ */
+declare const doSendChatMessage: (args: {
+    text: string;
+}) => AppThunk<void>;
+/**
+ * Selectors
+ */
+declare const selectChatRaw: (state: RootState) => ChatState;
+declare const selectChatMessages: (state: RootState) => ChatMessage[];
+
+/**
+ * Reducer
+ */
+interface AppState {
+    wantsToJoin: boolean;
+    roomUrl: string | null;
+    roomName: string | null;
+    roomKey: string | null;
+    displayName: string | null;
+    sdkVersion: string | null;
+    externalId: string | null;
+}
+declare const appSlice: _reduxjs_toolkit.Slice<AppState, {
+    doAppJoin: (state: {
+        wantsToJoin: boolean;
+        roomUrl: string | null;
+        roomName: string | null;
+        roomKey: string | null;
+        displayName: string | null;
+        sdkVersion: string | null;
+        externalId: string | null;
+    }, action: PayloadAction<{
+        displayName: string;
+        localMediaOptions?: LocalMediaOptions;
+        roomKey: string | null;
+        roomUrl: string;
+        sdkVersion: string;
+        externalId: string | null;
+    }>) => {
+        roomName: string;
+        wantsToJoin: true;
+        displayName: string;
+        localMediaOptions?: LocalMediaOptions | undefined;
+        roomKey: string | null;
+        roomUrl: string;
+        sdkVersion: string;
+        externalId: string | null;
+    };
+    appLeft: (state: {
+        wantsToJoin: boolean;
+        roomUrl: string | null;
+        roomName: string | null;
+        roomKey: string | null;
+        displayName: string | null;
+        sdkVersion: string | null;
+        externalId: string | null;
+    }) => {
+        wantsToJoin: false;
+        roomUrl: string | null;
+        roomName: string | null;
+        roomKey: string | null;
+        displayName: string | null;
+        sdkVersion: string | null;
+        externalId: string | null;
+    };
+    setRoomKey: (state: {
+        wantsToJoin: boolean;
+        roomUrl: string | null;
+        roomName: string | null;
+        roomKey: string | null;
+        displayName: string | null;
+        sdkVersion: string | null;
+        externalId: string | null;
+    }, action: PayloadAction<string>) => {
+        roomKey: string;
+        wantsToJoin: boolean;
+        roomUrl: string | null;
+        roomName: string | null;
+        displayName: string | null;
+        sdkVersion: string | null;
+        externalId: string | null;
+    };
+}, "app", "app", _reduxjs_toolkit.SliceSelectors<AppState>>;
+/**
+ * Action creators
+ */
+declare const doAppJoin: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    displayName: string;
+    localMediaOptions?: LocalMediaOptions | undefined;
+    roomKey: string | null;
+    roomUrl: string;
+    sdkVersion: string;
+    externalId: string | null;
+}, "app/doAppJoin">;
+declare const appLeft: _reduxjs_toolkit.ActionCreatorWithoutPayload<"app/appLeft">;
+declare const setRoomKey: _reduxjs_toolkit.ActionCreatorWithPayload<string, "app/setRoomKey">;
+/**
+ * Selectors
+ */
+declare const selectAppRaw: (state: RootState) => AppState;
+declare const selectAppWantsToJoin: (state: RootState) => boolean;
+declare const selectAppRoomName: (state: RootState) => string | null;
+declare const selectAppRoomUrl: (state: RootState) => string | null;
+declare const selectAppRoomKey: (state: RootState) => string | null;
+declare const selectAppDisplayName: (state: RootState) => string | null;
+declare const selectAppSdkVersion: (state: RootState) => string | null;
+declare const selectAppExternalId: (state: RootState) => string | null;
+
+type HttpClientRequestConfig = AxiosRequestConfig | {
+    [key: string]: unknown;
+};
+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 FetchOrganizationFunction = () => Promise<Organization | undefined>;
+/**
+ * Class used for all Whereby organization API calls.
+ */
+declare class OrganizationApiClient {
+    private _apiClient;
+    private _fetchOrganization;
+    /**
+     * Create an OrganizationApiClient instance.
+     *
+     * @param {Object} options - The options for the OrganizationApiClient.
+     * @param {ApiClient} [options.apiClient] - The apiClient to use.
+     * @param {Function} [options.fetchOrganization] - function that returns a promise with the organization.
+     */
+    constructor({ apiClient, fetchOrganization, }: {
+        apiClient: ApiClient;
+        fetchOrganization?: FetchOrganizationFunction;
+    });
+    _callRequestMethod(method: "request" | "requestMultipart", url: string, options: HttpClientRequestConfig): Promise<Response>;
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+    requestMultipart(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+
+type UserConsentAction = "accepted" | "rejected" | null;
+type ConsentGrantRequest = {
+    readonly consentRevisionId: string;
+    readonly action: UserConsentAction;
+};
+
+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>;
+}
+
+declare class OrganizationServiceCache {
+    private _organizationService;
+    private _subdomain;
+    private _organizationPromise;
+    constructor({ organizationService, subdomain }: {
+        organizationService: OrganizationService;
+        subdomain: string;
+    });
+    initOrganization(): Promise<void>;
+    fetchOrganization(): Promise<Organization | null>;
+}
+
+declare class Room {
+    readonly isLocked: boolean;
+    constructor(properties?: {});
+}
+
+/**
+ * Service for talking to the Room related APIs
+ */
+declare class RoomService {
+    /**
+     * @param {object} organizationApiClient (required)
+     */
+    constructor({ organizationApiClient }: {
+        organizationApiClient: any;
+    });
+    /**
+     * Gets the list of visited rooms
+     *
+     * @param {Object} args
+     * @param {Array<string>} [types=["team"]] - The type of rooms that should be fetched.
+     * @param {Array<string>} [fields=["meeting"]] - The fields of room that should be fetched.
+     * @returns {Promise<array>} - It will resolve with an array.
+     */
+    getRooms({ types, fields }?: {
+        types: any;
+        fields?: never[] | undefined;
+    }): any;
+    /**
+     * Gets the specified room.
+     *
+     * Currently information is implicitly alluded to via the servers
+     * `/room/roomName` response. This method patches the data
+     * tempoarily, until the day it comes back from the server.
+     *
+     * @returns {Promise<Room>} - It will resolve with the Room.
+     */
+    getRoom({ roomName, fields }: {
+        roomName: string;
+        fields?: Array<string>;
+    }): Promise<Room>;
+    /**
+     * Claims the specified room.
+     *
+     * @param {Object} args
+     * @param {String} args.roomName - The roomName to claim
+     * @param {String} args.type - The type of room to claim
+     * @param {String} args.mode - The optional mode of room to claim
+     * @param {[Boolean]} args.isLocked - The optional lock status of room to claim
+     * @returns {Promise} - It will resolve with undefined.
+     */
+    claimRoom({ roomName, type, mode, isLocked }: {
+        roomName: any;
+        type: any;
+        mode: any;
+        isLocked: any;
+    }): any;
+    /**
+     * Unclaims the specified room.
+     *
+     * @param {string} roomName - the room name to unclaim.
+     * @returns {Promise.<undefined>} - It will resolve with undefined.
+     */
+    unclaimRoom(roomName: any): any;
+    /**
+     * Changes the name of the room
+     *
+     * @param {Object} args
+     * @param {string} args.roomName - The name of the room to rename
+     * @param {string} args.newRoomName - The new name
+     * @returns {Promise<undefined>} - It will resolve if the room was renamed, reject for all other cases
+     */
+    renameRoom({ roomName, newRoomName }: {
+        roomName: any;
+        newRoomName: any;
+    }): any;
+    /**
+     * Changes the room mode (experimental)
+     *
+     * @param {string} roomName - The name of the room to change mode of
+     * @param {string} mode - The name of mode to set, currently only "group" is supported
+     * @returns {Promise<undefined>} - It will resolve if mode was changed, rejects for all other cases
+     */
+    changeMode({ roomName, mode }: {
+        roomName: any;
+        mode: any;
+    }): any;
+    /**
+     * Updates the room prefs
+     *
+     * @param {string} roomName - The name of the room to change mode of
+     * @param {object} preferences - The prefs you want to update and their values
+     * @returns {Promise<undefined>} - It will resolve if updated, rejects for all other cases
+     */
+    updatePreferences({ roomName, preferences }: {
+        roomName: any;
+        preferences: any;
+    }): any;
+    /**
+     * Updates the protected room prefs
+     *
+     * @param {string} roomName - The name of the room to change mode of
+     * @param {object} preferences - The protected prefs you want to update and their values
+     * @returns {Promise<undefined>} - It will resolve if updated, rejects for all other cases
+     */
+    updateProtectedPreferences({ roomName, preferences }: {
+        roomName: any;
+        preferences: any;
+    }): any;
+    getRoomPermissions(roomName: any, { roomKey }?: {
+        roomKey: any;
+    }): any;
+    /**
+     * Gets the specified room metrics
+     *
+     * @param {Object} args
+     * @param {string} args.roomName - The name of the room to get metrics from.
+     * @param {string} args.metrics - Comma-separated list of metrics to include.
+     * @param {string} args.from (optional) - Start time (inclusive) to count from in
+     * ISO format. Defaults to counting from the start of time.
+     * @param {string} args.to (optional) - End time (exclusive) to count up to in
+     * ISO format. Defaults to counting up to the current time.
+     * @returns {Promise<Object>} - It will resolve with the requested metrics.
+     */
+    getRoomMetrics({ roomName, metrics, from, to }: {
+        roomName: any;
+        metrics: any;
+        from: any;
+        to: any;
+    }): any;
+    /**
+     * Changes the room type
+     *
+     * @param {Object} args
+     * @param {string} args.roomName - The name of the room to change mode of
+     * @param {"personal" | "personal_xl"} args.type - Room type that should be set
+     * @returns {Promise<undefined>} - It will resolve if type was changed, rejects for all other cases
+     */
+    changeType({ roomName, type }: {
+        roomName: any;
+        type: any;
+    }): any;
+    /** Gets a Forest campaign social image
+     *
+     * @param {Object} args
+     * @param {string} args.roomName - The name of the room to get metrics from.
+     * @param {number} args.count - Number to be displayed in the image as tree count.
+     * @returns {Promise<string>} - It will resolve with the image url.
+     */
+    getForestSocialImage({ roomName, count }: {
+        roomName: any;
+        count: any;
+    }): any;
+}
+
+/**
+ * Reducer
+ */
+interface DeviceCredentialsState {
+    isFetching: boolean;
+    data?: Credentials | null;
+}
+declare const deviceCredentialsSlice: _reduxjs_toolkit.Slice<DeviceCredentialsState, {}, "deviceCredentials", "deviceCredentials", _reduxjs_toolkit.SliceSelectors<DeviceCredentialsState>>;
+/**
+ * Action creators
+ */
+declare const doGetDeviceCredentials: _reduxjs_toolkit.AsyncThunk<Credentials | null | undefined, undefined, ThunkConfig>;
+/**
+ * Selectors
+ */
+declare const selectDeviceCredentialsRaw: (state: RootState) => DeviceCredentialsState;
+declare const selectHasFetchedDeviceCredentials: (state: RootState) => boolean;
+declare const selectDeviceId: (state: RootState) => string | undefined;
+/**
+ * Reactors
+ */
+declare const selectShouldFetchDeviceCredentials: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: DeviceCredentialsState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: DeviceCredentialsState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean, (state: RootState) => DeviceCredentialsState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+interface DebouncedFunction {
+    (...args: any[]): void;
+}
+
+type LocalMediaOptions = {
+    audio: boolean;
+    video: boolean;
+};
+/**
+ * Reducer
+ */
+interface LocalMediaState {
+    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;
+}
+declare const initialLocalMediaState: LocalMediaState;
+declare const localMediaSlice: _reduxjs_toolkit.Slice<LocalMediaState, {
+    deviceBusy(state: {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    }, action: PayloadAction<{
+        deviceId: string;
+    }>): {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    toggleCameraEnabled(state: {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    }, action: PayloadAction<{
+        enabled?: boolean;
+    }>): {
+        cameraEnabled: boolean;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setCurrentCameraDeviceId(state: {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    }, action: PayloadAction<{
+        deviceId?: string;
+    }>): {
+        currentCameraDeviceId: string | undefined;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    toggleMicrophoneEnabled(state: {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    }, action: PayloadAction<{
+        enabled?: boolean;
+    }>): {
+        microphoneEnabled: boolean;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setCurrentMicrophoneDeviceId(state: {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    }, action: PayloadAction<{
+        deviceId?: string;
+    }>): {
+        currentMicrophoneDeviceId: string | undefined;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setDevices(state: {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    }, action: PayloadAction<{
+        devices: MediaDeviceInfo[];
+    }>): {
+        devices: MediaDeviceInfo[];
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setLocalMediaStream(state: {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    }, action: PayloadAction<{
+        stream: MediaStream;
+    }>): {
+        stream: MediaStream;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setLocalMediaOptions(state: {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    }, action: PayloadAction<{
+        options: LocalMediaOptions;
+    }>): {
+        options: LocalMediaOptions;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    localMediaStopped(state: {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    }): {
+        status: "stopped";
+        stream: undefined;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        startError?: unknown;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    localStreamMetadataUpdated(state: {
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    }, action: PayloadAction<ReturnType<typeof getDeviceData>>): {
+        currentCameraDeviceId: string;
+        currentMicrophoneDeviceId: string;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        devices: {
+            deviceId: string;
+            groupId: string;
+            kind: MediaDeviceKind;
+            label: string;
+            toJSON: () => any;
+        }[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        options?: {
+            audio: boolean;
+            video: boolean;
+        } | undefined;
+        status: "" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: {
+            active: boolean;
+            id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+            };
+            removeEventListener: {
+                <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+}, "localMedia", "localMedia", _reduxjs_toolkit.SliceSelectors<LocalMediaState>>;
+/**
+ * Action creators
+ */
+declare const deviceBusy: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    deviceId: string;
+}, "localMedia/deviceBusy">;
+declare const setCurrentCameraDeviceId: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    deviceId?: string | undefined;
+}, "localMedia/setCurrentCameraDeviceId">;
+declare const setCurrentMicrophoneDeviceId: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    deviceId?: string | undefined;
+}, "localMedia/setCurrentMicrophoneDeviceId">;
+declare const toggleCameraEnabled: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    enabled?: boolean | undefined;
+}, "localMedia/toggleCameraEnabled">;
+declare const toggleMicrophoneEnabled: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    enabled?: boolean | undefined;
+}, "localMedia/toggleMicrophoneEnabled">;
+declare const setLocalMediaOptions: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    options: LocalMediaOptions;
+}, "localMedia/setLocalMediaOptions">;
+declare const setLocalMediaStream: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    stream: MediaStream;
+}, "localMedia/setLocalMediaStream">;
+declare const localMediaStopped: _reduxjs_toolkit.ActionCreatorWithoutPayload<"localMedia/localMediaStopped">;
+declare const localStreamMetadataUpdated: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    audio: {
+        deviceId: string;
+        label: string;
+        kind: string;
+    };
+    video: {
+        deviceId: string;
+        label: string;
+        kind: string;
+    };
+}, "localMedia/localStreamMetadataUpdated">;
+declare const doToggleCamera: _reduxjs_toolkit.AsyncThunk<undefined, undefined, ThunkConfig>;
+declare const doSetDevice: _reduxjs_toolkit.AsyncThunk<{
+    replacedTracks: MediaStreamTrack[] | undefined;
+}, {
+    audio: boolean;
+    video: boolean;
+}, ThunkConfig>;
+declare const doUpdateDeviceList: _reduxjs_toolkit.AsyncThunk<{
+    devices: MediaDeviceInfo[];
+}, undefined, ThunkConfig>;
+declare const doSwitchLocalStream: _reduxjs_toolkit.AsyncThunk<{
+    replacedTracks: MediaStreamTrack[] | undefined;
+} | undefined, {
+    audioId?: string | undefined;
+    videoId?: string | undefined;
+}, ThunkConfig>;
+declare const doStartLocalMedia: _reduxjs_toolkit.AsyncThunk<{
+    stream: MediaStream;
+    onDeviceChange: DebouncedFunction;
+}, LocalMediaOptions | MediaStream, ThunkConfig>;
+declare const doStopLocalMedia: (args: void) => AppThunk<void>;
+/**
+ * Selectors
+ */
+declare const selectBusyDeviceIds: (state: RootState) => string[];
+declare const selectCameraDeviceError: (state: RootState) => unknown;
+declare const selectCurrentCameraDeviceId: (state: RootState) => string | undefined;
+declare const selectCurrentMicrophoneDeviceId: (state: RootState) => string | undefined;
+declare const selectIsCameraEnabled: (state: RootState) => boolean;
+declare const selectIsMicrophoneEnabled: (state: RootState) => boolean;
+declare const selectIsSettingCameraDevice: (state: RootState) => boolean;
+declare const selectIsSettingMicrophoneDevice: (state: RootState) => boolean;
+declare const selectIsToggleCamera: (state: RootState) => boolean;
+declare const selectLocalMediaDevices: (state: RootState) => MediaDeviceInfo[];
+declare const selectLocalMediaOptions: (state: RootState) => LocalMediaOptions | undefined;
+declare const selectLocalMediaOwnsStream: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: LocalMediaOptions | undefined) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: LocalMediaOptions | undefined) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => LocalMediaOptions | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectLocalMediaRaw: (state: RootState) => LocalMediaState;
+declare const selectLocalMediaStatus: (state: RootState) => "" | "error" | "stopped" | "starting" | "started";
+declare const selectLocalMediaStream: (state: RootState) => MediaStream | undefined;
+declare const selectMicrophoneDeviceError: (state: RootState) => unknown;
+declare const selectLocalMediaStartError: (state: RootState) => unknown;
+declare const selectLocalMediaIsSwitchingStream: (state: RootState) => boolean;
+declare const selectLocalMediaConstraintsOptions: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => {
+    devices: MediaDeviceInfo[];
+    options: {
+        disableAEC: boolean;
+        disableAGC: boolean;
+        hd: boolean;
+        lax: boolean;
+        lowDataMode: boolean;
+        simulcast: boolean;
+        widescreen: boolean;
+    };
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: MediaDeviceInfo[]) => {
+        devices: MediaDeviceInfo[];
+        options: {
+            disableAEC: boolean;
+            disableAGC: boolean;
+            hd: boolean;
+            lax: boolean;
+            lowDataMode: boolean;
+            simulcast: boolean;
+            widescreen: boolean;
+        };
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: MediaDeviceInfo[]) => {
+        devices: MediaDeviceInfo[];
+        options: {
+            disableAEC: boolean;
+            disableAGC: boolean;
+            hd: boolean;
+            lax: boolean;
+            lowDataMode: boolean;
+            simulcast: boolean;
+            widescreen: boolean;
+        };
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        devices: MediaDeviceInfo[];
+        options: {
+            disableAEC: boolean;
+            disableAGC: boolean;
+            hd: boolean;
+            lax: boolean;
+            lowDataMode: boolean;
+            simulcast: boolean;
+            widescreen: boolean;
+        };
+    };
+    dependencies: [(state: RootState) => MediaDeviceInfo[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectIsLocalMediaStarting: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: "" | "error" | "stopped" | "starting" | "started") => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: "" | "error" | "stopped" | "starting" | "started") => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => "" | "error" | "stopped" | "starting" | "started"];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectCameraDevices: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => MediaDeviceInfo[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: MediaDeviceInfo[], resultFuncArgs_1: string[]) => MediaDeviceInfo[];
+    memoizedResultFunc: ((resultFuncArgs_0: MediaDeviceInfo[], resultFuncArgs_1: string[]) => MediaDeviceInfo[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => MediaDeviceInfo[];
+    dependencies: [(state: RootState) => MediaDeviceInfo[], (state: RootState) => string[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectMicrophoneDevices: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => MediaDeviceInfo[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: MediaDeviceInfo[], resultFuncArgs_1: string[]) => MediaDeviceInfo[];
+    memoizedResultFunc: ((resultFuncArgs_0: MediaDeviceInfo[], resultFuncArgs_1: string[]) => MediaDeviceInfo[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => MediaDeviceInfo[];
+    dependencies: [(state: RootState) => MediaDeviceInfo[], (state: RootState) => string[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectSpeakerDevices: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => MediaDeviceInfo[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: MediaDeviceInfo[]) => MediaDeviceInfo[];
+    memoizedResultFunc: ((resultFuncArgs_0: MediaDeviceInfo[]) => MediaDeviceInfo[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => MediaDeviceInfo[];
+    dependencies: [(state: RootState) => MediaDeviceInfo[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+/**
+ * Reactors
+ */
+declare const selectLocalMediaShouldStartWithOptions: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => LocalMediaOptions | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: "" | "error" | "stopped" | "starting" | "started", resultFuncArgs_2: LocalMediaOptions | undefined) => LocalMediaOptions | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: "" | "error" | "stopped" | "starting" | "started", resultFuncArgs_2: LocalMediaOptions | undefined) => LocalMediaOptions | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => LocalMediaOptions | undefined;
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean, (state: RootState) => "" | "error" | "stopped" | "starting" | "started", (state: RootState) => LocalMediaOptions | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectLocalMediaShouldStop: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: "" | "error" | "stopped" | "starting" | "started", resultFuncArgs_2: LocalMediaOptions | undefined) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: "" | "error" | "stopped" | "starting" | "started", resultFuncArgs_2: LocalMediaOptions | undefined) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean, (state: RootState) => "" | "error" | "stopped" | "starting" | "started", (state: RootState) => LocalMediaOptions | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+/**
+ * Reducer
+ */
+interface OrganizationState {
+    data: Organization | null | undefined;
+    isFetching: boolean;
+    error: unknown;
+}
+declare const organizationSlice: _reduxjs_toolkit.Slice<OrganizationState, {}, "organization", "organization", _reduxjs_toolkit.SliceSelectors<OrganizationState>>;
+/**
+ * Action creators
+ */
+declare const doOrganizationFetch: _reduxjs_toolkit.AsyncThunk<Organization | undefined, undefined, ThunkConfig>;
+/**
+ * Selectors
+ */
+declare const selectOrganizationRaw: (state: RootState) => OrganizationState;
+declare const selectOrganizationId: (state: RootState) => string | undefined;
+/**
+ * Reducers
+ */
+declare const selectShouldFetchOrganization: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: OrganizationState, resultFuncArgs_2: DeviceCredentialsState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: OrganizationState, resultFuncArgs_2: DeviceCredentialsState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean, (state: RootState) => OrganizationState, (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => DeviceCredentialsState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+interface StreamStatusUpdate {
+    clientId: string;
+    streamId: string;
+    state: StreamState;
+}
+
+/**
+ * Reducer
+ */
+interface RemoteParticipantState {
+    remoteParticipants: RemoteParticipant[];
+}
+declare const remoteParticipantsSlice: _reduxjs_toolkit.Slice<RemoteParticipantState, {
+    streamStatusUpdated: (state: {
+        remoteParticipants: {
+            id: string;
+            displayName: string;
+            isAudioEnabled: boolean;
+            isVideoEnabled: boolean;
+            isLocalParticipant: boolean;
+            stream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+            streams: {
+                id: string;
+                state: StreamState;
+            }[];
+            newJoiner: boolean;
+            presentationStream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K_2 extends keyof MediaStreamEventMap>(type: K_2, listener: (this: MediaStream, ev: MediaStreamEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_3 extends keyof MediaStreamEventMap>(type: K_3, listener: (this: MediaStream, ev: MediaStreamEventMap[K_3]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+        }[];
+    }, action: PayloadAction<StreamStatusUpdate[]>) => {
+        remoteParticipants: {
+            id: string;
+            displayName: string;
+            isAudioEnabled: boolean;
+            isVideoEnabled: boolean;
+            isLocalParticipant: boolean;
+            stream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+            streams: {
+                id: string;
+                state: StreamState;
+            }[];
+            newJoiner: boolean;
+            presentationStream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K_2 extends keyof MediaStreamEventMap>(type: K_2, listener: (this: MediaStream, ev: MediaStreamEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_3 extends keyof MediaStreamEventMap>(type: K_3, listener: (this: MediaStream, ev: MediaStreamEventMap[K_3]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+        }[];
+    };
+    participantStreamAdded: (state: {
+        remoteParticipants: {
+            id: string;
+            displayName: string;
+            isAudioEnabled: boolean;
+            isVideoEnabled: boolean;
+            isLocalParticipant: boolean;
+            stream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+            streams: {
+                id: string;
+                state: StreamState;
+            }[];
+            newJoiner: boolean;
+            presentationStream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K_2 extends keyof MediaStreamEventMap>(type: K_2, listener: (this: MediaStream, ev: MediaStreamEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_3 extends keyof MediaStreamEventMap>(type: K_3, listener: (this: MediaStream, ev: MediaStreamEventMap[K_3]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+        }[];
+    }, action: PayloadAction<RtcStreamAddedPayload>) => RemoteParticipantState;
+    participantStreamIdAdded: (state: {
+        remoteParticipants: {
+            id: string;
+            displayName: string;
+            isAudioEnabled: boolean;
+            isVideoEnabled: boolean;
+            isLocalParticipant: boolean;
+            stream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+            streams: {
+                id: string;
+                state: StreamState;
+            }[];
+            newJoiner: boolean;
+            presentationStream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K_2 extends keyof MediaStreamEventMap>(type: K_2, listener: (this: MediaStream, ev: MediaStreamEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_3 extends keyof MediaStreamEventMap>(type: K_3, listener: (this: MediaStream, ev: MediaStreamEventMap[K_3]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+        }[];
+    }, action: PayloadAction<{
+        clientId: string;
+        streamId: string;
+    }>) => RemoteParticipantState;
+}, "remoteParticipants", "remoteParticipants", _reduxjs_toolkit.SliceSelectors<RemoteParticipantState>>;
+/**
+ * Action creators
+ */
+declare const participantStreamAdded: _reduxjs_toolkit.ActionCreatorWithPayload<RtcStreamAddedPayload, "remoteParticipants/participantStreamAdded">;
+declare const participantStreamIdAdded: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    clientId: string;
+    streamId: string;
+}, "remoteParticipants/participantStreamIdAdded">;
+declare const streamStatusUpdated: _reduxjs_toolkit.ActionCreatorWithPayload<StreamStatusUpdate[], "remoteParticipants/streamStatusUpdated">;
+/**
+ * Selectors
+ */
+declare const selectRemoteParticipantsRaw: (state: RootState) => RemoteParticipantState;
+declare const selectRemoteParticipants: (state: RootState) => RemoteParticipant[];
+declare const selectScreenshares: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => Screenshare[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: RemoteParticipant[]) => Screenshare[];
+    memoizedResultFunc: ((resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: RemoteParticipant[]) => Screenshare[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Screenshare[];
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => MediaStream | null, (state: RootState) => RemoteParticipant[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+type ConnectionStatus = "initializing" | "connecting" | "connected" | "reconnect" | "room_locked" | "knocking" | "disconnecting" | "disconnected" | "knock_rejected";
+/**
+ * Reducer
+ */
+interface RoomConnectionState {
+    session: {
+        createdAt: string;
+        id: string;
+    } | null;
+    status: ConnectionStatus;
+    error: unknown;
+}
+declare const roomConnectionSlice: _reduxjs_toolkit.Slice<RoomConnectionState, {
+    connectionStatusChanged: (state: {
+        session: {
+            createdAt: string;
+            id: string;
+        } | null;
+        status: ConnectionStatus;
+        error: unknown;
+    }, action: PayloadAction<ConnectionStatus>) => {
+        status: ConnectionStatus;
+        session: {
+            createdAt: string;
+            id: string;
+        } | null;
+        error: unknown;
+    };
+}, "roomConnection", "roomConnection", _reduxjs_toolkit.SliceSelectors<RoomConnectionState>>;
+declare const doKnockRoom: (args: void) => AppThunk<void>;
+declare const doConnectRoom: (args: void) => AppThunk<void>;
+/**
+ * Selectors
+ */
+declare const selectRoomConnectionRaw: (state: RootState) => RoomConnectionState;
+declare const selectRoomConnectionSession: (state: RootState) => {
+    createdAt: string;
+    id: string;
+} | null;
+declare const selectRoomConnectionSessionId: (state: RootState) => string | undefined;
+declare const selectRoomConnectionStatus: (state: RootState) => ConnectionStatus;
+/**
+ * Reactors
+ */
+declare const selectShouldConnectRoom: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string | undefined, resultFuncArgs_1: ConnectionStatus, resultFuncArgs_2: boolean, resultFuncArgs_3: "" | "error" | "stopped" | "starting" | "started") => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: string | undefined, resultFuncArgs_1: ConnectionStatus, resultFuncArgs_2: boolean, resultFuncArgs_3: "" | "error" | "stopped" | "starting" | "started") => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => string | undefined, (state: RootState) => ConnectionStatus, (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean, (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => "" | "error" | "stopped" | "starting" | "started"];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+declare const createWebRtcEmitter: (dispatch: AppDispatch) => {
+    emit: (eventName: keyof RtcEvents, data: RtcEvents[keyof RtcEvents]) => void;
+};
+/**
+ * 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;
+}
+declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
+    isAcceptingStreams: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }, action: PayloadAction<boolean>) => {
+        isAcceptingStreams: boolean;
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+    };
+    resolutionReported: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }, action: PayloadAction<StreamResolutionUpdate>) => {
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            } | {
+                width: number;
+                height: number;
+            };
+        };
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    };
+    rtcDisconnected: () => {
+        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;
+    };
+    rtcDispatcherCreated: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }, action: PayloadAction<RtcManagerDispatcher>) => {
+        dispatcherCreated: true;
+        rtcManagerDispatcher: RtcManagerDispatcher;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    };
+    rtcManagerCreated: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }, action: PayloadAction<RtcManager>) => {
+        rtcManager: RtcManager;
+        status: "ready";
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        isAcceptingStreams: boolean;
+    };
+    rtcManagerDestroyed: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }) => {
+        rtcManager: null;
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    };
+    rtcManagerInitialized: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }) => {
+        rtcManagerInitialized: true;
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    };
+}, "rtcConnection", "rtcConnection", _reduxjs_toolkit.SliceSelectors<RtcConnectionState>>;
+/**
+ * Action creators
+ */
+declare const resolutionReported: _reduxjs_toolkit.ActionCreatorWithPayload<StreamResolutionUpdate, "rtcConnection/resolutionReported">;
+declare const rtcDispatcherCreated: _reduxjs_toolkit.ActionCreatorWithPayload<RtcManagerDispatcher, "rtcConnection/rtcDispatcherCreated">;
+declare const rtcDisconnected: _reduxjs_toolkit.ActionCreatorWithoutPayload<"rtcConnection/rtcDisconnected">;
+declare const rtcManagerCreated: _reduxjs_toolkit.ActionCreatorWithPayload<RtcManager, "rtcConnection/rtcManagerCreated">;
+declare const rtcManagerDestroyed: _reduxjs_toolkit.ActionCreatorWithoutPayload<"rtcConnection/rtcManagerDestroyed">;
+declare const rtcManagerInitialized: _reduxjs_toolkit.ActionCreatorWithoutPayload<"rtcConnection/rtcManagerInitialized">;
+declare const isAcceptingStreams: _reduxjs_toolkit.ActionCreatorWithPayload<boolean, "rtcConnection/isAcceptingStreams">;
+declare const doConnectRtc: (args: void) => AppThunk<void>;
+declare const doDisconnectRtc: (args: void) => AppThunk<void>;
+declare const doHandleAcceptStreams: (args: StreamStatusUpdate[]) => AppThunk<void>;
+declare const doRtcReportStreamResolution: (args: StreamResolutionUpdate) => AppThunk<void>;
+declare const doRtcManagerCreated: (args: RtcManagerCreatedPayload) => AppThunk<void>;
+declare const doRtcManagerInitialize: (args: void) => AppThunk<void>;
+/**
+ * Selectors
+ */
+declare const selectRtcConnectionRaw: (state: RootState) => RtcConnectionState;
+declare const selectRtcManagerInitialized: (state: RootState) => boolean;
+declare const selectRtcManager: (state: RootState) => RtcManager | null;
+declare const selectRtcDispatcherCreated: (state: RootState) => boolean;
+declare const selectRtcIsCreatingDispatcher: (state: RootState) => boolean;
+declare const selectRtcStatus: (state: RootState) => "" | "reconnect" | "ready";
+declare const selectIsAcceptingStreams: (state: RootState) => boolean;
+declare const selectShouldConnectRtc: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: boolean, resultFuncArgs_2: _whereby_jslib_media_src_utils_ServerSocket.default | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: boolean, resultFuncArgs_2: _whereby_jslib_media_src_utils_ServerSocket.default | null) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => boolean, (state: RootState) => boolean, (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => _whereby_jslib_media_src_utils_ServerSocket.default | null];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectShouldInitializeRtc: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RtcManager | null, resultFuncArgs_1: boolean, resultFuncArgs_2: "" | "error" | "stopped" | "starting" | "started") => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: RtcManager | null, resultFuncArgs_1: boolean, resultFuncArgs_2: "" | "error" | "stopped" | "starting" | "started") => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => RtcManager | null, (state: RootState) => boolean, (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => "" | "error" | "stopped" | "starting" | "started"];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectShouldDisconnectRtc: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: "" | "reconnect" | "ready", resultFuncArgs_1: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: "" | "reconnect" | "ready", resultFuncArgs_1: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => "" | "reconnect" | "ready", (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectStreamsToAccept: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => {
+    clientId: string;
+    streamId: string;
+    state: StreamState;
+}[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: "" | "reconnect" | "ready", resultFuncArgs_1: RemoteParticipant[]) => {
+        clientId: string;
+        streamId: string;
+        state: StreamState;
+    }[];
+    memoizedResultFunc: ((resultFuncArgs_0: "" | "reconnect" | "ready", resultFuncArgs_1: RemoteParticipant[]) => {
+        clientId: string;
+        streamId: string;
+        state: StreamState;
+    }[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        clientId: string;
+        streamId: string;
+        state: StreamState;
+    }[];
+    dependencies: [(state: RootState) => "" | "reconnect" | "ready", (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => RemoteParticipant[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+/**
+ * Reducer
+ */
+interface SignalConnectionState {
+    deviceIdentified: boolean;
+    isIdentifyingDevice: boolean;
+    status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+    socket: _whereby_jslib_media_src_utils_ServerSocket__default | null;
+}
+declare const signalConnectionSlice: _reduxjs_toolkit.Slice<SignalConnectionState, {
+    socketConnecting: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }) => {
+        status: "connecting";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    };
+    socketConnected: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }, action: PayloadAction<_whereby_jslib_media_src_utils_ServerSocket__default>) => {
+        socket: _whereby_jslib_media_src_utils_ServerSocket__default;
+        status: "connected";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+    };
+    socketDisconnected: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }) => {
+        status: "disconnected";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    };
+    socketReconnecting: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }) => {
+        status: "reconnect";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    };
+    deviceIdentifying: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }) => {
+        isIdentifyingDevice: true;
+        deviceIdentified: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    };
+    deviceIdentified: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }) => {
+        deviceIdentified: true;
+        isIdentifyingDevice: false;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    };
+}, "signalConnection", "signalConnection", _reduxjs_toolkit.SliceSelectors<SignalConnectionState>>;
+declare const deviceIdentifying: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/deviceIdentifying">;
+declare const deviceIdentified: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/deviceIdentified">;
+declare const socketConnected: _reduxjs_toolkit.ActionCreatorWithPayload<_whereby_jslib_media_src_utils_ServerSocket__default, "signalConnection/socketConnected">;
+declare const socketConnecting: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/socketConnecting">;
+declare const socketDisconnected: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/socketDisconnected">;
+/**
+ * Action creators
+ */
+declare const doSignalSocketConnect: (args: void) => AppThunk<void>;
+declare const doSignalIdentifyDevice: (args: {
+    deviceCredentials: Credentials;
+}) => AppThunk<void>;
+declare const doSignalDisconnect: (args: void) => AppThunk<void>;
+declare const doSignalReconnect: (args: void) => AppThunk<void>;
+declare const socketReconnecting: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/socketReconnecting">;
+/**
+ * Selectors
+ */
+declare const selectSignalConnectionRaw: (state: RootState) => SignalConnectionState;
+declare const selectSignalIsIdentifyingDevice: (state: RootState) => boolean;
+declare const selectSignalConnectionDeviceIdentified: (state: RootState) => boolean;
+declare const selectSignalStatus: (state: RootState) => "" | "connecting" | "connected" | "reconnect" | "disconnected";
+declare const selectSignalConnectionSocket: (state: RootState) => _whereby_jslib_media_src_utils_ServerSocket__default | null;
+declare const selectShouldConnectSignal: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: "" | "connecting" | "connected" | "reconnect" | "disconnected") => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: "" | "connecting" | "connected" | "reconnect" | "disconnected") => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean, (state: RootState) => "" | "connecting" | "connected" | "reconnect" | "disconnected"];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectShouldIdentifyDevice: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: DeviceCredentialsState, resultFuncArgs_1: "" | "connecting" | "connected" | "reconnect" | "disconnected", resultFuncArgs_2: boolean, resultFuncArgs_3: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: DeviceCredentialsState, resultFuncArgs_1: "" | "connecting" | "connected" | "reconnect" | "disconnected", resultFuncArgs_2: boolean, resultFuncArgs_3: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => DeviceCredentialsState, (state: RootState) => "" | "connecting" | "connected" | "reconnect" | "disconnected", (state: RootState) => boolean, (state: RootState) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+declare function createServices(): {
+    credentialsService: CredentialsService;
+    apiClient: ApiClient;
+    organizationService: OrganizationService;
+    fetchOrganizationFromRoomUrl: (roomUrl: string) => Promise<Organization | null>;
+};
+
+declare const rootReducer: redux.Reducer<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, redux.UnknownAction, Partial<{
+    app: AppState | undefined;
+    chat: ChatState | undefined;
+    cloudRecording: CloudRecordingState | undefined;
+    deviceCredentials: DeviceCredentialsState | undefined;
+    localMedia: LocalMediaState | undefined;
+    localParticipant: LocalParticipantState | undefined;
+    localScreenshare: LocalScreenshareState | undefined;
+    organization: OrganizationState | undefined;
+    remoteParticipants: RemoteParticipantState | undefined;
+    roomConnection: RoomConnectionState | undefined;
+    rtcAnalytics: rtcAnalyticsState | undefined;
+    rtcConnection: RtcConnectionState | undefined;
+    signalConnection: SignalConnectionState | undefined;
+    streaming: StreamingState | undefined;
+    waitingParticipants: WaitingParticipantsState | undefined;
+}>>;
+declare const createStore: ({ preloadedState, injectServices, }: {
+    preloadedState?: Partial<{
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }> | undefined;
+    injectServices: ReturnType<typeof createServices>;
+}) => _reduxjs_toolkit.EnhancedStore<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    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;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        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 RootReducer = typeof rootReducer;
+type RootState = ReturnType<typeof rootReducer>;
+type AppDispatch = ReturnType<typeof createStore>["dispatch"];
+type Store = ReturnType<typeof createStore>;
+declare const observeStore: <T>(store: Store, select: (state: RootState) => T, onChange: (result: T) => void) => redux.Unsubscribe;
+
+type ThunkConfig = {
+    state: RootState;
+    dispatch: AppDispatch;
+    extra: {
+        services: ReturnType<typeof createServices>;
+    };
+};
+declare function createAppAsyncThunk<ReturnType, ArgType = undefined>(typePrefix: string, payloadCreator: AsyncThunkPayloadCreator<ReturnType, ArgType, ThunkConfig>): AsyncThunk<ReturnType, ArgType, ThunkConfig>;
+type AppThunk<R = void> = (dispatch: AppDispatch, getState: () => RootState, extra: {
+    services: ReturnType<typeof createServices>;
+}) => R;
+declare function createAppThunk<A = void>(thunk: (args: A) => AppThunk): (args: A) => AppThunk;
+
+declare const listenerMiddleware: _reduxjs_toolkit.ListenerMiddlewareInstance<unknown, redux_thunk.ThunkDispatch<unknown, unknown, redux.UnknownAction>, unknown>;
+type AppStartListening = TypedStartListening<RootState, AppDispatch, ReturnType<typeof createServices>>;
+declare const startAppListening: AppStartListening;
+declare const addAppListener: TypedAddListener<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, ((action: redux.Action<"listenerMiddleware/add">) => _reduxjs_toolkit.UnsubscribeListener) & redux_thunk.ThunkDispatch<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    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.Dispatch<redux.UnknownAction>>;
+type SelectorResults<Selectors extends Selector<RootState, unknown>[]> = {
+    [K in keyof Selectors]: Selectors[K] extends Selector<RootState, infer R> ? R : never;
+};
+/**
+ * Creates a reactor that will be called whenever the provided selectors change.
+ * Every reactor needs to update a piece of state that it depends on, to avoid infinite loops.
+ * example:
+ * ```ts
+ * createReactor(
+ *    [selectAppWantsToJoin, selectDeviceCredentialsRaw],
+ *   ({ dispatch }, wantsToJoin, deviceCredentialsRaw) => {
+ *      if (wantsToJoin && deviceCredentialsRaw.data) {
+ *         dispatch(doSignalIdentifyDevice({ deviceCredentials: deviceCredentialsRaw.data }));
+ *    }
+ * });
+ * ```
+ * @param selectors. The selectors to be used to check if the state has changed.
+ * @param callback. The callback to be called on every action. The first argument is the listenerApi, the second argument is the result of the selectors.
+ * @returns The unsubscribe function.
+ */
+declare const createReactor: <Selectors extends Selector<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, unknown>[]>(selectors: readonly [...Selectors], callback: (api: {
+    dispatch: AppDispatch;
+    getState: () => RootState;
+    extra: ReturnType<typeof createServices>;
+}, ...selectorValues: SelectorResults<Selectors>) => void | Promise<void>) => _reduxjs_toolkit.UnsubscribeListener;
+
+declare const sdkVersion = "__SDK_VERSION__";
+
+export { ApiClient, type AppDispatch, type AppStartListening, type AppState, type AppThunk, type ChatMessage, type ChatState, type CloudRecordingState, type ConnectionStatus, Credentials, CredentialsService, type DeviceCredentialsState, type LocalMediaOptions, type LocalMediaState, LocalParticipant, type LocalParticipantState, type LocalScreenshareState, OrganizationApiClient, OrganizationService, OrganizationServiceCache, type OrganizationState, type RemoteParticipant, type RemoteParticipantData, type RemoteParticipantState, type RoomConnectionState, RoomService, type RootReducer, type RootState, type RtcConnectionState, type Screenshare, type SignalConnectionState, type Store, type StreamState, type StreamingState, type ThunkConfig, type WaitingParticipant, type WaitingParticipantsState, addAppListener, appLeft, appSlice, chatSlice, cloudRecordingSlice, createAppAsyncThunk, createAppThunk, createReactor, createServices, createStore, createWebRtcEmitter, deviceBusy, deviceCredentialsSlice, deviceIdentified, deviceIdentifying, doAcceptWaitingParticipant, doAppJoin, doConnectRoom, doConnectRtc, doDisconnectRtc, doEnableAudio, doEnableVideo, doGetDeviceCredentials, doHandleAcceptStreams, doHandleStreamingStarted, doHandleStreamingStopped, doKnockRoom, doOrganizationFetch, doRejectWaitingParticipant, doRtcAnalyticsCustomEventsInitialize, doRtcManagerCreated, doRtcManagerInitialize, doRtcReportStreamResolution, doSendChatMessage, doSetDevice, doSetDisplayName, doSetLocalParticipant, doSignalDisconnect, doSignalIdentifyDevice, doSignalReconnect, doSignalSocketConnect, doStartCloudRecording, doStartLocalMedia, doStartScreenshare, doStopCloudRecording, doStopLocalMedia, doStopScreenshare, doSwitchLocalStream, doToggleCamera, doUpdateDeviceList, initialCloudRecordingState, initialLocalMediaState, isAcceptingStreams, listenerMiddleware, localMediaSlice, localMediaStopped, localParticipantSlice, localScreenshareSlice, localStreamMetadataUpdated, observeStore, organizationSlice, participantStreamAdded, participantStreamIdAdded, recordingRequestStarted, remoteParticipantsSlice, resolutionReported, roomConnectionSlice, rootReducer, rtcAnalyticsCustomEvents, rtcAnalyticsSlice, type rtcAnalyticsState, rtcConnectionSlice, rtcDisconnected, rtcDispatcherCreated, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, sdkVersion, selectAppDisplayName, selectAppExternalId, selectAppRaw, selectAppRoomKey, selectAppRoomName, selectAppRoomUrl, selectAppSdkVersion, selectAppWantsToJoin, selectBusyDeviceIds, selectCameraDeviceError, selectCameraDevices, selectChatMessages, selectChatRaw, selectCloudRecordingError, selectCloudRecordingRaw, selectCloudRecordingStartedAt, selectCloudRecordingStatus, selectCurrentCameraDeviceId, selectCurrentMicrophoneDeviceId, selectDeviceCredentialsRaw, selectDeviceId, selectHasFetchedDeviceCredentials, selectIsAcceptingStreams, selectIsCameraEnabled, selectIsCloudRecording, selectIsLocalMediaStarting, selectIsMicrophoneEnabled, selectIsSettingCameraDevice, selectIsSettingMicrophoneDevice, selectIsToggleCamera, selectLocalMediaConstraintsOptions, selectLocalMediaDevices, selectLocalMediaIsSwitchingStream, selectLocalMediaOptions, selectLocalMediaOwnsStream, selectLocalMediaRaw, selectLocalMediaShouldStartWithOptions, selectLocalMediaShouldStop, selectLocalMediaStartError, selectLocalMediaStatus, selectLocalMediaStream, selectLocalParticipantIsScreenSharing, selectLocalParticipantRaw, selectLocalParticipantRole, selectLocalScreenshareRaw, selectLocalScreenshareStatus, selectLocalScreenshareStream, selectMicrophoneDeviceError, selectMicrophoneDevices, selectOrganizationId, selectOrganizationRaw, selectRemoteParticipants, selectRemoteParticipantsRaw, selectRoomConnectionRaw, selectRoomConnectionSession, selectRoomConnectionSessionId, selectRoomConnectionStatus, selectRtcConnectionRaw, selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectRtcManager, selectRtcManagerInitialized, selectRtcStatus, selectScreenshares, selectSelfId, selectShouldConnectRoom, selectShouldConnectRtc, selectShouldConnectSignal, selectShouldDisconnectRtc, selectShouldFetchDeviceCredentials, selectShouldFetchOrganization, selectShouldIdentifyDevice, selectShouldInitializeRtc, selectSignalConnectionDeviceIdentified, selectSignalConnectionRaw, selectSignalConnectionSocket, selectSignalIsIdentifyingDevice, selectSignalStatus, selectSpeakerDevices, selectStreamingRaw, selectStreamsToAccept, selectWaitingParticipants, selectWaitingParticipantsRaw, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, setLocalMediaOptions, setLocalMediaStream, setRoomKey, signalConnectionSlice, socketConnected, socketConnecting, socketDisconnected, socketReconnecting, startAppListening, stopScreenshare, streamStatusUpdated, streamingSlice, toggleCameraEnabled, toggleMicrophoneEnabled, updateReportedValues, waitingParticipantsSlice };