@whereby.com/core 0.7.0 → 0.8.0

package/dist/index.d.ts

@@ -3,14 +3,11 @@ import { PayloadAction, ActionCreatorWithPayload, AsyncThunkPayloadCreator, Asyn
 import * as redux_thunk from 'redux-thunk';
 import * as redux from 'redux';
 import * as reselect from 'reselect';
-import * as _whereby_jslib_media_src_utils_ServerSocket from '@whereby/jslib-media/src/utils/ServerSocket';
-import _whereby_jslib_media_src_utils_ServerSocket__default, { ChatMessage as ChatMessage$1 } from '@whereby/jslib-media/src/utils/ServerSocket';
+import * as _whereby_com_media from '@whereby.com/media';
+import { ChatMessage as ChatMessage$1, getDeviceData, RtcStreamAddedPayload, RtcEvents, RtcManager, RtcManagerDispatcher, RtcManagerCreatedPayload, ServerSocket } from '@whereby.com/media';
 import { AsyncThunkFulfilledActionCreator } from '@reduxjs/toolkit/dist/createAsyncThunk';
-import { getDeviceData } from '@whereby/jslib-media/src/webrtc/MediaDevices';
-import RtcManagerDispatcher, { RtcStreamAddedPayload, RtcEvents, RtcManagerCreatedPayload } from '@whereby/jslib-media/src/webrtc/RtcManagerDispatcher';
-import RtcManager from '@whereby/jslib-media/src/webrtc/RtcManager';
 import { AxiosRequestConfig } from 'axios';
-import EventEmitter from 'events';
+import EventEmitter$1 from 'events';
 
 type Json = string | number | boolean | null | Array<Json> | {
     [key: string]: Json;
@@ -219,31 +216,19 @@ interface Screenshare {
     isLocal: boolean;
 }
 
-/**
- * Reducer
- */
 interface WaitingParticipantsState {
     waitingParticipants: WaitingParticipant[];
 }
 declare const waitingParticipantsSlice: _reduxjs_toolkit.Slice<WaitingParticipantsState, {}, "waitingParticipants", "waitingParticipants", _reduxjs_toolkit.SliceSelectors<WaitingParticipantsState>>;
-/**
- * Action creators
- */
 declare const doAcceptWaitingParticipant: (args: {
     participantId: string;
 }) => AppThunk<void>;
 declare const doRejectWaitingParticipant: (args: {
     participantId: string;
 }) => AppThunk<void>;
-/**
- * Selectors
- */
 declare const selectWaitingParticipantsRaw: (state: RootState) => WaitingParticipantsState;
 declare const selectWaitingParticipants: (state: RootState) => WaitingParticipant[];
 
-/**
- * Reducer
- */
 interface StreamingState {
     isStreaming: boolean;
     error: unknown;
@@ -269,14 +254,8 @@ declare const streamingSlice: _reduxjs_toolkit.Slice<StreamingState, {
         startedAt?: number | undefined;
     };
 }, "streaming", "streaming", _reduxjs_toolkit.SliceSelectors<StreamingState>>;
-/**
- * Action creators
- */
 declare const doHandleStreamingStarted: _reduxjs_toolkit.ActionCreatorWithoutPayload<"streaming/doHandleStreamingStarted">;
 declare const doHandleStreamingStopped: _reduxjs_toolkit.ActionCreatorWithoutPayload<"streaming/doHandleStreamingStopped">;
-/**
- * Selectors
- */
 declare const selectStreamingRaw: (state: RootState) => StreamingState;
 
 type RtcAnalyticsCustomEvent = {
@@ -288,9 +267,6 @@ type RtcAnalyticsCustomEvent = {
 declare const rtcAnalyticsCustomEvents: {
     [key: string]: RtcAnalyticsCustomEvent;
 };
-/**
- * Reducer
- */
 interface rtcAnalyticsState {
     reportedValues: {
         [key: string]: unknown;
@@ -311,9 +287,6 @@ declare const rtcAnalyticsSlice: _reduxjs_toolkit.Slice<rtcAnalyticsState, {
     };
 }, "rtcAnalytics", "rtcAnalytics", _reduxjs_toolkit.SliceSelectors<rtcAnalyticsState>>;
 declare const doRtcAnalyticsCustomEventsInitialize: (args: void) => AppThunk<void>;
-/**
- * Action creators
- */
 declare const updateReportedValues: ActionCreatorWithPayload<{
     rtcEventName: string;
     value: unknown;
@@ -324,9 +297,6 @@ interface LocalScreenshareState {
     stream: MediaStream | null;
     error: unknown | null;
 }
-/**
- * Reducer
- */
 declare const localScreenshareSlice: _reduxjs_toolkit.Slice<LocalScreenshareState, {
     stopScreenshare(state: {
         status: "" | "starting" | "active";
@@ -361,9 +331,6 @@ declare const localScreenshareSlice: _reduxjs_toolkit.Slice<LocalScreenshareStat
         error: unknown | null;
     };
 }, "localScreenshare", "localScreenshare", _reduxjs_toolkit.SliceSelectors<LocalScreenshareState>>;
-/**
- * Action creators
- */
 declare const stopScreenshare: _reduxjs_toolkit.ActionCreatorWithPayload<{
     stream: MediaStream;
 }, "localScreenshare/stopScreenshare">;
@@ -371,9 +338,6 @@ declare const doStartScreenshare: _reduxjs_toolkit.AsyncThunk<{
     stream: MediaStream;
 }, undefined, ThunkConfig>;
 declare const doStopScreenshare: (args: void) => AppThunk<void>;
-/**
- * Selectors
- */
 declare const selectLocalScreenshareRaw: (state: RootState) => LocalScreenshareState;
 declare const selectLocalScreenshareStatus: (state: RootState) => "" | "starting" | "active";
 declare const selectLocalScreenshareStream: (state: RootState) => MediaStream | null;
@@ -443,9 +407,6 @@ declare const selectLocalParticipantClientClaim: (state: RootState) => string |
 declare const selectLocalParticipantRole: (state: RootState) => string;
 declare const selectLocalParticipantIsScreenSharing: (state: RootState) => boolean;
 
-/**
- * Reducer
- */
 interface CloudRecordingState {
     isRecording: boolean;
     error: unknown;
@@ -466,15 +427,9 @@ declare const cloudRecordingSlice: _reduxjs_toolkit.Slice<CloudRecordingState, {
         startedAt?: number | undefined;
     };
 }, "cloudRecording", "cloudRecording", _reduxjs_toolkit.SliceSelectors<CloudRecordingState>>;
-/**
- * Action creators
- */
 declare const recordingRequestStarted: _reduxjs_toolkit.ActionCreatorWithoutPayload<"cloudRecording/recordingRequestStarted">;
 declare const doStartCloudRecording: (args: void) => AppThunk<void>;
 declare const doStopCloudRecording: (args: void) => AppThunk<void>;
-/**
- * Selectors
- */
 declare const selectCloudRecordingRaw: (state: RootState) => CloudRecordingState;
 declare const selectCloudRecordingStatus: (state: RootState) => "error" | "recording" | "requested" | undefined;
 declare const selectCloudRecordingStartedAt: (state: RootState) => number | undefined;
@@ -482,28 +437,16 @@ declare const selectCloudRecordingError: (state: RootState) => unknown;
 declare const selectIsCloudRecording: (state: RootState) => boolean;
 
 type ChatMessage = Pick<ChatMessage$1, "senderId" | "timestamp" | "text">;
-/**
- * Reducer
- */
 interface ChatState {
     chatMessages: ChatMessage[];
 }
 declare const chatSlice: _reduxjs_toolkit.Slice<ChatState, {}, "chat", "chat", _reduxjs_toolkit.SliceSelectors<ChatState>>;
-/**
- * Action creators
- */
 declare const doSendChatMessage: (args: {
     text: string;
 }) => AppThunk<void>;
-/**
- * Selectors
- */
 declare const selectChatRaw: (state: RootState) => ChatState;
 declare const selectChatMessages: (state: RootState) => ChatMessage[];
 
-/**
- * Reducer
- */
 interface AppState {
     isNodeSdk: boolean;
     wantsToJoin: boolean;
@@ -582,9 +525,6 @@ declare const appSlice: _reduxjs_toolkit.Slice<AppState, {
         externalId: string | null;
     };
 }, "app", "app", _reduxjs_toolkit.SliceSelectors<AppState>>;
-/**
- * Action creators
- */
 declare const doAppJoin: _reduxjs_toolkit.ActionCreatorWithPayload<{
     isNodeSdk?: boolean | undefined;
     displayName: string;
@@ -596,9 +536,6 @@ declare const doAppJoin: _reduxjs_toolkit.ActionCreatorWithPayload<{
 }, "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;
@@ -615,53 +552,21 @@ type HttpClientRequestConfig = AxiosRequestConfig | {
 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>;
 }
 
@@ -695,40 +600,19 @@ 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>;
 }
 
@@ -737,15 +621,10 @@ interface AbstractStore {
     save(value: Json): Promise<void>;
 }
 
-declare class CredentialsService extends EventEmitter {
+declare class CredentialsService extends EventEmitter$1 {
     _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;
@@ -755,55 +634,17 @@ declare class CredentialsService extends EventEmitter {
         storeName?: string;
         storeType?: "localStorage" | "chromeStorage";
     }): CredentialsService;
-    /**
-     * Contacts the REST API to get new credentials. DO NOT USE directly, call getCredentials() instead.
-     *
-     * @see getCredentials
-     * @returns {Promise.<Credentials>} - Promise that resolves with the credentials.
-     */
     _fetchNewCredentialsFromApi(): Promise<Credentials | null>;
-    /**
-     * Returns the current credentials without triggering an API request to get new ones.
-     * If no credentials are currently available it will return null.
-     *
-     * @returns {?Credentials} - The credentials currently in use, null otherwise.
-     */
     getCurrentCredentials(): Promise<Credentials | null>;
-    /**
-     * Returns a promise that will contain the credentials for this client.
-     * If no credentials are available in local storage, new ones will be fetched from the server.
-     *
-     * @returns {Promise.<Credentials>} - Promise that resolves with the credentials.
-     */
     getCredentials(): Promise<Credentials | null>;
-    /**
-     * Saves new credentials which replace the existing ones and abort any pending request to get new ones.
-     *
-     * @param {Credentials} credentials - New credentials to store.
-     */
     saveCredentials(credentials: Credentials): Promise<Credentials>;
-    /**
-     * It will set the userId for the current credentials.
-     *
-     * @param userId - The user id to set.
-     */
     setUserId(userId: string | null): Promise<void>;
 }
 
 type FetchOrganizationFunction = () => Promise<Organization | undefined>;
-/**
- * Class used for all Whereby organization API calls.
- */
 declare class OrganizationApiClient {
     private _apiClient;
     private _fetchOrganization;
-    /**
-     * Create an OrganizationApiClient instance.
-     *
-     * @param {Object} options - The options for the OrganizationApiClient.
-     * @param {ApiClient} [options.apiClient] - The apiClient to use.
-     * @param {Function} [options.fetchOrganization] - function that returns a promise with the organization.
-     */
     constructor({ apiClient, fetchOrganization, }: {
         apiClient: ApiClient;
         fetchOrganization?: FetchOrganizationFunction;
@@ -824,9 +665,6 @@ declare class OrganizationService {
     constructor({ apiClient }: {
         apiClient: ApiClient;
     });
-    /**
-     * Creates an organization.
-     */
     createOrganization({ organizationName, subdomain, owner, }: {
         organizationName: string;
         subdomain: string;
@@ -841,23 +679,8 @@ declare class OrganizationService {
             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;
@@ -865,37 +688,17 @@ declare class OrganizationService {
         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>;
@@ -918,105 +721,37 @@ declare class Room {
     constructor(properties?: {});
 }
 
-/**
- * Service for talking to the Room related APIs
- */
 declare class RoomService {
-    /**
-     * @param {object} organizationApiClient (required)
-     */
     constructor({ organizationApiClient }: {
         organizationApiClient: any;
     });
-    /**
-     * Gets the list of visited rooms
-     *
-     * @param {Object} args
-     * @param {Array<string>} [types=["team"]] - The type of rooms that should be fetched.
-     * @param {Array<string>} [fields=["meeting"]] - The fields of room that should be fetched.
-     * @returns {Promise<array>} - It will resolve with an array.
-     */
     getRooms({ types, fields }?: {
         types: any;
         fields?: never[] | undefined;
     }): any;
-    /**
-     * Gets the specified room.
-     *
-     * Currently information is implicitly alluded to via the servers
-     * `/room/roomName` response. This method patches the data
-     * tempoarily, until the day it comes back from the server.
-     *
-     * @returns {Promise<Room>} - It will resolve with the Room.
-     */
     getRoom({ roomName, fields }: {
         roomName: string;
         fields?: Array<string>;
     }): Promise<Room>;
-    /**
-     * Claims the specified room.
-     *
-     * @param {Object} args
-     * @param {String} args.roomName - The roomName to claim
-     * @param {String} args.type - The type of room to claim
-     * @param {String} args.mode - The optional mode of room to claim
-     * @param {[Boolean]} args.isLocked - The optional lock status of room to claim
-     * @returns {Promise} - It will resolve with undefined.
-     */
     claimRoom({ roomName, type, mode, isLocked }: {
         roomName: any;
         type: any;
         mode: any;
         isLocked: any;
     }): any;
-    /**
-     * Unclaims the specified room.
-     *
-     * @param {string} roomName - the room name to unclaim.
-     * @returns {Promise.<undefined>} - It will resolve with undefined.
-     */
     unclaimRoom(roomName: any): any;
-    /**
-     * Changes the name of the room
-     *
-     * @param {Object} args
-     * @param {string} args.roomName - The name of the room to rename
-     * @param {string} args.newRoomName - The new name
-     * @returns {Promise<undefined>} - It will resolve if the room was renamed, reject for all other cases
-     */
     renameRoom({ roomName, newRoomName }: {
         roomName: any;
         newRoomName: any;
     }): any;
-    /**
-     * Changes the room mode (experimental)
-     *
-     * @param {string} roomName - The name of the room to change mode of
-     * @param {string} mode - The name of mode to set, currently only "group" is supported
-     * @returns {Promise<undefined>} - It will resolve if mode was changed, rejects for all other cases
-     */
     changeMode({ roomName, mode }: {
         roomName: any;
         mode: any;
     }): any;
-    /**
-     * Updates the room prefs
-     *
-     * @param {string} roomName - The name of the room to change mode of
-     * @param {object} preferences - The prefs you want to update and their values
-     * @returns {Promise<undefined>} - It will resolve if updated, rejects for all other cases
-     */
     updatePreferences({ roomName, preferences }: {
         roomName: any;
         preferences: any;
     }): any;
-    /**
-     * Updates the protected room prefs
-     *
-     * @param {string} roomName - The name of the room to change mode of
-     * @param {object} preferences - The protected prefs you want to update and their values
-     * @returns {Promise<undefined>} - It will resolve if updated, rejects for all other cases
-     */
     updateProtectedPreferences({ roomName, preferences }: {
         roomName: any;
         preferences: any;
@@ -1024,70 +759,31 @@ declare class RoomService {
     getRoomPermissions(roomName: any, { roomKey }?: {
         roomKey: any;
     }): any;
-    /**
-     * Gets the specified room metrics
-     *
-     * @param {Object} args
-     * @param {string} args.roomName - The name of the room to get metrics from.
-     * @param {string} args.metrics - Comma-separated list of metrics to include.
-     * @param {string} args.from (optional) - Start time (inclusive) to count from in
-     * ISO format. Defaults to counting from the start of time.
-     * @param {string} args.to (optional) - End time (exclusive) to count up to in
-     * ISO format. Defaults to counting up to the current time.
-     * @returns {Promise<Object>} - It will resolve with the requested metrics.
-     */
     getRoomMetrics({ roomName, metrics, from, to }: {
         roomName: any;
         metrics: any;
         from: any;
         to: any;
     }): any;
-    /**
-     * Changes the room type
-     *
-     * @param {Object} args
-     * @param {string} args.roomName - The name of the room to change mode of
-     * @param {"personal" | "personal_xl"} args.type - Room type that should be set
-     * @returns {Promise<undefined>} - It will resolve if type was changed, rejects for all other cases
-     */
     changeType({ roomName, type }: {
         roomName: any;
         type: any;
     }): any;
-    /** Gets a Forest campaign social image
-     *
-     * @param {Object} args
-     * @param {string} args.roomName - The name of the room to get metrics from.
-     * @param {number} args.count - Number to be displayed in the image as tree count.
-     * @returns {Promise<string>} - It will resolve with the image url.
-     */
     getForestSocialImage({ roomName, count }: {
         roomName: any;
         count: any;
     }): any;
 }
 
-/**
- * Reducer
- */
 interface DeviceCredentialsState {
     isFetching: boolean;
     data?: Credentials | null;
 }
 declare const deviceCredentialsSlice: _reduxjs_toolkit.Slice<DeviceCredentialsState, {}, "deviceCredentials", "deviceCredentials", _reduxjs_toolkit.SliceSelectors<DeviceCredentialsState>>;
-/**
- * Action creators
- */
 declare const doGetDeviceCredentials: _reduxjs_toolkit.AsyncThunk<Credentials | null | undefined, undefined, ThunkConfig>;
-/**
- * Selectors
- */
 declare const selectDeviceCredentialsRaw: (state: RootState) => DeviceCredentialsState;
 declare const selectHasFetchedDeviceCredentials: (state: RootState) => boolean;
 declare const selectDeviceId: (state: RootState) => string | undefined;
-/**
- * Reactors
- */
 declare const selectShouldFetchDeviceCredentials: ((state: {
     app: AppState;
     chat: ChatState;
@@ -1150,9 +846,6 @@ type LocalMediaOptions = {
     audio: boolean;
     video: boolean;
 };
-/**
- * Reducer
- */
 interface LocalMediaState {
     busyDeviceIds: string[];
     cameraDeviceError?: unknown;
@@ -2110,9 +1803,6 @@ declare const localMediaSlice: _reduxjs_toolkit.Slice<LocalMediaState, {
         onDeviceChange?: (() => void) | undefined;
     };
 }, "localMedia", "localMedia", _reduxjs_toolkit.SliceSelectors<LocalMediaState>>;
-/**
- * Action creators
- */
 declare const deviceBusy: _reduxjs_toolkit.ActionCreatorWithPayload<{
     deviceId: string;
 }, "localMedia/deviceBusy">;
@@ -2135,18 +1825,7 @@ declare const setLocalMediaStream: _reduxjs_toolkit.ActionCreatorWithPayload<{
     stream: MediaStream;
 }, "localMedia/setLocalMediaStream">;
 declare const localMediaStopped: _reduxjs_toolkit.ActionCreatorWithoutPayload<"localMedia/localMediaStopped">;
-declare const localStreamMetadataUpdated: _reduxjs_toolkit.ActionCreatorWithPayload<{
-    audio: {
-        deviceId: string;
-        label: string;
-        kind: string;
-    };
-    video: {
-        deviceId: string;
-        label: string;
-        kind: string;
-    };
-}, "localMedia/localStreamMetadataUpdated">;
+declare const localStreamMetadataUpdated: _reduxjs_toolkit.ActionCreatorWithPayload<_whereby_com_media.GetDeviceDataResult, "localMedia/localStreamMetadataUpdated">;
 declare const doToggleCamera: _reduxjs_toolkit.AsyncThunk<undefined, undefined, ThunkConfig>;
 declare const doSetDevice: _reduxjs_toolkit.AsyncThunk<{
     replacedTracks: MediaStreamTrack[] | undefined;
@@ -2168,9 +1847,6 @@ declare const doStartLocalMedia: _reduxjs_toolkit.AsyncThunk<{
     onDeviceChange: DebouncedFunction;
 }, LocalMediaOptions | MediaStream, ThunkConfig>;
 declare const doStopLocalMedia: (args: void) => AppThunk<void>;
-/**
- * Selectors
- */
 declare const selectBusyDeviceIds: (state: RootState) => string[];
 declare const selectCameraDeviceError: (state: RootState) => unknown;
 declare const selectCurrentCameraDeviceId: (state: RootState) => string | undefined;
@@ -2454,9 +2130,6 @@ declare const selectSpeakerDevices: ((state: {
     argsMemoize: typeof reselect.weakMapMemoize;
     memoize: typeof reselect.weakMapMemoize;
 };
-/**
- * Reactors
- */
 declare const selectLocalMediaShouldStartWithOptions: ((state: {
     app: AppState;
     chat: ChatState;
@@ -2580,27 +2253,15 @@ declare const selectLocalMediaShouldStop: ((state: {
     memoize: typeof reselect.weakMapMemoize;
 };
 
-/**
- * Reducer
- */
 interface OrganizationState {
     data: Organization | null | undefined;
     isFetching: boolean;
     error: unknown;
 }
 declare const organizationSlice: _reduxjs_toolkit.Slice<OrganizationState, {}, "organization", "organization", _reduxjs_toolkit.SliceSelectors<OrganizationState>>;
-/**
- * Action creators
- */
 declare const doOrganizationFetch: _reduxjs_toolkit.AsyncThunk<Organization | undefined, undefined, ThunkConfig>;
-/**
- * Selectors
- */
 declare const selectOrganizationRaw: (state: RootState) => OrganizationState;
 declare const selectOrganizationId: (state: RootState) => string | undefined;
-/**
- * Reducers
- */
 declare const selectShouldFetchOrganization: ((state: {
     app: AppState;
     chat: ChatState;
@@ -2677,9 +2338,6 @@ interface StreamStatusUpdate {
     state: StreamState;
 }
 
-/**
- * Reducer
- */
 interface RemoteParticipantState {
     remoteParticipants: RemoteParticipant[];
 }
@@ -2927,18 +2585,12 @@ declare const remoteParticipantsSlice: _reduxjs_toolkit.Slice<RemoteParticipantS
         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: {
@@ -2996,9 +2648,6 @@ declare const selectScreenshares: ((state: {
 };
 
 type ConnectionStatus = "initializing" | "connecting" | "connected" | "reconnect" | "room_locked" | "knocking" | "disconnecting" | "disconnected" | "knock_rejected" | "kicked";
-/**
- * Reducer
- */
 interface RoomConnectionState {
     session: {
         createdAt: string;
@@ -3026,9 +2675,6 @@ declare const roomConnectionSlice: _reduxjs_toolkit.Slice<RoomConnectionState, {
 }, "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;
@@ -3037,9 +2683,6 @@ declare const selectRoomConnectionSession: (state: RootState) => {
 declare const selectRoomConnectionSessionId: (state: RootState) => string | undefined;
 declare const selectRoomConnectionStatus: (state: RootState) => ConnectionStatus;
 declare const selectRoomConnectionError: (state: RootState) => string | null;
-/**
- * Reactors
- */
 declare const selectShouldConnectRoom: ((state: {
     app: AppState;
     chat: ChatState;
@@ -3145,9 +2788,6 @@ declare const selectShouldConnectRoom: ((state: {
 declare const createWebRtcEmitter: (dispatch: AppDispatch) => {
     emit: (eventName: keyof RtcEvents, data: RtcEvents[keyof RtcEvents]) => void;
 };
-/**
- * Reducer
- */
 interface StreamResolutionUpdate {
     streamId: string;
     width: number;
@@ -3178,16 +2818,16 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
             };
         };
         rtcManager: {
-            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
-                activeBreakout: any;
-                clientId: any;
-                shouldAddLocalVideo: any;
-                streamId: any;
+            acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                activeBreakout: boolean;
+                clientId: string;
+                shouldAddLocalVideo: boolean;
+                streamId: string;
             }) => void;
             addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
-            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
             disconnectAll: () => void;
-            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => void;
             removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
             shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
             updateStreamResolution: (streamId: string, ignored: null, resolution: {
@@ -3195,8 +2835,46 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             }) => void;
             sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+            isInitializedWith: ({ selfId, roomName, isSfu }: {
+                selfId: string;
+                roomName: string;
+                isSfu: boolean;
+            }) => boolean;
+            setEventClaim?: ((eventClaim: string) => void) | undefined;
+            hasClient: (clientId: string) => boolean;
+        } | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => void;
         } | null;
-        rtcManagerDispatcher: {} | null;
         rtcManagerInitialized: boolean;
         status: "" | "ready" | "reconnect";
         isAcceptingStreams: boolean;
@@ -3212,16 +2890,16 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
             };
         };
         rtcManager: {
-            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
-                activeBreakout: any;
-                clientId: any;
-                shouldAddLocalVideo: any;
-                streamId: any;
+            acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                activeBreakout: boolean;
+                clientId: string;
+                shouldAddLocalVideo: boolean;
+                streamId: string;
             }) => void;
             addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
-            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
             disconnectAll: () => void;
-            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => void;
             removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
             shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
             updateStreamResolution: (streamId: string, ignored: null, resolution: {
@@ -3229,8 +2907,46 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             }) => void;
             sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+            isInitializedWith: ({ selfId, roomName, isSfu }: {
+                selfId: string;
+                roomName: string;
+                isSfu: boolean;
+            }) => boolean;
+            setEventClaim?: ((eventClaim: string) => void) | undefined;
+            hasClient: (clientId: string) => boolean;
+        } | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => void;
         } | null;
-        rtcManagerDispatcher: {} | null;
         rtcManagerInitialized: boolean;
         status: "" | "ready" | "reconnect";
     };
@@ -3245,16 +2961,16 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
             };
         };
         rtcManager: {
-            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
-                activeBreakout: any;
-                clientId: any;
-                shouldAddLocalVideo: any;
-                streamId: any;
+            acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                activeBreakout: boolean;
+                clientId: string;
+                shouldAddLocalVideo: boolean;
+                streamId: string;
             }) => void;
             addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
-            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
             disconnectAll: () => void;
-            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => void;
             removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
             shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
             updateStreamResolution: (streamId: string, ignored: null, resolution: {
@@ -3262,8 +2978,46 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             }) => void;
             sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+            isInitializedWith: ({ selfId, roomName, isSfu }: {
+                selfId: string;
+                roomName: string;
+                isSfu: boolean;
+            }) => boolean;
+            setEventClaim?: ((eventClaim: string) => void) | undefined;
+            hasClient: (clientId: string) => boolean;
+        } | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => void;
         } | null;
-        rtcManagerDispatcher: {} | null;
         rtcManagerInitialized: boolean;
         status: "" | "ready" | "reconnect";
         isAcceptingStreams: boolean;
@@ -3281,16 +3035,16 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
         error: unknown;
         isCreatingDispatcher: boolean;
         rtcManager: {
-            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
-                activeBreakout: any;
-                clientId: any;
-                shouldAddLocalVideo: any;
-                streamId: any;
+            acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                activeBreakout: boolean;
+                clientId: string;
+                shouldAddLocalVideo: boolean;
+                streamId: string;
             }) => void;
             addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
-            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
             disconnectAll: () => void;
-            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => void;
             removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
             shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
             updateStreamResolution: (streamId: string, ignored: null, resolution: {
@@ -3298,8 +3052,46 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             }) => void;
             sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+            isInitializedWith: ({ selfId, roomName, isSfu }: {
+                selfId: string;
+                roomName: string;
+                isSfu: boolean;
+            }) => boolean;
+            setEventClaim?: ((eventClaim: string) => void) | undefined;
+            hasClient: (clientId: string) => boolean;
+        } | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => void;
         } | null;
-        rtcManagerDispatcher: {} | null;
         rtcManagerInitialized: boolean;
         status: "" | "ready" | "reconnect";
         isAcceptingStreams: boolean;
@@ -3328,16 +3120,16 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
             };
         };
         rtcManager: {
-            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
-                activeBreakout: any;
-                clientId: any;
-                shouldAddLocalVideo: any;
-                streamId: any;
+            acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                activeBreakout: boolean;
+                clientId: string;
+                shouldAddLocalVideo: boolean;
+                streamId: string;
             }) => void;
             addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
-            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
             disconnectAll: () => void;
-            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => void;
             removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
             shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
             updateStreamResolution: (streamId: string, ignored: null, resolution: {
@@ -3345,8 +3137,46 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             }) => void;
             sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+            isInitializedWith: ({ selfId, roomName, isSfu }: {
+                selfId: string;
+                roomName: string;
+                isSfu: boolean;
+            }) => boolean;
+            setEventClaim?: ((eventClaim: string) => void) | undefined;
+            hasClient: (clientId: string) => boolean;
+        } | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => void;
         } | null;
-        rtcManagerDispatcher: {} | null;
         rtcManagerInitialized: boolean;
         status: "" | "ready" | "reconnect";
         isAcceptingStreams: boolean;
@@ -3362,16 +3192,16 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
             };
         };
         rtcManager: {
-            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
-                activeBreakout: any;
-                clientId: any;
-                shouldAddLocalVideo: any;
-                streamId: any;
+            acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                activeBreakout: boolean;
+                clientId: string;
+                shouldAddLocalVideo: boolean;
+                streamId: string;
             }) => void;
             addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
-            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
             disconnectAll: () => void;
-            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => void;
             removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
             shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
             updateStreamResolution: (streamId: string, ignored: null, resolution: {
@@ -3379,6 +3209,13 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             }) => void;
             sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+            isInitializedWith: ({ selfId, roomName, isSfu }: {
+                selfId: string;
+                roomName: string;
+                isSfu: boolean;
+            }) => boolean;
+            setEventClaim?: ((eventClaim: string) => void) | undefined;
+            hasClient: (clientId: string) => boolean;
         } | null;
         rtcManagerInitialized: boolean;
         status: "" | "ready" | "reconnect";
@@ -3395,16 +3232,16 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
             };
         };
         rtcManager: {
-            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
-                activeBreakout: any;
-                clientId: any;
-                shouldAddLocalVideo: any;
-                streamId: any;
+            acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                activeBreakout: boolean;
+                clientId: string;
+                shouldAddLocalVideo: boolean;
+                streamId: string;
             }) => void;
             addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
-            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
             disconnectAll: () => void;
-            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => void;
             removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
             shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
             updateStreamResolution: (streamId: string, ignored: null, resolution: {
@@ -3412,8 +3249,46 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             }) => void;
             sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+            isInitializedWith: ({ selfId, roomName, isSfu }: {
+                selfId: string;
+                roomName: string;
+                isSfu: boolean;
+            }) => boolean;
+            setEventClaim?: ((eventClaim: string) => void) | undefined;
+            hasClient: (clientId: string) => boolean;
+        } | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => void;
         } | null;
-        rtcManagerDispatcher: {} | null;
         rtcManagerInitialized: boolean;
         status: "" | "ready" | "reconnect";
         isAcceptingStreams: boolean;
@@ -3429,7 +3304,38 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             };
         };
-        rtcManagerDispatcher: {} | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => void;
+        } | null;
         rtcManagerInitialized: boolean;
         isAcceptingStreams: boolean;
     };
@@ -3444,16 +3350,16 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
             };
         };
         rtcManager: {
-            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
-                activeBreakout: any;
-                clientId: any;
-                shouldAddLocalVideo: any;
-                streamId: any;
+            acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                activeBreakout: boolean;
+                clientId: string;
+                shouldAddLocalVideo: boolean;
+                streamId: string;
             }) => void;
             addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
-            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
             disconnectAll: () => void;
-            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => void;
             removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
             shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
             updateStreamResolution: (streamId: string, ignored: null, resolution: {
@@ -3461,8 +3367,46 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             }) => void;
             sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+            isInitializedWith: ({ selfId, roomName, isSfu }: {
+                selfId: string;
+                roomName: string;
+                isSfu: boolean;
+            }) => boolean;
+            setEventClaim?: ((eventClaim: string) => void) | undefined;
+            hasClient: (clientId: string) => boolean;
+        } | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => void;
         } | null;
-        rtcManagerDispatcher: {} | null;
         rtcManagerInitialized: boolean;
         status: "" | "ready" | "reconnect";
         isAcceptingStreams: boolean;
@@ -3477,7 +3421,38 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             };
         };
-        rtcManagerDispatcher: {} | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => void;
+        } | null;
         rtcManagerInitialized: boolean;
         status: "" | "ready" | "reconnect";
         isAcceptingStreams: boolean;
@@ -3493,16 +3468,16 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
             };
         };
         rtcManager: {
-            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
-                activeBreakout: any;
-                clientId: any;
-                shouldAddLocalVideo: any;
-                streamId: any;
+            acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                activeBreakout: boolean;
+                clientId: string;
+                shouldAddLocalVideo: boolean;
+                streamId: string;
             }) => void;
             addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
-            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
             disconnectAll: () => void;
-            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => void;
             removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
             shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
             updateStreamResolution: (streamId: string, ignored: null, resolution: {
@@ -3510,8 +3485,46 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             }) => void;
             sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+            isInitializedWith: ({ selfId, roomName, isSfu }: {
+                selfId: string;
+                roomName: string;
+                isSfu: boolean;
+            }) => boolean;
+            setEventClaim?: ((eventClaim: string) => void) | undefined;
+            hasClient: (clientId: string) => boolean;
+        } | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => void;
         } | null;
-        rtcManagerDispatcher: {} | null;
         rtcManagerInitialized: boolean;
         status: "" | "ready" | "reconnect";
         isAcceptingStreams: boolean;
@@ -3527,16 +3540,16 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
             };
         };
         rtcManager: {
-            acceptNewStream: ({ activeBreakout: boolean, clientId: string, shouldAddLocalVideo: boolean, streamId: string, }: {
-                activeBreakout: any;
-                clientId: any;
-                shouldAddLocalVideo: any;
-                streamId: any;
+            acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                activeBreakout: boolean;
+                clientId: string;
+                shouldAddLocalVideo: boolean;
+                streamId: string;
             }) => void;
             addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
-            disconnect: (streamId: string, activeBreakout: boolean) => void;
+            disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
             disconnectAll: () => void;
-            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
+            replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => void;
             removeStream: (streamId: string, _stream: MediaStream, requestedByClientId: string | null) => void;
             shouldAcceptStreamsFromBothSides?: (() => boolean) | undefined;
             updateStreamResolution: (streamId: string, ignored: null, resolution: {
@@ -3544,15 +3557,50 @@ declare const rtcConnectionSlice: _reduxjs_toolkit.Slice<RtcConnectionState, {
                 height: number;
             }) => void;
             sendStatsCustomEvent: (eventName: string, data: unknown) => void;
+            isInitializedWith: ({ selfId, roomName, isSfu }: {
+                selfId: string;
+                roomName: string;
+                isSfu: boolean;
+            }) => boolean;
+            setEventClaim?: ((eventClaim: string) => void) | undefined;
+            hasClient: (clientId: string) => boolean;
+        } | null;
+        rtcManagerDispatcher: {
+            emitter: {
+                emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K] | undefined) => void;
+            };
+            currentManager: {
+                acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                    activeBreakout: boolean;
+                    clientId: string;
+                    shouldAddLocalVideo: boolean;
+                    streamId: string;
+                }) => void;
+                addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                disconnectAll: () => void;
+                replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                isInitializedWith: ({ selfId, roomName, isSfu }: {
+                    selfId: string;
+                    roomName: string;
+                    isSfu: boolean;
+                }) => boolean;
+                setEventClaim?: ((eventClaim: string) => void) | undefined;
+                hasClient: (clientId: string) => boolean;
+            } | null;
+            stopRtcManager: () => 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">;
@@ -3566,9 +3614,6 @@ declare const doHandleAcceptStreams: (args: StreamStatusUpdate[]) => AppThunk<vo
 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;
@@ -3597,8 +3642,8 @@ declare const selectShouldConnectRtc: ((state: {
     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) & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: boolean, resultFuncArgs_2: _whereby_com_media.ServerSocket | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: boolean, resultFuncArgs_2: _whereby_com_media.ServerSocket | null) => boolean) & {
         clearCache: () => void;
         resultsCount: () => number;
         resetResultsCount: () => void;
@@ -3620,7 +3665,7 @@ declare const selectShouldConnectRtc: ((state: {
         signalConnection: SignalConnectionState;
         streaming: StreamingState;
         waitingParticipants: WaitingParticipantsState;
-    }) => _whereby_jslib_media_src_utils_ServerSocket.default | null];
+    }) => _whereby_com_media.ServerSocket | null];
     recomputations: () => number;
     resetRecomputations: () => void;
     dependencyRecomputations: () => number;
@@ -3805,14 +3850,11 @@ declare const selectStreamsToAccept: ((state: {
     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;
+    socket: ServerSocket | null;
 }
 declare const signalConnectionSlice: _reduxjs_toolkit.Slice<SignalConnectionState, {
     socketConnecting: (state: {
@@ -3820,24 +3862,204 @@ declare const signalConnectionSlice: _reduxjs_toolkit.Slice<SignalConnectionStat
         isIdentifyingDevice: boolean;
         status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | null;
     }) => {
         status: "connecting";
         deviceIdentified: boolean;
         isIdentifyingDevice: boolean;
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | null;
     };
     socketConnected: (state: {
@@ -3845,15 +4067,105 @@ declare const signalConnectionSlice: _reduxjs_toolkit.Slice<SignalConnectionStat
         isIdentifyingDevice: boolean;
         status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | null;
-    }, action: PayloadAction<_whereby_jslib_media_src_utils_ServerSocket__default>) => {
-        socket: _whereby_jslib_media_src_utils_ServerSocket__default;
+    }, action: PayloadAction<ServerSocket>) => {
+        socket: ServerSocket;
         status: "connected";
         deviceIdentified: boolean;
         isIdentifyingDevice: boolean;
@@ -3863,24 +4175,204 @@ declare const signalConnectionSlice: _reduxjs_toolkit.Slice<SignalConnectionStat
         isIdentifyingDevice: boolean;
         status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | null;
     }) => {
         status: "disconnected";
         deviceIdentified: boolean;
         isIdentifyingDevice: boolean;
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | null;
     };
     socketReconnecting: (state: {
@@ -3888,24 +4380,204 @@ declare const signalConnectionSlice: _reduxjs_toolkit.Slice<SignalConnectionStat
         isIdentifyingDevice: boolean;
         status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | null;
     }) => {
         status: "reconnect";
         deviceIdentified: boolean;
         isIdentifyingDevice: boolean;
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | null;
     };
     deviceIdentifying: (state: {
@@ -3913,24 +4585,204 @@ declare const signalConnectionSlice: _reduxjs_toolkit.Slice<SignalConnectionStat
         isIdentifyingDevice: boolean;
         status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | null;
     }) => {
         isIdentifyingDevice: true;
         deviceIdentified: boolean;
         status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | null;
     };
     deviceIdentified: (state: {
@@ -3938,35 +4790,212 @@ declare const signalConnectionSlice: _reduxjs_toolkit.Slice<SignalConnectionStat
         isIdentifyingDevice: boolean;
         status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | null;
     }) => {
         deviceIdentified: true;
         isIdentifyingDevice: false;
         status: "connected" | "connecting" | "disconnected" | "reconnect" | "";
         socket: {
+            _socket: any;
+            _reconnectManager?: {
+                _socket: any;
+                _clients: any;
+                _signalDisconnectTime?: number | undefined;
+                rtcManager?: {
+                    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+                        activeBreakout: boolean;
+                        clientId: string;
+                        shouldAddLocalVideo: boolean;
+                        streamId: string;
+                    }) => void;
+                    addNewStream: (streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean) => void;
+                    disconnect: (streamId: string, activeBreakout: boolean | null, eventClaim?: string | undefined) => void;
+                    disconnectAll: () => void;
+                    replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => 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;
+                    isInitializedWith: ({ selfId, roomName, isSfu }: {
+                        selfId: string;
+                        roomName: string;
+                        isSfu: boolean;
+                    }) => boolean;
+                    setEventClaim?: ((eventClaim: string) => void) | undefined;
+                    hasClient: (clientId: string) => boolean;
+                } | undefined;
+                metrics: {
+                    roomJoinedLate: number;
+                    pendingClientCanceled: number;
+                    evaluationFailed: number;
+                    roomJoined: number;
+                };
+                _onRoomJoined: (payload: any) => Promise<void>;
+                _onClientLeft: (payload: any) => void;
+                _onPendingClientLeft: (payload: any) => void;
+                _onNewClient: (payload: any) => void;
+                _abortIfNotActive: (payload: any) => Promise<void>;
+                _checkIsActive: (clientId: string) => Promise<boolean>;
+                _isClientMediaActive: (stats: any, clientId: string) => boolean;
+                _onAudioEnabled: (payload: any) => void;
+                _onVideoEnabled: (payload: any) => void;
+                _onScreenshareChanged: (payload: any, action: boolean) => void;
+                _hasClientStateChanged: ({ clientId, webcam, mic, screenShare, }: {
+                    clientId: string;
+                    webcam: boolean;
+                    mic: boolean;
+                    screenShare: boolean;
+                }) => boolean;
+                _addClientToState: (newClient: any) => void;
+                _wasClientSendingMedia: (clientId: string) => any;
+                _getPendingClientsByDeviceId: (deviceId: string) => unknown[];
+                _resetClientState: (payload: any) => void;
+                [EventEmitter.captureRejectionSymbol]?: ((error: Error, event: string, ...args: any[]) => void) | undefined;
+                addListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                on: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                once: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                off: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                removeAllListeners: (event?: string | symbol | undefined) => _whereby_com_media.ReconnectManager;
+                setMaxListeners: (n: number) => _whereby_com_media.ReconnectManager;
+                getMaxListeners: () => number;
+                listeners: (eventName: string | symbol) => Function[];
+                rawListeners: (eventName: string | symbol) => Function[];
+                emit: (eventName: string | symbol, ...args: any[]) => boolean;
+                listenerCount: (eventName: string | symbol, listener?: Function | undefined) => number;
+                prependListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                prependOnceListener: (eventName: string | symbol, listener: (...args: any[]) => void) => _whereby_com_media.ReconnectManager;
+                eventNames: () => (string | symbol)[];
+            } | null | undefined;
+            noopKeepaliveInterval: any;
+            _wasConnectedUsingWebsocket?: boolean | undefined;
+            setRtcManager: (rtcManager?: _whereby_com_media.RtcManager | undefined) => void;
             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;
+            disconnectOnConnect: () => void;
+            emit: (eventName: string, ...args: any[]) => void;
+            emitIfConnected: (eventName: string, data: any) => void;
+            getTransport: () => any;
+            getManager: () => any;
+            isConnecting: () => any;
+            isConnected: () => any;
+            on: (eventName: string, handler: Function) => () => void;
+            once: (eventName: string, handler: Function) => void;
+            off: (eventName: string, handler: Function) => void;
+            _interceptEvent: (eventName: string, handler: any) => () => void;
+            getGlitchFreeMetrics: () => {
+                roomJoinedLate: number;
+                pendingClientCanceled: number;
+                evaluationFailed: number;
+                roomJoined: number;
+            } | undefined;
         } | 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 socketConnected: _reduxjs_toolkit.ActionCreatorWithPayload<ServerSocket, "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;
@@ -3974,14 +5003,11 @@ declare const doSignalIdentifyDevice: (args: {
 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 selectSignalConnectionSocket: (state: RootState) => ServerSocket | null;
 declare const selectShouldConnectSignal: ((state: {
     app: AppState;
     chat: ChatState;
@@ -4255,23 +5281,6 @@ declare const addAppListener: TypedAddListener<{
 type SelectorResults<Selectors extends Selector<RootState, unknown>[]> = {
     [K in keyof Selectors]: Selectors[K] extends Selector<RootState, infer R> ? R : never;
 };
-/**
- * Creates a reactor that will be called whenever the provided selectors change.
- * Every reactor needs to update a piece of state that it depends on, to avoid infinite loops.
- * example:
- * ```ts
- * createReactor(
- *    [selectAppWantsToJoin, selectDeviceCredentialsRaw],
- *   ({ dispatch }, wantsToJoin, deviceCredentialsRaw) => {
- *      if (wantsToJoin && deviceCredentialsRaw.data) {
- *         dispatch(doSignalIdentifyDevice({ deviceCredentials: deviceCredentialsRaw.data }));
- *    }
- * });
- * ```
- * @param selectors. The selectors to be used to check if the state has changed.
- * @param callback. The callback to be called on every action. The first argument is the listenerApi, the second argument is the result of the selectors.
- * @returns The unsubscribe function.
- */
 declare const createReactor: <Selectors extends Selector<{
     app: AppState;
     chat: ChatState;