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 { LiveCaptionEvent, RoleName, ChatMessage as ChatMessage$1, ChatFileShare, FileShareErrorCode, BreakoutConfig, getDeviceData, SignalClient, RtcStreamAddedPayload, AudioEnableRequest, VideoEnableRequest, RoomMode, KnockResponse, RtcManagerCreatedPayload, RtcClientConnectionStatusChangedPayload, RtcManager, RtcManagerDispatcher, RtcEvents, AudioEnabledEvent, AudioEnableRequestedEvent, BreakoutGroupJoinedEvent, BreakoutSessionUpdatedEvent, ChatMessageRemoved, ChatMessageError, ClientLeftEvent, ClientKickedEvent, ClientMetadataReceivedEvent, ClientUnableToJoinEvent, CloudRecordingStartedEvent, KnockerLeftEvent, KnockAcceptedEvent, KnockOnHoldEvent, KnockRejectedEvent, NewClientEvent, RoomJoinedEvent, RoomKnockedEvent, RoomLockedEvent, RoomSessionEndedEvent, ScreenshareStartedEvent, ScreenshareStoppedEvent, SpotlightAddedEvent, SpotlightRemovedEvent, VideoEnabledEvent, VideoEnableRequestedEvent, LiveTranscriptionStartedEvent, LiveTranscriptionStoppedEvent, LiveCaptionsStartedEvent, LiveCaptionsStoppedEvent, ServerSocket, Spotlight } from '@whereby.com/media';
import * as immer from 'immer';
import * as reselect from 'reselect';
import { Setup, Params } from '@whereby.com/camera-effects';

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);
}

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>;
}

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 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>;
}

declare class LiveCaption {
    resultId: string;
    participantId: string;
    text: string;
    timestamp: number;
    constructor({ resultId, senderId, text }: LiveCaptionEvent);
}

interface StickyReaction {
    reaction: string;
    timestamp: string;
}
interface RoomParticipantData {
    breakoutGroup: string | null;
    displayName: string;
    id: string;
    isAudioEnabled: boolean;
    isAudioRecorder: boolean;
    isDialIn: boolean;
    isVideoEnabled: boolean;
    stickyReaction?: StickyReaction | null;
    stream?: MediaStream;
}
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;
    readonly isAudioRecorder: boolean;
    constructor({ breakoutGroup, displayName, id, isAudioEnabled, isAudioRecorder, isDialIn, isVideoEnabled, stickyReaction, stream, }: RoomParticipantData);
}
type StreamState = "new_accept" | "to_accept" | "done_accept" | "to_unaccept" | "done_unaccept";
interface Stream {
    id: string;
    state: StreamState;
}
interface RemoteParticipant {
    breakoutGroup: string | null;
    deviceId: string;
    displayName: string;
    externalId: string | null;
    id: string;
    isAudioEnabled: boolean;
    isAudioRecorder: boolean;
    isDialIn: boolean;
    isLocalParticipant: boolean;
    isVideoEnabled: boolean;
    newJoiner: boolean;
    presentationStream: (MediaStream & {
        inboundId?: string;
    }) | null;
    roleName: RoleName;
    stickyReaction?: StickyReaction | null;
    stream: (MediaStream & {
        inboundId?: string;
    }) | null;
    streams: Stream[];
}
declare class LocalParticipant extends RoomParticipant {
    readonly isLocalParticipant = true;
    constructor({ breakoutGroup, displayName, id, isAudioEnabled, isAudioRecorder, isDialIn, isVideoEnabled, stickyReaction, stream, }: 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 doHoldWaitingParticipant: (args: {
    participantId: string;
    response?: string;
}) => AppThunk;
declare const doRejectWaitingParticipant: (args: {
    participantId: string;
    response?: 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<T = any> = {
    actions: Array<ActionCreatorWithPayload<any> | AsyncThunk<any, any, ThunkConfig>["fulfilled"]> | null;
    rtcEventName: string;
    getValue: (state: RootState) => T;
    getOutput: (value: T) => 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, "id" | "senderId" | "parentId" | "timestamp" | "text" | "sig"> & {
    removed: boolean;
    file?: ChatFileShare;
};
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;
    parentId?: string;
}) => AppThunk;
declare const doRemoveChatMessage: (args: Pick<ChatMessage$1, "id" | "sig">) => 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>;
interface BreakoutTimerEventProps {
}
type BreakoutTimerEvent = NotificationEvent<"breakoutTimerEnding" | "breakoutTimerEnded" | "breakoutTimerExtended", BreakoutTimerEventProps>;
interface BreakoutGroupAssignedEventProps {
    group: string;
    groupName: string;
}
type BreakoutGroupAssignedEvent = NotificationEvent<"breakoutGroupAssigned", BreakoutGroupAssignedEventProps>;
type NotificationEventTypes = {
    ["requestAudioEnable"]: RequestAudioEvent;
    ["requestAudioDisable"]: RequestAudioEvent;
    ["chatMessageReceived"]: ChatMessageEvent;
    ["remoteHandRaised"]: StickyReactionEvent;
    ["remoteHandLowered"]: StickyReactionEvent;
    ["signalTrouble"]: SignalStatusEvent;
    ["signalOk"]: SignalStatusEvent;
    ["clientUnableToJoinFullRoom"]: SignalClientEvent;
    ["requestVideoEnable"]: RequestVideoEvent;
    ["requestVideoDisable"]: RequestVideoEvent;
    ["breakoutTimerEnding"]: BreakoutTimerEvent;
    ["breakoutTimerEnded"]: BreakoutTimerEvent;
    ["breakoutTimerExtended"]: BreakoutTimerEvent;
    ["breakoutGroupAssigned"]: BreakoutGroupAssignedEvent;
};
type NotificationEvents = NotificationEventTypes[keyof NotificationEventTypes];
type NotificationEventMap = {
    "*": [NotificationEvents];
} & {
    [Type in keyof NotificationEventTypes]: [NotificationEventTypes[Type]];
};

type NotificationsEventEmitter = EventEmitter<NotificationEventMap>;
declare function createNotificationEvent<Type, PropsType>(payload: Notification<Type, PropsType>): NotificationEvent<Type, PropsType>;
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) => "active" | "inactive" | "starting";
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;
        isAudioRecorder: 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;
        isAudioRecorder: 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 LiveTranscriptionState {
    isInitiator: boolean;
    isTranscribing: boolean;
    error?: string;
    status?: "transcribing" | "requested" | "error";
    startedAt?: number;
}
declare const initialLiveTranscriptionState: LiveTranscriptionState;
declare const liveTranscriptionSlice: _reduxjs_toolkit.Slice<LiveTranscriptionState, {
    transcribingRequestStarted: (state: immer.WritableDraft<LiveTranscriptionState>) => {
        isInitiator: true;
        status: "requested";
        isTranscribing: boolean;
        error?: string | undefined;
        startedAt?: number | undefined;
    };
}, "liveTranscription", "liveTranscription", _reduxjs_toolkit.SliceSelectors<LiveTranscriptionState>>;
declare const transcribingRequestStarted: _reduxjs_toolkit.ActionCreatorWithoutPayload<"liveTranscription/transcribingRequestStarted">;
declare const doStartLiveTranscription: (args: void) => AppThunk;
declare const doStopLiveTranscription: (args: void) => AppThunk;
declare const selectLiveTranscriptionRaw: (state: RootState) => LiveTranscriptionState;
declare const selectLiveTranscriptionStatus: (state: RootState) => "error" | "requested" | "transcribing" | undefined;
declare const selectLiveTranscriptionStartedAt: (state: RootState) => number | undefined;
declare const selectLiveTranscriptionError: (state: RootState) => string | undefined;
declare const selectIsLiveTranscription: (state: RootState) => boolean;
declare const selectLiveTranscriptionIsInitiator: (state: RootState) => boolean;

interface LiveCaptionsState {
    isCaptioning: boolean;
    error?: string;
    status?: "captioning" | "requested" | "error";
    startedAt?: number;
    captionLog: Array<LiveCaption>;
}
declare const initialLiveCaptionsState: LiveCaptionsState;
declare const liveCaptionsSlice: _reduxjs_toolkit.Slice<LiveCaptionsState, {
    captioningRequestStarted: (state: immer.WritableDraft<LiveCaptionsState>) => {
        status: "requested";
        isCaptioning: boolean;
        error?: string | undefined;
        startedAt?: number | undefined;
        captionLog: immer.WritableDraft<LiveCaption>[];
    };
    clearCaption: (state: immer.WritableDraft<LiveCaptionsState>, action: PayloadAction<{
        resultId: string;
    }>) => {
        captionLog: immer.WritableDraft<LiveCaption>[];
        isCaptioning: boolean;
        error?: string | undefined;
        status?: "captioning" | "requested" | "error" | undefined;
        startedAt?: number | undefined;
    };
}, "liveCaptions", "liveCaptions", _reduxjs_toolkit.SliceSelectors<LiveCaptionsState>>;
declare const captioningRequestStarted: _reduxjs_toolkit.ActionCreatorWithoutPayload<"liveCaptions/captioningRequestStarted">;
declare const clearCaption: _reduxjs_toolkit.ActionCreatorWithPayload<{
    resultId: string;
}, "liveCaptions/clearCaption">;
declare const doStartLiveCaptions: (args: void) => AppThunk;
declare const doStopLiveCaptions: (args: void) => AppThunk;
declare const selectLiveCaptionsRaw: (state: RootState) => LiveCaptionsState;
declare const selectLiveCaptionsStatus: (state: RootState) => "error" | "requested" | "captioning" | undefined;
declare const selectLiveCaptionsStartedAt: (state: RootState) => number | undefined;
declare const selectLiveCaptionsError: (state: RootState) => string | undefined;
declare const selectLiveCaptionsLog: (state: RootState) => LiveCaption[];
declare const selectIsLiveCaptions: (state: RootState) => boolean;

type FileShareError = FileShareErrorCode | "upload_failed" | "too_many_files" | "unsupported_file_type" | "file_too_large";
declare const MAX_FILES_PER_UPLOAD = 10;
declare const MAX_FILE_SIZE: number;
declare const ACCEPTED_FILE_TYPES: Record<string, string[]>;
interface FileUpload {
    id: string;
    name: string;
    size: number;
    type: string;
    status: "uploading" | "sent" | "error";
    error?: FileShareError;
}
interface FileShareState {
    uploads: FileUpload[];
    requestInFlight: boolean;
}
declare const fileShareSliceInitialState: FileShareState;
declare const fileShareSlice: _reduxjs_toolkit.Slice<FileShareState, {
    fileUploadsStarted: (state: immer.WritableDraft<FileShareState>, action: PayloadAction<FileUpload[]>) => void;
    fileShareRequestSettled: (state: immer.WritableDraft<FileShareState>) => void;
    fileUploadSucceeded: (state: immer.WritableDraft<FileShareState>, action: PayloadAction<{
        id: string;
    }>) => void;
    fileUploadFailed: (state: immer.WritableDraft<FileShareState>, action: PayloadAction<{
        id: string;
        error: FileShareError;
    }>) => void;
    clearFileUploads: (state: immer.WritableDraft<FileShareState>) => void;
}, "fileShare", "fileShare", _reduxjs_toolkit.SliceSelectors<FileShareState>>;
declare const fileUploadsStarted: _reduxjs_toolkit.ActionCreatorWithPayload<FileUpload[], "fileShare/fileUploadsStarted">;
declare const fileShareRequestSettled: _reduxjs_toolkit.ActionCreatorWithoutPayload<"fileShare/fileShareRequestSettled">;
declare const fileUploadSucceeded: _reduxjs_toolkit.ActionCreatorWithPayload<{
    id: string;
}, "fileShare/fileUploadSucceeded">;
declare const fileUploadFailed: _reduxjs_toolkit.ActionCreatorWithPayload<{
    id: string;
    error: FileShareError;
}, "fileShare/fileUploadFailed">;
declare const clearFileUploads: _reduxjs_toolkit.ActionCreatorWithoutPayload<"fileShare/clearFileUploads">;
interface SendFilesOptions {
    parentId?: string;
    isBroadcast?: boolean;
}
declare const doSendFiles: _reduxjs_toolkit.AsyncThunk<undefined, {
    files: File[];
} & SendFilesOptions, ThunkConfig>;
declare const doDownloadFile: _reduxjs_toolkit.AsyncThunk<Blob, {
    file: ChatFileShare;
}, ThunkConfig>;
declare const selectFileShareRaw: (state: RootState) => FileShareState;
declare const selectFileUploads: (state: RootState) => FileUpload[];
declare const selectFileShareRequestInFlight: (state: RootState) => boolean;

interface CloudRecordingState {
    isInitiator: boolean;
    isRecording: boolean;
    error?: string;
    status?: "recording" | "requested" | "error";
    startedAt?: number;
}
declare const initialCloudRecordingState: CloudRecordingState;
declare const cloudRecordingSlice: _reduxjs_toolkit.Slice<CloudRecordingState, {
    recordingRequestStarted: (state: immer.WritableDraft<CloudRecordingState>) => {
        isInitiator: true;
        status: "requested";
        isRecording: boolean;
        error?: string | undefined;
        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) => string | undefined;
declare const selectIsCloudRecording: (state: RootState) => boolean;
declare const selectCloudRecordingIsInitiator: (state: RootState) => boolean;

type TryUpdateFn = (presetId: string, setup: Setup, params: Params) => Promise<boolean>;
type StopFn$1 = () => void;
interface CameraEffectsState {
    currentEffectId?: string | null;
    setup?: Setup;
    params?: Params;
    backgroundUrl?: string;
    allowSafari?: boolean;
    isPaused: boolean;
    isSwitching: boolean;
    error?: unknown;
    raw: {
        stop?: StopFn$1;
        tryUpdate?: TryUpdateFn;
        effectStream?: MediaStream;
    };
}

type StopFn = () => void;
interface AudioDenoiserState {
    wanted: boolean;
    isSwitching: boolean;
    error?: unknown;
    raw: {
        stop?: StopFn;
        outputStream?: MediaStream;
        audioContext?: AudioContext;
        denoiserNode?: AudioWorkletNode;
    };
}

interface AppConfig {
    assistantKey?: string | null;
    displayName: string;
    externalId: string | null;
    ignoreBreakoutGroups?: boolean;
    isAudioRecorder?: boolean;
    isDialIn?: boolean;
    isNodeSdk?: boolean;
    localMediaOptions?: LocalMediaOptions;
    roomKey: string | null;
    roomUrl: string;
    userAgent?: string;
}
interface AppState {
    displayName: string | null;
    externalId: string | null;
    ignoreBreakoutGroups: boolean;
    initialConfig?: AppConfig;
    isActive: boolean;
    isAssistant: boolean;
    isAudioRecorder: boolean;
    isDialIn: boolean;
    isNodeSdk: boolean;
    roomName: string | null;
    roomUrl: string | null;
    userAgent: string | null;
}
declare const initialState: AppState;
declare const appSlice: _reduxjs_toolkit.Slice<AppState, {
    doAppStart: (state: immer.WritableDraft<AppState>, action: PayloadAction<AppConfig>) => {
        roomName: string | null;
        initialConfig: {
            assistantKey?: string | null;
            displayName: string;
            externalId: string | null;
            ignoreBreakoutGroups?: boolean;
            isAudioRecorder?: boolean;
            isDialIn?: boolean;
            isNodeSdk?: boolean;
            localMediaOptions?: LocalMediaOptions;
            roomKey: string | null;
            roomUrl: string;
            userAgent?: string;
        };
        isActive: true;
        isAssistant: boolean;
        assistantKey?: string | null;
        displayName: string;
        externalId: string | null;
        ignoreBreakoutGroups: boolean;
        isAudioRecorder: boolean;
        isDialIn: boolean;
        isNodeSdk: boolean;
        localMediaOptions?: LocalMediaOptions;
        roomKey: string | null;
        roomUrl: string;
        userAgent: string | null;
    };
    doAppStop: (state: immer.WritableDraft<AppState>) => {
        isActive: false;
        displayName: string | null;
        externalId: string | null;
        ignoreBreakoutGroups: boolean;
        initialConfig?: immer.WritableDraft<AppConfig> | undefined;
        isAssistant: boolean;
        isAudioRecorder: boolean;
        isDialIn: boolean;
        isNodeSdk: boolean;
        roomName: string | null;
        roomUrl: string | null;
        userAgent: string | null;
    };
}, "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 selectAppIsAudioRecorder: (state: RootState) => boolean;
declare const selectAppIsAssistant: (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;
    assistantKey?: 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;
        assistantKey?: string | null | undefined;
        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 selectAssistantKey: (state: RootState) => string | null | undefined;
declare const selectAuthorizationRoleName: (state: RootState) => RoleName;
declare const selectIsAuthorizedToLockRoom: ((state: {
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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 selectIsAuthorizedToManageBreakout: ((state: {
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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 DEFAULT_BREAKOUT_TIMER_DURATION = 1800;
interface BreakoutState extends BreakoutConfig {
    error: string | null;
}
declare const breakoutSliceInitialState: BreakoutState;
declare const BREAKOUT_UNAVAILABLE_ERROR = "Breakout groups are not available in peer-to-peer rooms";
declare const breakoutSlice: _reduxjs_toolkit.Slice<BreakoutState, {
    setBreakoutError: (state: immer.WritableDraft<BreakoutState>, action: PayloadAction<{
        error: string | null;
    }>) => {
        error: string | null;
        assignments?: immer.WritableDraft<{
            [key: string]: string;
        }> | null | undefined;
        autoMoveToGroup?: boolean | undefined;
        autoMoveToMain?: boolean | undefined;
        breakoutEnabledAt?: string | null | undefined;
        breakoutNotification?: string | null | undefined;
        breakoutTimerDuration?: number | undefined;
        breakoutStartedAt?: string | null | undefined;
        breakoutEndedAt?: string | null | undefined;
        breakoutTimerSetting?: boolean | undefined;
        moveToGroupGracePeriod?: number | null | undefined;
        moveToMainGracePeriod?: number | null | undefined;
        enforceAssignment?: boolean | undefined;
        groups?: immer.WritableDraft<{
            [key: string]: string;
        }> | null | undefined;
        initiatedBy?: immer.WritableDraft<{
            clientId: string;
            userId: string;
            deviceId: string;
            active: boolean;
        }> | null | undefined;
        startedAt?: (Date | null) | undefined;
    };
}, "breakout", "breakout", _reduxjs_toolkit.SliceSelectors<BreakoutState>>;
declare const setBreakoutError: _reduxjs_toolkit.ActionCreatorWithPayload<{
    error: string | null;
}, "breakout/setBreakoutError">;
declare const doBreakoutJoin: (args: {
    group: string;
}) => AppThunk;
interface BreakoutSessionSettings {
    enforceAssignment?: boolean;
    autoMoveToGroup?: boolean;
    autoMoveToMain?: boolean;
    moveToGroupGracePeriod?: number | null;
    moveToMainGracePeriod?: number | null;
    breakoutTimerSetting?: boolean;
    breakoutTimerDuration?: number;
}
interface StartBreakoutSessionOptions extends BreakoutSessionSettings {
    groups: {
        [groupId: string]: string;
    };
    assignments?: {
        [clientId: string]: string;
    };
}
interface UpdateBreakoutSessionOptions extends BreakoutSessionSettings {
    groups?: {
        [groupId: string]: string;
    };
    assignments?: {
        [clientId: string]: string;
    };
}
declare const doStartBreakoutSession: (args: StartBreakoutSessionOptions) => AppThunk;
declare const doUpdateBreakoutSession: (args: UpdateBreakoutSessionOptions) => AppThunk;
declare const doStopBreakoutSession: (args: void) => AppThunk;
declare const doAssignBreakoutParticipants: (args: {
    assignments: {
        [clientId: string]: string;
    };
}) => AppThunk;
declare const BREAKOUT_GROUPS_MIN_MAX: [number, number];
declare function defaultBreakoutGroupName(groupId: string): string;
declare function createBreakoutGroups(count?: number): {
    [groupId: string]: string;
};
declare const doAssignAllBreakoutParticipants: (args: void) => AppThunk;
declare const doUnassignAllBreakoutParticipants: (args: void) => AppThunk;
declare const doShuffleBreakoutParticipants: (args: void) => AppThunk;
declare const doExtendBreakoutTimer: (args: void | {
    seconds?: number;
}) => AppThunk;
declare const doStopBreakoutTimer: (args: void) => AppThunk;
declare const selectBreakoutRaw: (state: RootState) => BreakoutState;
declare const selectBreakoutError: (state: RootState) => string | null;
declare const selectBreakoutIsAvailable: (state: RootState) => boolean;
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 selectBreakoutEnforceAssignment: (state: RootState) => boolean | undefined;
declare const selectBreakoutTimerSetting: (state: RootState) => boolean | undefined;
declare const selectBreakoutTimerDuration: (state: RootState) => number | undefined;
declare const selectBreakoutAutoMoveToGroup: (state: RootState) => boolean | undefined;
declare const selectBreakoutMoveToGroupGracePeriod: (state: RootState) => number | null | undefined;
declare const selectBreakoutAutoMoveToMain: (state: RootState) => boolean | undefined;
declare const selectBreakoutMoveToMainGracePeriod: (state: RootState) => number | null | undefined;
declare const selectBreakoutStartedAt: (state: RootState) => Date | null | undefined;
declare const selectBreakoutEndTime: ((state: {
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    room: RoomState;
    roomConnection: RoomConnectionState;
    rtcAnalytics: rtcAnalyticsState;
    rtcConnection: RtcConnectionState;
    signalConnection: SignalConnectionState;
    spotlights: SpotlightsState;
    streaming: StreamingState;
    waitingParticipants: WaitingParticipantsState;
}) => number | null) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: BreakoutState) => number | null;
    memoizedResultFunc: ((resultFuncArgs_0: BreakoutState) => number | null) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => number | null;
    dependencies: [(state: RootState) => BreakoutState];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof reselect.weakMapMemoize;
    memoize: typeof reselect.weakMapMemoize;
};
declare const selectBreakoutMoveToGroupAt: ((state: {
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    room: RoomState;
    roomConnection: RoomConnectionState;
    rtcAnalytics: rtcAnalyticsState;
    rtcConnection: RtcConnectionState;
    signalConnection: SignalConnectionState;
    spotlights: SpotlightsState;
    streaming: StreamingState;
    waitingParticipants: WaitingParticipantsState;
}) => number | null) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: BreakoutState) => number | null;
    memoizedResultFunc: ((resultFuncArgs_0: BreakoutState) => number | null) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => number | null;
    dependencies: [(state: RootState) => BreakoutState];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof reselect.weakMapMemoize;
    memoize: typeof reselect.weakMapMemoize;
};
declare const selectBreakoutMoveToMainAt: ((state: {
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    room: RoomState;
    roomConnection: RoomConnectionState;
    rtcAnalytics: rtcAnalyticsState;
    rtcConnection: RtcConnectionState;
    signalConnection: SignalConnectionState;
    spotlights: SpotlightsState;
    streaming: StreamingState;
    waitingParticipants: WaitingParticipantsState;
}) => number | null) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: BreakoutState) => number | null;
    memoizedResultFunc: ((resultFuncArgs_0: BreakoutState) => number | null) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => number | null;
    dependencies: [(state: RootState) => BreakoutState];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof reselect.weakMapMemoize;
    memoize: typeof reselect.weakMapMemoize;
};
declare const selectBreakoutCurrentId: ((state: {
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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: string | null) => string;
    memoizedResultFunc: ((resultFuncArgs_0: string | null) => string) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => string;
    dependencies: [(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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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: string | null) => string;
        memoizedResultFunc: ((resultFuncArgs_0: string | null) => string) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => string;
        dependencies: [(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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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 {
    beforeEffectTracks?: {
        audio?: MediaStreamTrack;
        video?: MediaStreamTrack;
    };
    busyDeviceIds: string[];
    cameraDeviceError?: unknown;
    cameraEnabled: boolean;
    currentCameraDeviceId?: string;
    currentMicrophoneDeviceId?: string;
    currentSpeakerDeviceId?: string;
    devices: MediaDeviceInfo[];
    hdMode: boolean;
    isSettingCameraDevice: boolean;
    isSettingMicrophoneDevice: boolean;
    isSettingSpeakerDevice: boolean;
    isSwitchingStream: boolean;
    isTogglingCamera: boolean;
    lowDataMode: boolean;
    microphoneDeviceError?: unknown;
    microphoneEnabled: boolean;
    onDeviceChange?: () => void;
    options?: LocalMediaOptions;
    speakerDeviceError?: unknown;
    status: "inactive" | "stopped" | "starting" | "started" | "error";
    startError?: unknown;
    stream?: MediaStream;
    widescreenMode: boolean;
}
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;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        currentCameraDeviceId?: string | undefined;
        currentMicrophoneDeviceId?: string | undefined;
        currentSpeakerDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
        widescreenMode: boolean;
    };
    setCurrentCameraDeviceId(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
        deviceId?: string;
    }>): {
        currentCameraDeviceId: string | undefined;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentMicrophoneDeviceId?: string | undefined;
        currentSpeakerDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
        widescreenMode: boolean;
    };
    toggleMicrophoneEnabled(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
        enabled?: boolean;
    }>): {
        microphoneEnabled: boolean;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentCameraDeviceId?: string | undefined;
        currentMicrophoneDeviceId?: string | undefined;
        currentSpeakerDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
        widescreenMode: boolean;
    };
    setCurrentMicrophoneDeviceId(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
        deviceId?: string;
    }>): {
        currentMicrophoneDeviceId: string | undefined;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentCameraDeviceId?: string | undefined;
        currentSpeakerDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
        widescreenMode: boolean;
    };
    setCurrentSpeakerDeviceId(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
        deviceId?: string;
    }>): {
        currentSpeakerDeviceId: string;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentCameraDeviceId?: string | undefined;
        currentMicrophoneDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
        widescreenMode: boolean;
    };
    toggleHdModeEnabled(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
        enabled?: boolean;
    }>): {
        hdMode: boolean;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | 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;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
        widescreenMode: boolean;
    };
    toggleLowDataModeEnabled(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
        enabled?: boolean;
    }>): {
        lowDataMode: boolean;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentCameraDeviceId?: string | undefined;
        currentMicrophoneDeviceId?: string | undefined;
        currentSpeakerDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
        widescreenMode: boolean;
    };
    toggleWidescreenModeEnabled(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
        enabled?: boolean;
    }>): {
        widescreenMode: boolean;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentCameraDeviceId?: string | undefined;
        currentMicrophoneDeviceId?: string | undefined;
        currentSpeakerDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
    };
    setDevices(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
        devices: MediaDeviceInfo[];
    }>): {
        devices: MediaDeviceInfo[];
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentCameraDeviceId?: string | undefined;
        currentMicrophoneDeviceId?: string | undefined;
        currentSpeakerDeviceId?: string | undefined;
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
        widescreenMode: boolean;
    };
    setLocalMediaStream(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
        stream: MediaStream;
    }>): {
        stream: MediaStream;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentCameraDeviceId?: string | undefined;
        currentMicrophoneDeviceId?: string | undefined;
        currentSpeakerDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        widescreenMode: boolean;
    };
    setLocalMediaOptions(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<{
        options: LocalMediaOptions;
    }>): {
        options: LocalMediaOptions;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentCameraDeviceId?: string | undefined;
        currentMicrophoneDeviceId?: string | undefined;
        currentSpeakerDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
        widescreenMode: boolean;
    };
    localMediaStopped(state: immer.WritableDraft<LocalMediaState>): {
        status: "stopped";
        stream: undefined;
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        busyDeviceIds: string[];
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentCameraDeviceId?: string | undefined;
        currentMicrophoneDeviceId?: string | undefined;
        currentSpeakerDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        startError?: unknown;
        widescreenMode: boolean;
    };
    localStreamMetadataUpdated(state: immer.WritableDraft<LocalMediaState>, action: PayloadAction<ReturnType<typeof getDeviceData>>): {
        currentCameraDeviceId: string;
        currentMicrophoneDeviceId: string;
        busyDeviceIds: string[];
        beforeEffectTracks?: immer.WritableDraft<{
            audio?: MediaStreamTrack;
            video?: MediaStreamTrack;
        }> | undefined;
        cameraDeviceError?: unknown;
        cameraEnabled: boolean;
        currentSpeakerDeviceId?: string | undefined;
        devices: immer.WritableDraft<MediaDeviceInfo>[];
        hdMode: boolean;
        isSettingCameraDevice: boolean;
        isSettingMicrophoneDevice: boolean;
        isSettingSpeakerDevice: boolean;
        isSwitchingStream: boolean;
        isTogglingCamera: boolean;
        lowDataMode: boolean;
        microphoneDeviceError?: unknown;
        microphoneEnabled: boolean;
        onDeviceChange?: (() => void) | undefined;
        options?: immer.WritableDraft<LocalMediaOptions> | undefined;
        speakerDeviceError?: unknown;
        status: "inactive" | "stopped" | "starting" | "started" | "error";
        startError?: unknown;
        stream?: immer.WritableDraft<MediaStream> | undefined;
        widescreenMode: boolean;
    };
}, "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 toggleHdModeEnabled: _reduxjs_toolkit.ActionCreatorWithPayload<{
    enabled?: boolean;
}, "localMedia/toggleHdModeEnabled">;
declare const toggleLowDataModeEnabled: _reduxjs_toolkit.ActionCreatorWithPayload<{
    enabled?: boolean;
}, "localMedia/toggleLowDataModeEnabled">;
declare const toggleWidescreenModeEnabled: _reduxjs_toolkit.ActionCreatorWithPayload<{
    enabled?: boolean;
}, "localMedia/toggleWidescreenModeEnabled">;
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 doTriggerLocalStreamRefresh: (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;
    beforeEffectTracks: {
        audio?: MediaStreamTrack;
        video?: MediaStreamTrack;
    } | undefined;
} | undefined, {
    audioId?: string | null;
    videoId?: string | null;
}, ThunkConfig>;
declare const doStartLocalMedia: _reduxjs_toolkit.AsyncThunk<{
    stream: MediaStream;
    onDeviceChange: DebouncedFunction;
} | {
    stream: undefined;
    onDeviceChange: DebouncedFunction;
}, LocalMediaOptions | MediaStream, ThunkConfig>;
declare const doStopLocalMedia: (args: void) => AppThunk;
declare const doLocalStreamEffect: _reduxjs_toolkit.AsyncThunk<{
    effectStream: MediaStream | undefined;
    beforeEffectTracks: {
        audio?: MediaStreamTrack;
        video?: MediaStreamTrack;
    } | undefined;
    replacedTracks: MediaStreamTrack[] | null;
} | undefined, {
    effectStream?: MediaStream;
    only: "audio" | "video";
    stopBeforeTrack?: boolean;
}, ThunkConfig>;
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 selectIsHDModeEnabled: (state: RootState) => boolean;
declare const selectIsLowDataModeEnabled: (state: RootState) => boolean;
declare const selectIsWidescreenModeEnabled: (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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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 selectLocalMediaBeforeEffectTracks: (state: RootState) => {
    audio?: MediaStreamTrack;
    video?: MediaStreamTrack;
} | undefined;
declare const selectLocalMediaConstraintsOptions: ((state: {
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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, resultFuncArgs_4: boolean, resultFuncArgs_5: 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, resultFuncArgs_4: boolean, resultFuncArgs_5: 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, (state: RootState) => boolean, (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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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 RemoteParticipantSliceState {
    remoteParticipants: RemoteParticipant[];
}
declare const remoteParticipantsSliceInitialState: RemoteParticipantSliceState;
declare const remoteParticipantsSlice: _reduxjs_toolkit.Slice<RemoteParticipantSliceState, {
    streamStatusUpdated: (state: immer.WritableDraft<RemoteParticipantSliceState>, action: PayloadAction<StreamStatusUpdate[]>) => immer.WritableDraft<RemoteParticipantSliceState>;
    participantStreamAdded: (state: immer.WritableDraft<RemoteParticipantSliceState>, action: PayloadAction<RtcStreamAddedPayload>) => RemoteParticipantSliceState;
    participantStreamIdAdded: (state: immer.WritableDraft<RemoteParticipantSliceState>, action: PayloadAction<{
        clientId: string;
        streamId: string;
    }>) => RemoteParticipantSliceState;
}, "remoteParticipants", "remoteParticipants", _reduxjs_toolkit.SliceSelectors<RemoteParticipantSliceState>>;
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) => RemoteParticipantSliceState;
declare const selectRemoteClients: (state: RootState) => RemoteParticipant[];
declare const selectRemoteParticipants: ((state: {
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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;
    mode: RoomMode | null;
}
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 selectRoomMode: (state: RootState) => RoomMode | null;
declare const selectScreenshares: ((state: {
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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: string | null) => string;
        memoizedResultFunc: ((resultFuncArgs_0: string | null) => string) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => string;
        dependencies: [(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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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;
            audioDenoiser: AudioDenoiserState;
            authorization: AuthorizationState;
            breakout: BreakoutState;
            cameraEffects: CameraEffectsState;
            chat: ChatState;
            cloudRecording: CloudRecordingState;
            connectionMonitor: ConnectionMonitorState;
            deviceCredentials: DeviceCredentialsState;
            fileShare: FileShareState;
            liveCaptions: LiveCaptionsState;
            liveTranscription: LiveTranscriptionState;
            localMedia: LocalMediaState;
            localParticipant: LocalParticipantState;
            localScreenshare: LocalScreenshareState;
            notifications: NotificationsState;
            organization: OrganizationState;
            remoteParticipants: RemoteParticipantSliceState;
            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;
            audioDenoiser: AudioDenoiserState;
            authorization: AuthorizationState;
            breakout: BreakoutState;
            cameraEffects: CameraEffectsState;
            chat: ChatState;
            cloudRecording: CloudRecordingState;
            connectionMonitor: ConnectionMonitorState;
            deviceCredentials: DeviceCredentialsState;
            fileShare: FileShareState;
            liveCaptions: LiveCaptionsState;
            liveTranscription: LiveTranscriptionState;
            localMedia: LocalMediaState;
            localParticipant: LocalParticipantState;
            localScreenshare: LocalScreenshareState;
            notifications: NotificationsState;
            organization: OrganizationState;
            remoteParticipants: RemoteParticipantSliceState;
            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: string | null) => string;
            memoizedResultFunc: ((resultFuncArgs_0: string | null) => string) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => string;
            dependencies: [(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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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;
            audioDenoiser: AudioDenoiserState;
            authorization: AuthorizationState;
            breakout: BreakoutState;
            cameraEffects: CameraEffectsState;
            chat: ChatState;
            cloudRecording: CloudRecordingState;
            connectionMonitor: ConnectionMonitorState;
            deviceCredentials: DeviceCredentialsState;
            fileShare: FileShareState;
            liveCaptions: LiveCaptionsState;
            liveTranscription: LiveTranscriptionState;
            localMedia: LocalMediaState;
            localParticipant: LocalParticipantState;
            localScreenshare: LocalScreenshareState;
            notifications: NotificationsState;
            organization: OrganizationState;
            remoteParticipants: RemoteParticipantSliceState;
            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;
            audioDenoiser: AudioDenoiserState;
            authorization: AuthorizationState;
            breakout: BreakoutState;
            cameraEffects: CameraEffectsState;
            chat: ChatState;
            cloudRecording: CloudRecordingState;
            connectionMonitor: ConnectionMonitorState;
            deviceCredentials: DeviceCredentialsState;
            fileShare: FileShareState;
            liveCaptions: LiveCaptionsState;
            liveTranscription: LiveTranscriptionState;
            localMedia: LocalMediaState;
            localParticipant: LocalParticipantState;
            localScreenshare: LocalScreenshareState;
            notifications: NotificationsState;
            organization: OrganizationState;
            remoteParticipants: RemoteParticipantSliceState;
            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;
                audioDenoiser: AudioDenoiserState;
                authorization: AuthorizationState;
                breakout: BreakoutState;
                cameraEffects: CameraEffectsState;
                chat: ChatState;
                cloudRecording: CloudRecordingState;
                connectionMonitor: ConnectionMonitorState;
                deviceCredentials: DeviceCredentialsState;
                fileShare: FileShareState;
                liveCaptions: LiveCaptionsState;
                liveTranscription: LiveTranscriptionState;
                localMedia: LocalMediaState;
                localParticipant: LocalParticipantState;
                localScreenshare: LocalScreenshareState;
                notifications: NotificationsState;
                organization: OrganizationState;
                remoteParticipants: RemoteParticipantSliceState;
                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;
                audioDenoiser: AudioDenoiserState;
                authorization: AuthorizationState;
                breakout: BreakoutState;
                cameraEffects: CameraEffectsState;
                chat: ChatState;
                cloudRecording: CloudRecordingState;
                connectionMonitor: ConnectionMonitorState;
                deviceCredentials: DeviceCredentialsState;
                fileShare: FileShareState;
                liveCaptions: LiveCaptionsState;
                liveTranscription: LiveTranscriptionState;
                localMedia: LocalMediaState;
                localParticipant: LocalParticipantState;
                localScreenshare: LocalScreenshareState;
                notifications: NotificationsState;
                organization: OrganizationState;
                remoteParticipants: RemoteParticipantSliceState;
                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: string | null) => string;
                memoizedResultFunc: ((resultFuncArgs_0: string | null) => string) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => string;
                dependencies: [(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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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: string | null) => string;
        memoizedResultFunc: ((resultFuncArgs_0: string | null) => string) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => string;
        dependencies: [(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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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;
            audioDenoiser: AudioDenoiserState;
            authorization: AuthorizationState;
            breakout: BreakoutState;
            cameraEffects: CameraEffectsState;
            chat: ChatState;
            cloudRecording: CloudRecordingState;
            connectionMonitor: ConnectionMonitorState;
            deviceCredentials: DeviceCredentialsState;
            fileShare: FileShareState;
            liveCaptions: LiveCaptionsState;
            liveTranscription: LiveTranscriptionState;
            localMedia: LocalMediaState;
            localParticipant: LocalParticipantState;
            localScreenshare: LocalScreenshareState;
            notifications: NotificationsState;
            organization: OrganizationState;
            remoteParticipants: RemoteParticipantSliceState;
            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;
            audioDenoiser: AudioDenoiserState;
            authorization: AuthorizationState;
            breakout: BreakoutState;
            cameraEffects: CameraEffectsState;
            chat: ChatState;
            cloudRecording: CloudRecordingState;
            connectionMonitor: ConnectionMonitorState;
            deviceCredentials: DeviceCredentialsState;
            fileShare: FileShareState;
            liveCaptions: LiveCaptionsState;
            liveTranscription: LiveTranscriptionState;
            localMedia: LocalMediaState;
            localParticipant: LocalParticipantState;
            localScreenshare: LocalScreenshareState;
            notifications: NotificationsState;
            organization: OrganizationState;
            remoteParticipants: RemoteParticipantSliceState;
            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;
                audioDenoiser: AudioDenoiserState;
                authorization: AuthorizationState;
                breakout: BreakoutState;
                cameraEffects: CameraEffectsState;
                chat: ChatState;
                cloudRecording: CloudRecordingState;
                connectionMonitor: ConnectionMonitorState;
                deviceCredentials: DeviceCredentialsState;
                fileShare: FileShareState;
                liveCaptions: LiveCaptionsState;
                liveTranscription: LiveTranscriptionState;
                localMedia: LocalMediaState;
                localParticipant: LocalParticipantState;
                localScreenshare: LocalScreenshareState;
                notifications: NotificationsState;
                organization: OrganizationState;
                remoteParticipants: RemoteParticipantSliceState;
                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;
                audioDenoiser: AudioDenoiserState;
                authorization: AuthorizationState;
                breakout: BreakoutState;
                cameraEffects: CameraEffectsState;
                chat: ChatState;
                cloudRecording: CloudRecordingState;
                connectionMonitor: ConnectionMonitorState;
                deviceCredentials: DeviceCredentialsState;
                fileShare: FileShareState;
                liveCaptions: LiveCaptionsState;
                liveTranscription: LiveTranscriptionState;
                localMedia: LocalMediaState;
                localParticipant: LocalParticipantState;
                localScreenshare: LocalScreenshareState;
                notifications: NotificationsState;
                organization: OrganizationState;
                remoteParticipants: RemoteParticipantSliceState;
                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: string | null) => string;
                memoizedResultFunc: ((resultFuncArgs_0: string | null) => string) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => string;
                dependencies: [(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_on_hold" | "knock_rejected" | "kicked" | "leaving" | "left" | "disconnected" | "reconnecting";
interface RoomConnectionState {
    session: {
        createdAt: string;
        id: string;
    } | null;
    status: ConnectionStatus;
    error: string | null;
    knockResponse: KnockResponse | 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;
        knockResponse: immer.WritableDraft<KnockResponse> | null;
    };
    knockResponseReceived: (state: immer.WritableDraft<RoomConnectionState>, action: PayloadAction<KnockResponse | null>) => {
        knockResponse: KnockResponse | null;
        session: immer.WritableDraft<{
            createdAt: string;
            id: string;
        }> | null;
        status: ConnectionStatus;
        error: string | null;
    };
}, "roomConnection", "roomConnection", _reduxjs_toolkit.SliceSelectors<RoomConnectionState>>;
declare const doKnockRoom: (args: void) => AppThunk;
declare const doCancelKnock: (args: void) => AppThunk;
declare const doConnectRoom: (args: void) => AppThunk;
declare const selectShouldConnectRoom: ((state: {
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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: string | null) => string;
        memoizedResultFunc: ((resultFuncArgs_0: string | null) => string) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => string;
        dependencies: [(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>;
    breakoutEnding: _reduxjs_toolkit.ActionCreatorWithoutPayload<string>;
    breakoutTimerEnded: _reduxjs_toolkit.ActionCreatorWithoutPayload<string>;
    breakoutTimerExtended: _reduxjs_toolkit.ActionCreatorWithoutPayload<string>;
    chatMessage: _reduxjs_toolkit.ActionCreatorWithPayload<ChatMessage$1, string>;
    chatMessageRemoved: _reduxjs_toolkit.ActionCreatorWithPayload<ChatMessageRemoved, string>;
    fileSharingError: _reduxjs_toolkit.ActionCreatorWithPayload<ChatMessageError, 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 | KnockOnHoldEvent | 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>;
    liveCaptionsStarted: _reduxjs_toolkit.ActionCreatorWithPayload<LiveCaptionsStartedEvent, string>;
    liveCaptionsStopped: _reduxjs_toolkit.ActionCreatorWithPayload<LiveCaptionsStoppedEvent, string>;
    liveCaption: _reduxjs_toolkit.ActionCreatorWithPayload<LiveCaptionEvent, 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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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;
            audioDenoiser: AudioDenoiserState;
            authorization: AuthorizationState;
            breakout: BreakoutState;
            cameraEffects: CameraEffectsState;
            chat: ChatState;
            cloudRecording: CloudRecordingState;
            connectionMonitor: ConnectionMonitorState;
            deviceCredentials: DeviceCredentialsState;
            fileShare: FileShareState;
            liveCaptions: LiveCaptionsState;
            liveTranscription: LiveTranscriptionState;
            localMedia: LocalMediaState;
            localParticipant: LocalParticipantState;
            localScreenshare: LocalScreenshareState;
            notifications: NotificationsState;
            organization: OrganizationState;
            remoteParticipants: RemoteParticipantSliceState;
            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;
            audioDenoiser: AudioDenoiserState;
            authorization: AuthorizationState;
            breakout: BreakoutState;
            cameraEffects: CameraEffectsState;
            chat: ChatState;
            cloudRecording: CloudRecordingState;
            connectionMonitor: ConnectionMonitorState;
            deviceCredentials: DeviceCredentialsState;
            fileShare: FileShareState;
            liveCaptions: LiveCaptionsState;
            liveTranscription: LiveTranscriptionState;
            localMedia: LocalMediaState;
            localParticipant: LocalParticipantState;
            localScreenshare: LocalScreenshareState;
            notifications: NotificationsState;
            organization: OrganizationState;
            remoteParticipants: RemoteParticipantSliceState;
            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;
                audioDenoiser: AudioDenoiserState;
                authorization: AuthorizationState;
                breakout: BreakoutState;
                cameraEffects: CameraEffectsState;
                chat: ChatState;
                cloudRecording: CloudRecordingState;
                connectionMonitor: ConnectionMonitorState;
                deviceCredentials: DeviceCredentialsState;
                fileShare: FileShareState;
                liveCaptions: LiveCaptionsState;
                liveTranscription: LiveTranscriptionState;
                localMedia: LocalMediaState;
                localParticipant: LocalParticipantState;
                localScreenshare: LocalScreenshareState;
                notifications: NotificationsState;
                organization: OrganizationState;
                remoteParticipants: RemoteParticipantSliceState;
                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;
                audioDenoiser: AudioDenoiserState;
                authorization: AuthorizationState;
                breakout: BreakoutState;
                cameraEffects: CameraEffectsState;
                chat: ChatState;
                cloudRecording: CloudRecordingState;
                connectionMonitor: ConnectionMonitorState;
                deviceCredentials: DeviceCredentialsState;
                fileShare: FileShareState;
                liveCaptions: LiveCaptionsState;
                liveTranscription: LiveTranscriptionState;
                localMedia: LocalMediaState;
                localParticipant: LocalParticipantState;
                localScreenshare: LocalScreenshareState;
                notifications: NotificationsState;
                organization: OrganizationState;
                remoteParticipants: RemoteParticipantSliceState;
                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: string | null) => string;
                memoizedResultFunc: ((resultFuncArgs_0: string | null) => string) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => string;
                dependencies: [(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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    room: RoomState;
    roomConnection: RoomConnectionState;
    rtcAnalytics: rtcAnalyticsState;
    rtcConnection: RtcConnectionState;
    signalConnection: SignalConnectionState;
    spotlights: SpotlightsState;
    streaming: StreamingState;
    waitingParticipants: WaitingParticipantsState;
}, redux.UnknownAction, Partial<{
    app: AppState | undefined;
    audioDenoiser: AudioDenoiserState | undefined;
    authorization: AuthorizationState | undefined;
    breakout: BreakoutState | undefined;
    cameraEffects: CameraEffectsState | undefined;
    chat: ChatState | undefined;
    cloudRecording: CloudRecordingState | undefined;
    connectionMonitor: ConnectionMonitorState | undefined;
    deviceCredentials: DeviceCredentialsState | undefined;
    fileShare: FileShareState | undefined;
    liveCaptions: LiveCaptionsState | undefined;
    liveTranscription: LiveTranscriptionState | undefined;
    localMedia: LocalMediaState | undefined;
    localParticipant: LocalParticipantState | undefined;
    localScreenshare: LocalScreenshareState | undefined;
    notifications: NotificationsState | undefined;
    organization: OrganizationState | undefined;
    remoteParticipants: RemoteParticipantSliceState | 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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState;
        liveTranscription: LiveTranscriptionState;
        localMedia: LocalMediaState;
        localParticipant: LocalParticipantState;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        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;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState;
    liveTranscription: LiveTranscriptionState;
    localMedia: LocalMediaState;
    localParticipant: LocalParticipantState;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    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;
declare const selectRoomConnectionKnockResponse: (state: RootState) => _whereby_com_media.KnockResponse | null;

export { ACCEPTED_FILE_TYPES, BREAKOUT_GROUPS_MIN_MAX, BREAKOUT_UNAVAILABLE_ERROR, DEFAULT_BREAKOUT_TIMER_DURATION, MAX_FILES_PER_UPLOAD, MAX_FILE_SIZE, addAppListener, addSpotlight, appSlice, authorizationSlice, authorizationSliceInitialState, breakoutSlice, breakoutSliceInitialState, captioningRequestStarted, chatSlice, chatSliceInitialState, clearCaption, clearFileUploads, cloudRecordingSlice, connectionMonitorSlice, connectionMonitorSliceInitialState, connectionMonitorStarted, connectionMonitorStopped, createAppAsyncThunk, createAppAuthorizedThunk, createAppThunk, createAsyncRoomConnectedThunk, createAuthorizedRoomConnectedThunk, createBreakoutGroups, createNotificationEvent, createReactor, createRemoteParticipant, createRoomConnectedThunk, createServices, createStore, createWebRtcEmitter, defaultBreakoutGroupName, deviceBusy, deviceCredentialsSlice, deviceCredentialsSliceInitialState, deviceIdentified, deviceIdentifying, doAcceptWaitingParticipant, doAppStart, doAppStop, doAssignAllBreakoutParticipants, doAssignBreakoutParticipants, doBreakoutJoin, doCancelKnock, doClearNotifications, doConnectRoom, doConnectRtc, doDisconnectRtc, doDownloadFile, doEnableAudio, doEnableVideo, doEndMeeting, doExtendBreakoutTimer, doGetDeviceCredentials, doHandleAcceptStreams, doHandleStreamingStarted, doHandleStreamingStopped, doHoldWaitingParticipant, doKickParticipant, doKnockRoom, doLocalStreamEffect, doLockRoom, doOrganizationFetch, doRejectWaitingParticipant, doRemoveChatMessage, doRemoveSpotlight, doRequestAudioEnable, doRequestVideoEnable, doRtcAnalyticsCustomEventsInitialize, doRtcManagerCreated, doRtcManagerInitialize, doRtcReportStreamResolution, doSendChatMessage, doSendClientMetadata, doSendFiles, doSetDevice, doSetDisplayName, doSetLocalStickyReaction, doSetNotification, doShuffleBreakoutParticipants, doSignalConnect, doSignalDisconnect, doSignalIdentifyDevice, doSpotlightParticipant, doStartBreakoutSession, doStartCloudRecording, doStartConnectionMonitor, doStartLiveCaptions, doStartLiveTranscription, doStartLocalMedia, doStartScreenshare, doStopBreakoutSession, doStopBreakoutTimer, doStopCloudRecording, doStopConnectionMonitor, doStopLiveCaptions, doStopLiveTranscription, doStopLocalMedia, doStopScreenshare, doSwitchLocalStream, doToggleCamera, doTriggerLocalStreamRefresh, doUnassignAllBreakoutParticipants, doUpdateBreakoutSession, doUpdateDeviceList, fileShareRequestSettled, fileShareSlice, fileShareSliceInitialState, fileUploadFailed, fileUploadSucceeded, fileUploadsStarted, initialCloudRecordingState, initialLiveCaptionsState, initialLiveTranscriptionState, initialLocalMediaState, initialNotificationsState, initialState, isAcceptingStreams, isClientSpotlighted, listenerMiddleware, liveCaptionsSlice, liveTranscriptionSlice, 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, selectAppIsAssistant, selectAppIsAudioRecorder, selectAppIsDialIn, selectAppIsNodeSdk, selectAppRaw, selectAppRoomName, selectAppRoomUrl, selectAppUserAgent, selectAssistantKey, selectAuthorizationRoleName, selectBreakoutActive, selectBreakoutAssignments, selectBreakoutAutoMoveToGroup, selectBreakoutAutoMoveToMain, selectBreakoutCurrentGroup, selectBreakoutCurrentId, selectBreakoutEndTime, selectBreakoutEnforceAssignment, selectBreakoutError, selectBreakoutGroupedParticipants, selectBreakoutGroups, selectBreakoutInitiatedBy, selectBreakoutIsAvailable, selectBreakoutMoveToGroupAt, selectBreakoutMoveToGroupGracePeriod, selectBreakoutMoveToMainAt, selectBreakoutMoveToMainGracePeriod, selectBreakoutRaw, selectBreakoutStartedAt, selectBreakoutTimerDuration, selectBreakoutTimerSetting, selectBusyDeviceIds, selectCameraDeviceError, selectCameraDevices, selectChatMessages, selectChatRaw, selectCloudRecordingError, selectCloudRecordingIsInitiator, selectCloudRecordingRaw, selectCloudRecordingStartedAt, selectCloudRecordingStatus, selectConnectionMonitorIsRunning, selectCurrentCameraDeviceId, selectCurrentMicrophoneDeviceId, selectCurrentSpeakerDeviceId, selectDeviceCredentialsRaw, selectDeviceId, selectFileShareRaw, selectFileShareRequestInFlight, selectFileUploads, selectHasFetchedDeviceCredentials, selectIsAcceptingStreams, selectIsAuthorizedToAskToSpeak, selectIsAuthorizedToEndMeeting, selectIsAuthorizedToKickClient, selectIsAuthorizedToLockRoom, selectIsAuthorizedToManageBreakout, selectIsAuthorizedToRequestAudioEnable, selectIsAuthorizedToRequestVideoEnable, selectIsAuthorizedToSpotlight, selectIsCameraEnabled, selectIsCloudRecording, selectIsHDModeEnabled, selectIsLiveCaptions, selectIsLiveTranscription, selectIsLocalMediaStarting, selectIsLocalParticipantSpotlighted, selectIsLowDataModeEnabled, selectIsMicrophoneEnabled, selectIsSettingCameraDevice, selectIsSettingMicrophoneDevice, selectIsToggleCamera, selectIsWidescreenModeEnabled, selectLiveCaptionsError, selectLiveCaptionsLog, selectLiveCaptionsRaw, selectLiveCaptionsStartedAt, selectLiveCaptionsStatus, selectLiveTranscriptionError, selectLiveTranscriptionIsInitiator, selectLiveTranscriptionRaw, selectLiveTranscriptionStartedAt, selectLiveTranscriptionStatus, selectLocalMediaBeforeEffectTracks, 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, selectRoomConnectionKnockResponse, selectRoomConnectionRaw, selectRoomConnectionSession, selectRoomConnectionSessionId, selectRoomConnectionStatus, selectRoomIsLocked, selectRoomKey, selectRoomMode, 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, setBreakoutError, setBreakoutGroupAssigned, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, setCurrentSpeakerDeviceId, setDisplayName, setLocalMediaOptions, setLocalMediaStream, setRoomKey, signalConnectionSlice, signalConnectionSliceInitialState, signalEvents, socketConnected, socketConnecting, socketDisconnected, socketReconnecting, spotlightsSlice, spotlightsSliceInitialState, startAppListening, stopScreenshare, streamIdForClient, streamStatusUpdated, streamingSlice, streamingSliceInitialState, toggleCameraEnabled, toggleHdModeEnabled, toggleLowDataModeEnabled, toggleMicrophoneEnabled, toggleWidescreenModeEnabled, transcribingRequestStarted, updateReportedValues, waitingParticipantsSlice, waitingParticipantsSliceInitialState };
export type { AppConfig, AppDispatch, AppReducer, AppStartListening, AppState, AppThunk, AuthorizationState, BreakoutGroupAssignedEvent, BreakoutGroupAssignedEventProps, BreakoutSessionSettings, BreakoutState, BreakoutTimerEvent, BreakoutTimerEventProps, ChatMessage, ChatMessageEvent, ChatMessageEventProps, ChatState, ClientView, CloudRecordingState, ConnectionMonitorStart, ConnectionMonitorState, ConnectionStatus, DeviceCredentialsState, FileShareError, FileShareState, FileUpload, LiveCaptionsState, LiveTranscriptionState, LocalMediaOptions, LocalMediaState, LocalParticipantState, LocalScreenshareState, Notification, NotificationEvent, NotificationEventMap, NotificationEvents, NotificationsEventEmitter, NotificationsState, OrganizationState, RemoteParticipantSliceState, RequestAudioEvent, RequestAudioEventProps, RequestVideoEvent, RequestVideoEventProps, RoomConnectionState, RoomState, RootState, RtcConnectionState, SendFilesOptions, SignalClientEvent, SignalClientEventProps, SignalConnectionState, SignalStatusEvent, SignalStatusEventProps, SpotlightsState, StartBreakoutSessionOptions, StickyReactionEvent, StickyReactionEventProps, Store, StreamingState, ThunkConfig, UpdateBreakoutSessionOptions, WaitingParticipantsState, rtcAnalyticsState };