@whereby.com/browser-sdk 2.1.0-beta1 → 2.1.0-beta3

package/dist/core/index.d.ts

@@ -0,0 +1,2356 @@
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import { PayloadAction, AsyncThunkPayloadCreator, AsyncThunk, 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 reselect from 'reselect';
+import * as _whereby_jslib_media_src_utils_ServerSocket from '@whereby/jslib-media/src/utils/ServerSocket';
+import _whereby_jslib_media_src_utils_ServerSocket__default, { ChatMessage as ChatMessage$1 } from '@whereby/jslib-media/src/utils/ServerSocket';
+import RtcManagerDispatcher, { RtcStreamAddedPayload, RtcEvents, RtcManagerCreatedPayload } from '@whereby/jslib-media/src/webrtc/RtcManagerDispatcher';
+import RtcManager from '@whereby/jslib-media/src/webrtc/RtcManager';
+import * as _reduxjs_toolkit_dist_listenerMiddleware_types from '@reduxjs/toolkit/dist/listenerMiddleware/types';
+
+type Json = string | number | boolean | null | Array<Json> | {
+    [key: string]: Json;
+};
+interface ResponseOptions {
+    data?: Json;
+    headers?: Record<string, unknown>;
+    status?: number;
+    statusText?: string;
+    url?: string | null;
+}
+declare class Response {
+    data: Json;
+    headers: Record<string, unknown>;
+    status: number;
+    statusText: string;
+    url: string | null;
+    constructor(initialValues?: ResponseOptions);
+}
+
+declare class EmbeddedFreeTierStatus {
+    isExhausted: boolean;
+    renewsAt: Date;
+    totalMinutesLimit: number;
+    totalMinutesUsed: number;
+    constructor({ isExhausted, renewsAt, totalMinutesLimit, totalMinutesUsed, }: {
+        isExhausted: boolean;
+        renewsAt: Date;
+        totalMinutesLimit: number;
+        totalMinutesUsed: number;
+    });
+    static fromJson(data: Record<string, unknown>): EmbeddedFreeTierStatus;
+}
+
+interface AccountProps {
+    basePlanId: string | null;
+    isDeactivated: boolean;
+    isOnTrial: boolean;
+    onTrialUntil: Date | null;
+    trialStatus: string | null;
+    embeddedFreeTierStatus: EmbeddedFreeTierStatus | null;
+}
+declare class Account {
+    basePlanId: string | null;
+    embeddedFreeTierStatus: EmbeddedFreeTierStatus | null;
+    isDeactivated: boolean;
+    isOnTrial: boolean;
+    onTrialUntil: Date | null;
+    trialStatus: string | null;
+    constructor({ basePlanId, embeddedFreeTierStatus, isDeactivated, isOnTrial, onTrialUntil, trialStatus, }: AccountProps);
+    static fromJson(data: Record<string, unknown>): Account;
+}
+
+interface OrganizationPermissionAction {
+    isAllowed: boolean;
+    isSupported: boolean;
+}
+interface FullOrganizationPermissions {
+    images: {
+        logoImageUrl: {
+            set: OrganizationPermissionAction;
+            reset: OrganizationPermissionAction;
+        };
+        roomBackgroundImageUrl: {
+            set: OrganizationPermissionAction;
+            reset: OrganizationPermissionAction;
+        };
+        roomKnockPageBackgroundImageUrl: {
+            set: OrganizationPermissionAction;
+            reset: OrganizationPermissionAction;
+        };
+    };
+    invitations: {
+        add: OrganizationPermissionAction;
+        delete: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+    };
+    roles: {
+        set: OrganizationPermissionAction;
+        remove: OrganizationPermissionAction;
+        removeSelf: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+    };
+    users: {
+        signUpWithoutInvitation: OrganizationPermissionAction;
+    };
+    rooms: {
+        customize: OrganizationPermissionAction;
+        customizeSelf: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+        lock: OrganizationPermissionAction;
+        unclaim: OrganizationPermissionAction;
+        unclaimSelf: OrganizationPermissionAction;
+    };
+    subscriptions: {
+        add: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+        payLatestInvoice: OrganizationPermissionAction;
+        updatePlan: OrganizationPermissionAction;
+    };
+    browserExtension: {
+        install: OrganizationPermissionAction;
+    };
+}
+type OrganizationPermissions = Partial<FullOrganizationPermissions>;
+interface OrganizationLimits {
+    maxNumberOfInvitationsAndUsers: number | null;
+    maxNumberOfClaimedRooms: number | null;
+    maxRoomLimitPerOrganization: number | null;
+    trialMinutesLimit: number | null;
+    includedUnits: number | null;
+}
+interface OrganizationOnboardingSurvey {
+    name: string;
+    value: unknown;
+}
+type OrganizationPreferences = Record<string, boolean | string | null | number>;
+declare class Organization {
+    static GLOBAL_ORGANIZATION_ID: string;
+    organizationId: string;
+    organizationName: string;
+    subdomain: string;
+    permissions: OrganizationPermissions;
+    limits: OrganizationLimits;
+    account: Account | null;
+    logoImageUrl: string | null;
+    roomBackgroundImageUrl: string | null;
+    roomBackgroundThumbnailUrl: string | null;
+    roomKnockPageBackgroundImageUrl: string | null;
+    roomKnockPageBackgroundThumbnailUrl: string | null;
+    preferences: OrganizationPreferences | null;
+    onboardingSurvey: OrganizationOnboardingSurvey | null;
+    type: string | null;
+    constructor(properties: {
+        account: Account | null;
+        organizationId: string;
+        organizationName: string;
+        subdomain: string;
+        permissions: OrganizationPermissions;
+        limits: OrganizationLimits;
+        logoImageUrl: string | null;
+        roomBackgroundImageUrl: string | null;
+        roomBackgroundThumbnailUrl: string | null;
+        roomKnockPageBackgroundImageUrl: string | null;
+        roomKnockPageBackgroundThumbnailUrl: string | null;
+        preferences: OrganizationPreferences | null;
+        onboardingSurvey: OrganizationOnboardingSurvey | null;
+        type: string | null;
+    });
+    static fromJson(data: Json): Organization;
+}
+
+type HttpClientRequestConfig = AxiosRequestConfig | {
+    [key: string]: unknown;
+};
+interface IHttpClient {
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+/**
+ * Class used for making http calls. This is just a pure
+ * wrapper around the http lib that we decide to use,
+ * so that we can switch implementations.
+ */
+declare class HttpClient implements IHttpClient {
+    _baseUrl: string;
+    /**
+     * Creates an HttpClient instance.
+     *
+     * @param {string} [baseUrl] - The base URL where all requests are made.
+     */
+    constructor({ baseUrl }: {
+        baseUrl: string;
+    });
+    private _requestAxios;
+    /**
+     * Wrapper for the axios API
+     *
+     * @param {string} url - Required. URL (appended to base URL) where API call will be made
+     * @param {object} options - Required. Contains the data needed for the fetch API
+     * @return {Promise<Response>} - A promise which will return a Response object (https://developer.mozilla.org/en-US/docs/Web/API/Response)
+     */
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+
+/**
+ * ApiClient for doing multipart/form-data requests.
+ */
+declare class MultipartHttpClient implements IHttpClient {
+    _httpClient: IHttpClient;
+    constructor({ httpClient }: {
+        httpClient: IHttpClient;
+    });
+    /**
+     * Convert the provided object to a FormData object containing the same keys and values.
+     * @param {object} data - the data to convert.
+     * @returns {FormData}
+     */
+    static dataToFormData(data: Record<string, string>): FormData;
+    /**
+     * Request a resource using multipart/form-data encoding.
+     *
+     * @param {string} url - the url to request
+     * @param {object} options - Required. Contains the data needed for the fetch API
+     * @return {Promise<Response>} - A promise which will return a Response object (https://developer.mozilla.org/en-US/docs/Web/API/Response)
+     */
+    request(url: string, options?: HttpClientRequestConfig): Promise<Response>;
+}
+
+interface CredentialsOptions {
+    uuid: string;
+    hmac: string;
+    userId?: string;
+}
+declare class Credentials {
+    credentials: {
+        uuid: CredentialsOptions["uuid"];
+    };
+    hmac: CredentialsOptions["hmac"];
+    userId: CredentialsOptions["userId"];
+    constructor(uuid: CredentialsOptions["uuid"], hmac: CredentialsOptions["hmac"], userId?: CredentialsOptions["userId"]);
+    toJson(): Json;
+    static fromJson(json: Json): Credentials;
+}
+
+interface AuthenticatedHttpClientOptions {
+    httpClient: HttpClient;
+    fetchDeviceCredentials: () => Promise<Credentials | null>;
+}
+declare class AuthenticatedHttpClient {
+    private _httpClient;
+    private _fetchDeviceCredentials;
+    constructor({ httpClient, fetchDeviceCredentials }: AuthenticatedHttpClientOptions);
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+interface ApiClientOptions {
+    baseUrl?: string;
+    fetchDeviceCredentials?: AuthenticatedHttpClientOptions["fetchDeviceCredentials"];
+}
+/**
+ * Class used for all Whereby API calls.
+ */
+declare class ApiClient {
+    authenticatedHttpClient: AuthenticatedHttpClient;
+    authenticatedFormDataHttpClient: MultipartHttpClient;
+    /**
+     * Create an ApiClient instance.
+     */
+    constructor({ baseUrl, fetchDeviceCredentials, }?: ApiClientOptions);
+    /**
+     * Wrapper for the fetch API
+     */
+    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
+    /**
+     * Performs a multipart request where data is multipart/form-data encoded.
+     */
+    requestMultipart(url: string, options: HttpClientRequestConfig): Promise<Response>;
+}
+
+/**
+ * Related to device calls needed to obtain credentials
+ */
+declare class DeviceService {
+    _apiClient: ApiClient;
+    constructor({ apiClient }: {
+        apiClient: ApiClient;
+    });
+    /**
+     * Get's the device credentials needed for most of the other API services
+     *
+     * @return {Promise} A promise which is fulfilled or failed based on the
+     * response.
+     */
+    getCredentials(): Promise<Credentials | null>;
+}
+
+interface AbstractStore {
+    loadOrDefault(defaultValue: Json): Promise<Json>;
+    save(value: Json): Promise<void>;
+}
+
+declare class CredentialsService extends EventEmitter {
+    _deviceService: DeviceService;
+    _credentialsStore: AbstractStore;
+    credentialsPromise?: Promise<Credentials | null>;
+    /**
+     * Service to manage Whereby's Rest API credentials.
+     *
+     * @param {ObjectStore} credentialsStore - Store to manage the credentials.
+     */
+    constructor({ deviceService, credentialsStore, }: {
+        deviceService: DeviceService;
+        credentialsStore: AbstractStore;
+    });
+    static create({ baseUrl, storeName, storeType, }: {
+        baseUrl: string;
+        storeName?: string;
+        storeType?: "localStorage" | "chromeStorage";
+    }): CredentialsService;
+    /**
+     * Contacts the REST API to get new credentials. DO NOT USE directly, call getCredentials() instead.
+     *
+     * @see getCredentials
+     * @returns {Promise.<Credentials>} - Promise that resolves with the credentials.
+     */
+    _fetchNewCredentialsFromApi(): Promise<Credentials | null>;
+    /**
+     * Returns the current credentials without triggering an API request to get new ones.
+     * If no credentials are currently available it will return null.
+     *
+     * @returns {?Credentials} - The credentials currently in use, null otherwise.
+     */
+    getCurrentCredentials(): Promise<Credentials | null>;
+    /**
+     * Returns a promise that will contain the credentials for this client.
+     * If no credentials are available in local storage, new ones will be fetched from the server.
+     *
+     * @returns {Promise.<Credentials>} - Promise that resolves with the credentials.
+     */
+    getCredentials(): Promise<Credentials | null>;
+    /**
+     * Saves new credentials which replace the existing ones and abort any pending request to get new ones.
+     *
+     * @param {Credentials} credentials - New credentials to store.
+     */
+    saveCredentials(credentials: Credentials): Promise<Credentials>;
+    /**
+     * It will set the userId for the current credentials.
+     *
+     * @param userId - The user id to set.
+     */
+    setUserId(userId: string | null): Promise<void>;
+}
+
+type UserConsentAction = "accepted" | "rejected" | null;
+type ConsentGrantRequest = {
+    readonly consentRevisionId: string;
+    readonly action: UserConsentAction;
+};
+
+declare class OrganizationService {
+    _apiClient: ApiClient;
+    constructor({ apiClient }: {
+        apiClient: ApiClient;
+    });
+    /**
+     * Creates an organization.
+     */
+    createOrganization({ organizationName, subdomain, owner, }: {
+        organizationName: string;
+        subdomain: string;
+        owner: {
+            email: string;
+            displayName: string;
+            verificationCode: string;
+            consents?: ReadonlyArray<ConsentGrantRequest>;
+        } | {
+            idToken: string;
+            displayName: string;
+            consents?: ReadonlyArray<ConsentGrantRequest>;
+        };
+    }): Promise<string>;
+    /**
+     * Retrieves the organization based on the subdomain.
+     */
+    getOrganizationBySubdomain(subdomain: string): Promise<Organization | null>;
+    /**
+     * Retrieves the organization based on the organizationId.
+     *
+     * Note: This endpoint should only be used to retrieve an organization when the device is linked
+     * to a user in that organization. Use getOrganizationBySubdomain instead if you just want the information
+     * about an organization that is mapped to a given subdomain.
+     */
+    getOrganizationByOrganizationId(organizationId: string): Promise<Organization | null>;
+    /**
+     * Retrieves the organizations that contain a user
+     * matching provided the email+code or phoneNumber+code
+     * combination.
+     */
+    getOrganizationsByContactPoint(options: {
+        email: string;
+        code: string;
+    } | {
+        phoneNumber: string;
+        code: string;
+    }): Promise<ReadonlyArray<Organization>>;
+    /**
+     * Retrieves the organizations that contain a user
+     * matching provided the idToken
+     */
+    getOrganizationsByIdToken({ idToken }: {
+        idToken: string;
+    }): Promise<ReadonlyArray<Organization>>;
+    /**
+     * Retrieves the organizations containing a user
+     * with either the email or phoneNumber matching the logged in user.
+     *
+     * This is useful for showing the possible organization that the current
+     * user could log in to.
+     */
+    getOrganizationsByLoggedInUser(): Promise<ReadonlyArray<Organization>>;
+    /**
+     * Checks if a subdomain is available and verifies its format.
+     */
+    getSubdomainAvailability(subdomain: string): Promise<{
+        status: string;
+    }>;
+    /**
+     * Updates preferences of the organization.
+     */
+    updatePreferences({ organizationId, preferences, }: {
+        organizationId: string;
+        preferences: OrganizationPreferences;
+    }): Promise<undefined>;
+    /**
+     * Delete organization
+     */
+    deleteOrganization({ organizationId }: {
+        organizationId: string;
+    }): Promise<undefined>;
+}
+
+interface RoomParticipantData {
+    displayName: string;
+    id: string;
+    stream?: MediaStream;
+    isAudioEnabled: boolean;
+    isVideoEnabled: boolean;
+}
+declare class RoomParticipant {
+    readonly displayName: string;
+    readonly id: string;
+    readonly stream?: MediaStream;
+    readonly isAudioEnabled: boolean;
+    readonly isLocalParticipant: boolean;
+    readonly isVideoEnabled: boolean;
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }: RoomParticipantData);
+}
+type StreamState = "new_accept" | "to_accept" | "old_accept" | "done_accept" | "to_unaccept" | "done_unaccept" | "auto";
+interface Stream {
+    id: string;
+    state: StreamState;
+}
+interface RemoteParticipant {
+    id: string;
+    displayName: string;
+    isAudioEnabled: boolean;
+    isVideoEnabled: boolean;
+    isLocalParticipant: boolean;
+    stream: (MediaStream & {
+        inboundId?: string;
+    }) | null;
+    streams: Stream[];
+    newJoiner: boolean;
+    presentationStream: (MediaStream & {
+        inboundId?: string;
+    }) | null;
+}
+declare class LocalParticipant extends RoomParticipant {
+    readonly isLocalParticipant = true;
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }: RoomParticipantData);
+}
+interface WaitingParticipant {
+    id: string;
+    displayName: string | null;
+}
+interface Screenshare {
+    participantId: string;
+    id: string;
+    hasAudioTrack: boolean;
+    stream?: MediaStream;
+    isLocal: boolean;
+}
+
+/**
+ * Reducer
+ */
+interface WaitingParticipantsState {
+    waitingParticipants: WaitingParticipant[];
+}
+
+/**
+ * Reducer
+ */
+interface StreamingState {
+    isStreaming: boolean;
+    error: unknown;
+    startedAt?: number;
+}
+
+/**
+ * Reducer
+ */
+interface rtcAnalyticsState {
+    reportedValues: {
+        [key: string]: unknown;
+    };
+}
+
+interface LocalScreenshareState {
+    status: "" | "starting" | "active";
+    stream: MediaStream | null;
+    error: unknown | null;
+}
+
+/**
+ * Reducer
+ */
+interface CloudRecordingState {
+    isRecording: boolean;
+    error: unknown;
+    status?: "recording" | "requested" | "error";
+    startedAt?: number;
+}
+
+type ChatMessage = Pick<ChatMessage$1, "senderId" | "timestamp" | "text">;
+/**
+ * Reducer
+ */
+interface ChatState {
+    chatMessages: ChatMessage[];
+}
+
+/**
+ * Reducer
+ */
+interface AppState {
+    wantsToJoin: boolean;
+    roomUrl: string | null;
+    roomName: string | null;
+    roomKey: string | null;
+    displayName: string | null;
+    sdkVersion: string | null;
+    externalId: string | null;
+    isNodeSdk: boolean;
+}
+declare const appSlice: _reduxjs_toolkit.Slice<AppState, {
+    doAppJoin: (state: {
+        wantsToJoin: boolean;
+        roomUrl: string | null;
+        roomName: string | null;
+        roomKey: string | null;
+        displayName: string | null;
+        sdkVersion: string | null;
+        externalId: string | null;
+        isNodeSdk: boolean;
+    }, action: PayloadAction<{
+        displayName: string;
+        localMediaOptions?: LocalMediaOptions;
+        roomKey: string | null;
+        roomUrl: string;
+        sdkVersion: string;
+        externalId: string | null;
+    }>) => {
+        roomName: string;
+        wantsToJoin: true;
+        displayName: string;
+        localMediaOptions?: LocalMediaOptions | undefined;
+        roomKey: string | null;
+        roomUrl: string;
+        sdkVersion: string;
+        externalId: string | null;
+        isNodeSdk: boolean;
+    };
+    appLeft: (state: {
+        wantsToJoin: boolean;
+        roomUrl: string | null;
+        roomName: string | null;
+        roomKey: string | null;
+        displayName: string | null;
+        sdkVersion: string | null;
+        externalId: string | null;
+        isNodeSdk: boolean;
+    }) => {
+        wantsToJoin: false;
+        roomUrl: string | null;
+        roomName: string | null;
+        roomKey: string | null;
+        displayName: string | null;
+        sdkVersion: string | null;
+        externalId: string | null;
+        isNodeSdk: boolean;
+    };
+    setRoomKey: (state: {
+        wantsToJoin: boolean;
+        roomUrl: string | null;
+        roomName: string | null;
+        roomKey: string | null;
+        displayName: string | null;
+        sdkVersion: string | null;
+        externalId: string | null;
+        isNodeSdk: boolean;
+    }, action: PayloadAction<string>) => {
+        roomKey: string;
+        wantsToJoin: boolean;
+        roomUrl: string | null;
+        roomName: string | null;
+        displayName: string | null;
+        sdkVersion: string | null;
+        externalId: string | null;
+        isNodeSdk: boolean;
+    };
+}, "app", "app", _reduxjs_toolkit.SliceSelectors<AppState>>;
+/**
+ * Action creators
+ */
+declare const doAppJoin: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    displayName: string;
+    localMediaOptions?: LocalMediaOptions | undefined;
+    roomKey: string | null;
+    roomUrl: string;
+    sdkVersion: string;
+    externalId: string | null;
+}, "app/doAppJoin">;
+declare const appLeft: _reduxjs_toolkit.ActionCreatorWithoutPayload<"app/appLeft">;
+declare const setRoomKey: _reduxjs_toolkit.ActionCreatorWithPayload<string, "app/setRoomKey">;
+/**
+ * Selectors
+ */
+declare const selectAppRaw: (state: RootState) => AppState;
+declare const selectAppWantsToJoin: (state: RootState) => boolean;
+declare const selectAppRoomName: (state: RootState) => string | null;
+declare const selectAppRoomUrl: (state: RootState) => string | null;
+declare const selectAppRoomKey: (state: RootState) => string | null;
+declare const selectAppDisplayName: (state: RootState) => string | null;
+declare const selectAppSdkVersion: (state: RootState) => string | null;
+declare const selectAppExternalId: (state: RootState) => string | null;
+declare const selectAppIsNodeSdk: (state: RootState) => boolean;
+
+/**
+ * Reducer
+ */
+interface DeviceCredentialsState {
+    isFetching: boolean;
+    data?: Credentials | null;
+}
+
+type LocalMediaOptions = {
+    disabled?: boolean;
+    audio: boolean;
+    video: boolean;
+};
+/**
+ * Reducer
+ */
+interface LocalMediaState {
+    busyDeviceIds: string[];
+    cameraDeviceError?: unknown;
+    cameraEnabled: boolean;
+    currentCameraDeviceId?: string;
+    currentMicrophoneDeviceId?: string;
+    devices: MediaDeviceInfo[];
+    isSettingCameraDevice: boolean;
+    isSettingMicrophoneDevice: boolean;
+    isTogglingCamera: boolean;
+    microphoneDeviceError?: unknown;
+    microphoneEnabled: boolean;
+    options?: LocalMediaOptions;
+    status: "" | "stopped" | "starting" | "started" | "error";
+    startError?: unknown;
+    stream?: MediaStream;
+    isSwitchingStream: boolean;
+    onDeviceChange?: () => void;
+}
+
+type LocalParticipantState$1 = LocalParticipant;
+
+declare const sdkVersion = "__SDK_VERSION__";
+
+interface LocalParticipantState extends LocalParticipantState$1 {
+    isScreenSharing: boolean;
+    roleName: string;
+}
+
+/**
+ * Reducer
+ */
+interface OrganizationState {
+    data: Organization | null | undefined;
+    isFetching: boolean;
+    error: unknown;
+}
+
+interface StreamStatusUpdate {
+    clientId: string;
+    streamId: string;
+    state: StreamState;
+}
+
+/**
+ * Reducer
+ */
+interface RemoteParticipantState {
+    remoteParticipants: RemoteParticipant[];
+}
+declare const remoteParticipantsSlice: _reduxjs_toolkit.Slice<RemoteParticipantState, {
+    streamStatusUpdated: (state: {
+        remoteParticipants: {
+            id: string;
+            displayName: string;
+            isAudioEnabled: boolean;
+            isVideoEnabled: boolean;
+            isLocalParticipant: boolean;
+            stream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+            streams: {
+                id: string;
+                state: StreamState;
+            }[];
+            newJoiner: boolean;
+            presentationStream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K_2 extends keyof MediaStreamEventMap>(type: K_2, listener: (this: MediaStream, ev: MediaStreamEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_3 extends keyof MediaStreamEventMap>(type: K_3, listener: (this: MediaStream, ev: MediaStreamEventMap[K_3]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+        }[];
+    }, action: PayloadAction<StreamStatusUpdate[]>) => {
+        remoteParticipants: {
+            id: string;
+            displayName: string;
+            isAudioEnabled: boolean;
+            isVideoEnabled: boolean;
+            isLocalParticipant: boolean;
+            stream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+            streams: {
+                id: string;
+                state: StreamState;
+            }[];
+            newJoiner: boolean;
+            presentationStream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K_2 extends keyof MediaStreamEventMap>(type: K_2, listener: (this: MediaStream, ev: MediaStreamEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_3 extends keyof MediaStreamEventMap>(type: K_3, listener: (this: MediaStream, ev: MediaStreamEventMap[K_3]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+        }[];
+    };
+    participantStreamAdded: (state: {
+        remoteParticipants: {
+            id: string;
+            displayName: string;
+            isAudioEnabled: boolean;
+            isVideoEnabled: boolean;
+            isLocalParticipant: boolean;
+            stream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+            streams: {
+                id: string;
+                state: StreamState;
+            }[];
+            newJoiner: boolean;
+            presentationStream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K_2 extends keyof MediaStreamEventMap>(type: K_2, listener: (this: MediaStream, ev: MediaStreamEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_3 extends keyof MediaStreamEventMap>(type: K_3, listener: (this: MediaStream, ev: MediaStreamEventMap[K_3]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+        }[];
+    }, action: PayloadAction<RtcStreamAddedPayload>) => RemoteParticipantState;
+    participantStreamIdAdded: (state: {
+        remoteParticipants: {
+            id: string;
+            displayName: string;
+            isAudioEnabled: boolean;
+            isVideoEnabled: boolean;
+            isLocalParticipant: boolean;
+            stream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_1 extends keyof MediaStreamEventMap>(type: K_1, listener: (this: MediaStream, ev: MediaStreamEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+            streams: {
+                id: string;
+                state: StreamState;
+            }[];
+            newJoiner: boolean;
+            presentationStream: {
+                active: boolean;
+                id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K_2 extends keyof MediaStreamEventMap>(type: K_2, listener: (this: MediaStream, ev: MediaStreamEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                };
+                removeEventListener: {
+                    <K_3 extends keyof MediaStreamEventMap>(type: K_3, listener: (this: MediaStream, ev: MediaStreamEventMap[K_3]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+                inboundId?: string | undefined;
+            } | null;
+        }[];
+    }, action: PayloadAction<{
+        clientId: string;
+        streamId: string;
+    }>) => RemoteParticipantState;
+}, "remoteParticipants", "remoteParticipants", _reduxjs_toolkit.SliceSelectors<RemoteParticipantState>>;
+/**
+ * Action creators
+ */
+declare const participantStreamAdded: _reduxjs_toolkit.ActionCreatorWithPayload<RtcStreamAddedPayload, "remoteParticipants/participantStreamAdded">;
+declare const participantStreamIdAdded: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    clientId: string;
+    streamId: string;
+}, "remoteParticipants/participantStreamIdAdded">;
+declare const streamStatusUpdated: _reduxjs_toolkit.ActionCreatorWithPayload<StreamStatusUpdate[], "remoteParticipants/streamStatusUpdated">;
+/**
+ * Selectors
+ */
+declare const selectRemoteParticipantsRaw: (state: RootState) => RemoteParticipantState;
+declare const selectRemoteParticipants: (state: RootState) => RemoteParticipant[];
+declare const selectScreenshares: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => Screenshare[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: RemoteParticipant[]) => Screenshare[];
+    memoizedResultFunc: ((resultFuncArgs_0: MediaStream | null, resultFuncArgs_1: RemoteParticipant[]) => Screenshare[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Screenshare[];
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => MediaStream | null, (state: RootState) => RemoteParticipant[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+type ConnectionStatus = "initializing" | "connecting" | "connected" | "reconnect" | "room_locked" | "knocking" | "disconnecting" | "disconnected" | "knock_rejected";
+/**
+ * Reducer
+ */
+interface RoomConnectionState {
+    session: {
+        createdAt: string;
+        id: string;
+    } | null;
+    status: ConnectionStatus;
+    error: unknown;
+}
+declare const roomConnectionSlice: _reduxjs_toolkit.Slice<RoomConnectionState, {
+    connectionStatusChanged: (state: {
+        session: {
+            createdAt: string;
+            id: string;
+        } | null;
+        status: ConnectionStatus;
+        error: unknown;
+    }, action: PayloadAction<ConnectionStatus>) => {
+        status: ConnectionStatus;
+        session: {
+            createdAt: string;
+            id: string;
+        } | null;
+        error: unknown;
+    };
+}, "roomConnection", "roomConnection", _reduxjs_toolkit.SliceSelectors<RoomConnectionState>>;
+declare const doKnockRoom: (args: void) => AppThunk<void>;
+declare const doConnectRoom: (args: void) => AppThunk<void>;
+/**
+ * Selectors
+ */
+declare const selectRoomConnectionRaw: (state: RootState) => RoomConnectionState;
+declare const selectRoomConnectionSession: (state: RootState) => {
+    createdAt: string;
+    id: string;
+} | null;
+declare const selectRoomConnectionSessionId: (state: RootState) => string | undefined;
+declare const selectRoomConnectionStatus: (state: RootState) => ConnectionStatus;
+/**
+ * Reactors
+ */
+declare const selectShouldConnectRoom: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string | undefined, resultFuncArgs_1: ConnectionStatus, resultFuncArgs_2: boolean, resultFuncArgs_3: "" | "error" | "stopped" | "starting" | "started", resultFuncArgs_4: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: string | undefined, resultFuncArgs_1: ConnectionStatus, resultFuncArgs_2: boolean, resultFuncArgs_3: "" | "error" | "stopped" | "starting" | "started", resultFuncArgs_4: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => string | undefined, (state: RootState) => ConnectionStatus, (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean, (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => "" | "error" | "stopped" | "starting" | "started", (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+declare const createWebRtcEmitter: (dispatch: AppDispatch) => {
+    emit: (eventName: keyof RtcEvents, data: RtcEvents[keyof RtcEvents]) => void;
+};
+/**
+ * Reducer
+ */
+interface StreamResolutionUpdate {
+    streamId: string;
+    width: number;
+    height: number;
+}
+interface RtcConnectionState {
+    dispatcherCreated: boolean;
+    error: unknown;
+    isCreatingDispatcher: boolean;
+    reportedStreamResolutions: {
+        [streamId: string]: Omit<StreamResolutionUpdate, "streamId">;
+    };
+    rtcManager: RtcManager | null;
+    rtcManagerDispatcher: RtcManagerDispatcher | null;
+    rtcManagerInitialized: boolean;
+    status: "" | "ready" | "reconnect";
+    isAcceptingStreams: boolean;
+}
+declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
+    isAcceptingStreams: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }, action: PayloadAction<boolean>) => {
+        isAcceptingStreams: boolean;
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+    };
+    resolutionReported: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }, action: PayloadAction<StreamResolutionUpdate>) => {
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            } | {
+                width: number;
+                height: number;
+            };
+        };
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    };
+    rtcDisconnected: () => {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [streamId: string]: Omit<StreamResolutionUpdate, "streamId">;
+        };
+        rtcManager: RtcManager | null;
+        rtcManagerDispatcher: RtcManagerDispatcher | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    };
+    rtcDispatcherCreated: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }, action: PayloadAction<RtcManagerDispatcher>) => {
+        dispatcherCreated: true;
+        rtcManagerDispatcher: RtcManagerDispatcher;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    };
+    rtcManagerCreated: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }, action: PayloadAction<RtcManager>) => {
+        rtcManager: RtcManager;
+        status: "ready";
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        isAcceptingStreams: boolean;
+    };
+    rtcManagerDestroyed: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }) => {
+        rtcManager: null;
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    };
+    rtcManagerInitialized: (state: {
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        rtcManagerInitialized: boolean;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    }) => {
+        rtcManagerInitialized: true;
+        dispatcherCreated: boolean;
+        error: unknown;
+        isCreatingDispatcher: boolean;
+        reportedStreamResolutions: {
+            [x: string]: {
+                width: number;
+                height: number;
+            };
+        };
+        rtcManager: {
+            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
+                activeBreakout: any;
+                clientId: any;
+                shouldAddLocalVideo: any;
+                streamId: any;
+            }) => void;
+            addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnectAll: () => void;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
+            shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
+            updateStreamResolution: (streamId: string, ignored: null, resolution: {
+                width: number;
+                height: number;
+            }) => void;
+            sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+        } | null;
+        rtcManagerDispatcher: {} | null;
+        status: "" | "ready" | "reconnect";
+        isAcceptingStreams: boolean;
+    };
+}, "rtcConnection", "rtcConnection", _reduxjs_toolkit.SliceSelectors<RtcConnectionState>>;
+/**
+ * Action creators
+ */
+declare const resolutionReported: _reduxjs_toolkit.ActionCreatorWithPayload<StreamResolutionUpdate, "rtcConnection/resolutionReported">;
+declare const rtcDispatcherCreated: _reduxjs_toolkit.ActionCreatorWithPayload<RtcManagerDispatcher, "rtcConnection/rtcDispatcherCreated">;
+declare const rtcDisconnected: _reduxjs_toolkit.ActionCreatorWithoutPayload<"rtcConnection/rtcDisconnected">;
+declare const rtcManagerCreated: _reduxjs_toolkit.ActionCreatorWithPayload<RtcManager, "rtcConnection/rtcManagerCreated">;
+declare const rtcManagerDestroyed: _reduxjs_toolkit.ActionCreatorWithoutPayload<"rtcConnection/rtcManagerDestroyed">;
+declare const rtcManagerInitialized: _reduxjs_toolkit.ActionCreatorWithoutPayload<"rtcConnection/rtcManagerInitialized">;
+declare const isAcceptingStreams: _reduxjs_toolkit.ActionCreatorWithPayload<boolean, "rtcConnection/isAcceptingStreams">;
+declare const doConnectRtc: (args: void) => AppThunk<void>;
+declare const doDisconnectRtc: (args: void) => AppThunk<void>;
+declare const doHandleAcceptStreams: (args: StreamStatusUpdate[]) => AppThunk<void>;
+declare const doRtcReportStreamResolution: (args: StreamResolutionUpdate) => AppThunk<void>;
+declare const doRtcManagerCreated: (args: RtcManagerCreatedPayload) => AppThunk<void>;
+declare const doRtcManagerInitialize: (args: void) => AppThunk<void>;
+/**
+ * Selectors
+ */
+declare const selectRtcConnectionRaw: (state: RootState) => RtcConnectionState;
+declare const selectRtcManagerInitialized: (state: RootState) => boolean;
+declare const selectRtcManager: (state: RootState) => RtcManager | null;
+declare const selectRtcDispatcherCreated: (state: RootState) => boolean;
+declare const selectRtcIsCreatingDispatcher: (state: RootState) => boolean;
+declare const selectRtcStatus: (state: RootState) => "" | "reconnect" | "ready";
+declare const selectIsAcceptingStreams: (state: RootState) => boolean;
+declare const selectShouldConnectRtc: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: boolean, resultFuncArgs_2: _whereby_jslib_media_src_utils_ServerSocket.default | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: boolean, resultFuncArgs_2: _whereby_jslib_media_src_utils_ServerSocket.default | null) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => boolean, (state: RootState) => boolean, (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => _whereby_jslib_media_src_utils_ServerSocket.default | null];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectShouldInitializeRtc: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: RtcManager | null, resultFuncArgs_1: boolean, resultFuncArgs_2: "" | "error" | "stopped" | "starting" | "started") => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: RtcManager | null, resultFuncArgs_1: boolean, resultFuncArgs_2: "" | "error" | "stopped" | "starting" | "started") => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => RtcManager | null, (state: RootState) => boolean, (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => "" | "error" | "stopped" | "starting" | "started"];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectShouldDisconnectRtc: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: "" | "reconnect" | "ready", resultFuncArgs_1: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: "" | "reconnect" | "ready", resultFuncArgs_1: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: RootState) => "" | "reconnect" | "ready", (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectStreamsToAccept: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => {
+    clientId: string;
+    streamId: string;
+    state: StreamState;
+}[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: "" | "reconnect" | "ready", resultFuncArgs_1: RemoteParticipant[]) => {
+        clientId: string;
+        streamId: string;
+        state: StreamState;
+    }[];
+    memoizedResultFunc: ((resultFuncArgs_0: "" | "reconnect" | "ready", resultFuncArgs_1: RemoteParticipant[]) => {
+        clientId: string;
+        streamId: string;
+        state: StreamState;
+    }[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        clientId: string;
+        streamId: string;
+        state: StreamState;
+    }[];
+    dependencies: [(state: RootState) => "" | "reconnect" | "ready", (state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => RemoteParticipant[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+/**
+ * Reducer
+ */
+interface SignalConnectionState {
+    deviceIdentified: boolean;
+    isIdentifyingDevice: boolean;
+    status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+    socket: _whereby_jslib_media_src_utils_ServerSocket__default | null;
+}
+declare const signalConnectionSlice: _reduxjs_toolkit.Slice<SignalConnectionState, {
+    socketConnecting: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }) => {
+        status: "connecting";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    };
+    socketConnected: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }, action: PayloadAction<_whereby_jslib_media_src_utils_ServerSocket__default>) => {
+        socket: _whereby_jslib_media_src_utils_ServerSocket__default;
+        status: "connected";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+    };
+    socketDisconnected: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }) => {
+        status: "disconnected";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    };
+    socketReconnecting: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }) => {
+        status: "reconnect";
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    };
+    deviceIdentifying: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }) => {
+        isIdentifyingDevice: true;
+        deviceIdentified: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    };
+    deviceIdentified: (state: {
+        deviceIdentified: boolean;
+        isIdentifyingDevice: boolean;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    }) => {
+        deviceIdentified: true;
+        isIdentifyingDevice: false;
+        status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
+        socket: {
+            connect: () => void;
+            disconnect: () => void;
+            getManager: () => _whereby_jslib_media_src_utils_ServerSocket.SocketManager;
+            emit: <K extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalRequests>(eventName: K, payload?: any) => any;
+            on: <K_1 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_1, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_1]) => void) => any;
+            once: <K_2 extends keyof _whereby_jslib_media_src_utils_ServerSocket.SignalEvents>(eventName: K_2, callback: (args: _whereby_jslib_media_src_utils_ServerSocket.SignalEvents[K_2]) => void) => any;
+        } | null;
+    };
+}, "signalConnection", "signalConnection", _reduxjs_toolkit.SliceSelectors<SignalConnectionState>>;
+declare const deviceIdentifying: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/deviceIdentifying">;
+declare const deviceIdentified: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/deviceIdentified">;
+declare const socketConnected: _reduxjs_toolkit.ActionCreatorWithPayload<_whereby_jslib_media_src_utils_ServerSocket__default, "signalConnection/socketConnected">;
+declare const socketConnecting: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/socketConnecting">;
+declare const socketDisconnected: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/socketDisconnected">;
+/**
+ * Action creators
+ */
+declare const doSignalSocketConnect: (args: void) => AppThunk<void>;
+declare const doSignalIdentifyDevice: (args: {
+    deviceCredentials: Credentials;
+}) => AppThunk<void>;
+declare const doSignalDisconnect: (args: void) => AppThunk<void>;
+declare const doSignalReconnect: (args: void) => AppThunk<void>;
+declare const socketReconnecting: _reduxjs_toolkit.ActionCreatorWithoutPayload<"signalConnection/socketReconnecting">;
+/**
+ * Selectors
+ */
+declare const selectSignalConnectionRaw: (state: RootState) => SignalConnectionState;
+declare const selectSignalIsIdentifyingDevice: (state: RootState) => boolean;
+declare const selectSignalConnectionDeviceIdentified: (state: RootState) => boolean;
+declare const selectSignalStatus: (state: RootState) => "" | "connecting" | "connected" | "reconnect" | "disconnected";
+declare const selectSignalConnectionSocket: (state: RootState) => _whereby_jslib_media_src_utils_ServerSocket__default | null;
+declare const selectShouldConnectSignal: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: "" | "connecting" | "connected" | "reconnect" | "disconnected") => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: "" | "connecting" | "connected" | "reconnect" | "disconnected") => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => boolean, (state: RootState) => "" | "connecting" | "connected" | "reconnect" | "disconnected"];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+declare const selectShouldIdentifyDevice: ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: DeviceCredentialsState, resultFuncArgs_1: "" | "connecting" | "connected" | "reconnect" | "disconnected", resultFuncArgs_2: boolean, resultFuncArgs_3: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: DeviceCredentialsState, resultFuncArgs_1: "" | "connecting" | "connected" | "reconnect" | "disconnected", resultFuncArgs_2: boolean, resultFuncArgs_3: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: {
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }) => DeviceCredentialsState, (state: RootState) => "" | "connecting" | "connected" | "reconnect" | "disconnected", (state: RootState) => boolean, (state: RootState) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof reselect.weakMapMemoize;
+    memoize: typeof reselect.weakMapMemoize;
+};
+
+declare function createServices(): {
+    credentialsService: CredentialsService;
+    apiClient: ApiClient;
+    organizationService: OrganizationService;
+    fetchOrganizationFromRoomUrl: (roomUrl: string) => Promise<Organization | null>;
+};
+
+declare const rootReducer: redux.Reducer<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, redux.UnknownAction, Partial<{
+    app: AppState | undefined;
+    chat: ChatState | undefined;
+    cloudRecording: CloudRecordingState | undefined;
+    deviceCredentials: DeviceCredentialsState | undefined;
+    localMedia: LocalMediaState | undefined;
+    localParticipant: LocalParticipantState | undefined;
+    localScreenshare: LocalScreenshareState | undefined;
+    organization: OrganizationState | undefined;
+    remoteParticipants: RemoteParticipantState | undefined;
+    roomConnection: RoomConnectionState | undefined;
+    rtcAnalytics: rtcAnalyticsState | undefined;
+    rtcConnection: RtcConnectionState | undefined;
+    signalConnection: SignalConnectionState | undefined;
+    streaming: StreamingState | undefined;
+    waitingParticipants: WaitingParticipantsState | undefined;
+}>>;
+declare const createStore: ({ preloadedState, injectServices, }: {
+    preloadedState?: Partial<{
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }> | undefined;
+    injectServices: ReturnType<typeof createServices>;
+}) => _reduxjs_toolkit.EnhancedStore<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, redux.UnknownAction, _reduxjs_toolkit.Tuple<[redux.StoreEnhancer<{
+    dispatch: ((action: redux.Action<"listenerMiddleware/add">) => _reduxjs_toolkit.UnsubscribeListener) & redux_thunk.ThunkDispatch<{
+        app: AppState;
+        chat: ChatState;
+        cloudRecording: CloudRecordingState;
+        deviceCredentials: DeviceCredentialsState;
+        localMedia: LocalMediaState;
+        localParticipant: LocalParticipantState;
+        localScreenshare: LocalScreenshareState;
+        organization: OrganizationState;
+        remoteParticipants: RemoteParticipantState;
+        roomConnection: RoomConnectionState;
+        rtcAnalytics: rtcAnalyticsState;
+        rtcConnection: RtcConnectionState;
+        signalConnection: SignalConnectionState;
+        streaming: StreamingState;
+        waitingParticipants: WaitingParticipantsState;
+    }, {
+        services: {
+            credentialsService: CredentialsService;
+            apiClient: ApiClient;
+            organizationService: OrganizationService;
+            fetchOrganizationFromRoomUrl: (roomUrl: string) => Promise<Organization | null>;
+        };
+    }, redux.UnknownAction>;
+}, {}>, redux.StoreEnhancer<{}, {}>]>>;
+type RootReducer = typeof rootReducer;
+type RootState = ReturnType<typeof rootReducer>;
+type AppDispatch = ReturnType<typeof createStore>["dispatch"];
+type Store = ReturnType<typeof createStore>;
+declare const observeStore: <T>(store: Store, select: (state: RootState) => T, onChange: (result: T) => void) => redux.Unsubscribe;
+
+type ThunkConfig = {
+    state: RootState;
+    dispatch: AppDispatch;
+    extra: {
+        services: ReturnType<typeof createServices>;
+    };
+};
+declare function createAppAsyncThunk<ReturnType, ArgType = undefined>(typePrefix: string, payloadCreator: AsyncThunkPayloadCreator<ReturnType, ArgType, ThunkConfig>): AsyncThunk<ReturnType, ArgType, ThunkConfig>;
+type AppThunk<R = void> = (dispatch: AppDispatch, getState: () => RootState, extra: {
+    services: ReturnType<typeof createServices>;
+}) => R;
+declare function createAppThunk<A = void>(thunk: (args: A) => AppThunk): (args: A) => AppThunk;
+
+declare const listenerMiddleware: _reduxjs_toolkit.ListenerMiddlewareInstance<unknown, redux_thunk.ThunkDispatch<unknown, unknown, redux.UnknownAction>, unknown>;
+type AppStartListening = TypedStartListening<RootState, AppDispatch, ReturnType<typeof createServices>>;
+declare const startAppListening: AppStartListening;
+declare const addAppListener: TypedAddListener<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, ((action: redux.Action<"listenerMiddleware/add">) => _reduxjs_toolkit.UnsubscribeListener) & redux_thunk.ThunkDispatch<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, {
+    services: {
+        credentialsService: CredentialsService;
+        apiClient: ApiClient;
+        organizationService: OrganizationService;
+        fetchOrganizationFromRoomUrl: (roomUrl: string) => Promise<Organization | null>;
+    };
+}, redux.UnknownAction> & redux.Dispatch<redux.UnknownAction>, unknown, _reduxjs_toolkit_dist_listenerMiddleware_types.ListenerEntry<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, ((action: redux.Action<"listenerMiddleware/add">) => _reduxjs_toolkit.UnsubscribeListener) & redux_thunk.ThunkDispatch<{
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, {
+    services: {
+        credentialsService: CredentialsService;
+        apiClient: ApiClient;
+        organizationService: OrganizationService;
+        fetchOrganizationFromRoomUrl: (roomUrl: string) => Promise<Organization | null>;
+    };
+}, redux.UnknownAction> & redux.Dispatch<redux.UnknownAction>>, "listenerMiddleware/add">;
+type SelectorResults<Selectors extends Selector<RootState, unknown>[]> = {
+    [K in keyof Selectors]: Selectors[K] extends Selector<RootState, infer R> ? R : never;
+};
+/**
+ * Creates a reactor that will be called whenever the provided selectors change.
+ * Every reactor needs to update a piece of state that it depends on, to avoid infinite loops.
+ * example:
+ * ```ts
+ * createReactor(
+ *    [selectAppWantsToJoin, selectDeviceCredentialsRaw],
+ *   ({ dispatch }, wantsToJoin, deviceCredentialsRaw) => {
+ *      if (wantsToJoin && deviceCredentialsRaw.data) {
+ *         dispatch(doSignalIdentifyDevice({ deviceCredentials: deviceCredentialsRaw.data }));
+ *    }
+ * });
+ * ```
+ * @param selectors. The selectors to be used to check if the state has changed.
+ * @param callback. The callback to be called on every action. The first argument is the listenerApi, the second argument is the result of the selectors.
+ * @returns The unsubscribe function.
+ */
+declare const createReactor: <Selectors extends ((state: {
+    app: AppState;
+    chat: ChatState;
+    cloudRecording: CloudRecordingState;
+    deviceCredentials: DeviceCredentialsState;
+    localMedia: LocalMediaState;
+    localParticipant: LocalParticipantState;
+    localScreenshare: LocalScreenshareState;
+    organization: OrganizationState;
+    remoteParticipants: RemoteParticipantState;
+    roomConnection: RoomConnectionState;
+    rtcAnalytics: rtcAnalyticsState;
+    rtcConnection: RtcConnectionState;
+    signalConnection: SignalConnectionState;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipantsState;
+}, ...params: any[]) => unknown)[]>(selectors: readonly [...Selectors], callback: (api: {
+    dispatch: AppDispatch;
+    getState: () => RootState;
+    extra: ReturnType<typeof createServices>;
+}, ...selectorValues: SelectorResults<Selectors>) => void | Promise<void>) => _reduxjs_toolkit.UnsubscribeListener;
+
+export { type AppDispatch, type AppStartListening, type AppState, type AppThunk, type ConnectionStatus, type RemoteParticipantState, type RoomConnectionState, type RootReducer, type RootState, type RtcConnectionState, type SignalConnectionState, type Store, type ThunkConfig, addAppListener, appLeft, appSlice, createAppAsyncThunk, createAppThunk, createReactor, createServices, createStore, createWebRtcEmitter, deviceIdentified, deviceIdentifying, doAppJoin, doConnectRoom, doConnectRtc, doDisconnectRtc, doHandleAcceptStreams, doKnockRoom, doRtcManagerCreated, doRtcManagerInitialize, doRtcReportStreamResolution, doSignalDisconnect, doSignalIdentifyDevice, doSignalReconnect, doSignalSocketConnect, isAcceptingStreams, listenerMiddleware, observeStore, participantStreamAdded, participantStreamIdAdded, remoteParticipantsSlice, resolutionReported, roomConnectionSlice, rootReducer, rtcConnectionSlice, rtcDisconnected, rtcDispatcherCreated, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, sdkVersion, selectAppDisplayName, selectAppExternalId, selectAppIsNodeSdk, selectAppRaw, selectAppRoomKey, selectAppRoomName, selectAppRoomUrl, selectAppSdkVersion, selectAppWantsToJoin, selectIsAcceptingStreams, selectRemoteParticipants, selectRemoteParticipantsRaw, selectRoomConnectionRaw, selectRoomConnectionSession, selectRoomConnectionSessionId, selectRoomConnectionStatus, selectRtcConnectionRaw, selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectRtcManager, selectRtcManagerInitialized, selectRtcStatus, selectScreenshares, selectShouldConnectRoom, selectShouldConnectRtc, selectShouldConnectSignal, selectShouldDisconnectRtc, selectShouldIdentifyDevice, selectShouldInitializeRtc, selectSignalConnectionDeviceIdentified, selectSignalConnectionRaw, selectSignalConnectionSocket, selectSignalIsIdentifyingDevice, selectSignalStatus, selectStreamsToAccept, setRoomKey, signalConnectionSlice, socketConnected, socketConnecting, socketDisconnected, socketReconnecting, startAppListening, streamStatusUpdated };