@whereby.com/core 0.36.1 → 1.0.0

package/dist/redux/index.d.mts

@@ -0,0 +1,4691 @@
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import { ActionCreatorWithPayload, AsyncThunk, PayloadAction, AsyncThunkPayloadCreator, TypedStartListening, TypedAddListener, Selector } from '@reduxjs/toolkit';
+import * as redux_thunk from 'redux-thunk';
+import { AxiosRequestConfig } from 'axios';
+import { EventEmitter } from 'events';
+import * as redux from 'redux';
+import * as _whereby_com_media from '@whereby.com/media';
+import { RoleName, ChatMessage as ChatMessage$1, BreakoutConfig, getDeviceData, SignalClient, RtcStreamAddedPayload, AudioEnableRequest, VideoEnableRequest, RtcManagerCreatedPayload, RtcClientConnectionStatusChangedPayload, RtcManager, RtcManagerDispatcher, RtcEvents, AudioEnabledEvent, AudioEnableRequestedEvent, BreakoutGroupJoinedEvent, BreakoutSessionUpdatedEvent, ClientLeftEvent, ClientKickedEvent, ClientMetadataReceivedEvent, ClientUnableToJoinEvent, CloudRecordingStartedEvent, KnockerLeftEvent, KnockAcceptedEvent, KnockRejectedEvent, NewClientEvent, RoomJoinedEvent, RoomKnockedEvent, RoomLockedEvent, RoomSessionEndedEvent, ScreenshareStartedEvent, ScreenshareStoppedEvent, SpotlightAddedEvent, SpotlightRemovedEvent, VideoEnabledEvent, VideoEnableRequestedEvent, LiveTranscriptionStartedEvent, LiveTranscriptionStoppedEvent, ServerSocket, Spotlight } from '@whereby.com/media';
+import * as immer from 'immer';
+import * as reselect from 'reselect';
+
+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;
+}
+
+type HttpClientRequestConfig = AxiosRequestConfig | {
+    [key: string]: unknown;
+};
+interface IHttpClient {
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+declare class HttpClient implements IHttpClient {
+    _baseUrl: string;
+    constructor({ baseUrl }: {
+        baseUrl: string;
+    });
+    private _requestAxios;
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+
+declare class MultipartHttpClient implements IHttpClient {
+    _httpClient: IHttpClient;
+    constructor({ httpClient }: {
+        httpClient: IHttpClient;
+    });
+    static dataToFormData(data: Record<string, string>): FormData;
+    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"];
+}
+declare class ApiClient {
+    authenticatedHttpClient: AuthenticatedHttpClient;
+    authenticatedFormDataHttpClient: MultipartHttpClient;
+    constructor({ baseUrl, fetchDeviceCredentials, }?: ApiClientOptions);
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+    requestMultipart(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+
+declare class DeviceService {
+    _apiClient: ApiClient;
+    constructor({ apiClient }: {
+        apiClient: ApiClient;
+    });
+    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>;
+    constructor({ deviceService, credentialsStore, }: {
+        deviceService: DeviceService;
+        credentialsStore: AbstractStore;
+    });
+    static create({ baseUrl, storeName, storeType, }: {
+        baseUrl: string;
+        storeName?: string;
+        storeType?: "localStorage" | "chromeStorage";
+    }): CredentialsService;
+    _fetchNewCredentialsFromApi(): Promise<Credentials | null>;
+    getCurrentCredentials(): Promise<Credentials | null>;
+    getCredentials(): Promise<Credentials | null>;
+    saveCredentials(credentials: Credentials): Promise<Credentials>;
+    setUserId(userId: string | null): Promise<void>;
+}
+
+type UserConsentAction = "accepted" | "rejected" | null;
+type ConsentGrantRequest = {
+    readonly consentRevisionId: string;
+    readonly action: UserConsentAction;
+};
+
+declare class OrganizationService {
+    _apiClient: ApiClient;
+    constructor({ apiClient }: {
+        apiClient: ApiClient;
+    });
+    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>;
+    getOrganizationBySubdomain(subdomain: string): Promise<Organization | null>;
+    getOrganizationByOrganizationId(organizationId: string): Promise<Organization | null>;
+    getOrganizationsByContactPoint(options: {
+        email: string;
+        code: string;
+    } | {
+        phoneNumber: string;
+        code: string;
+    }): Promise<ReadonlyArray<Organization>>;
+    getOrganizationsByIdToken({ idToken }: {
+        idToken: string;
+    }): Promise<ReadonlyArray<Organization>>;
+    getOrganizationsByLoggedInUser(): Promise<ReadonlyArray<Organization>>;
+    getSubdomainAvailability(subdomain: string): Promise<{
+        status: string;
+    }>;
+    updatePreferences({ organizationId, preferences, }: {
+        organizationId: string;
+        preferences: OrganizationPreferences;
+    }): Promise<undefined>;
+    deleteOrganization({ organizationId }: {
+        organizationId: string;
+    }): Promise<undefined>;
+}
+
+interface StickyReaction {
+    reaction: string;
+    timestamp: string;
+}
+interface RoomParticipantData {
+    displayName: string;
+    id: string;
+    stream?: MediaStream;
+    isAudioEnabled: boolean;
+    isVideoEnabled: boolean;
+    breakoutGroup: string | null;
+    stickyReaction?: StickyReaction | null;
+    isDialIn: boolean;
+}
+declare class RoomParticipant {
+    readonly displayName: string;
+    readonly id: string;
+    readonly stream?: MediaStream;
+    readonly isAudioEnabled: boolean;
+    readonly isLocalParticipant: boolean;
+    readonly isVideoEnabled: boolean;
+    readonly breakoutGroup: string | null;
+    readonly stickyReaction?: StickyReaction | null;
+    readonly isDialIn: boolean;
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled, breakoutGroup, stickyReaction, isDialIn, }: RoomParticipantData);
+}
+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;
+    deviceId: string;
+    roleName: RoleName;
+    isAudioEnabled: boolean;
+    isVideoEnabled: boolean;
+    isLocalParticipant: boolean;
+    breakoutGroup: string | null;
+    stream: (MediaStream & {
+        inboundId?: string;
+    }) | null;
+    streams: Stream[];
+    newJoiner: boolean;
+    presentationStream: (MediaStream & {
+        inboundId?: string;
+    }) | null;
+    externalId: string | null;
+    stickyReaction?: StickyReaction | null;
+    isDialIn: boolean;
+}
+declare class LocalParticipant extends RoomParticipant {
+    readonly isLocalParticipant = true;
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled, breakoutGroup, stickyReaction, isDialIn, }: RoomParticipantData);
+}
+interface WaitingParticipant {
+    id: string;
+    displayName: string | null;
+}
+interface Screenshare {
+    participantId: string;
+    id: string;
+    hasAudioTrack: boolean;
+    breakoutGroup: string | null;
+    stream?: MediaStream;
+    isLocal: boolean;
+}
+
+interface WaitingParticipantsState {
+    waitingParticipants: WaitingParticipant[];
+}
+declare const waitingParticipantsSliceInitialState: WaitingParticipantsState;
+declare const waitingParticipantsSlice: _reduxjs_toolkit.Slice<WaitingParticipantsState, {}, "waitingParticipants", "waitingParticipants", _reduxjs_toolkit.SliceSelectors<WaitingParticipantsState>>;
+declare const doAcceptWaitingParticipant: (args: {
+    participantId: string;
+}) => AppThunk;
+declare const doRejectWaitingParticipant: (args: {
+    participantId: string;
+}) => AppThunk;
+declare const selectWaitingParticipantsRaw: (state: RootState) => WaitingParticipantsState;
+declare const selectWaitingParticipants: (state: RootState) => WaitingParticipant[];
+
+interface StreamingState {
+    isStreaming: boolean;
+    error: unknown;
+    startedAt?: number;
+}
+declare const streamingSliceInitialState: StreamingState;
+declare const streamingSlice: _reduxjs_toolkit.Slice<StreamingState, {
+    doHandleStreamingStarted: (state: immer.WritableDraft<StreamingState>) => {
+        isStreaming: true;
+        error: null;
+        startedAt: number;
+    };
+    doHandleStreamingStopped: (state: immer.WritableDraft<StreamingState>) => {
+        isStreaming: false;
+        error: unknown;
+        startedAt?: number | undefined;
+    };
+}, "streaming", "streaming", _reduxjs_toolkit.SliceSelectors<StreamingState>>;
+declare const doHandleStreamingStarted: _reduxjs_toolkit.ActionCreatorWithoutPayload<"streaming/doHandleStreamingStarted">;
+declare const doHandleStreamingStopped: _reduxjs_toolkit.ActionCreatorWithoutPayload<"streaming/doHandleStreamingStopped">;
+declare const selectStreamingRaw: (state: RootState) => StreamingState;
+
+type RtcAnalyticsCustomEvent = {
+    actions: Array<ActionCreatorWithPayload<any> | AsyncThunk<any, any, ThunkConfig>["fulfilled"]> | null;
+    rtcEventName: string;
+    getValue: (state: RootState) => unknown;
+    getOutput: (value: unknown) => unknown;
+};
+declare const rtcAnalyticsCustomEvents: {
+    [key: string]: RtcAnalyticsCustomEvent;
+};
+interface rtcAnalyticsState {
+    reportedValues: {
+        [key: string]: unknown;
+    };
+}
+declare const rtcAnalyticsSliceInitialState: rtcAnalyticsState;
+declare const rtcAnalyticsSlice: _reduxjs_toolkit.Slice<rtcAnalyticsState, {
+    updateReportedValues(state: immer.WritableDraft<rtcAnalyticsState>, action: PayloadAction<{
+        rtcEventName: string;
+        value: unknown;
+    }>): {
+        reportedValues: {
+            [x: string]: unknown;
+        };
+    };
+}, "rtcAnalytics", "rtcAnalytics", _reduxjs_toolkit.SliceSelectors<rtcAnalyticsState>>;
+declare const doRtcAnalyticsCustomEventsInitialize: (args: void) => AppThunk;
+declare const updateReportedValues: ActionCreatorWithPayload<{
+    rtcEventName: string;
+    value: unknown;
+}, "rtcAnalytics/updateReportedValues">;
+
+type ChatMessage = Pick<ChatMessage$1, "senderId" | "timestamp" | "text">;
+interface ChatState {
+    chatMessages: ChatMessage[];
+}
+declare const chatSliceInitialState: ChatState;
+declare const chatSlice: _reduxjs_toolkit.Slice<ChatState, {}, "chat", "chat", _reduxjs_toolkit.SliceSelectors<ChatState>>;
+declare const doSendChatMessage: (args: {
+    text: string;
+    isBroadcast?: boolean;
+}) => AppThunk;
+declare const selectChatRaw: (state: RootState) => ChatState;
+declare const selectChatMessages: (state: RootState) => ChatMessage[];
+
+interface NotificationEvent<Type = string, PropsType = unknown> {
+    type: Type;
+    message: string;
+    props: PropsType;
+    timestamp: number;
+}
+type Notification<Type, PropsType> = Omit<NotificationEvent<Type, PropsType>, "timestamp">;
+interface RequestAudioEventProps {
+    client: RemoteParticipant;
+    enable: boolean;
+}
+type RequestAudioEvent = NotificationEvent<"requestAudioEnable" | "requestAudioDisable", RequestAudioEventProps>;
+interface RequestVideoEventProps {
+    client: RemoteParticipant;
+    enable: boolean;
+}
+type RequestVideoEvent = NotificationEvent<"requestVideoEnable" | "requestVideoDisable", RequestVideoEventProps>;
+interface ChatMessageEventProps {
+    client: RemoteParticipant;
+    chatMessage: ChatMessage;
+}
+type ChatMessageEvent = NotificationEvent<"chatMessageReceived", ChatMessageEventProps>;
+interface SignalStatusEventProps {
+}
+type SignalStatusEvent = NotificationEvent<"signalTrouble" | "signalOk", SignalStatusEventProps>;
+interface SignalClientEventProps {
+}
+type SignalClientEvent = NotificationEvent<"clientUnableToJoinFullRoom", SignalClientEventProps>;
+interface StickyReactionEventProps {
+    client: RemoteParticipant;
+    stickyReaction?: {
+        reaction: string;
+        timestamp: string;
+    } | null;
+}
+type StickyReactionEvent = NotificationEvent<"remoteHandRaised" | "remoteHandLowered", StickyReactionEventProps>;
+type NotificationEventTypes = {
+    ["requestAudioEnable"]: RequestAudioEvent;
+    ["requestAudioDisable"]: RequestAudioEvent;
+    ["chatMessageReceived"]: ChatMessageEvent;
+    ["remoteHandRaised"]: StickyReactionEvent;
+    ["remoteHandLowered"]: StickyReactionEvent;
+    ["signalTrouble"]: SignalStatusEvent;
+    ["signalOk"]: SignalStatusEvent;
+    ["clientUnableToJoinFullRoom"]: SignalClientEvent;
+    ["requestVideoEnable"]: RequestVideoEvent;
+    ["requestVideoDisable"]: RequestVideoEvent;
+};
+type NotificationEvents = NotificationEventTypes[keyof NotificationEventTypes];
+type NotificationEventMap = {
+    "*": [NotificationEvents];
+} & {
+    [Type in keyof NotificationEventTypes]: [NotificationEventTypes[Type]];
+};
+
+type NotificationsEventEmitter = EventEmitter<NotificationEventMap>;
+interface NotificationsState {
+    emitter: NotificationsEventEmitter;
+    events: Array<NotificationEvent>;
+}
+declare const initialNotificationsState: NotificationsState;
+declare const notificationsSlice: _reduxjs_toolkit.Slice<NotificationsState, {
+    addNotification: (state: immer.WritableDraft<NotificationsState>, action: PayloadAction<NotificationEvent>) => {
+        events: immer.WritableDraft<NotificationEvent<string, unknown>>[];
+        emitter: immer.WritableDraft<NotificationsEventEmitter>;
+    };
+    doClearNotifications: (state: immer.WritableDraft<NotificationsState>) => {
+        events: never[];
+        emitter: immer.WritableDraft<NotificationsEventEmitter>;
+    };
+}, "notifications", "notifications", _reduxjs_toolkit.SliceSelectors<NotificationsState>>;
+declare const doClearNotifications: _reduxjs_toolkit.ActionCreatorWithoutPayload<"notifications/doClearNotifications">;
+declare const doSetNotification: (args: NotificationEvents) => AppThunk;
+declare const selectNotificationsRaw: (state: RootState) => NotificationsState;
+declare const selectNotificationsEvents: (state: RootState) => NotificationEvent<string, unknown>[];
+declare const selectNotificationsEmitter: (state: RootState) => NotificationsEventEmitter;
+
+interface LocalScreenshareState {
+    status: "inactive" | "starting" | "active";
+    stream: MediaStream | null;
+    error: unknown | null;
+}
+declare const localScreenshareSliceInitialState: LocalScreenshareState;
+declare const localScreenshareSlice: _reduxjs_toolkit.Slice<LocalScreenshareState, {
+    stopScreenshare(state: immer.WritableDraft<LocalScreenshareState>, action: PayloadAction<{
+        stream: MediaStream;
+    }>): {
+        status: "inactive";
+        stream: null;
+        error: unknown | null;
+    };
+}, "localScreenshare", "localScreenshare", _reduxjs_toolkit.SliceSelectors<LocalScreenshareState>>;
+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;
+declare const selectLocalScreenshareRaw: (state: RootState) => LocalScreenshareState;
+declare const selectLocalScreenshareStatus: (state: RootState) => "inactive" | "starting" | "active";
+declare const selectLocalScreenshareStream: (state: RootState) => MediaStream | null;
+
+interface LocalParticipantState extends LocalParticipant {
+    isScreenSharing: boolean;
+    roleName: RoleName;
+    clientClaim?: string;
+    breakoutGroupAssigned: string;
+}
+declare const localParticipantSliceInitialState: LocalParticipantState;
+declare const localParticipantSlice: _reduxjs_toolkit.Slice<LocalParticipantState, {
+    setDisplayName: (state: immer.WritableDraft<LocalParticipantState>, action: PayloadAction<{
+        displayName: string;
+    }>) => {
+        displayName: string;
+        isScreenSharing: boolean;
+        roleName: RoleName;
+        clientClaim?: string | undefined;
+        breakoutGroupAssigned: string;
+        isLocalParticipant: true;
+        id: string;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isAudioEnabled: boolean;
+        isVideoEnabled: boolean;
+        breakoutGroup: string | null;
+        stickyReaction?: immer.WritableDraft<StickyReaction> | null | undefined;
+        isDialIn: boolean;
+    };
+    setBreakoutGroupAssigned: (state: immer.WritableDraft<LocalParticipantState>, action: PayloadAction<{
+        breakoutGroupAssigned: string;
+    }>) => {
+        breakoutGroupAssigned: string;
+        isScreenSharing: boolean;
+        roleName: RoleName;
+        clientClaim?: string | undefined;
+        isLocalParticipant: true;
+        displayName: string;
+        id: string;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isAudioEnabled: boolean;
+        isVideoEnabled: boolean;
+        breakoutGroup: string | null;
+        stickyReaction?: immer.WritableDraft<StickyReaction> | null | undefined;
+        isDialIn: boolean;
+    };
+}, "localParticipant", "localParticipant", _reduxjs_toolkit.SliceSelectors<LocalParticipantState>>;
+declare const setDisplayName: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    displayName: string;
+}, "localParticipant/setDisplayName">;
+declare const setBreakoutGroupAssigned: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    breakoutGroupAssigned: string;
+}, "localParticipant/setBreakoutGroupAssigned">;
+declare const doSetDisplayName: (args: {
+    displayName: string;
+}) => AppThunk;
+declare const doEnableAudio: _reduxjs_toolkit.AsyncThunk<boolean, {
+    enabled: boolean;
+}, ThunkConfig>;
+declare const doEnableVideo: _reduxjs_toolkit.AsyncThunk<boolean, {
+    enabled: boolean;
+}, ThunkConfig>;
+declare const doSetLocalStickyReaction: _reduxjs_toolkit.AsyncThunk<{
+    reaction: string;
+    timestamp: string;
+} | null, {
+    enabled?: boolean;
+}, ThunkConfig>;
+declare const doSendClientMetadata: (args: void) => AppThunk;
+
+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: immer.WritableDraft<CloudRecordingState>) => {
+        status: "requested";
+        isRecording: boolean;
+        error: unknown;
+        startedAt?: number | undefined;
+    };
+}, "cloudRecording", "cloudRecording", _reduxjs_toolkit.SliceSelectors<CloudRecordingState>>;
+declare const recordingRequestStarted: _reduxjs_toolkit.ActionCreatorWithoutPayload<"cloudRecording/recordingRequestStarted">;
+declare const doStartCloudRecording: (args: void) => AppThunk;
+declare const doStopCloudRecording: (args: void) => AppThunk;
+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;
+
+interface AppConfig {
+    isNodeSdk?: boolean;
+    isDialIn?: boolean;
+    ignoreBreakoutGroups?: boolean;
+    displayName: string;
+    localMediaOptions?: LocalMediaOptions;
+    roomKey: string | null;
+    roomUrl: string;
+    userAgent?: string;
+    externalId: string | null;
+}
+interface AppState {
+    isNodeSdk: boolean;
+    isActive: boolean;
+    isDialIn: boolean;
+    ignoreBreakoutGroups: boolean;
+    roomUrl: string | null;
+    roomName: string | null;
+    displayName: string | null;
+    userAgent: string | null;
+    externalId: string | null;
+    initialConfig?: AppConfig;
+}
+declare const initialState: AppState;
+declare const appSlice: _reduxjs_toolkit.Slice<AppState, {
+    doAppStart: (state: immer.WritableDraft<AppState>, action: PayloadAction<AppConfig>) => {
+        roomName: string;
+        initialConfig: {
+            isNodeSdk?: boolean;
+            isDialIn?: boolean;
+            ignoreBreakoutGroups?: boolean;
+            displayName: string;
+            localMediaOptions?: LocalMediaOptions;
+            roomKey: string | null;
+            roomUrl: string;
+            userAgent?: string;
+            externalId: string | null;
+        };
+        isActive: true;
+        isNodeSdk: boolean;
+        isDialIn: boolean;
+        ignoreBreakoutGroups: boolean;
+        displayName: string;
+        localMediaOptions?: LocalMediaOptions;
+        roomKey: string | null;
+        roomUrl: string;
+        userAgent: string | null;
+        externalId: string | null;
+    };
+    doAppStop: (state: immer.WritableDraft<AppState>) => {
+        isActive: false;
+        isNodeSdk: boolean;
+        isDialIn: boolean;
+        ignoreBreakoutGroups: boolean;
+        roomUrl: string | null;
+        roomName: string | null;
+        displayName: string | null;
+        userAgent: string | null;
+        externalId: string | null;
+        initialConfig?: immer.WritableDraft<AppConfig> | undefined;
+    };
+}, "app", "app", _reduxjs_toolkit.SliceSelectors<AppState>>;
+declare const doAppStop: _reduxjs_toolkit.ActionCreatorWithoutPayload<"app/doAppStop">;
+declare const doAppStart: _reduxjs_toolkit.ActionCreatorWithPayload<AppConfig, "app/doAppStart">;
+declare const selectAppRaw: (state: RootState) => AppState;
+declare const selectAppIsActive: (state: RootState) => boolean;
+declare const selectAppIsDialIn: (state: RootState) => boolean;
+declare const selectAppRoomName: (state: RootState) => string | null;
+declare const selectAppRoomUrl: (state: RootState) => string | null;
+declare const selectAppDisplayName: (state: RootState) => string | null;
+declare const selectAppUserAgent: (state: RootState) => string | null;
+declare const selectAppExternalId: (state: RootState) => string | null;
+declare const selectAppIsNodeSdk: (state: RootState) => boolean;
+declare const selectAppInitialConfig: (state: RootState) => AppConfig | undefined;
+declare const selectAppIgnoreBreakoutGroups: (state: RootState) => boolean;
+
+interface AuthorizationState {
+    roomKey: string | null;
+    roleName: RoleName;
+}
+declare const authorizationSliceInitialState: AuthorizationState;
+declare const authorizationSlice: _reduxjs_toolkit.Slice<AuthorizationState, {
+    setRoomKey: (state: immer.WritableDraft<AuthorizationState>, action: PayloadAction<string | null>) => {
+        roomKey: string | null;
+        roleName: RoleName;
+    };
+}, "authorization", "authorization", _reduxjs_toolkit.SliceSelectors<AuthorizationState>>;
+declare const setRoomKey: _reduxjs_toolkit.ActionCreatorWithPayload<string | null, "authorization/setRoomKey">;
+declare const selectRoomKey: (state: RootState) => string | null;
+declare const selectAuthorizationRoleName: (state: RootState) => RoleName;
+declare const selectIsAuthorizedToLockRoom: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RoleName) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: RoleName) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => RoleName];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectIsAuthorizedToRequestAudioEnable: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RoleName) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: RoleName) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => RoleName];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectIsAuthorizedToRequestVideoEnable: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RoleName) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: RoleName) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => RoleName];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectIsAuthorizedToKickClient: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RoleName) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: RoleName) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => RoleName];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectIsAuthorizedToEndMeeting: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RoleName) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: RoleName) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => RoleName];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectIsAuthorizedToAskToSpeak: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RoleName) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: RoleName) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => RoleName];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectIsAuthorizedToSpotlight: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RoleName) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: RoleName) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => RoleName];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+interface BreakoutState extends BreakoutConfig {
+    groupId: string | null;
+}
+declare const breakoutSliceInitialState: BreakoutState;
+declare const breakoutSlice: _reduxjs_toolkit.Slice<BreakoutState, {}, "breakout", "breakout", _reduxjs_toolkit.SliceSelectors<BreakoutState>>;
+declare const doBreakoutJoin: (args: {
+    group: string;
+}) => AppThunk;
+declare const selectBreakoutRaw: (state: RootState) => BreakoutState;
+declare const selectBreakoutInitiatedBy: (state: RootState) => {
+    clientId: string;
+    userId: string;
+    deviceId: string;
+    active: boolean;
+} | null | undefined;
+declare const selectBreakoutActive: (state: RootState) => boolean;
+declare const selectBreakoutAssignments: (state: RootState) => {
+    [key: string]: string;
+} | null | undefined;
+declare const selectBreakoutGroups: (state: RootState) => {
+    [key: string]: string;
+} | null | undefined;
+declare const selectBreakoutCurrentId: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: RootState) => BreakoutState, (state: RootState) => string | null];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectBreakoutCurrentGroup: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => {
+    id: string;
+    name: string;
+} | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string) => {
+        id: string;
+        name: string;
+    } | null;
+    memoizedResultFunc: ((resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string) => {
+        id: string;
+        name: string;
+    } | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        id: string;
+        name: string;
+    } | null;
+    dependencies: [(state: RootState) => BreakoutState, ((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string;
+        memoizedResultFunc: ((resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string;
+        dependencies: [(state: RootState) => BreakoutState, (state: RootState) => string | null];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+interface ConnectionMonitorStart {
+    stopIssueSubscription: () => void;
+}
+interface ConnectionMonitorState {
+    running: boolean;
+    stopCallbackFunction?: () => void;
+}
+declare const connectionMonitorSliceInitialState: ConnectionMonitorState;
+declare const connectionMonitorSlice: _reduxjs_toolkit.Slice<ConnectionMonitorState, {
+    connectionMonitorStarted: (state: immer.WritableDraft<ConnectionMonitorState>, action: PayloadAction<ConnectionMonitorStart>) => {
+        running: true;
+        stopCallbackFunction: () => void;
+    };
+    connectionMonitorStopped: () => {
+        running: boolean;
+        stopCallbackFunction?: () => void;
+    };
+}, "connectionMonitor", "connectionMonitor", _reduxjs_toolkit.SliceSelectors<ConnectionMonitorState>>;
+declare const connectionMonitorStarted: _reduxjs_toolkit.ActionCreatorWithPayload<ConnectionMonitorStart, "connectionMonitor/connectionMonitorStarted">;
+declare const connectionMonitorStopped: _reduxjs_toolkit.ActionCreatorWithoutPayload<"connectionMonitor/connectionMonitorStopped">;
+declare const doStartConnectionMonitor: (args: void) => AppThunk;
+declare const doStopConnectionMonitor: (args: void) => AppThunk;
+declare const selectConnectionMonitorIsRunning: (state: RootState) => boolean;
+declare const selectStopCallbackFunction: (state: RootState) => (() => void) | undefined;
+declare const selectShouldStartConnectionMonitor: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ConnectionStatus, resultFuncArgs_1: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: ConnectionStatus, resultFuncArgs_1: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => ConnectionStatus, (state: RootState) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectShouldStopConnectionMonitor: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ConnectionStatus, resultFuncArgs_1: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: ConnectionStatus, resultFuncArgs_1: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => ConnectionStatus, (state: RootState) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+interface DeviceCredentialsState {
+    isFetching: boolean;
+    data?: Credentials | null;
+}
+declare const deviceCredentialsSliceInitialState: DeviceCredentialsState;
+declare const deviceCredentialsSlice: _reduxjs_toolkit.Slice<DeviceCredentialsState, {}, "deviceCredentials", "deviceCredentials", _reduxjs_toolkit.SliceSelectors<DeviceCredentialsState>>;
+declare const doGetDeviceCredentials: _reduxjs_toolkit.AsyncThunk<Credentials | null | undefined, undefined, ThunkConfig>;
+declare const selectDeviceCredentialsRaw: (state: RootState) => DeviceCredentialsState;
+declare const selectHasFetchedDeviceCredentials: (state: RootState) => boolean;
+declare const selectDeviceId: (state: RootState) => string | undefined;
+declare const selectShouldFetchDeviceCredentials: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    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: RootState) => 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;
+};
+interface LocalMediaState {
+    busyDeviceIds: string[];
+    cameraDeviceError?: unknown;
+    cameraEnabled: boolean;
+    currentCameraDeviceId?: string;
+    currentMicrophoneDeviceId?: string;
+    currentSpeakerDeviceId?: string;
+    devices: MediaDeviceInfo[];
+    isSettingCameraDevice: boolean;
+    isSettingMicrophoneDevice: boolean;
+    isSettingSpeakerDevice: boolean;
+    isTogglingCamera: boolean;
+    lowDataMode: boolean;
+    microphoneDeviceError?: unknown;
+    microphoneEnabled: boolean;
+    speakerDeviceError?: unknown;
+    options?: LocalMediaOptions;
+    status: "inactive" | "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: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
+        deviceId: string;
+    }>): immer.WritableDraft<LocalMediaState>;
+    toggleCameraEnabled(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
+        enabled?: boolean;
+    }>): {
+        cameraEnabled: boolean;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        currentSpeakerDeviceId?: string | undefined;
+        devices: immer.WritableDraft<MediaDeviceInfo>[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        lowDataMode: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        speakerDeviceError?: unknown;
+        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
+        status: "inactive" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setCurrentCameraDeviceId(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
+        deviceId?: string;
+    }>): {
+        currentCameraDeviceId: string | undefined;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentMicrophoneDeviceId?: string | undefined;
+        currentSpeakerDeviceId?: string | undefined;
+        devices: immer.WritableDraft<MediaDeviceInfo>[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        lowDataMode: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        speakerDeviceError?: unknown;
+        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
+        status: "inactive" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    toggleMicrophoneEnabled(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
+        enabled?: boolean;
+    }>): {
+        microphoneEnabled: boolean;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        currentSpeakerDeviceId?: string | undefined;
+        devices: immer.WritableDraft<MediaDeviceInfo>[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        lowDataMode: boolean;
+        microphoneDeviceError?: unknown;
+        speakerDeviceError?: unknown;
+        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
+        status: "inactive" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setCurrentMicrophoneDeviceId(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
+        deviceId?: string;
+    }>): {
+        currentMicrophoneDeviceId: string | undefined;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentSpeakerDeviceId?: string | undefined;
+        devices: immer.WritableDraft<MediaDeviceInfo>[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        lowDataMode: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        speakerDeviceError?: unknown;
+        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
+        status: "inactive" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setCurrentSpeakerDeviceId(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
+        deviceId?: string;
+    }>): {
+        currentSpeakerDeviceId: string;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        devices: immer.WritableDraft<MediaDeviceInfo>[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        lowDataMode: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        speakerDeviceError?: unknown;
+        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
+        status: "inactive" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    toggleLowDataModeEnabled(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
+        enabled?: boolean;
+    }>): {
+        lowDataMode: boolean;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        currentSpeakerDeviceId?: string | undefined;
+        devices: immer.WritableDraft<MediaDeviceInfo>[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        speakerDeviceError?: unknown;
+        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
+        status: "inactive" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setDevices(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
+        devices: MediaDeviceInfo[];
+    }>): {
+        devices: MediaDeviceInfo[];
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        currentSpeakerDeviceId?: string | undefined;
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        lowDataMode: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        speakerDeviceError?: unknown;
+        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
+        status: "inactive" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setLocalMediaStream(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
+        stream: MediaStream;
+    }>): {
+        stream: MediaStream;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        currentSpeakerDeviceId?: string | undefined;
+        devices: immer.WritableDraft<MediaDeviceInfo>[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        lowDataMode: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        speakerDeviceError?: unknown;
+        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
+        status: "inactive" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    setLocalMediaOptions(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
+        options: LocalMediaOptions;
+    }>): {
+        options: LocalMediaOptions;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        currentSpeakerDeviceId?: string | undefined;
+        devices: immer.WritableDraft<MediaDeviceInfo>[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        lowDataMode: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        speakerDeviceError?: unknown;
+        status: "inactive" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    localMediaStopped(state: immer.WritableDraft<LocalMediaState>): {
+        status: "stopped";
+        stream: undefined;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentCameraDeviceId?: string | undefined;
+        currentMicrophoneDeviceId?: string | undefined;
+        currentSpeakerDeviceId?: string | undefined;
+        devices: immer.WritableDraft<MediaDeviceInfo>[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        lowDataMode: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        speakerDeviceError?: unknown;
+        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
+        startError?: unknown;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+    localStreamMetadataUpdated(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<ReturnType<typeof getDeviceData>>): {
+        currentCameraDeviceId: string;
+        currentMicrophoneDeviceId: string;
+        busyDeviceIds: string[];
+        cameraDeviceError?: unknown;
+        cameraEnabled: boolean;
+        currentSpeakerDeviceId?: string | undefined;
+        devices: immer.WritableDraft<MediaDeviceInfo>[];
+        isSettingCameraDevice: boolean;
+        isSettingMicrophoneDevice: boolean;
+        isSettingSpeakerDevice: boolean;
+        isTogglingCamera: boolean;
+        lowDataMode: boolean;
+        microphoneDeviceError?: unknown;
+        microphoneEnabled: boolean;
+        speakerDeviceError?: unknown;
+        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
+        status: "inactive" | "stopped" | "starting" | "started" | "error";
+        startError?: unknown;
+        stream?: immer.WritableDraft<MediaStream> | undefined;
+        isSwitchingStream: boolean;
+        onDeviceChange?: (() => void) | undefined;
+    };
+}, "localMedia", "localMedia", _reduxjs_toolkit.SliceSelectors<LocalMediaState>>;
+declare const deviceBusy: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    deviceId: string;
+}, "localMedia/deviceBusy">;
+declare const setCurrentCameraDeviceId: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    deviceId?: string;
+}, "localMedia/setCurrentCameraDeviceId">;
+declare const setCurrentMicrophoneDeviceId: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    deviceId?: string;
+}, "localMedia/setCurrentMicrophoneDeviceId">;
+declare const setCurrentSpeakerDeviceId: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    deviceId?: string;
+}, "localMedia/setCurrentSpeakerDeviceId">;
+declare const toggleCameraEnabled: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    enabled?: boolean;
+}, "localMedia/toggleCameraEnabled">;
+declare const toggleMicrophoneEnabled: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    enabled?: boolean;
+}, "localMedia/toggleMicrophoneEnabled">;
+declare const toggleLowDataModeEnabled: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    enabled?: boolean;
+}, "localMedia/toggleLowDataModeEnabled">;
+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<_whereby_com_media.GetDeviceDataResult, "localMedia/localStreamMetadataUpdated">;
+declare const doToggleCamera: _reduxjs_toolkit.AsyncThunk<undefined, undefined, ThunkConfig>;
+declare const doToggleLowDataMode: (args: void) => AppThunk;
+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 | null;
+    videoId?: string | null;
+}, ThunkConfig>;
+declare const doStartLocalMedia: _reduxjs_toolkit.AsyncThunk<{
+    stream: MediaStream;
+    onDeviceChange: DebouncedFunction;
+}, LocalMediaOptions | MediaStream, ThunkConfig>;
+declare const doStopLocalMedia: (args: void) => AppThunk;
+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 selectCurrentSpeakerDeviceId: (state: RootState) => string | undefined;
+declare const selectIsCameraEnabled: (state: RootState) => boolean;
+declare const selectIsMicrophoneEnabled: (state: RootState) => boolean;
+declare const selectIsLowDataModeEnabled: (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;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    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" | "inactive" | "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;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => {
+    devices: MediaDeviceInfo[];
+    videoId: string | undefined;
+    audioId: string | undefined;
+    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[], resultFuncArgs_1: string | undefined, resultFuncArgs_2: string | undefined, resultFuncArgs_3: boolean) => {
+        devices: MediaDeviceInfo[];
+        videoId: string | undefined;
+        audioId: string | undefined;
+        options: {
+            disableAEC: boolean;
+            disableAGC: boolean;
+            hd: boolean;
+            lax: boolean;
+            lowDataMode: boolean;
+            simulcast: boolean;
+            widescreen: boolean;
+        };
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: MediaDeviceInfo[], resultFuncArgs_1: string | undefined, resultFuncArgs_2: string | undefined, resultFuncArgs_3: boolean) => {
+        devices: MediaDeviceInfo[];
+        videoId: string | undefined;
+        audioId: string | undefined;
+        options: {
+            disableAEC: boolean;
+            disableAGC: boolean;
+            hd: boolean;
+            lax: boolean;
+            lowDataMode: boolean;
+            simulcast: boolean;
+            widescreen: boolean;
+        };
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        devices: MediaDeviceInfo[];
+        videoId: string | undefined;
+        audioId: string | undefined;
+        options: {
+            disableAEC: boolean;
+            disableAGC: boolean;
+            hd: boolean;
+            lax: boolean;
+            lowDataMode: boolean;
+            simulcast: boolean;
+            widescreen: boolean;
+        };
+    };
+    dependencies: [(state: RootState) => MediaDeviceInfo[], (state: RootState) => string | undefined, (state: RootState) => string | undefined, (state: RootState) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectIsLocalMediaStarting: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: "error" | "inactive" | "stopped" | "starting" | "started") => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: "error" | "inactive" | "stopped" | "starting" | "started") => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => "error" | "inactive" | "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;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    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;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    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;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    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;
+};
+declare const selectLocalMediaShouldStartWithOptions: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => LocalMediaOptions | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: "error" | "inactive" | "stopped" | "starting" | "started", resultFuncArgs_2: LocalMediaOptions | undefined) => LocalMediaOptions | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: "error" | "inactive" | "stopped" | "starting" | "started", resultFuncArgs_2: LocalMediaOptions | undefined) => LocalMediaOptions | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => LocalMediaOptions | undefined;
+    dependencies: [(state: RootState) => boolean, (state: RootState) => "error" | "inactive" | "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;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: "error" | "inactive" | "stopped" | "starting" | "started", resultFuncArgs_2: LocalMediaOptions | undefined) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: "error" | "inactive" | "stopped" | "starting" | "started", resultFuncArgs_2: LocalMediaOptions | undefined) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => boolean, (state: RootState) => "error" | "inactive" | "stopped" | "starting" | "started", (state: RootState) => LocalMediaOptions | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+interface OrganizationState {
+    data: Organization | null | undefined;
+    isFetching: boolean;
+    error: unknown;
+}
+declare const organizationSliceInitialState: OrganizationState;
+declare const organizationSlice: _reduxjs_toolkit.Slice<OrganizationState, {}, "organization", "organization", _reduxjs_toolkit.SliceSelectors<OrganizationState>>;
+declare const doOrganizationFetch: _reduxjs_toolkit.AsyncThunk<Organization | undefined, undefined, ThunkConfig>;
+declare const selectOrganizationRaw: (state: RootState) => OrganizationState;
+declare const selectOrganizationId: (state: RootState) => string | undefined;
+declare const selectOrganizationPreferences: (state: RootState) => OrganizationPreferences | null | undefined;
+declare const selectShouldFetchOrganization: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    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: RootState) => boolean, (state: RootState) => OrganizationState, (state: RootState) => 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;
+}
+
+declare function createRemoteParticipant(client: SignalClient, newJoiner?: boolean): RemoteParticipant;
+interface RemoteParticipantState {
+    remoteParticipants: RemoteParticipant[];
+}
+declare const remoteParticipantsSliceInitialState: RemoteParticipantState;
+declare const remoteParticipantsSlice: _reduxjs_toolkit.Slice<RemoteParticipantState, {
+    streamStatusUpdated: (state: immer.WritableDraft<RemoteParticipantState>, action: PayloadAction<StreamStatusUpdate[]>) => immer.WritableDraft<RemoteParticipantState>;
+    participantStreamAdded: (state: immer.WritableDraft<RemoteParticipantState>, action: PayloadAction<RtcStreamAddedPayload>) => RemoteParticipantState;
+    participantStreamIdAdded: (state: immer.WritableDraft<RemoteParticipantState>, action: PayloadAction<{
+        clientId: string;
+        streamId: string;
+    }>) => RemoteParticipantState;
+}, "remoteParticipants", "remoteParticipants", _reduxjs_toolkit.SliceSelectors<RemoteParticipantState>>;
+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">;
+declare const doRequestAudioEnable: (args: AudioEnableRequest) => AppThunk;
+declare const doRequestVideoEnable: (args: VideoEnableRequest) => AppThunk;
+declare const selectRemoteParticipantsRaw: (state: RootState) => RemoteParticipantState;
+declare const selectRemoteClients: (state: RootState) => RemoteParticipant[];
+declare const selectRemoteParticipants: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => RemoteParticipant[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[];
+    memoizedResultFunc: ((resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => RemoteParticipant[];
+    dependencies: [(state: RootState) => RemoteParticipant[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectNumClients: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RemoteParticipant[]) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: RemoteParticipant[]) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [(state: RootState) => RemoteParticipant[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectNumParticipants: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RemoteParticipant[], resultFuncArgs_1: LocalParticipantState) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: RemoteParticipant[], resultFuncArgs_1: LocalParticipantState) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => RemoteParticipant[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[];
+        memoizedResultFunc: ((resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => RemoteParticipant[];
+        dependencies: [(state: RootState) => RemoteParticipant[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }, (state: RootState) => LocalParticipantState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+type ClientView = {
+    id: string;
+    clientId: string;
+    displayName: string;
+    hasActivePresentation?: boolean;
+    stream?: (MediaStream & {
+        outboundId?: string;
+        inboundId?: string;
+    }) | null;
+    isLocalClient?: boolean;
+    isPresentation?: boolean;
+    isVideoEnabled?: boolean;
+    isAudioEnabled?: boolean;
+    breakoutGroup?: string | null;
+    breakoutGroupAssigned?: string;
+};
+
+interface RoomState {
+    isLocked: boolean;
+}
+declare const roomSliceInitialState: RoomState;
+declare const roomSlice: _reduxjs_toolkit.Slice<RoomState, {}, "room", "room", _reduxjs_toolkit.SliceSelectors<RoomState>>;
+declare const doLockRoom: (args: {
+    locked: boolean;
+}) => AppThunk;
+declare const doKickParticipant: (args: {
+    clientId: string;
+}) => AppThunk;
+declare const doEndMeeting: (args: {
+    stayBehind?: boolean;
+}) => AppThunk;
+declare const selectRoomIsLocked: (state: RootState) => boolean;
+declare const selectScreenshares: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => Screenshare[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[]) => Screenshare[];
+    memoizedResultFunc: ((resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[]) => Screenshare[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Screenshare[];
+    dependencies: [(state: RootState) => MediaStream | null, (state: RootState) => LocalParticipantState, ((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => RemoteParticipant[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[];
+        memoizedResultFunc: ((resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => RemoteParticipant[];
+        dependencies: [(state: RootState) => RemoteParticipant[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectRemoteClientViews: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => ClientView[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[], resultFuncArgs_3: string, resultFuncArgs_4: {
+        [key: string]: string;
+    } | null | undefined) => ClientView[];
+    memoizedResultFunc: ((resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[], resultFuncArgs_3: string, resultFuncArgs_4: {
+        [key: string]: string;
+    } | null | undefined) => ClientView[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => ClientView[];
+    dependencies: [(state: RootState) => MediaStream | null, (state: RootState) => LocalParticipantState, ((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => RemoteParticipant[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[];
+        memoizedResultFunc: ((resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => RemoteParticipant[];
+        dependencies: [(state: RootState) => RemoteParticipant[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }, ((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string;
+        memoizedResultFunc: ((resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string;
+        dependencies: [(state: RootState) => BreakoutState, (state: RootState) => string | null];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }, (state: RootState) => {
+        [key: string]: string;
+    } | null | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectAllClientViews: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => ClientView[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ClientView | null, resultFuncArgs_1: ClientView[]) => ClientView[];
+    memoizedResultFunc: ((resultFuncArgs_0: ClientView | null, resultFuncArgs_1: ClientView[]) => ClientView[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => ClientView[];
+    dependencies: [((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => ClientView | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: MediaStream | undefined) => ClientView | null;
+        memoizedResultFunc: ((resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: MediaStream | undefined) => ClientView | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => ClientView | null;
+        dependencies: [(state: RootState) => LocalParticipantState, (state: RootState) => MediaStream | undefined];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }, ((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => ClientView[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[], resultFuncArgs_3: string, resultFuncArgs_4: {
+            [key: string]: string;
+        } | null | undefined) => ClientView[];
+        memoizedResultFunc: ((resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[], resultFuncArgs_3: string, resultFuncArgs_4: {
+            [key: string]: string;
+        } | null | undefined) => ClientView[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => ClientView[];
+        dependencies: [(state: RootState) => MediaStream | null, (state: RootState) => LocalParticipantState, ((state: {
+            app: AppState;
+            authorization: AuthorizationState;
+            breakout: BreakoutState;
+            chat: ChatState;
+            cloudRecording: CloudRecordingState;
+            connectionMonitor: ConnectionMonitorState;
+            deviceCredentials: DeviceCredentialsState;
+            localMedia: LocalMediaState;
+            localParticipant: LocalParticipantState;
+            localScreenshare: LocalScreenshareState;
+            notifications: NotificationsState;
+            organization: OrganizationState;
+            remoteParticipants: RemoteParticipantState;
+            room: RoomState;
+            roomConnection: RoomConnectionState;
+            rtcAnalytics: rtcAnalyticsState;
+            rtcConnection: RtcConnectionState;
+            signalConnection: SignalConnectionState;
+            spotlights: SpotlightsState;
+            streaming: StreamingState;
+            waitingParticipants: WaitingParticipantsState;
+        }) => RemoteParticipant[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[];
+            memoizedResultFunc: ((resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => RemoteParticipant[];
+            dependencies: [(state: RootState) => RemoteParticipant[]];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof reselect.weakMapMemoize;
+            memoize: typeof reselect.weakMapMemoize;
+        }, ((state: {
+            app: AppState;
+            authorization: AuthorizationState;
+            breakout: BreakoutState;
+            chat: ChatState;
+            cloudRecording: CloudRecordingState;
+            connectionMonitor: ConnectionMonitorState;
+            deviceCredentials: DeviceCredentialsState;
+            localMedia: LocalMediaState;
+            localParticipant: LocalParticipantState;
+            localScreenshare: LocalScreenshareState;
+            notifications: NotificationsState;
+            organization: OrganizationState;
+            remoteParticipants: RemoteParticipantState;
+            room: RoomState;
+            roomConnection: RoomConnectionState;
+            rtcAnalytics: rtcAnalyticsState;
+            rtcConnection: RtcConnectionState;
+            signalConnection: SignalConnectionState;
+            spotlights: SpotlightsState;
+            streaming: StreamingState;
+            waitingParticipants: WaitingParticipantsState;
+        }) => string) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string;
+            memoizedResultFunc: ((resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => string;
+            dependencies: [(state: RootState) => BreakoutState, (state: RootState) => string | null];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof reselect.weakMapMemoize;
+            memoize: typeof reselect.weakMapMemoize;
+        }, (state: RootState) => {
+            [key: string]: string;
+        } | null | undefined];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectAllClientViewsInCurrentGroup: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => ClientView[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ClientView[], resultFuncArgs_1: boolean, resultFuncArgs_2: string) => ClientView[];
+    memoizedResultFunc: ((resultFuncArgs_0: ClientView[], resultFuncArgs_1: boolean, resultFuncArgs_2: string) => ClientView[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => ClientView[];
+    dependencies: [((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => ClientView[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: ClientView | null, resultFuncArgs_1: ClientView[]) => ClientView[];
+        memoizedResultFunc: ((resultFuncArgs_0: ClientView | null, resultFuncArgs_1: ClientView[]) => ClientView[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => ClientView[];
+        dependencies: [((state: {
+            app: AppState;
+            authorization: AuthorizationState;
+            breakout: BreakoutState;
+            chat: ChatState;
+            cloudRecording: CloudRecordingState;
+            connectionMonitor: ConnectionMonitorState;
+            deviceCredentials: DeviceCredentialsState;
+            localMedia: LocalMediaState;
+            localParticipant: LocalParticipantState;
+            localScreenshare: LocalScreenshareState;
+            notifications: NotificationsState;
+            organization: OrganizationState;
+            remoteParticipants: RemoteParticipantState;
+            room: RoomState;
+            roomConnection: RoomConnectionState;
+            rtcAnalytics: rtcAnalyticsState;
+            rtcConnection: RtcConnectionState;
+            signalConnection: SignalConnectionState;
+            spotlights: SpotlightsState;
+            streaming: StreamingState;
+            waitingParticipants: WaitingParticipantsState;
+        }) => ClientView | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: MediaStream | undefined) => ClientView | null;
+            memoizedResultFunc: ((resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: MediaStream | undefined) => ClientView | null) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => ClientView | null;
+            dependencies: [(state: RootState) => LocalParticipantState, (state: RootState) => MediaStream | undefined];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof reselect.weakMapMemoize;
+            memoize: typeof reselect.weakMapMemoize;
+        }, ((state: {
+            app: AppState;
+            authorization: AuthorizationState;
+            breakout: BreakoutState;
+            chat: ChatState;
+            cloudRecording: CloudRecordingState;
+            connectionMonitor: ConnectionMonitorState;
+            deviceCredentials: DeviceCredentialsState;
+            localMedia: LocalMediaState;
+            localParticipant: LocalParticipantState;
+            localScreenshare: LocalScreenshareState;
+            notifications: NotificationsState;
+            organization: OrganizationState;
+            remoteParticipants: RemoteParticipantState;
+            room: RoomState;
+            roomConnection: RoomConnectionState;
+            rtcAnalytics: rtcAnalyticsState;
+            rtcConnection: RtcConnectionState;
+            signalConnection: SignalConnectionState;
+            spotlights: SpotlightsState;
+            streaming: StreamingState;
+            waitingParticipants: WaitingParticipantsState;
+        }) => ClientView[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[], resultFuncArgs_3: string, resultFuncArgs_4: {
+                [key: string]: string;
+            } | null | undefined) => ClientView[];
+            memoizedResultFunc: ((resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[], resultFuncArgs_3: string, resultFuncArgs_4: {
+                [key: string]: string;
+            } | null | undefined) => ClientView[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => ClientView[];
+            dependencies: [(state: RootState) => MediaStream | null, (state: RootState) => LocalParticipantState, ((state: {
+                app: AppState;
+                authorization: AuthorizationState;
+                breakout: BreakoutState;
+                chat: ChatState;
+                cloudRecording: CloudRecordingState;
+                connectionMonitor: ConnectionMonitorState;
+                deviceCredentials: DeviceCredentialsState;
+                localMedia: LocalMediaState;
+                localParticipant: LocalParticipantState;
+                localScreenshare: LocalScreenshareState;
+                notifications: NotificationsState;
+                organization: OrganizationState;
+                remoteParticipants: RemoteParticipantState;
+                room: RoomState;
+                roomConnection: RoomConnectionState;
+                rtcAnalytics: rtcAnalyticsState;
+                rtcConnection: RtcConnectionState;
+                signalConnection: SignalConnectionState;
+                spotlights: SpotlightsState;
+                streaming: StreamingState;
+                waitingParticipants: WaitingParticipantsState;
+            }) => RemoteParticipant[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            } & {
+                resultFunc: (resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[];
+                memoizedResultFunc: ((resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[]) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                };
+                lastResult: () => RemoteParticipant[];
+                dependencies: [(state: RootState) => RemoteParticipant[]];
+                recomputations: () => number;
+                resetRecomputations: () => void;
+                dependencyRecomputations: () => number;
+                resetDependencyRecomputations: () => void;
+            } & {
+                argsMemoize: typeof reselect.weakMapMemoize;
+                memoize: typeof reselect.weakMapMemoize;
+            }, ((state: {
+                app: AppState;
+                authorization: AuthorizationState;
+                breakout: BreakoutState;
+                chat: ChatState;
+                cloudRecording: CloudRecordingState;
+                connectionMonitor: ConnectionMonitorState;
+                deviceCredentials: DeviceCredentialsState;
+                localMedia: LocalMediaState;
+                localParticipant: LocalParticipantState;
+                localScreenshare: LocalScreenshareState;
+                notifications: NotificationsState;
+                organization: OrganizationState;
+                remoteParticipants: RemoteParticipantState;
+                room: RoomState;
+                roomConnection: RoomConnectionState;
+                rtcAnalytics: rtcAnalyticsState;
+                rtcConnection: RtcConnectionState;
+                signalConnection: SignalConnectionState;
+                spotlights: SpotlightsState;
+                streaming: StreamingState;
+                waitingParticipants: WaitingParticipantsState;
+            }) => string) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            } & {
+                resultFunc: (resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string;
+                memoizedResultFunc: ((resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                };
+                lastResult: () => string;
+                dependencies: [(state: RootState) => BreakoutState, (state: RootState) => string | null];
+                recomputations: () => number;
+                resetRecomputations: () => void;
+                dependencyRecomputations: () => number;
+                resetDependencyRecomputations: () => void;
+            } & {
+                argsMemoize: typeof reselect.weakMapMemoize;
+                memoize: typeof reselect.weakMapMemoize;
+            }, (state: RootState) => {
+                [key: string]: string;
+            } | null | undefined];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof reselect.weakMapMemoize;
+            memoize: typeof reselect.weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }, (state: RootState) => boolean, ((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string;
+        memoizedResultFunc: ((resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string;
+        dependencies: [(state: RootState) => BreakoutState, (state: RootState) => string | null];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectBreakoutGroupedParticipants: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => {
+    clients: ClientView[];
+    group: {
+        id: string;
+        name: string;
+    };
+}[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ClientView[], resultFuncArgs_1: boolean, resultFuncArgs_2: {
+        [key: string]: string;
+    } | null | undefined) => {
+        clients: ClientView[];
+        group: {
+            id: string;
+            name: string;
+        };
+    }[];
+    memoizedResultFunc: ((resultFuncArgs_0: ClientView[], resultFuncArgs_1: boolean, resultFuncArgs_2: {
+        [key: string]: string;
+    } | null | undefined) => {
+        clients: ClientView[];
+        group: {
+            id: string;
+            name: string;
+        };
+    }[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        clients: ClientView[];
+        group: {
+            id: string;
+            name: string;
+        };
+    }[];
+    dependencies: [((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => ClientView[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: ClientView | null, resultFuncArgs_1: ClientView[]) => ClientView[];
+        memoizedResultFunc: ((resultFuncArgs_0: ClientView | null, resultFuncArgs_1: ClientView[]) => ClientView[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => ClientView[];
+        dependencies: [((state: {
+            app: AppState;
+            authorization: AuthorizationState;
+            breakout: BreakoutState;
+            chat: ChatState;
+            cloudRecording: CloudRecordingState;
+            connectionMonitor: ConnectionMonitorState;
+            deviceCredentials: DeviceCredentialsState;
+            localMedia: LocalMediaState;
+            localParticipant: LocalParticipantState;
+            localScreenshare: LocalScreenshareState;
+            notifications: NotificationsState;
+            organization: OrganizationState;
+            remoteParticipants: RemoteParticipantState;
+            room: RoomState;
+            roomConnection: RoomConnectionState;
+            rtcAnalytics: rtcAnalyticsState;
+            rtcConnection: RtcConnectionState;
+            signalConnection: SignalConnectionState;
+            spotlights: SpotlightsState;
+            streaming: StreamingState;
+            waitingParticipants: WaitingParticipantsState;
+        }) => ClientView | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: MediaStream | undefined) => ClientView | null;
+            memoizedResultFunc: ((resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: MediaStream | undefined) => ClientView | null) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => ClientView | null;
+            dependencies: [(state: RootState) => LocalParticipantState, (state: RootState) => MediaStream | undefined];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof reselect.weakMapMemoize;
+            memoize: typeof reselect.weakMapMemoize;
+        }, ((state: {
+            app: AppState;
+            authorization: AuthorizationState;
+            breakout: BreakoutState;
+            chat: ChatState;
+            cloudRecording: CloudRecordingState;
+            connectionMonitor: ConnectionMonitorState;
+            deviceCredentials: DeviceCredentialsState;
+            localMedia: LocalMediaState;
+            localParticipant: LocalParticipantState;
+            localScreenshare: LocalScreenshareState;
+            notifications: NotificationsState;
+            organization: OrganizationState;
+            remoteParticipants: RemoteParticipantState;
+            room: RoomState;
+            roomConnection: RoomConnectionState;
+            rtcAnalytics: rtcAnalyticsState;
+            rtcConnection: RtcConnectionState;
+            signalConnection: SignalConnectionState;
+            spotlights: SpotlightsState;
+            streaming: StreamingState;
+            waitingParticipants: WaitingParticipantsState;
+        }) => ClientView[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[], resultFuncArgs_3: string, resultFuncArgs_4: {
+                [key: string]: string;
+            } | null | undefined) => ClientView[];
+            memoizedResultFunc: ((resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[], resultFuncArgs_3: string, resultFuncArgs_4: {
+                [key: string]: string;
+            } | null | undefined) => ClientView[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => ClientView[];
+            dependencies: [(state: RootState) => MediaStream | null, (state: RootState) => LocalParticipantState, ((state: {
+                app: AppState;
+                authorization: AuthorizationState;
+                breakout: BreakoutState;
+                chat: ChatState;
+                cloudRecording: CloudRecordingState;
+                connectionMonitor: ConnectionMonitorState;
+                deviceCredentials: DeviceCredentialsState;
+                localMedia: LocalMediaState;
+                localParticipant: LocalParticipantState;
+                localScreenshare: LocalScreenshareState;
+                notifications: NotificationsState;
+                organization: OrganizationState;
+                remoteParticipants: RemoteParticipantState;
+                room: RoomState;
+                roomConnection: RoomConnectionState;
+                rtcAnalytics: rtcAnalyticsState;
+                rtcConnection: RtcConnectionState;
+                signalConnection: SignalConnectionState;
+                spotlights: SpotlightsState;
+                streaming: StreamingState;
+                waitingParticipants: WaitingParticipantsState;
+            }) => RemoteParticipant[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            } & {
+                resultFunc: (resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[];
+                memoizedResultFunc: ((resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[]) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                };
+                lastResult: () => RemoteParticipant[];
+                dependencies: [(state: RootState) => RemoteParticipant[]];
+                recomputations: () => number;
+                resetRecomputations: () => void;
+                dependencyRecomputations: () => number;
+                resetDependencyRecomputations: () => void;
+            } & {
+                argsMemoize: typeof reselect.weakMapMemoize;
+                memoize: typeof reselect.weakMapMemoize;
+            }, ((state: {
+                app: AppState;
+                authorization: AuthorizationState;
+                breakout: BreakoutState;
+                chat: ChatState;
+                cloudRecording: CloudRecordingState;
+                connectionMonitor: ConnectionMonitorState;
+                deviceCredentials: DeviceCredentialsState;
+                localMedia: LocalMediaState;
+                localParticipant: LocalParticipantState;
+                localScreenshare: LocalScreenshareState;
+                notifications: NotificationsState;
+                organization: OrganizationState;
+                remoteParticipants: RemoteParticipantState;
+                room: RoomState;
+                roomConnection: RoomConnectionState;
+                rtcAnalytics: rtcAnalyticsState;
+                rtcConnection: RtcConnectionState;
+                signalConnection: SignalConnectionState;
+                spotlights: SpotlightsState;
+                streaming: StreamingState;
+                waitingParticipants: WaitingParticipantsState;
+            }) => string) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            } & {
+                resultFunc: (resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string;
+                memoizedResultFunc: ((resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                };
+                lastResult: () => string;
+                dependencies: [(state: RootState) => BreakoutState, (state: RootState) => string | null];
+                recomputations: () => number;
+                resetRecomputations: () => void;
+                dependencyRecomputations: () => number;
+                resetDependencyRecomputations: () => void;
+            } & {
+                argsMemoize: typeof reselect.weakMapMemoize;
+                memoize: typeof reselect.weakMapMemoize;
+            }, (state: RootState) => {
+                [key: string]: string;
+            } | null | undefined];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof reselect.weakMapMemoize;
+            memoize: typeof reselect.weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }, (state: RootState) => boolean, (state: RootState) => {
+        [key: string]: string;
+    } | null | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+type ConnectionStatus = "ready" | "connecting" | "connected" | "room_locked" | "knocking" | "knock_rejected" | "kicked" | "leaving" | "left" | "disconnected" | "reconnecting";
+interface RoomConnectionState {
+    session: {
+        createdAt: string;
+        id: string;
+    } | null;
+    status: ConnectionStatus;
+    error: string | null;
+}
+declare const roomConnectionSliceInitialState: RoomConnectionState;
+declare const roomConnectionSlice: _reduxjs_toolkit.Slice<RoomConnectionState, {
+    connectionStatusChanged: (state: immer.WritableDraft<RoomConnectionState>, action: PayloadAction<ConnectionStatus>) => {
+        status: ConnectionStatus;
+        session: immer.WritableDraft<{
+            createdAt: string;
+            id: string;
+        }> | null;
+        error: string | null;
+    };
+}, "roomConnection", "roomConnection", _reduxjs_toolkit.SliceSelectors<RoomConnectionState>>;
+declare const doKnockRoom: (args: void) => AppThunk;
+declare const doConnectRoom: (args: void) => AppThunk;
+declare const selectShouldConnectRoom: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: string | undefined, resultFuncArgs_2: ConnectionStatus, resultFuncArgs_3: boolean, resultFuncArgs_4: "error" | "inactive" | "stopped" | "starting" | "started", resultFuncArgs_5: string | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: string | undefined, resultFuncArgs_2: ConnectionStatus, resultFuncArgs_3: boolean, resultFuncArgs_4: "error" | "inactive" | "stopped" | "starting" | "started", resultFuncArgs_5: string | null) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => boolean, (state: RootState) => string | undefined, (state: RootState) => ConnectionStatus, (state: RootState) => boolean, (state: RootState) => "error" | "inactive" | "stopped" | "starting" | "started", (state: RootState) => string | null];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+declare const rtcEvents: {
+    rtcManagerCreated: _reduxjs_toolkit.ActionCreatorWithPayload<RtcManagerCreatedPayload, string>;
+    rtcManagerDestroyed: _reduxjs_toolkit.ActionCreatorWithoutPayload<string>;
+    streamAdded: _reduxjs_toolkit.ActionCreatorWithPayload<RtcStreamAddedPayload, string>;
+    clientConnectionStatusChanged: _reduxjs_toolkit.ActionCreatorWithPayload<RtcClientConnectionStatusChangedPayload, string>;
+};
+
+declare const createWebRtcEmitter: (dispatch: AppDispatch) => {
+    emit: (eventName: keyof RtcEvents, data: RtcEvents[keyof RtcEvents]) => void;
+};
+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: "inactive" | "ready" | "reconnecting";
+    isAcceptingStreams: boolean;
+}
+declare const rtcConnectionSliceInitialState: RtcConnectionState;
+declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
+    isAcceptingStreams: (state: immer.WritableDraft<RtcConnectionState>, action: PayloadAction<boolean>) => {
+        isAcceptingStreams: boolean;
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: immer.WritableDraft<{
+            [streamId: string]: Omit<StreamResolutionUpdate, "streamId">;
+        }>;
+        rtcManager: immer.WritableDraft<RtcManager> | null;
+        rtcManagerDispatcher: immer.WritableDraft<RtcManagerDispatcher> | null;
+        rtcManagerInitialized: boolean;
+        status: "inactive" | "ready" | "reconnecting";
+    };
+    resolutionReported: (state: immer.WritableDraft<RtcConnectionState>, action: PayloadAction<StreamResolutionUpdate>) => {
+        reportedStreamResolutions: {
+            [x: string]: immer.WritableDraft<Omit<StreamResolutionUpdate, "streamId">> | {
+                width: number;
+                height: number;
+            };
+        };
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        rtcManager: immer.WritableDraft<RtcManager> | null;
+        rtcManagerDispatcher: immer.WritableDraft<RtcManagerDispatcher> | null;
+        rtcManagerInitialized: boolean;
+        status: "inactive" | "ready" | "reconnecting";
+        isAcceptingStreams: boolean;
+    };
+    rtcDisconnected: () => {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [streamId: string]: Omit<StreamResolutionUpdate, "streamId">;
+        };
+        rtcManager: RtcManager | null;
+        rtcManagerDispatcher: RtcManagerDispatcher | null;
+        rtcManagerInitialized: boolean;
+        status: "inactive" | "ready" | "reconnecting";
+        isAcceptingStreams: boolean;
+    };
+    rtcDispatcherCreated: (state: immer.WritableDraft<RtcConnectionState>, action: PayloadAction<RtcManagerDispatcher>) => {
+        dispatcherCreated: true;
+        rtcManagerDispatcher: RtcManagerDispatcher;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: immer.WritableDraft<{
+            [streamId: string]: Omit<StreamResolutionUpdate, "streamId">;
+        }>;
+        rtcManager: immer.WritableDraft<RtcManager> | null;
+        rtcManagerInitialized: boolean;
+        status: "inactive" | "ready" | "reconnecting";
+        isAcceptingStreams: boolean;
+    };
+    rtcManagerCreated: (state: immer.WritableDraft<RtcConnectionState>, action: PayloadAction<RtcManager>) => {
+        rtcManager: RtcManager;
+        status: "ready";
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: immer.WritableDraft<{
+            [streamId: string]: Omit<StreamResolutionUpdate, "streamId">;
+        }>;
+        rtcManagerDispatcher: immer.WritableDraft<RtcManagerDispatcher> | null;
+        rtcManagerInitialized: boolean;
+        isAcceptingStreams: boolean;
+    };
+    rtcManagerDestroyed: (state: immer.WritableDraft<RtcConnectionState>) => {
+        rtcManager: null;
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: immer.WritableDraft<{
+            [streamId: string]: Omit<StreamResolutionUpdate, "streamId">;
+        }>;
+        rtcManagerDispatcher: immer.WritableDraft<RtcManagerDispatcher> | null;
+        rtcManagerInitialized: boolean;
+        status: "inactive" | "ready" | "reconnecting";
+        isAcceptingStreams: boolean;
+    };
+    rtcManagerInitialized: (state: immer.WritableDraft<RtcConnectionState>) => {
+        rtcManagerInitialized: true;
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: immer.WritableDraft<{
+            [streamId: string]: Omit<StreamResolutionUpdate, "streamId">;
+        }>;
+        rtcManager: immer.WritableDraft<RtcManager> | null;
+        rtcManagerDispatcher: immer.WritableDraft<RtcManagerDispatcher> | null;
+        status: "inactive" | "ready" | "reconnecting";
+        isAcceptingStreams: boolean;
+    };
+    rtcClientConnectionStatusChanged: {
+        reducer: (state: immer.WritableDraft<RtcConnectionState>) => immer.WritableDraft<RtcConnectionState>;
+        prepare: (payload: {
+            localParticipantId: string;
+        }) => {
+            payload: {};
+            meta: {
+                localParticipantId: string;
+            };
+        };
+    };
+}, "rtcConnection", "rtcConnection", _reduxjs_toolkit.SliceSelectors<RtcConnectionState>>;
+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 rtcClientConnectionStatusChanged: _reduxjs_toolkit.ActionCreatorWithPreparedPayload<[payload: {
+    localParticipantId: string;
+}], {}, "rtcConnection/rtcClientConnectionStatusChanged", never, {
+    localParticipantId: string;
+}>;
+declare const doConnectRtc: (args: void) => AppThunk;
+declare const doDisconnectRtc: (args: void) => AppThunk;
+declare const doHandleAcceptStreams: (args: StreamStatusUpdate[]) => AppThunk;
+declare const doRtcReportStreamResolution: (args: StreamResolutionUpdate) => AppThunk;
+declare const doRtcManagerCreated: (args: RtcManagerCreatedPayload) => AppThunk;
+declare const doRtcManagerInitialize: (args: void) => AppThunk;
+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) => "inactive" | "ready" | "reconnecting";
+declare const selectIsAcceptingStreams: (state: RootState) => boolean;
+declare const selectShouldConnectRtc: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: "inactive" | "ready" | "reconnecting", resultFuncArgs_1: boolean, resultFuncArgs_2: boolean, resultFuncArgs_3: boolean, resultFuncArgs_4: _whereby_com_media.ServerSocket | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: "inactive" | "ready" | "reconnecting", resultFuncArgs_1: boolean, resultFuncArgs_2: boolean, resultFuncArgs_3: boolean, resultFuncArgs_4: _whereby_com_media.ServerSocket | null) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => "inactive" | "ready" | "reconnecting", (state: RootState) => boolean, (state: RootState) => boolean, (state: RootState) => boolean, (state: RootState) => _whereby_com_media.ServerSocket | null];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectShouldInitializeRtc: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RtcManager | null, resultFuncArgs_1: boolean, resultFuncArgs_2: "error" | "inactive" | "stopped" | "starting" | "started") => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: RtcManager | null, resultFuncArgs_1: boolean, resultFuncArgs_2: "error" | "inactive" | "stopped" | "starting" | "started") => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => RtcManager | null, (state: RootState) => boolean, (state: RootState) => "error" | "inactive" | "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;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: "inactive" | "ready" | "reconnecting", resultFuncArgs_1: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: "inactive" | "ready" | "reconnecting", resultFuncArgs_1: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => "inactive" | "ready" | "reconnecting", (state: RootState) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectStreamsToAccept: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => {
+    clientId: string;
+    streamId: string;
+    state: StreamState;
+}[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: "inactive" | "ready" | "reconnecting", resultFuncArgs_1: RemoteParticipant[], resultFuncArgs_2: string, resultFuncArgs_3: {
+        clientId: string;
+        streamId: string;
+    }[], resultFuncArgs_4: boolean) => {
+        clientId: string;
+        streamId: string;
+        state: StreamState;
+    }[];
+    memoizedResultFunc: ((resultFuncArgs_0: "inactive" | "ready" | "reconnecting", resultFuncArgs_1: RemoteParticipant[], resultFuncArgs_2: string, resultFuncArgs_3: {
+        clientId: string;
+        streamId: string;
+    }[], resultFuncArgs_4: boolean) => {
+        clientId: string;
+        streamId: string;
+        state: StreamState;
+    }[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        clientId: string;
+        streamId: string;
+        state: StreamState;
+    }[];
+    dependencies: [(state: RootState) => "inactive" | "ready" | "reconnecting", (state: RootState) => RemoteParticipant[], ((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string;
+        memoizedResultFunc: ((resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string;
+        dependencies: [(state: RootState) => BreakoutState, (state: RootState) => string | null];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }, (state: RootState) => {
+        clientId: string;
+        streamId: string;
+    }[], (state: RootState) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+declare const signalEvents: {
+    audioEnabled: _reduxjs_toolkit.ActionCreatorWithPayload<AudioEnabledEvent, string>;
+    audioEnableRequested: _reduxjs_toolkit.ActionCreatorWithPayload<AudioEnableRequestedEvent, string>;
+    breakoutGroupJoined: _reduxjs_toolkit.ActionCreatorWithPayload<BreakoutGroupJoinedEvent, string>;
+    breakoutMoveToGroup: _reduxjs_toolkit.ActionCreatorWithoutPayload<string>;
+    breakoutMoveToMain: _reduxjs_toolkit.ActionCreatorWithoutPayload<string>;
+    breakoutSessionUpdated: _reduxjs_toolkit.ActionCreatorWithPayload<BreakoutSessionUpdatedEvent, string>;
+    chatMessage: _reduxjs_toolkit.ActionCreatorWithPayload<ChatMessage$1, string>;
+    clientLeft: _reduxjs_toolkit.ActionCreatorWithPayload<ClientLeftEvent, string>;
+    clientKicked: _reduxjs_toolkit.ActionCreatorWithPayload<ClientKickedEvent, string>;
+    clientMetadataReceived: _reduxjs_toolkit.ActionCreatorWithPayload<ClientMetadataReceivedEvent, string>;
+    clientUnableToJoin: _reduxjs_toolkit.ActionCreatorWithPayload<ClientUnableToJoinEvent, string>;
+    cloudRecordingStarted: _reduxjs_toolkit.ActionCreatorWithPayload<CloudRecordingStartedEvent, string>;
+    cloudRecordingStopped: _reduxjs_toolkit.ActionCreatorWithoutPayload<string>;
+    disconnect: _reduxjs_toolkit.ActionCreatorWithoutPayload<string>;
+    knockerLeft: _reduxjs_toolkit.ActionCreatorWithPayload<KnockerLeftEvent, string>;
+    knockHandled: _reduxjs_toolkit.ActionCreatorWithPayload<KnockAcceptedEvent | KnockRejectedEvent, string>;
+    newClient: _reduxjs_toolkit.ActionCreatorWithPayload<NewClientEvent, string>;
+    roomJoined: _reduxjs_toolkit.ActionCreatorWithPayload<RoomJoinedEvent, string>;
+    roomKnocked: _reduxjs_toolkit.ActionCreatorWithPayload<RoomKnockedEvent, string>;
+    roomLeft: _reduxjs_toolkit.ActionCreatorWithoutPayload<string>;
+    roomLocked: _reduxjs_toolkit.ActionCreatorWithPayload<RoomLockedEvent, string>;
+    roomSessionEnded: _reduxjs_toolkit.ActionCreatorWithPayload<RoomSessionEndedEvent, string>;
+    screenshareStarted: _reduxjs_toolkit.ActionCreatorWithPayload<ScreenshareStartedEvent, string>;
+    screenshareStopped: _reduxjs_toolkit.ActionCreatorWithPayload<ScreenshareStoppedEvent, string>;
+    spotlightAdded: _reduxjs_toolkit.ActionCreatorWithPayload<SpotlightAddedEvent, string>;
+    spotlightRemoved: _reduxjs_toolkit.ActionCreatorWithPayload<SpotlightRemovedEvent, string>;
+    streamingStopped: _reduxjs_toolkit.ActionCreatorWithoutPayload<string>;
+    videoEnabled: _reduxjs_toolkit.ActionCreatorWithPayload<VideoEnabledEvent, string>;
+    videoEnableRequested: _reduxjs_toolkit.ActionCreatorWithPayload<VideoEnableRequestedEvent, string>;
+    liveTranscriptionStarted: _reduxjs_toolkit.ActionCreatorWithPayload<LiveTranscriptionStartedEvent, string>;
+    liveTranscriptionStopped: _reduxjs_toolkit.ActionCreatorWithPayload<LiveTranscriptionStoppedEvent, string>;
+};
+
+interface SignalConnectionState {
+    deviceIdentified: boolean;
+    isIdentifyingDevice: boolean;
+    status: "ready" | "connecting" | "connected" | "disconnected" | "reconnecting";
+    socket: ServerSocket | null;
+}
+declare const signalConnectionSliceInitialState: SignalConnectionState;
+declare const signalConnectionSlice: _reduxjs_toolkit.Slice<SignalConnectionState, {
+    socketConnecting: (state: immer.WritableDraft<SignalConnectionState>) => {
+        status: "connecting";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        socket: immer.WritableDraft<ServerSocket> | null;
+    };
+    socketConnected: (state: immer.WritableDraft<SignalConnectionState>, action: PayloadAction<ServerSocket>) => {
+        socket: ServerSocket;
+        status: "connected";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+    };
+    socketDisconnected: (state: immer.WritableDraft<SignalConnectionState>) => {
+        socket: null;
+        deviceIdentified: false;
+        status: "disconnected";
+        isIdentifyingDevice: boolean;
+    };
+    socketReconnecting: (state: immer.WritableDraft<SignalConnectionState>) => {
+        status: "reconnecting";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        socket: immer.WritableDraft<ServerSocket> | null;
+    };
+    deviceIdentifying: (state: immer.WritableDraft<SignalConnectionState>) => {
+        isIdentifyingDevice: true;
+        deviceIdentified: boolean;
+        status: "ready" | "connecting" | "connected" | "disconnected" | "reconnecting";
+        socket: immer.WritableDraft<ServerSocket> | null;
+    };
+    deviceIdentified: (state: immer.WritableDraft<SignalConnectionState>) => {
+        deviceIdentified: true;
+        isIdentifyingDevice: false;
+        status: "ready" | "connecting" | "connected" | "disconnected" | "reconnecting";
+        socket: immer.WritableDraft<ServerSocket> | 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<ServerSocket, "signalConnection/socketConnected">;
+declare const socketConnecting: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/socketConnecting">;
+declare const socketDisconnected: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/socketDisconnected">;
+declare const socketReconnecting: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/socketReconnecting">;
+declare const doSignalConnect: (args: void) => AppThunk;
+declare const doSignalIdentifyDevice: (args: {
+    deviceCredentials: Credentials;
+}) => AppThunk;
+declare const doSignalDisconnect: (args: void) => AppThunk;
+declare const selectSignalConnectionRaw: (state: RootState) => SignalConnectionState;
+declare const selectSignalIsIdentifyingDevice: (state: RootState) => boolean;
+declare const selectSignalConnectionDeviceIdentified: (state: RootState) => boolean;
+declare const selectSignalStatus: (state: RootState) => "ready" | "connecting" | "connected" | "disconnected" | "reconnecting";
+declare const selectSignalConnectionSocket: (state: RootState) => ServerSocket | null;
+declare const selectShouldConnectSignal: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: "ready" | "connecting" | "connected" | "disconnected" | "reconnecting") => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: "ready" | "connecting" | "connected" | "disconnected" | "reconnecting") => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => boolean, (state: RootState) => "ready" | "connecting" | "connected" | "disconnected" | "reconnecting"];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectShouldIdentifyDevice: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: DeviceCredentialsState, resultFuncArgs_1: "ready" | "connecting" | "connected" | "disconnected" | "reconnecting", resultFuncArgs_2: boolean, resultFuncArgs_3: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: DeviceCredentialsState, resultFuncArgs_1: "ready" | "connecting" | "connected" | "disconnected" | "reconnecting", resultFuncArgs_2: boolean, resultFuncArgs_3: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => DeviceCredentialsState, (state: RootState) => "ready" | "connecting" | "connected" | "disconnected" | "reconnecting", (state: RootState) => boolean, (state: RootState) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+declare function streamIdForClient({ isPresentation, stream }: Pick<ClientView, "isPresentation" | "stream">): string | undefined;
+declare function isClientSpotlighted({ spotlights, isPresentation, clientId, stream, }: {
+    spotlights: Spotlight[];
+    isPresentation?: boolean;
+    clientId: string;
+    stream: ClientView["stream"];
+}): boolean;
+interface SpotlightsState {
+    sorted: {
+        clientId: string;
+        streamId: string;
+    }[];
+}
+declare const spotlightsSliceInitialState: SpotlightsState;
+declare const spotlightsSlice: _reduxjs_toolkit.Slice<SpotlightsState, {
+    addSpotlight(state: immer.WritableDraft<SpotlightsState>, action: {
+        payload: {
+            clientId: string;
+            streamId: string;
+        };
+    }): {
+        sorted: Spotlight[];
+    };
+    removeSpotlight(state: immer.WritableDraft<SpotlightsState>, action: {
+        payload: {
+            clientId: string;
+            streamId: string;
+        };
+    }): {
+        sorted: immer.WritableDraft<{
+            clientId: string;
+            streamId: string;
+        }>[];
+    };
+}, "spotlights", "spotlights", _reduxjs_toolkit.SliceSelectors<SpotlightsState>>;
+declare const addSpotlight: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    clientId: string;
+    streamId: string;
+}, "spotlights/addSpotlight">;
+declare const removeSpotlight: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    clientId: string;
+    streamId: string;
+}, "spotlights/removeSpotlight">;
+declare const doSpotlightParticipant: (args: {
+    id: string;
+}) => AppThunk;
+declare const doRemoveSpotlight: (args: {
+    id: string;
+}) => AppThunk;
+declare const selectSpotlightsRaw: (state: RootState) => SpotlightsState;
+declare const selectSpotlights: (state: RootState) => {
+    clientId: string;
+    streamId: string;
+}[];
+declare const selectIsLocalParticipantSpotlighted: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: {
+        clientId: string;
+        streamId: string;
+    }[]) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: {
+        clientId: string;
+        streamId: string;
+    }[]) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => LocalParticipantState, (state: RootState) => {
+        clientId: string;
+        streamId: string;
+    }[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectSpotlightedClientViews: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => ClientView[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ClientView[], resultFuncArgs_1: {
+        clientId: string;
+        streamId: string;
+    }[]) => ClientView[];
+    memoizedResultFunc: ((resultFuncArgs_0: ClientView[], resultFuncArgs_1: {
+        clientId: string;
+        streamId: string;
+    }[]) => ClientView[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => ClientView[];
+    dependencies: [((state: {
+        app: AppState;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => ClientView[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: ClientView | null, resultFuncArgs_1: ClientView[]) => ClientView[];
+        memoizedResultFunc: ((resultFuncArgs_0: ClientView | null, resultFuncArgs_1: ClientView[]) => ClientView[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => ClientView[];
+        dependencies: [((state: {
+            app: AppState;
+            authorization: AuthorizationState;
+            breakout: BreakoutState;
+            chat: ChatState;
+            cloudRecording: CloudRecordingState;
+            connectionMonitor: ConnectionMonitorState;
+            deviceCredentials: DeviceCredentialsState;
+            localMedia: LocalMediaState;
+            localParticipant: LocalParticipantState;
+            localScreenshare: LocalScreenshareState;
+            notifications: NotificationsState;
+            organization: OrganizationState;
+            remoteParticipants: RemoteParticipantState;
+            room: RoomState;
+            roomConnection: RoomConnectionState;
+            rtcAnalytics: rtcAnalyticsState;
+            rtcConnection: RtcConnectionState;
+            signalConnection: SignalConnectionState;
+            spotlights: SpotlightsState;
+            streaming: StreamingState;
+            waitingParticipants: WaitingParticipantsState;
+        }) => ClientView | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: MediaStream | undefined) => ClientView | null;
+            memoizedResultFunc: ((resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: MediaStream | undefined) => ClientView | null) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => ClientView | null;
+            dependencies: [(state: RootState) => LocalParticipantState, (state: RootState) => MediaStream | undefined];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof reselect.weakMapMemoize;
+            memoize: typeof reselect.weakMapMemoize;
+        }, ((state: {
+            app: AppState;
+            authorization: AuthorizationState;
+            breakout: BreakoutState;
+            chat: ChatState;
+            cloudRecording: CloudRecordingState;
+            connectionMonitor: ConnectionMonitorState;
+            deviceCredentials: DeviceCredentialsState;
+            localMedia: LocalMediaState;
+            localParticipant: LocalParticipantState;
+            localScreenshare: LocalScreenshareState;
+            notifications: NotificationsState;
+            organization: OrganizationState;
+            remoteParticipants: RemoteParticipantState;
+            room: RoomState;
+            roomConnection: RoomConnectionState;
+            rtcAnalytics: rtcAnalyticsState;
+            rtcConnection: RtcConnectionState;
+            signalConnection: SignalConnectionState;
+            spotlights: SpotlightsState;
+            streaming: StreamingState;
+            waitingParticipants: WaitingParticipantsState;
+        }) => ClientView[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[], resultFuncArgs_3: string, resultFuncArgs_4: {
+                [key: string]: string;
+            } | null | undefined) => ClientView[];
+            memoizedResultFunc: ((resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: LocalParticipantState, resultFuncArgs_2: RemoteParticipant[], resultFuncArgs_3: string, resultFuncArgs_4: {
+                [key: string]: string;
+            } | null | undefined) => ClientView[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => ClientView[];
+            dependencies: [(state: RootState) => MediaStream | null, (state: RootState) => LocalParticipantState, ((state: {
+                app: AppState;
+                authorization: AuthorizationState;
+                breakout: BreakoutState;
+                chat: ChatState;
+                cloudRecording: CloudRecordingState;
+                connectionMonitor: ConnectionMonitorState;
+                deviceCredentials: DeviceCredentialsState;
+                localMedia: LocalMediaState;
+                localParticipant: LocalParticipantState;
+                localScreenshare: LocalScreenshareState;
+                notifications: NotificationsState;
+                organization: OrganizationState;
+                remoteParticipants: RemoteParticipantState;
+                room: RoomState;
+                roomConnection: RoomConnectionState;
+                rtcAnalytics: rtcAnalyticsState;
+                rtcConnection: RtcConnectionState;
+                signalConnection: SignalConnectionState;
+                spotlights: SpotlightsState;
+                streaming: StreamingState;
+                waitingParticipants: WaitingParticipantsState;
+            }) => RemoteParticipant[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            } & {
+                resultFunc: (resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[];
+                memoizedResultFunc: ((resultFuncArgs_0: RemoteParticipant[]) => RemoteParticipant[]) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                };
+                lastResult: () => RemoteParticipant[];
+                dependencies: [(state: RootState) => RemoteParticipant[]];
+                recomputations: () => number;
+                resetRecomputations: () => void;
+                dependencyRecomputations: () => number;
+                resetDependencyRecomputations: () => void;
+            } & {
+                argsMemoize: typeof reselect.weakMapMemoize;
+                memoize: typeof reselect.weakMapMemoize;
+            }, ((state: {
+                app: AppState;
+                authorization: AuthorizationState;
+                breakout: BreakoutState;
+                chat: ChatState;
+                cloudRecording: CloudRecordingState;
+                connectionMonitor: ConnectionMonitorState;
+                deviceCredentials: DeviceCredentialsState;
+                localMedia: LocalMediaState;
+                localParticipant: LocalParticipantState;
+                localScreenshare: LocalScreenshareState;
+                notifications: NotificationsState;
+                organization: OrganizationState;
+                remoteParticipants: RemoteParticipantState;
+                room: RoomState;
+                roomConnection: RoomConnectionState;
+                rtcAnalytics: rtcAnalyticsState;
+                rtcConnection: RtcConnectionState;
+                signalConnection: SignalConnectionState;
+                spotlights: SpotlightsState;
+                streaming: StreamingState;
+                waitingParticipants: WaitingParticipantsState;
+            }) => string) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            } & {
+                resultFunc: (resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string;
+                memoizedResultFunc: ((resultFuncArgs_0: BreakoutState, resultFuncArgs_1: string | null) => string) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                };
+                lastResult: () => string;
+                dependencies: [(state: RootState) => BreakoutState, (state: RootState) => string | null];
+                recomputations: () => number;
+                resetRecomputations: () => void;
+                dependencyRecomputations: () => number;
+                resetDependencyRecomputations: () => void;
+            } & {
+                argsMemoize: typeof reselect.weakMapMemoize;
+                memoize: typeof reselect.weakMapMemoize;
+            }, (state: RootState) => {
+                [key: string]: string;
+            } | null | undefined];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof reselect.weakMapMemoize;
+            memoize: typeof reselect.weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof reselect.weakMapMemoize;
+        memoize: typeof reselect.weakMapMemoize;
+    }, (state: RootState) => {
+        clientId: string;
+        streamId: string;
+    }[]];
+    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 appReducer: redux.Reducer<{
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, redux.UnknownAction, Partial<{
+    app: AppState | undefined;
+    authorization: AuthorizationState | undefined;
+    breakout: BreakoutState | undefined;
+    chat: ChatState | undefined;
+    cloudRecording: CloudRecordingState | undefined;
+    connectionMonitor: ConnectionMonitorState | undefined;
+    deviceCredentials: DeviceCredentialsState | undefined;
+    localMedia: LocalMediaState | undefined;
+    localParticipant: LocalParticipantState | undefined;
+    localScreenshare: LocalScreenshareState | undefined;
+    notifications: NotificationsState | undefined;
+    organization: OrganizationState | undefined;
+    remoteParticipants: RemoteParticipantState | undefined;
+    room: RoomState | undefined;
+    roomConnection: RoomConnectionState | undefined;
+    rtcAnalytics: rtcAnalyticsState | undefined;
+    rtcConnection: RtcConnectionState | undefined;
+    signalConnection: SignalConnectionState | undefined;
+    spotlights: SpotlightsState | undefined;
+    streaming: StreamingState | undefined;
+    waitingParticipants: WaitingParticipantsState | undefined;
+}>>;
+declare const rootReducer: AppReducer;
+declare const createStore: ({ preloadedState, injectServices, }: {
+    preloadedState?: Partial<RootState>;
+    injectServices: ReturnType<typeof createServices>;
+}) => _reduxjs_toolkit.EnhancedStore<{
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    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;
+        authorization: AuthorizationState;
+        breakout: BreakoutState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        connectionMonitor: ConnectionMonitorState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        notifications: NotificationsState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        room: RoomState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        spotlights: SpotlightsState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }, {
+        services: {
+            credentialsService: CredentialsService;
+            apiClient: ApiClient;
+            organizationService: OrganizationService;
+            fetchOrganizationFromRoomUrl: (roomUrl: string) => Promise<Organization | null>;
+        };
+    }, redux.UnknownAction>;
+}>, redux.StoreEnhancer]>>;
+type AppReducer = typeof appReducer;
+type RootState = ReturnType<typeof appReducer>;
+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 function createAppAuthorizedThunk<A = void>(authorizationSelector: (state: RootState) => boolean, thunk: (args: A) => AppThunk): (args: A) => AppThunk;
+declare function createRoomConnectedThunk<A = void>(thunk: (args: A) => AppThunk): (args: A) => AppThunk;
+declare function createAsyncRoomConnectedThunk<ReturnType, ArgType = undefined>(typePrefix: string, payloadCreator: AsyncThunkPayloadCreator<ReturnType, ArgType, ThunkConfig>): AsyncThunk<ReturnType, ArgType, ThunkConfig>;
+declare function createAuthorizedRoomConnectedThunk<A = void>(authorizationSelector: (state: RootState) => boolean, 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<RootState, AppDispatch>;
+type SelectorResults<Selectors extends Selector<RootState, unknown>[]> = {
+    [K in keyof Selectors]: Selectors[K] extends Selector<RootState, infer R> ? R : never;
+};
+declare const createReactor: <Selectors extends Selector<RootState, 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 selectLocalParticipantRaw: (state: RootState) => LocalParticipantState;
+declare const selectSelfId: (state: RootState) => string;
+declare const selectLocalParticipantDisplayName: (state: RootState) => string;
+declare const selectLocalParticipantClientClaim: (state: RootState) => string | undefined;
+declare const selectLocalParticipantIsScreenSharing: (state: RootState) => boolean;
+declare const selectLocalParticipantStickyReaction: (state: RootState) => StickyReaction | null | undefined;
+declare const selectLocalParticipantBreakoutGroup: (state: RootState) => string | null;
+declare const selectLocalParticipantBreakoutAssigned: (state: RootState) => string;
+declare const selectLocalParticipantView: ((state: {
+    app: AppState;
+    authorization: AuthorizationState;
+    breakout: BreakoutState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    connectionMonitor: ConnectionMonitorState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    notifications: NotificationsState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    room: RoomState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    spotlights: SpotlightsState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => ClientView | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: MediaStream | undefined) => ClientView | null;
+    memoizedResultFunc: ((resultFuncArgs_0: LocalParticipantState, resultFuncArgs_1: MediaStream | undefined) => ClientView | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => ClientView | null;
+    dependencies: [(state: RootState) => LocalParticipantState, (state: RootState) => MediaStream | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+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;
+declare const selectRoomConnectionError: (state: RootState) => string | null;
+
+export { addAppListener, addSpotlight, appSlice, authorizationSlice, authorizationSliceInitialState, breakoutSlice, breakoutSliceInitialState, chatSlice, chatSliceInitialState, cloudRecordingSlice, connectionMonitorSlice, connectionMonitorSliceInitialState, connectionMonitorStarted, connectionMonitorStopped, createAppAsyncThunk, createAppAuthorizedThunk, createAppThunk, createAsyncRoomConnectedThunk, createAuthorizedRoomConnectedThunk, createReactor, createRemoteParticipant, createRoomConnectedThunk, createStore, createWebRtcEmitter, deviceBusy, deviceCredentialsSlice, deviceCredentialsSliceInitialState, deviceIdentified, deviceIdentifying, doAcceptWaitingParticipant, doAppStart, doAppStop, doBreakoutJoin, doClearNotifications, doConnectRoom, doConnectRtc, doDisconnectRtc, doEnableAudio, doEnableVideo, doEndMeeting, doGetDeviceCredentials, doHandleAcceptStreams, doHandleStreamingStarted, doHandleStreamingStopped, doKickParticipant, doKnockRoom, doLockRoom, doOrganizationFetch, doRejectWaitingParticipant, doRemoveSpotlight, doRequestAudioEnable, doRequestVideoEnable, doRtcAnalyticsCustomEventsInitialize, doRtcManagerCreated, doRtcManagerInitialize, doRtcReportStreamResolution, doSendChatMessage, doSendClientMetadata, doSetDevice, doSetDisplayName, doSetLocalStickyReaction, doSetNotification, doSignalConnect, doSignalDisconnect, doSignalIdentifyDevice, doSpotlightParticipant, doStartCloudRecording, doStartConnectionMonitor, doStartLocalMedia, doStartScreenshare, doStopCloudRecording, doStopConnectionMonitor, doStopLocalMedia, doStopScreenshare, doSwitchLocalStream, doToggleCamera, doToggleLowDataMode, doUpdateDeviceList, initialCloudRecordingState, initialLocalMediaState, initialNotificationsState, initialState, isAcceptingStreams, isClientSpotlighted, listenerMiddleware, localMediaSlice, localMediaStopped, localParticipantSlice, localParticipantSliceInitialState, localScreenshareSlice, localScreenshareSliceInitialState, localStreamMetadataUpdated, notificationsSlice, observeStore, organizationSlice, organizationSliceInitialState, participantStreamAdded, participantStreamIdAdded, recordingRequestStarted, remoteParticipantsSlice, remoteParticipantsSliceInitialState, removeSpotlight, resolutionReported, roomConnectionSlice, roomConnectionSliceInitialState, roomSlice, roomSliceInitialState, rootReducer, rtcAnalyticsCustomEvents, rtcAnalyticsSlice, rtcAnalyticsSliceInitialState, rtcClientConnectionStatusChanged, rtcConnectionSlice, rtcConnectionSliceInitialState, rtcDisconnected, rtcDispatcherCreated, rtcEvents, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, selectAllClientViews, selectAllClientViewsInCurrentGroup, selectAppDisplayName, selectAppExternalId, selectAppIgnoreBreakoutGroups, selectAppInitialConfig, selectAppIsActive, selectAppIsDialIn, selectAppIsNodeSdk, selectAppRaw, selectAppRoomName, selectAppRoomUrl, selectAppUserAgent, selectAuthorizationRoleName, selectBreakoutActive, selectBreakoutAssignments, selectBreakoutCurrentGroup, selectBreakoutCurrentId, selectBreakoutGroupedParticipants, selectBreakoutGroups, selectBreakoutInitiatedBy, selectBreakoutRaw, selectBusyDeviceIds, selectCameraDeviceError, selectCameraDevices, selectChatMessages, selectChatRaw, selectCloudRecordingError, selectCloudRecordingRaw, selectCloudRecordingStartedAt, selectCloudRecordingStatus, selectConnectionMonitorIsRunning, selectCurrentCameraDeviceId, selectCurrentMicrophoneDeviceId, selectCurrentSpeakerDeviceId, selectDeviceCredentialsRaw, selectDeviceId, selectHasFetchedDeviceCredentials, selectIsAcceptingStreams, selectIsAuthorizedToAskToSpeak, selectIsAuthorizedToEndMeeting, selectIsAuthorizedToKickClient, selectIsAuthorizedToLockRoom, selectIsAuthorizedToRequestAudioEnable, selectIsAuthorizedToRequestVideoEnable, selectIsAuthorizedToSpotlight, selectIsCameraEnabled, selectIsCloudRecording, selectIsLocalMediaStarting, selectIsLocalParticipantSpotlighted, selectIsLowDataModeEnabled, selectIsMicrophoneEnabled, selectIsSettingCameraDevice, selectIsSettingMicrophoneDevice, selectIsToggleCamera, selectLocalMediaConstraintsOptions, selectLocalMediaDevices, selectLocalMediaIsSwitchingStream, selectLocalMediaOptions, selectLocalMediaOwnsStream, selectLocalMediaRaw, selectLocalMediaShouldStartWithOptions, selectLocalMediaShouldStop, selectLocalMediaStartError, selectLocalMediaStatus, selectLocalMediaStream, selectLocalParticipantBreakoutAssigned, selectLocalParticipantBreakoutGroup, selectLocalParticipantClientClaim, selectLocalParticipantDisplayName, selectLocalParticipantIsScreenSharing, selectLocalParticipantRaw, selectLocalParticipantStickyReaction, selectLocalParticipantView, selectLocalScreenshareRaw, selectLocalScreenshareStatus, selectLocalScreenshareStream, selectMicrophoneDeviceError, selectMicrophoneDevices, selectNotificationsEmitter, selectNotificationsEvents, selectNotificationsRaw, selectNumClients, selectNumParticipants, selectOrganizationId, selectOrganizationPreferences, selectOrganizationRaw, selectRemoteClientViews, selectRemoteClients, selectRemoteParticipants, selectRemoteParticipantsRaw, selectRoomConnectionError, selectRoomConnectionRaw, selectRoomConnectionSession, selectRoomConnectionSessionId, selectRoomConnectionStatus, selectRoomIsLocked, selectRoomKey, selectRtcConnectionRaw, selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectRtcManager, selectRtcManagerInitialized, selectRtcStatus, selectScreenshares, selectSelfId, selectShouldConnectRoom, selectShouldConnectRtc, selectShouldConnectSignal, selectShouldDisconnectRtc, selectShouldFetchDeviceCredentials, selectShouldFetchOrganization, selectShouldIdentifyDevice, selectShouldInitializeRtc, selectShouldStartConnectionMonitor, selectShouldStopConnectionMonitor, selectSignalConnectionDeviceIdentified, selectSignalConnectionRaw, selectSignalConnectionSocket, selectSignalIsIdentifyingDevice, selectSignalStatus, selectSpeakerDevices, selectSpotlightedClientViews, selectSpotlights, selectSpotlightsRaw, selectStopCallbackFunction, selectStreamingRaw, selectStreamsToAccept, selectWaitingParticipants, selectWaitingParticipantsRaw, setBreakoutGroupAssigned, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, setCurrentSpeakerDeviceId, setDisplayName, setLocalMediaOptions, setLocalMediaStream, setRoomKey, signalConnectionSlice, signalConnectionSliceInitialState, signalEvents, socketConnected, socketConnecting, socketDisconnected, socketReconnecting, spotlightsSlice, spotlightsSliceInitialState, startAppListening, stopScreenshare, streamIdForClient, streamStatusUpdated, streamingSlice, streamingSliceInitialState, toggleCameraEnabled, toggleLowDataModeEnabled, toggleMicrophoneEnabled, updateReportedValues, waitingParticipantsSlice, waitingParticipantsSliceInitialState };
+export type { AppConfig, AppDispatch, AppReducer, AppStartListening, AppState, AppThunk, AuthorizationState, BreakoutState, ChatMessage, ChatMessageEvent, ChatMessageEventProps, ChatState, ClientView, CloudRecordingState, ConnectionMonitorStart, ConnectionMonitorState, ConnectionStatus, DeviceCredentialsState, LocalMediaOptions, LocalMediaState, LocalParticipantState, LocalScreenshareState, Notification, NotificationEvent, NotificationEventMap, NotificationEvents, NotificationsEventEmitter, NotificationsState, OrganizationState, RemoteParticipantState, RequestAudioEvent, RequestAudioEventProps, RequestVideoEvent, RequestVideoEventProps, RoomConnectionState, RoomState, RootState, RtcConnectionState, SignalClientEvent, SignalClientEventProps, SignalConnectionState, SignalStatusEvent, SignalStatusEventProps, SpotlightsState, StickyReactionEvent, StickyReactionEventProps, Store, StreamingState, ThunkConfig, WaitingParticipantsState, rtcAnalyticsState };