@cloudflare/realtimekit 1.0.2 → 1.1.0-staging.11

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { EventEmitter } from 'events';
+/// <reference types="node" />
+import EventEmitter$1, { EventEmitter } from 'events';
 import { MessageType as MessageType$1 } from '@protobuf-ts/runtime';
 import * as _dyteinternals_utils from '@dyteinternals/utils';
-import { ViewType, MediaVideoQualityType, LivestreamViewerMediaQualityType, MediaProductionPermissionType, WaitingRoomTypes, PresetTypeV2, MediaScreenShareQualityType, PluginAccessControls, RecorderType as RecorderType$1, BorderRadius, BorderWidth, Theme } from '@dyteinternals/utils';
+import { ViewType, createNewFlagsmithInstance, PresetTypeV2, MediaVideoQualityType, LivestreamViewerMediaQualityType, MediaProductionPermissionType, WaitingRoomTypes, MediaScreenShareQualityType, PluginAccessControls, RecorderType as RecorderType$1, BorderRadius, BorderWidth, Theme } from '@dyteinternals/utils';
 import * as WorkerTimers from 'worker-timers';
 
 declare global {
@@ -50,13 +51,13 @@ declare class RTKEventEmitter<T extends string | symbol> extends EventEmitter {
     listeners(event: T): Function[];
     listenerCount(event: T): number;
 }
-type EventMap = {
+type EventMap$1 = {
     [key: string]: (...args: any[]) => void;
 };
 type WildCardEvent<T> = {
     ['*']: (event: StringKeyOf<T>, ...args: any) => void;
 };
-declare class RTKTypedEventEmitter<Events extends EventMap & WildCardEvent<Events>> extends EventEmitter {
+declare class RTKTypedEventEmitter<Events extends EventMap$1 & WildCardEvent<Events>> extends EventEmitter {
     constructor();
     emit<E extends StringKeyOf<Events>>(event: E, ...args: Parameters<Events[E]>): boolean;
     on<E extends StringKeyOf<Events>>(event: E, callback: Events[E]): this;
@@ -828,6 +829,86 @@ interface RoomInfoResponse {
  * @generated MessageType for protobuf message socket.room.RoomInfoResponse
  */
 declare const RoomInfoResponse: RoomInfoResponse$Type;
+declare class CreateRoomRequestPayload$Type extends MessageType$1<CreateRoomRequestPayload> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.CreateRoomRequestPayload
+ */
+interface CreateRoomRequestPayload {
+    /**
+     * @generated from protobuf field: optional string title = 1;
+     */
+    title?: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.room.CreateRoomRequestPayload
+ */
+declare const CreateRoomRequestPayload: CreateRoomRequestPayload$Type;
+declare class UpdateRoomRequestPayload$Type extends MessageType$1<UpdateRoomRequestPayload> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.UpdateRoomRequestPayload
+ */
+interface UpdateRoomRequestPayload {
+    /**
+     * @generated from protobuf field: optional string meeting_id = 1;
+     */
+    meetingId?: string;
+    /**
+     * @generated from protobuf field: optional string title = 2;
+     */
+    title?: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.room.UpdateRoomRequestPayload
+ */
+declare const UpdateRoomRequestPayload: UpdateRoomRequestPayload$Type;
+declare class MovePeerPayload$Type extends MessageType$1<MovePeerPayload> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.MovePeerPayload
+ */
+interface MovePeerPayload {
+    /**
+     * @generated from protobuf field: optional string id = 1;
+     */
+    id?: string;
+    /**
+     * @generated from protobuf field: optional string preset_id = 2;
+     */
+    presetId?: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.room.MovePeerPayload
+ */
+declare const MovePeerPayload: MovePeerPayload$Type;
+declare class MovePeersBetweenRoomsRequest$Type extends MessageType$1<MovePeersBetweenRoomsRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.MovePeersBetweenRoomsRequest
+ */
+interface MovePeersBetweenRoomsRequest {
+    /**
+     * @generated from protobuf field: optional string source_meeting_id = 1;
+     */
+    sourceMeetingId?: string;
+    /**
+     * @generated from protobuf field: optional string destination_meeting_id = 2;
+     */
+    destinationMeetingId?: string;
+    /**
+     * @generated from protobuf field: repeated socket.room.MovePeerPayload participants = 3;
+     */
+    participants: MovePeerPayload[];
+}
+/**
+ * @generated MessageType for protobuf message socket.room.MovePeersBetweenRoomsRequest
+ */
+declare const MovePeersBetweenRoomsRequest: MovePeersBetweenRoomsRequest$Type;
 declare class WaitingRoomRequest$Type extends MessageType$1<WaitingRoomRequest> {
     constructor();
 }
@@ -1875,7 +1956,916 @@ interface RecordingEvent {
  */
 declare const RecordingEvent: RecordingEvent$Type;
 
+interface DeviceInfo$1 {
+    isMobile: boolean;
+    browserName: string;
+    browserVersion: string;
+    osName: string;
+    osVersionName: string;
+    engineName: string;
+    userAgent: string;
+    cpus: number;
+    memory?: number;
+    webglSupport?: number;
+}
+interface GeoLocation {
+    coords: {
+        latitude: number;
+        longitude: number;
+    };
+}
+interface IPDetails {
+    ip: string;
+    city: string;
+    region: string;
+    country: string;
+    loc: string | GeoLocation;
+    org: string;
+    portal: string;
+    timezone: string;
+}
+interface ThroughputInformation {
+    throughput: number;
+    fractionalLoss: number;
+    RTT: number;
+    jitter: number;
+    backendRTT: number;
+}
+interface IceConnectivity {
+    host: boolean;
+    relay: boolean;
+    reflexive: boolean;
+}
+interface NetworkQualityInformation extends ThroughputInformation {
+    connectivity: IceConnectivity;
+}
+interface NetworkInformation extends NetworkQualityInformation {
+    ipDetails: IPDetails;
+    location: GeoLocation;
+    turnConnectivity: boolean;
+    effectiveNetworkType: string;
+}
+interface NetworkInformationWithoutConnectivityData {
+    ipDetails: IPDetails;
+    location: GeoLocation;
+    effectiveNetworkType: string;
+}
+type RTCDtlsTransportState = 'closed' | 'connected' | 'connecting' | 'failed' | 'new';
+type RTCIceRole = 'controlled' | 'controlling' | 'unknown';
+interface VideoStreamStats {
+    frameHeight: number;
+    frameWidth: number;
+    droppedFrames?: number;
+    framerateMean?: number;
+    framesDropped: number;
+    framesPerSecond: number;
+    firCount: number;
+}
+interface AudioStreamStats {
+}
+interface InboundStreamStats {
+    codecId: string;
+    bytesReceived: number;
+    headerBytesReceived: number;
+    packetsReceived: number;
+    packetsLost: number;
+    packetsDiscarded: number;
+    jitter: number;
+    nackCount: number;
+    jitterBufferDelay: number;
+    jitterBufferEmittedCount: number;
+    jitterBufferMinimumDelay: number;
+    jitterBufferTargetDelay: number;
+    lastPacketReceivedTimestamp: number;
+    ssrc: number;
+    mid: string;
+    score?: number;
+}
+interface RemoteInboundStreamStats {
+    jitter: number;
+    fractionLost: number;
+    roundTripTime: number;
+    roundTripTimeMeasurements: number;
+    totalRoundTripTime: number;
+    packetsLost: number;
+    localId?: string;
+}
+interface OutboundStreamStats {
+    active: boolean;
+    codecId: string;
+    headerBytesSent: number;
+    totalPacketSendDelay: number;
+    bytesSent: number;
+    packetsSent: number;
+    retransmittedBytesSent?: number;
+    retransmittedPacketsSent?: number;
+    remoteData?: RemoteInboundStreamStats;
+    nackCount: number;
+    ssrc: number;
+    mid: string;
+    score?: number;
+}
+interface InboundVideoStreamStats extends VideoStreamStats, InboundStreamStats {
+    qpSum: number;
+    totalAssemblyTime: number;
+    totalDecodeTime: number;
+    totalFreezesDuration: number;
+    totalInterFrameDelay: number;
+    totalPausesDuration: number;
+    totalSquaredInterFrameDelay: number;
+    framesDecoded: number;
+    framesDropped: number;
+    keyFramesDecoded: number;
+    freezeCount: number;
+    framesReceived: number;
+    pauseCount: number;
+    pliCount: number;
+    totalProcessingDelay: number;
+    decoderImplementation: string;
+    powerEfficientDecoder: boolean;
+}
+interface QualityLimitationDurations {
+    bandwidth: number;
+    cpu: number;
+    none: number;
+    other: number;
+}
+interface OutboundVideoStreamStats extends VideoStreamStats, OutboundStreamStats {
+    hugeFramesSent: number;
+    pliCount: number;
+    qpSum: number;
+    framesEncoded: number;
+    framesSent: number;
+    keyFramesEncoded: number;
+    encoderImplementation: string;
+    qualityLimitationReason: string;
+    qualityLimitationResolutionChanges: number;
+    qualityLimitationDurations: QualityLimitationDurations;
+    totalEncodeTime: number;
+    targetBitrate?: number;
+    scalabilityMode: string;
+    powerEfficientEncoder: boolean;
+}
+interface InboundAudioStreamStats extends AudioStreamStats, InboundStreamStats {
+    audioLevel: number;
+    concealedSamples: number;
+    concealmentEvents: number;
+    totalAudioEnergy: number;
+    totalSamplesDuration: number;
+    totalSamplesReceived: number;
+    fecPacketsDiscarded: number;
+    fecPacketsReceived: number;
+    insertedSamplesForDeceleration: number;
+    removedSamplesForAcceleration: number;
+    silentConcealedSamples: number;
+    playoutId: string;
+}
+interface OutboundAudioStreamStats extends AudioStreamStats, OutboundStreamStats {
+}
+interface IceCandidateStats {
+    id: string;
+    type?: string;
+    address?: string;
+    port?: number;
+    relatedAddress?: string;
+    relatedPort?: number;
+    url?: string;
+    protocol?: string;
+    networkType?: string;
+}
+interface IceCandidatePairStats {
+    nominated: boolean;
+    currentRoundTripTime?: number;
+    totalRoundTripTime?: number;
+    bytesSent?: number;
+    bytesReceived?: number;
+    bytesDiscardedOnSend?: number;
+    packetsSent?: number;
+    packetsReceived?: number;
+    packetsDiscardedOnSend?: number;
+    availableOutgoingBitrate?: number;
+    availableIncomingBitrate?: number;
+    lastPacketReceivedTimestamp?: number;
+    lastPacketSentTimestamp?: number;
+    localCandidateId?: string;
+    localCandidateType?: string;
+    localCandidateAddress?: string;
+    localCandidatePort?: number;
+    localCandidateRelatedAddress?: string;
+    localCandidateRelatedPort?: number;
+    localCandidateUrl?: string;
+    localCandidateProtocol?: string;
+    localCandidateNetworkType?: string;
+    remoteCandidateId?: string;
+    remoteCandidateType?: string;
+    remoteCandidateAddress?: string;
+    remoteCandidatePort?: number;
+    remoteCandidateUrl?: string;
+    remoteCandidateProtocol?: string;
+}
+interface WebRtcTransportStat {
+    bytesReceived?: number;
+    bytesSent?: number;
+    roundTripTime?: number;
+    totalRoundTripTime?: number;
+    availableOutgoingBitrate?: number;
+    availableIncomingBitrate?: number;
+    dtlsCipher?: string;
+    dtlsState?: RTCDtlsTransportState;
+    iceRole?: RTCIceRole;
+    packetsReceived?: number;
+    packetsSent?: number;
+    candidatePairs?: IceCandidatePairStats[];
+}
+interface TransportStatistics extends Object {
+    transportId: string;
+    consuming: boolean;
+    producing: boolean;
+    stats: WebRtcTransportStat;
+}
+interface ProducerStatistics extends Object {
+    producerId: string;
+    videoStats: OutboundVideoStreamStats[];
+    audioStats: OutboundAudioStreamStats[];
+    appData?: {
+        screenShare?: boolean;
+        supportsRemoteControl?: boolean;
+    };
+}
+interface ConsumerStatistics extends Object {
+    consumerId: string;
+    peerId: string;
+    producerId: string;
+    videoStats: InboundVideoStreamStats[];
+    audioStats: InboundAudioStreamStats[];
+    appData: Record<string, unknown>;
+}
+interface ProcessedStatsReport {
+    transportReport: TransportStatistics;
+    producerReport: ProducerStatistics[];
+    consumerReport: ConsumerStatistics[];
+}
+interface AudioProducerScoreStats {
+    score: number;
+    packetsLostPercentage: number;
+    jitter: number;
+    isScreenShare: boolean;
+    bitrate: number;
+}
+interface VideoProducerScoreStats {
+    score: number;
+    frameWidth: number;
+    frameHeight: number;
+    framesPerSecond: number;
+    packetsLostPercentage: number;
+    jitter: number;
+    isScreenShare: boolean;
+    bitrate: number;
+    cpuLimitations: boolean;
+    bandwidthLimitations: boolean;
+}
+interface AudioConsumerScoreStats {
+    score: number;
+    packetsLostPercentage: number;
+    jitter: number;
+    isScreenShare: boolean;
+    bitrate: number;
+}
+interface VideoConsumerScoreStats {
+    score: number;
+    frameWidth: number;
+    frameHeight: number;
+    framesPerSecond: number;
+    packetsLostPercentage: number;
+    jitter: number;
+    isScreenShare: boolean;
+    bitrate: number;
+}
+type ProducerScoreStats = AudioProducerScoreStats | VideoProducerScoreStats;
+type ConsumerScoreStats = AudioConsumerScoreStats | VideoConsumerScoreStats;
+
+interface IceServerInfo {
+    urls: string;
+    username: string;
+    credential?: string;
+    /**
+     * Note(ravindra-dyte):
+     * credentialType is deprecated.
+     * https://developer.mozilla.org/en-US/docs/Web/API/RTCIceServer/credentialType
+     */
+    credentialType?: 'password';
+}
+interface RegionalIceInformation {
+    regionId: string;
+    iceServers: IceServerInfo[];
+}
+interface ApiHostnames {
+    location: string;
+    locationLegacy: string;
+    daCollector: string;
+}
 type ClientEnvTypeAll = 'devel' | 'preprod' | 'prod';
+declare enum MediaDeviceType {
+    AUDIO = "AUDIO",
+    VIDEO = "VIDEO",
+    SPEAKER = "SPEAKER",
+    SCREENSHARE = "SCREENSHARE"
+}
+type MediaDeviceTypeAll = keyof typeof MediaDeviceType;
+interface DeviceInfo {
+    isMobile: boolean;
+    browserName: string;
+    browserVersion: string;
+    osName: string;
+    osVersionName: string;
+    engineName: string;
+    userAgent: string;
+    cpus: number;
+    memory: number;
+    webglSupport?: number;
+}
+interface PeerMetaData$1 {
+    metaData: Object;
+    deviceInfo: DeviceInfo;
+    meetingEnv?: string;
+    peerId: string;
+    userId: string;
+    roomUUID: string;
+    permissions: Object;
+    participantRole?: string;
+    roomViewType: string;
+}
+/** Similar to what web-core has for media permissions */
+type MediaPermissions$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'CANCELED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE';
+interface InhouseCallStatsInitializeParams {
+    peerId: string;
+    engineName: string;
+    env?: ClientEnvTypeAll;
+    iceServers: any[];
+    apiBase?: string;
+    flags: Record<string, Record<'enabled' | 'value', any>>;
+    logger?: RTKLogger$2;
+    apiHostnames: ApiHostnames;
+    skipConnectivityChecks: boolean;
+}
+/**
+ * Note(ravindra-dyte):
+ * This is redundantly added here to avoid circular dependency on web-core build
+ *   */
+declare type LogData$3 = {
+    [key: string]: string | number | boolean | null | undefined | LogData$3;
+};
+declare interface RTKLogger$2 {
+    info(humanReadableLogIdentifier: string, logData?: LogData$3, isCrucial?: boolean): void;
+    error(humanReadableLogIdentifier: string, logData?: LogData$3, isCrucial?: boolean): void;
+    debug(humanReadableLogIdentifier: string, logData?: LogData$3, isCrucial?: boolean): void;
+    log(humanReadableLogIdentifier: string, logData?: LogData$3, isCrucial?: boolean): void;
+    warn(humanReadableLogIdentifier: string, logData?: LogData$3, isCrucial?: boolean): void;
+}
+
+declare enum Event {
+    PRECALL_TEST_BEGIN = "precall_begin",
+    PRECALL_TEST_COMPLETE = "precall_end",
+    CALL_JOIN_BEGIN = "call_join",
+    NET_QUALITY_TEST_BEGIN = "net_quality_test_begin",
+    NET_QUALITY_TEST_END = "net_quality_test_end",
+    WEBSOCKET_CONNECTED = "websocket_connected",
+    TRANSPORT_CONNECTED = "transport_connected",
+    AUDIO_ON = "audio_on",
+    AUDIO_OFF = "audio_off",
+    VIDEO_ON = "video_on",
+    VIDEO_OFF = "video_off",
+    PARTICIPANT_ROLE = "participant_role",
+    PING_STAT = "ping_stat",
+    DISCONNECT = "disconnect",
+    RECONNECT_ATTEMPT = "reconnect_attempt",
+    SCREENSHARE_START_REQUESTED = "screenshare_start_requested",
+    SCREENSHARE_STARTED = "screenshare_started",
+    SCREENSHARE_STOPPED = "screenshare_stopped",
+    TAB_CHANGE = "tab_change",
+    BROWSER_BACKGROUNDED = "browser_backgrounded",
+    BROWSER_FOREGROUNDED = "browser_foregrounded",
+    DOMINANT_SPEAKER = "dominant_speaker",
+    AUDIO_DEVICES_UPDATES = "audio_devices_updates",
+    VIDEO_DEVICES_UPDATES = "video_devices_updates",
+    SPEAKER_DEVICES_UPDATES = "speaker_devices_updates",
+    SELECTED_MICROHPONE_UPDATE = "selected_microphone_update",
+    SELECTED_CAMERA_UPDATE = "selected_camera_update",
+    SELECTED_SPEAKER_UPDATE = "selected_speaker_update",
+    EXPECTED_VIDEO_RESOLUTION = "expected_video_resolution",
+    EXPECTED_SCREENSHARE_RESOLUTION = "expected_screenshare_resolution",
+    MEDIA_PERMISSION = "media_permission",
+    LEGACY_SWITCH = "legacy_switch",
+    AUDIO_PLAY_FAILED = "audio_play_failed",
+    VIDEO_PLAY_FAILED = "video_play_failed",
+    AUDIO_TRACK_MUTED = "audio_track_muted",
+    VIDEO_TRACK_MUTED = "video_track_muted",
+    IVS_PLAYER_REBUFFERING = "ivs_player_rebuffering",
+    IVS_PLAYER_AUDIO_BLOCKED = "ivs_player_audio_blocked",
+    IVS_PLAYER_PLAYBACK_BLOCKED = "ivs_player_playback_blocked",
+    IVS_PLAYER_ERROR = "ivs_player_error",
+    IVS_PLAYER_RECOVERABLE_ERROR = "ivs_player_recoverable_error",
+    IVS_PLAYER_WORKER_ERROR = "ivs_player_worker_error",
+    IVS_PLAYER_NETWORK_UNAVAILABLE = "ivs_player_network_unavailable",
+    LIVESTREAM_LATENCY = "livestream_latency",
+    IVS_PLAYER_ANALYTICS_EVENT = "ivs_player_analytics_event",
+    IVS_PLAYER_PLAYBACK_RATE_CHANGED = "ivs_player_playback_rate_changed",
+    IVS_PLAYER_QUALITY_CHANGED = "ivs_player_quality_changed",
+    IVS_PLAYER_INITIALIZED = "ivs_player_initialized"
+}
+interface PeerMetaData {
+    metaData: Object;
+    deviceInfo: DeviceInfo$1;
+    meetingEnv?: string;
+    peerId: string;
+    userId: string;
+    roomUUID: string;
+    permissions: Object;
+    participantRole?: string;
+    roomViewType: string;
+}
+interface EventDataBase extends Object {
+}
+interface CallJoinData extends EventDataBase {
+    peerMetaData: PeerMetaData;
+}
+interface PingStatsData extends EventDataBase {
+    producingTransportStats?: TransportStatistics;
+    consumingTransportStats?: TransportStatistics;
+    producerStats?: ProducerStatistics[];
+    consumerStats?: ConsumerStatistics[];
+}
+interface PreCallTestData extends EventDataBase {
+    connectionInfo?: NetworkInformation;
+}
+interface PreCallTestDataWithoutConnectivityData extends EventDataBase {
+    connectionInfo?: NetworkInformationWithoutConnectivityData;
+}
+interface RegionalNetworkQualityTestData extends RegionalIceInformation {
+    networkResults: NetworkQualityInformation;
+}
+interface NetworkQualityTestData extends EventDataBase {
+    regionData: RegionalNetworkQualityTestData[];
+}
+interface ParticipantRoleData extends EventDataBase {
+    participantRole: string;
+}
+interface ExpectedVideoResolutionEntry extends EventEntryBase {
+    event: Event.EXPECTED_VIDEO_RESOLUTION;
+    metaData: {
+        frameWidth: number;
+        frameHeight: number;
+    };
+}
+interface ExpectedScreenshareResolutionEntry extends EventEntryBase {
+    event: Event.EXPECTED_SCREENSHARE_RESOLUTION;
+    metaData: {
+        frameWidth: number;
+        frameHeight: number;
+    };
+}
+interface EmptyData extends EventDataBase {
+}
+interface MediaDevicesData extends EventDataBase {
+    deviceList: MediaDeviceInfo[];
+}
+interface IVSPlayerQualityChangedData extends EventDataBase {
+    name: string;
+    group: string;
+    codecs: string;
+    bitrate: number;
+    width: number;
+    height: number;
+    framerate: number;
+    isDefault: boolean;
+}
+interface IVSPlayerAnalyticsEventData extends EventDataBase {
+    name: string;
+    properties: Object;
+}
+interface IVSPlayerErrorData extends EventDataBase {
+    type: string;
+    code: number;
+    source: string;
+    message: string;
+}
+interface IVSPlayerRecoverableErrorData extends EventDataBase {
+    type: string;
+    code: number;
+    source: string;
+    message: string;
+}
+interface IVSPlayerPlaybackRateChangedData extends EventDataBase {
+    updatedPlaybackRate: number;
+}
+interface IVSPlayerLiveLatencyData extends EventDataBase {
+    latency: number;
+}
+type EventData = CallJoinData | PingStatsData | NetworkQualityTestData | EmptyData | ParticipantRoleData | ParticipantRoleData | MediaDevicesData | IVSPlayerQualityChangedData | IVSPlayerAnalyticsEventData | IVSPlayerErrorData | IVSPlayerRecoverableErrorData | IVSPlayerPlaybackRateChangedData | IVSPlayerLiveLatencyData;
+interface EventEntryBase {
+    event: Event;
+    timestamp: Date;
+    metaData?: EventData;
+}
+interface PreCallTestBeginEntry extends EventEntryBase {
+    event: Event.PRECALL_TEST_BEGIN;
+}
+interface PreCallTestCompletedEntry extends EventEntryBase {
+    event: Event.PRECALL_TEST_COMPLETE;
+    metaData: PreCallTestData | PreCallTestDataWithoutConnectivityData;
+}
+interface CallJoinBeginEntry extends EventEntryBase {
+    event: Event.CALL_JOIN_BEGIN;
+    metaData: CallJoinData;
+}
+interface NetworkQualityTestBeginEntry extends EventEntryBase {
+    event: Event.NET_QUALITY_TEST_BEGIN;
+}
+interface NetworkQualityTestEndEntry extends EventEntryBase {
+    event: Event.NET_QUALITY_TEST_END;
+    metaData: NetworkQualityTestData;
+}
+interface WebSocketConnectedEntry extends EventEntryBase {
+    event: Event.WEBSOCKET_CONNECTED;
+}
+interface TransportConnectedEntry extends EventEntryBase {
+    event: Event.TRANSPORT_CONNECTED;
+}
+interface AudioToggleEntry extends EventEntryBase {
+    event: Event.AUDIO_OFF | Event.AUDIO_ON;
+}
+interface VideoToggleEntry extends EventEntryBase {
+    event: Event.VIDEO_OFF | Event.VIDEO_ON;
+}
+interface ScreenShareToggleEntry extends EventEntryBase {
+    event: Event.SCREENSHARE_STARTED | Event.SCREENSHARE_STOPPED;
+    metaData: {
+        ssrc: number;
+    };
+}
+interface ScreenShareRequestedEntry extends EventEntryBase {
+    event: Event.SCREENSHARE_START_REQUESTED;
+}
+interface DominantSpeakerEntry extends EventEntryBase {
+    event: Event.DOMINANT_SPEAKER;
+    metaData: {
+        peerId: string;
+    };
+}
+interface DevicesEntry extends EventEntryBase {
+    event: Event.AUDIO_DEVICES_UPDATES | Event.VIDEO_DEVICES_UPDATES | Event.SPEAKER_DEVICES_UPDATES;
+    metaData: MediaDevicesData;
+}
+interface SelectedDeviceEntry extends EventEntryBase {
+    event: Event.SELECTED_CAMERA_UPDATE | Event.SELECTED_MICROHPONE_UPDATE | Event.SELECTED_SPEAKER_UPDATE;
+    metaData: {
+        device: MediaDeviceInfo;
+    };
+}
+interface MediaPermissionEntry extends EventEntryBase {
+    event: Event.MEDIA_PERMISSION;
+    metaData: {
+        deviceType: MediaDeviceTypeAll;
+        permission: MediaPermissions$1;
+    };
+}
+interface MediaPlaybackFailureEntry extends EventEntryBase {
+    event: Event.AUDIO_PLAY_FAILED | Event.VIDEO_PLAY_FAILED;
+    metaData: {
+        deviceType: MediaDeviceTypeAll;
+    };
+}
+interface MediaTrackFailureEntry extends EventEntryBase {
+    event: Event.AUDIO_TRACK_MUTED | Event.VIDEO_TRACK_MUTED;
+    metaData: {
+        deviceType: MediaDeviceTypeAll;
+    };
+}
+interface TabChangeEntry extends EventEntryBase {
+    event: Event.TAB_CHANGE;
+    metaData: {
+        isMeetingsTabActive: boolean;
+    };
+}
+interface BrowserBackgroundedEntry extends EventEntryBase {
+    event: Event.BROWSER_BACKGROUNDED;
+}
+interface BrowserForegroundedEntry extends EventEntryBase {
+    event: Event.BROWSER_FOREGROUNDED;
+}
+interface LegacySwitchEntry extends EventEntryBase {
+    event: Event.LEGACY_SWITCH;
+    metadata: {
+        on: boolean;
+    };
+}
+interface ParticipantRoleToggleEntry extends EventEntryBase {
+    event: Event.PARTICIPANT_ROLE;
+    metaData: ParticipantRoleData;
+}
+interface PingStatsEntry extends EventEntryBase {
+    event: Event.PING_STAT;
+    metaData: PingStatsData;
+}
+interface DisconnectEntry extends EventEntryBase {
+    event: Event.DISCONNECT;
+}
+interface ReconnectEntry extends EventEntryBase {
+    event: Event.RECONNECT_ATTEMPT;
+}
+interface IVSPlayerRebufferingEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_REBUFFERING;
+}
+interface IVSPlayerAudioBlockedEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_AUDIO_BLOCKED;
+}
+interface IVSPlayerPlaybackBlockedEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_PLAYBACK_BLOCKED;
+}
+interface IVSPlayerNetworkUnavailableEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_NETWORK_UNAVAILABLE;
+}
+interface IVSPlayerInitializedEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_INITIALIZED;
+}
+interface IVSPlayerWorkerErrorEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_WORKER_ERROR;
+}
+interface IVSPlayerErrorEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_ERROR;
+    metaData: IVSPlayerErrorData;
+}
+interface IVSPlayerRecoverableErrorEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_RECOVERABLE_ERROR;
+    metaData: IVSPlayerRecoverableErrorData;
+}
+interface IVSPlayerAnalyticsEventEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_ANALYTICS_EVENT;
+    metaData: IVSPlayerAnalyticsEventData;
+}
+interface IVSPlayerPlaybackRateChangedEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_PLAYBACK_RATE_CHANGED;
+    metaData: IVSPlayerPlaybackRateChangedData;
+}
+interface IVSPlayerQualityChangedEntry extends EventEntryBase {
+    event: Event.IVS_PLAYER_QUALITY_CHANGED;
+    metaData: IVSPlayerQualityChangedData;
+}
+interface IVSPlayerLiveLatencyEntry extends EventEntryBase {
+    event: Event.LIVESTREAM_LATENCY;
+    metaData: IVSPlayerLiveLatencyData;
+}
+type EventEntry = CallJoinBeginEntry | NetworkQualityTestBeginEntry | NetworkQualityTestEndEntry | BrowserForegroundedEntry | PingStatsEntry | PreCallTestBeginEntry | PreCallTestCompletedEntry | WebSocketConnectedEntry | TransportConnectedEntry | AudioToggleEntry | VideoToggleEntry | ScreenShareToggleEntry | DisconnectEntry | ReconnectEntry | ParticipantRoleToggleEntry | DominantSpeakerEntry | DevicesEntry | SelectedDeviceEntry | MediaPermissionEntry | MediaPlaybackFailureEntry | MediaTrackFailureEntry | ScreenShareRequestedEntry | ExpectedVideoResolutionEntry | ExpectedScreenshareResolutionEntry | TabChangeEntry | BrowserBackgroundedEntry | LegacySwitchEntry | IVSPlayerRebufferingEntry | IVSPlayerAudioBlockedEntry | IVSPlayerPlaybackBlockedEntry | IVSPlayerNetworkUnavailableEntry | IVSPlayerInitializedEntry | IVSPlayerErrorEntry | IVSPlayerRecoverableErrorEntry | IVSPlayerAnalyticsEventEntry | IVSPlayerLiveLatencyEntry | IVSPlayerPlaybackRateChangedEntry | IVSPlayerQualityChangedEntry | IVSPlayerWorkerErrorEntry;
+
+declare class EventHandler extends EventEmitter$1 {
+    constructor({ logger, peerId, apiHostnames, }: {
+        logger: RTKLogger$2;
+        peerId: string;
+        apiHostnames: ApiHostnames;
+    });
+    callEvent(entry: EventEntry): void;
+    flush(): Promise<boolean>;
+}
+
+interface ParsedProducerStats {
+    outboundVideoRtpId: string[];
+    outboundAudioRtpId: string[];
+}
+interface ParsedConsumerStats {
+    inboundVideoRtpId: string[];
+    inboundAudioRtpId: string[];
+}
+declare class ParsedRTCStats {
+    transport: WebRtcTransportStat;
+    candidatePair: IceCandidatePairStats;
+    outboundVideoRtp: Map<string, OutboundVideoStreamStats>;
+    inboundVideoRtp: Map<string, InboundVideoStreamStats>;
+    outboundAudioRtp: Map<string, OutboundAudioStreamStats>;
+    inboundAudioRtp: Map<string, InboundAudioStreamStats>;
+    remoteInboundRtp: Map<string, RemoteInboundStreamStats>;
+    producerStreamMap: Map<string, ParsedProducerStats>;
+    consumerStreamMap: Map<string, ParsedConsumerStats>;
+    staleProducerStreamMap: boolean;
+    staleConsumerStreamMap: boolean;
+}
+declare abstract class Measurements extends EventEmitter$1 {
+    observer: EventEmitter$1;
+    outboundProducerMap: Map<string, string>;
+    inboundConsumerMap: Map<string, string>;
+    consumerPeerIdMap: Map<string, {
+        producerId: string;
+        peerId: string;
+        appData: Record<string, unknown>;
+    }>;
+    pausedConsumerMap: Map<string, {
+        lastReportCalculated: boolean;
+    }>;
+    pausedProducerMap: Map<string, {
+        lastReportCalculated: boolean;
+    }>;
+    overallProducingTransportsStatsMap: Record<string, {
+        totalPacketsSent: number;
+    }>;
+    overallConsumingTransportsStatsMap: Record<string, {
+        totalPacketsReceived: number;
+    }>;
+    overallConsumersStatsMap: Record<string, {
+        totalVideoPacketsReceived: number;
+        totalAudioPacketsReceived: number;
+    }>;
+    overallProducersStatsMap: Record<string, {
+        totalVideoPacketsSent: number;
+        totalAudioPacketsSent: number;
+    }>;
+    videoProducerToStatsMap: Map<string, OutboundVideoStreamStats>;
+    audioProducerToStatsMap: Map<string, OutboundAudioStreamStats>;
+    videoConsumerToStatsMap: Map<string, InboundVideoStreamStats>;
+    audioConsumerToStatsMap: Map<string, InboundAudioStreamStats>;
+    consumerIdsWithFreezedVideo: Set<string>;
+    consumerIdsWithFreezedAudio: Set<string>;
+    producerIdsWithFreezedVideo: Set<string>;
+    producerIdsWithFreezedAudio: Set<string>;
+    freezedProducingTransportIds: Set<string>;
+    freezedConsumingTransportIds: Set<string>;
+    screenShareProducers: Set<string>;
+    screenShareConsumers: Set<string>;
+    ipDetails: IPDetails;
+    callStatsInstance: CallStats;
+    constructor();
+    registerProducer(producer: any): Promise<void>;
+    pauseProducer(producerId: string): void;
+    resumeProducer(producerId: string): void;
+    processInboundConsumerVideoStats(consumerId: string, overallStatsForConsumer: {
+        totalVideoPacketsReceived: number;
+        totalAudioPacketsReceived: number;
+    }, streamStatsData: InboundVideoStreamStats): void;
+    processInboundConsumerAudioStats(consumerId: string, overallStatsForConsumer: {
+        totalVideoPacketsReceived: number;
+        totalAudioPacketsReceived: number;
+    }, streamStatsData: InboundAudioStreamStats): void;
+    processOutboundProducerVideoStats(producerId: string, overallStatsForProducer: {
+        totalVideoPacketsSent: number;
+        totalAudioPacketsSent: number;
+    }, streamStatsData: OutboundVideoStreamStats): void;
+    processOutboundProducerAudioStats(producerId: string, overallStatsForProducer: {
+        totalVideoPacketsSent: number;
+        totalAudioPacketsSent: number;
+    }, streamStatsData: OutboundAudioStreamStats): void;
+    processProducingTransportStats(transportId: string, overallStatsForTransport: {
+        totalPacketsSent: number;
+    }, transportStatsData: WebRtcTransportStat): void;
+    processConsumingTransportStats(transportId: string, overallStatsForTransport: {
+        totalPacketsReceived: number;
+    }, streamStatsData: WebRtcTransportStat): void;
+    registerConsumer(consumer: any): Promise<void>;
+    pauseConsumer(consumerId: string): void;
+    resumeConsumer(consumerId: string): void;
+    generateProducerStreamMap(producer: any, parse?: boolean): Promise<ProducerStatistics>;
+    generateConsumerStreamMap(consumer: any, parse?: boolean): Promise<ConsumerStatistics>;
+    deregisterProducer(producer: any): void;
+    deregisterConsumer(consumer: any): void;
+    getWorkingSimulcastVideoStats(videoStatsList: OutboundVideoStreamStats[]): OutboundVideoStreamStats;
+    getProducersReport(producers: any[]): Promise<ProducerStatistics[]>;
+    getConsumersReport(consumers: any[]): Promise<ConsumerStatistics[]>;
+    getTransportReport(transport: any): Promise<any>;
+    getProcessedStats(transport: any, consuming: boolean, producing: boolean): Promise<ProcessedStatsReport>;
+    getUserLocation(): Promise<GeoLocation>;
+    getConnectivity(iceServers: IceServerInfo[]): Promise<{
+        host: boolean;
+        relay: boolean;
+        reflexive: boolean;
+    }>;
+    getThroughput(iceServers: IceServerInfo[]): Promise<ThroughputInformation>;
+    getIPDetails(): Promise<IPDetails>;
+    getNetworkQuality(iceServers: IceServerInfo[]): Promise<NetworkQualityInformation>;
+    getNetworkInfo(iceServers: IceServerInfo[], skipConnectivityChecks?: boolean): Promise<NetworkInformation | NetworkInformationWithoutConnectivityData>;
+}
+
+declare class CallStats extends EventEmitter$1 {
+    observer: EventEmitter$1;
+    eventHandler: EventHandler;
+    producers: Map<string, any>;
+    logger: RTKLogger$2;
+    env: ClientEnvTypeAll;
+    apiHostnames: ApiHostnames;
+    peerId: string;
+    consumerSharedMediaStatesMap: Map<string, {
+        audio?: boolean;
+        video?: boolean;
+        screen?: boolean;
+    }>;
+    currentUserMediaStates: {
+        audio?: boolean;
+        video?: boolean;
+        screen?: boolean;
+    };
+    constructor(backendUrl: string, engineName: string, env: ClientEnvTypeAll, flags: InhouseCallStatsInitializeParams['flags'], logger: RTKLogger$2, peerId: string, apiHostnames: ApiHostnames);
+    registerIceServers(servers: IceServerInfo[]): void;
+    sendConsumerSharedMediaStateEvent(consumerId: string, statusObj: {
+        audio?: boolean;
+        video?: boolean;
+        screen?: boolean;
+    }): void;
+    registerProducingTransport(transport: any): void;
+    registerConsumingTransport(transport: any): void;
+    disconnectConsumingTransport(): void;
+    disconnectProducingTransport(): void;
+    sendPreCallTestBeginEvent(skipConnectivityChecks: boolean, timestamp: Date): void;
+    sendScreenShareToggleEvent(on: boolean, ssrc: number, timestamp: Date): void;
+    sendScreenShareRequestedEvent(timestamp: Date): void;
+    sendActiveSpeakerEvent(peerId: string, timestamp: Date): void;
+    devices(deviceType: MediaDeviceTypeAll, deviceList: MediaDeviceInfo[], timestamp: Date): void;
+    selectedDevice(deviceType: MediaDeviceTypeAll, device: MediaDeviceInfo, timestamp: Date): void;
+    mediaPermission(deviceType: MediaDeviceTypeAll, permission: MediaPermissions$1, timestamp: Date): void;
+    mediaPlaybackFailed(deviceType: MediaDeviceTypeAll, timestamp: Date): void;
+    mediaTrackMuted(deviceType: MediaDeviceTypeAll, timestamp: Date): void;
+    tabChanged(isMeetingsTabActive: boolean, timestamp: Date): void;
+    browserBackgrounded(timestamp: Date): void;
+    browserForegrounded(timestamp: Date): void;
+    legacySwitch(on: boolean, timestamp: Date): void;
+    getPreCallTestResults(): Promise<NetworkInformation | NetworkInformationWithoutConnectivityData>;
+    sendCallJoinBeginEvent(peerMetaData: PeerMetaData, timestamp: Date): void;
+    sendNetworkQualityTestBeginEvent(regionalInformations: RegionalIceInformation[], timestamp: Date): void;
+    sendWebSocketConnectedEvent(timestamp: Date): void;
+    sendTransportConnectedEvent(timestamp: Date): void;
+    sendAudioToggleEvent(on: boolean, timestamp: Date): void;
+    sendVideoToggleEvent(on: boolean, timestamp: Date): void;
+    sendParticipantRoleToggleEvent(role: ParticipantRoleData, timestamp: Date): void;
+    startPingStats(interval?: number): void;
+    stopPingStats(): void;
+    sendPingStatsEvent(optimize: boolean, timestamp: Date): Promise<void>;
+    sendIVSPlayerRebufferEvent(timestamp: Date): void;
+    sendIVSPlayerAudioBlockEvent(timestamp: Date): void;
+    sendIVSPlayerPlaybackBlockedEvent(timestamp: Date): void;
+    sendIVSPlayerNetworkUnavailableEvent(timestamp: Date): void;
+    sendIVSPlayerInitializedEvent(timestamp: Date): void;
+    sendIVSPlayerWorkerErrorEvent(timestamp: Date): void;
+    sendIVSPlayerErrorEvent(payload: IVSPlayerErrorData, timestamp: Date): void;
+    sendIVSPlayerRecoverableErrorEvent(payload: IVSPlayerRecoverableErrorData, timestamp: Date): void;
+    sendIVSPlayerAnalyticsEvent(payload: IVSPlayerAnalyticsEventData, timestamp: Date): void;
+    sendIVSPlayerPlaybackRateChangedEvent(updatedPlaybackRate: number, timestamp: Date): void;
+    sendIVSPlayerQualityChanged(payload: IVSPlayerQualityChangedData, timestamp: Date): void;
+    sendPlayerLiveLatency(latency: number, timestamp: Date): void;
+    sendDisconnectEvent(timestamp: Date): void;
+    sendReconnectEvent(timestamp: Date): void;
+    expectedVideoResolution(frameWidth: number, frameHeight: number, timestamp: Date): void;
+    expectedScreenshareResolution(frameWidth: number, frameHeight: number, timestamp: Date): void;
+}
+
+declare class InhouseCallStats extends EventEmitter$1 {
+    stats: any;
+    peerId: string;
+    backend: CallStats;
+    iceServers: IceServerInfo[];
+    initialized: boolean;
+    stalled: boolean;
+    ipInformation: Object;
+    logger: RTKLogger$2;
+    initialize({ peerId, engineName, env, iceServers, apiBase, flags, logger, apiHostnames, skipConnectivityChecks, }: InhouseCallStatsInitializeParams): Promise<void>;
+    configureSendTransport(sendTransport: any): void;
+    configureRecvTransport(recvTransport: any): void;
+    candidateRegionalNetworkQualityTest(regionalIceServersInfo: RegionalIceInformation[]): Promise<void>;
+    roomJoined(peerData: PeerMetaData$1): Promise<void>;
+    audioOff(): void;
+    audioOn(): void;
+    videoOff(): void;
+    videoOn(): void;
+    callEnded(): void;
+    screenShareStart(ssrc?: number): void;
+    consumerSharedMediaState(consumerId: string, statusObj: {
+        audio?: boolean;
+        video?: boolean;
+        screen?: boolean;
+    }): void;
+    screenShareStop(ssrc?: number): void;
+    screenShareRequested(): void;
+    activeSpeaker(peerId: string): void;
+    devices(deviceType: MediaDeviceTypeAll, deviceList: MediaDeviceInfo[]): void;
+    selectedDevice(deviceType: MediaDeviceTypeAll, device: MediaDeviceInfo): void;
+    mediaPermission(deviceType: MediaDeviceTypeAll, permission: MediaPermissions$1): void;
+    mediaPlaybackFailed(deviceType: MediaDeviceTypeAll): void;
+    mediaTrackMuted(deviceType: MediaDeviceTypeAll): void;
+    tabChanged(isMeetingsTabActive?: boolean): void;
+    browserBackgrounded(): void;
+    browserForegrounded(): void;
+    legacySwitch(on: boolean): void;
+    startPreCallTest(skipConnectivityChecks?: boolean): Promise<void>;
+    onPreCallTestResults(fx: any): any;
+    onReceivingConsumerAudioStatus(fx: any): void;
+    onReceivingConsumerVideoStatus(fx: any): void;
+    onReceivingProducerAudioStatus(fx: any): void;
+    onReceivingProducerVideoStatus(fx: any): void;
+    onReceivingProducingTransportStatus(fx: any): void;
+    onReceivingConsumingTransportStatus(fx: any): void;
+    onProducerScore(fx: any): void;
+    onConsumerScore(fx: any): void;
+    removeInitializationListener(fx: Function): void;
+    stallCallStats(): void;
+    ivsPlayerEvent(type: String, payload: any): void;
+    livestreamLatency(latency: number): void;
+    expectedVideoResolution(frameWidth: number, frameHeight: number): void;
+    expectedScreenshareResolution(frameWidth: number, frameHeight: number): void;
+}
 
 interface RTKBasicParticipant {
     userId: string;
@@ -1966,77 +2956,37 @@ declare class RTKSelectedPeers {
 type PipEvents = {
     ['cameraToggled']: () => void;
     ['micToggled']: () => void;
-    ['hangup']: () => void;
-    ['pipStarted']: () => void;
-    ['pipEnded']: () => void;
-    ['*']: (eventName: string, ...args: any[]) => void;
-};
-declare class RTKPip extends RTKTypedEventEmitter<PipEvents> {
-    private constructor();
-    static _init(context: Context<RTKContextState>, self: RTKSelf$1): Promise<RTKPip>;
-    overrideIcon(icon: 'handRaise' | 'pin', value: string): Promise<void>;
-    isSupported(): boolean;
-    get isActive(): boolean;
-    init({ height, width }?: {
-        height?: number;
-        width?: number;
-    }): void;
-    enableSource(source: string): void;
-    disableSource(source: string): void;
-    addSource(id: string, element: HTMLVideoElement, enabled: boolean, pinned?: boolean, displayText?: string, imageUrl?: string, handRaised?: boolean): void;
-    updateSource(id: string, source: any): void;
-    removeSource(id: string): void;
-    removePinnedSource(): void;
-    removeAllSources(): void;
-    enable(): void;
-    disable: (partial?: boolean) => void;
-}
-
-interface AudioProducerScoreStats {
-    score: number;
-    packetsLostPercentage: number;
-    jitter: number;
-    isScreenShare: boolean;
-    bitrate: number;
-}
-interface VideoProducerScoreStats {
-    score: number;
-    frameWidth: number;
-    frameHeight: number;
-    framesPerSecond: number;
-    packetsLostPercentage: number;
-    jitter: number;
-    isScreenShare: boolean;
-    bitrate: number;
-    cpuLimitations: boolean;
-    bandwidthLimitations: boolean;
-}
-interface AudioConsumerScoreStats {
-    score: number;
-    packetsLostPercentage: number;
-    jitter: number;
-    isScreenShare: boolean;
-    bitrate: number;
-}
-interface VideoConsumerScoreStats {
-    score: number;
-    frameWidth: number;
-    frameHeight: number;
-    framesPerSecond: number;
-    packetsLostPercentage: number;
-    jitter: number;
-    isScreenShare: boolean;
-    bitrate: number;
+    ['hangup']: () => void;
+    ['pipStarted']: () => void;
+    ['pipEnded']: () => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
+};
+declare class RTKPip extends RTKTypedEventEmitter<PipEvents> {
+    private constructor();
+    static _init(context: Context<RTKContextState>, self: RTKSelf$1): Promise<RTKPip>;
+    overrideIcon(icon: 'handRaise' | 'pin', value: string): Promise<void>;
+    isSupported(): boolean;
+    get isActive(): boolean;
+    init({ height, width }?: {
+        height?: number;
+        width?: number;
+    }): void;
+    enableSource(source: string): void;
+    disableSource(source: string): void;
+    addSource(id: string, element: HTMLVideoElement, enabled: boolean, pinned?: boolean, displayText?: string, imageUrl?: string, handRaised?: boolean): void;
+    updateSource(id: string, source: any): void;
+    removeSource(id: string): void;
+    removePinnedSource(): void;
+    removeAllSources(): void;
+    enable(): void;
+    disable: (partial?: boolean) => void;
 }
-type ProducerScoreStats = AudioProducerScoreStats | VideoProducerScoreStats;
-type ConsumerScoreStats = AudioConsumerScoreStats | VideoConsumerScoreStats;
 
 type EventHandlerTypes = PeerInfoResponse | GetWaitingRoomRequests | RecordingEvent | UpdatePeersPresetResponse | PeerJoinBroadcastResponse | PeerJoinCompleteResponse | GlobalPeerPinningBroadcastResponse | PeerLeaveResponse | SelectedPeersResponse | SelectedPeersDiffResponse;
 declare class RoomSocketHandler {
     socket: SocketService;
-    static create(socket: SocketService, context: Context<RTKContextState>): RoomSocketHandler;
-    static cleanup(): void;
-    constructor(socketService: SocketService, context: Context<RTKContextState>);
+    cleanup(): Promise<void>;
+    constructor(context: Context<RTKContextState>, socketService: SocketService);
     joinRoom(opts: {
         name: string;
         id: string;
@@ -2083,6 +3033,29 @@ declare class EnhancedEventEmitter<TransportPromiseEvents> extends EventEmitter
     safeEmitAsPromiseWithTimeout<T extends keyof TransportPromiseEvents>(event: T, timeout: number, ...args: any[]): Promise<TransportPromiseEvents[T]>;
 }
 
+declare enum TransportState {
+    NEW = "new",
+    CONNECTING = "connecting",
+    RECONNECTING = "reconnecting",
+    DISCONNECTED = "disconnected",
+    CONNECTED = "connected",
+    FAILED = "failed",
+    CLOSED = "closed"
+}
+declare enum MediaNodeType {
+    HIVE = 1,
+    ROOM_NODE = 2,
+    CF = 3
+}
+type MediaConnectionState = {
+    recv: {
+        state: `${TransportState}`;
+    };
+    send: {
+        state: `${TransportState}`;
+    };
+};
+
 interface GenericHandlerResult {
     offerSdp: RTCSessionDescriptionInit;
     callback: (answer: RTCSessionDescriptionInit) => Promise<any>;
@@ -2115,6 +3088,7 @@ declare abstract class HandlerInterface<TransportPromiseEvents> extends Enhanced
     enableHighBitrate: boolean;
     enableStereo: boolean;
     enableDtx: boolean;
+    sfu: MediaNodeType;
     get midTransceiverMap(): Map<string, RTCRtpTransceiver>;
     abstract get name(): string;
     close(): void;
@@ -2140,29 +3114,6 @@ type DCMessage = {
     payload: Record<string, unknown>;
 };
 
-declare enum TransportState {
-    NEW = "new",
-    CONNECTING = "connecting",
-    RECONNECTING = "reconnecting",
-    DISCONNECTED = "disconnected",
-    CONNECTED = "connected",
-    FAILED = "failed",
-    CLOSED = "closed"
-}
-declare enum MediaNodeType {
-    HIVE = 1,
-    ROOM_NODE = 2,
-    CF = 3
-}
-type MediaConnectionState = {
-    recv: {
-        state: `${TransportState}`;
-    };
-    send: {
-        state: `${TransportState}`;
-    };
-};
-
 type TransportPromiseEvents = {
     'close': {
         answer: RTCSessionDescriptionInit;
@@ -2297,6 +3248,7 @@ type SelfEvents = {
     ['roomJoined']: (payload: {
         reconnected: boolean;
     }) => void;
+    ['autoplayError']: (error: Error) => void;
     ['*']: (event: string, ...args: any[]) => void;
 };
 
@@ -2450,19 +3402,19 @@ declare class RTKMeta$1 extends RTKTypedEventEmitter<MetaEvents> {
     setSelfActiveTab(spotlightTab: ActiveTab, tabChangeSource: TabChangeSource): void;
 }
 
-interface RTKMapEvents<T extends EventMap> {
+interface RTKMapEvents<T extends EventMap$1> {
     onAddEvent?: keyof T;
     onDeleteEvent?: keyof T;
     onClearEvent?: keyof T;
 }
-type ModifyPrependObject<T extends EventMap, U> = {
+type ModifyPrependObject<T extends EventMap$1, U> = {
     [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
 } & {
     ['*']: (event: String, ...args: any[]) => void;
 };
-declare class RTKMap<T extends (EventMap & WildCardEvent<T>), U extends {
+declare class RTKMap<T extends (EventMap$1 & WildCardEvent<T>), U extends {
         id: string;
-    } & RTKTypedEventEmitter<T>, V extends EventMap> extends Map<string, U> {
+    } & RTKTypedEventEmitter<T>, V extends EventMap$1> extends Map<string, U> {
     readonly onAddEvent: keyof V;
     readonly onDeleteEvent: keyof V;
     readonly onClearEvent: keyof V;
@@ -3567,9 +4519,10 @@ declare class BrowserCapabilities extends BrowserDetection {
 }
 
 declare class RTKFeatures {
-    static hasFeature(featureName: string): boolean;
-    static getFeatureValue(featureName: string): _dyteinternals_utils.RTKFlagValues;
-    static getAllFeatures(): {
+    constructor(context: Context<RTKContextState>);
+    hasFeature(featureName: string): boolean;
+    getFeatureValue(featureName: string): _dyteinternals_utils.RTKFlagValues;
+    getAllFeatures(): {
             [x: string]: _dyteinternals_utils.RTKFlagsEntry;
         };
 }
@@ -3898,11 +4851,11 @@ declare class RTKLogger$1 {
 
 declare class RTKInternals {
     logger: typeof RTKLogger$1;
-    features: typeof RTKFeatures;
+    features: RTKFeatures;
     browserSpecs: BrowserCapabilities;
-    callStats: any;
-    constructor(logger: typeof RTKLogger$1, features: typeof RTKFeatures, callStats: any);
-    static init(callstats: any): RTKInternals;
+    callStats: InhouseCallStats;
+    constructor(logger: typeof RTKLogger$1, features: RTKFeatures, callStats: any);
+    static init(context: Context<RTKContextState>): RTKInternals;
 }
 
 type StoreData = {
@@ -4028,6 +4981,115 @@ declare class MediaNodeClient {
     handlePeerLeaving(peerId: string): void;
 }
 
+interface SocketServicePayload {
+    payload: any;
+}
+interface ConnectedMeetingParticipant {
+    id?: string;
+    customParticipantId?: string;
+    presetId?: string;
+    displayName?: string;
+    displayPictureUrl?: string;
+}
+interface ConnectedMeeting {
+    id?: string;
+    title?: string;
+    participants: ConnectedMeetingParticipant[];
+}
+declare class ConnectedMeetingsSocketHandler {
+    socketService: SocketService;
+    constructor(socketService: SocketService);
+    handleConnectedRoomsDumpRaw({ payload }: SocketServicePayload): {
+        parentMeeting: ConnectedMeeting;
+        meetings: ConnectedMeeting[];
+    };
+    handleTransferPeerRaw({ payload }: SocketServicePayload): {
+        authToken: string;
+        meetingId: string;
+    };
+    handleMovedPeerRaw({ payload }: SocketServicePayload): {
+        meetingId: string;
+        customParticipantId: string;
+    };
+    handleConnectedRoomsUpdatedRaw({ payload }: SocketServicePayload): {
+        id: string;
+        title: string;
+    }[];
+    handleConnectedRoomsDeletedRaw({ payload }: SocketServicePayload): {
+        id: string;
+    }[];
+    getConnectedRoomsDump(): Promise<{
+        parentMeeting: ConnectedMeeting;
+        meetings: ConnectedMeeting[];
+    }>;
+    createConnectedRooms(request: CreateRoomRequestPayload[]): Promise<{
+        id: string;
+        title: string;
+    }[]>;
+    updateConnectedRooms(request: UpdateRoomRequestPayload[]): Promise<void>;
+    disableConnectedRooms(meetingIds: string[]): Promise<{
+        id: string;
+    }[]>;
+    movePeersBetweenRooms(request: MovePeersBetweenRoomsRequest): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+}
+
+type ConnectedMeetingsEvents = {
+    ['meetingChanged']: (meeting: RealtimeKitClient) => void;
+    ['stateUpdate']: (payload: {
+        meetings: ConnectedMeeting[];
+        parentMeeting: ConnectedMeeting;
+    }) => void;
+    ['changingMeeting']: (meetingId: string) => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
+};
+declare class RTKConnectedMeetings$1 extends RTKTypedEventEmitter<ConnectedMeetingsEvents> {
+    constructor(context: Context<RTKContextState>);
+    meetings: ConnectedMeeting[];
+    parentMeeting: ConnectedMeeting;
+    get supportsConnectedMeetings(): boolean;
+    get isActive(): boolean;
+    getConnectedMeetings(): Promise<{
+        parentMeeting: ConnectedMeeting;
+        meetings: ConnectedMeeting[];
+    }>;
+    createMeetings(request: {
+        title: string;
+    }[]): Promise<{
+        id: string;
+        title: string;
+    }[]>;
+    updateMeetings(request: {
+        id: string;
+        title: string;
+    }[]): Promise<void>;
+    deleteMeetings(meetingIds: string[]): Promise<{
+        id: string;
+    }[]>;
+    moveParticipants(sourceMeetingId: string, destinationMeetingId: string, participantIds: string[]): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+    moveParticipantsWithCustomPreset(sourceMeetingId: string, destinationMeetingId: string, participants: {
+        id: string;
+        presetId: string;
+    }[]): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+}
+
 interface Modules {
     pip?: boolean;
     chat?: boolean;
@@ -4056,6 +5118,7 @@ interface Modules {
             staggered?: boolean;
         }[];
     };
+    experimentalAudioPlayback?: boolean;
 }
 interface DefaultOptions {
     video?: boolean;
@@ -4086,7 +5149,7 @@ declare class ConnectionHandler {
     mediaState: MediaConnectionState;
     get joinAttempted(): boolean;
     get roomJoined(): boolean;
-    constructor();
+    constructor(context: Context<RTKContextState>);
     updateSocketConnectionState(state: SocketStateEvent, attempt?: number): void;
 }
 
@@ -4184,6 +5247,140 @@ declare class RTKError extends Error {
     constructor(message: string, code?: keyof typeof ERROR_CODES, log?: boolean);
 }
 
+type EventMap = {
+    [key: string]: (...args: any[]) => void;
+};
+interface TypedEventEmitter<Events extends EventMap> {
+    addListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    on<E extends keyof Events>(event: E, listener: Events[E]): this;
+    onAsync<E extends keyof Events>(event: E, listener: Events[E]): this;
+    once<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependOnceListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    off<E extends keyof Events>(event: E, listener: Events[E]): this;
+    removeAllListeners<E extends keyof Events>(event?: E): this;
+    removeListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    emit<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): void;
+    emitAsync<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): Promise<void>;
+    eventNames(): (keyof Events | string | symbol)[];
+    rawListeners<E extends keyof Events>(event: E): Events[E][];
+    listeners<E extends keyof Events>(event: E): Events[E][];
+    listenerCount<E extends keyof Events>(event: E): number;
+    getMaxListeners(): number;
+    setMaxListeners(maxListeners: number): this;
+    reset(): void;
+}
+
+declare enum SessionEvents {
+    NEW_PRODUCER = "NEW_PRODUCER",
+    PRODUCER_TRACK_ENDED = "PRODUCER_TRACK_ENDED",
+    ROOM_NODE_CONNECTION_ERROR = "ROOM_NODE_CONNECTION_ERROR",
+    SOCKET_SERVICE_ROOM_JOINED = "SOCKET_SERVICE_ROOM_JOINED",
+    SOCKET_SERVICE_RECONNECTED = "SOCKET_SERVICE_RECONNECTED",
+    SOCKET_SERVICE_DISCONNECTED = "SOCKET_SERVICE_DISCONNECTED",
+    SOCKET_SERVICE_FAILED = "SOCKET_SERVICE_FAILED",
+    SOCKET_STATE_UPDATE = "SOCKET_STATE_UPDATE",
+    ROOM_NODE_RECONNECTED = "ROOM_NODE_RECONNECTED",
+    ROOM_NODE_DISCONNECTED = "ROOM_NODE_DISCONNECTED",
+    ROOM_NODE_FAILED = "ROOM_NODE_FAILED",
+    TRANSPORT_STATE_UPDATE = "TRANSPORT_STATE_UPDATE",
+    PRODUCER_SCORE_UPDATE = "PRODUCER_SCORE_UPDATE",
+    CONSUMER_SCORE_UPDATE = "CONSUMER_SCORE_UPDATE",
+    PRODUCER_STATUS_UPDATE = "PRODUCER_STATUS_UPDATE",
+    CONSUMER_STATUS_UPDATE = "CONSUMER_STATUS_UPDATE",
+    LOW_PRODUCER_SCORE = "LOW_PRODUCER_SCORE",
+    LOW_CONSUMER_SCORE = "LOW_CONSUMER_SCORE",
+    MEDIA_PERMISSION_ERROR = "MEDIA_PERMISSION_ERROR",
+    MEDIA_PERMISSION_UPDATE = "MEDIA_PERMISSION_UPDATE",
+    WAITLISTED = "WAIT_LISTED",
+    MESSAGE = "websocket/message",
+    ROOM_MESSAGE = "websocket/room-message",
+    PEER_JOINED_INTERNAL = "peer/joined-internal",
+    PEER_CLOSED = "websocket/peer-closed",
+    CONSUMER_CLOSED = "websocket/consumer-closed",
+    CONSUMER_PAUSED = "websocket/consumer-paused",
+    CONSUMER_RESUMED = "websocket/consumer-resumed",
+    PRODUCER_CLOSED = "websocket/producer-closed",
+    NEW_CONSUMER = "websocket/new-consumer",
+    PRODUCER_SCORE = "websocket/producer-score",
+    CONSUMER_SCORE = "websocket/consumer-score",
+    PRODUCER_TOGGLE = "hive/producer-toggle",
+    CONSUMER_TOGGLE = "hive/consumer-toggle",
+    SELECTED_PEERS_DIFF = "hive/selected-peers-diff",
+    UPDATE_ACTIVE = "media/update-active",
+    RESET_PRODUCER_STATE = "hive/reset-producer-state",
+    CF_TRANSPORT_STATE_CHANGED = "cf/transport-state-changed",
+    CF_ROOM_REJOINING = "cf/room-rejoining",
+    CF_ROOM_REJOIN_FAILED = "cf/room-rejoining-failed",
+    CF_ROOM_REJOINED = "cf/room-rejoined",
+    CF_TRANPSORT_RECONNECTING = "cf/transport-reconnecting",
+    ROOM_STATE = "sockethub/room-state",
+    PEER_DISPLAY_NAME_CHANGED = "hive/display-name-changed",
+    GET_STAGE_REQUESTS = "GET_STAGE_REQUESTS",
+    UPDATE_STAGE_REQUESTS = "UPDATE_STAGE_REQUESTS",
+    KICK_PEER = "KICK_PEER",
+    UPDATE_PEER_STAGE_STATUS = "UPDATE_PEER_STAGE_STATUS",
+    JOIN_MEDIA_ROOM = "JOIN_MEDIA_ROOM",
+    LEAVE_MEDIA_ROOM = "LEAVE_MEDIA_ROOM",
+    PIP_HANGUP = "PIP_HANGUP",
+    E2EE_ACTIVE_PRODUCER = "E2EE_ACTIVE_PRODUCER",
+    E2EE_INACTIVE_PRODUCER = "E2EE_INACTIVE_PRODUCER",
+    E2EE_ACTIVE_CONSUMER = "E2EE_ACTIVE_CONSUMER",
+    E2EE_INACTIVE_CONSUMER = "E2EE_INACTIVE_CONSUMER",
+    SOCKET_PEERS = "SOCKET_PEERS",
+    UPDATE_PERMISSIONS = "UPDATE_PERMISSIONS",
+    MAX_SPATIAL_LAYER_CHANGE = "MAX_SPATIAL_LAYER_CHANGE",
+    MUTE_SELF = "MUTE_SELF",
+    MUTE_SELF_VIDEO = "MUTE_SELF_VIDEO"
+}
+type AllEvents = {
+    [key in SessionEvents]: (payload?: any) => void;
+};
+type TypedEvents = {
+    [SessionEvents.UPDATE_PERMISSIONS]: (p: PresetUpdates) => void;
+    [SessionEvents.MAX_SPATIAL_LAYER_CHANGE]: (p: {
+        peerId: string;
+        maxSpatialLayer: number;
+    }) => void;
+    [SessionEvents.UPDATE_ACTIVE]: (p?: {
+        page?: number;
+        createAllConsumers?: boolean;
+    }) => void;
+    [SessionEvents.PEER_JOINED_INTERNAL]: (p: RTKParticipant$1) => void;
+    [SessionEvents.UPDATE_PEER_STAGE_STATUS]: (p: {
+        id: string;
+        status: string;
+    }) => void;
+    [SessionEvents.GET_STAGE_REQUESTS]: (stageRequests: StageRequest[]) => void;
+    [SessionEvents.UPDATE_STAGE_REQUESTS]: (payload: {
+        request: StageRequestPayload;
+        add: boolean;
+    }) => void;
+    [SessionEvents.KICK_PEER]: (payload: {
+        peerId: string;
+    }) => void;
+    [SessionEvents.JOIN_MEDIA_ROOM]: () => void;
+    [SessionEvents.LEAVE_MEDIA_ROOM]: (state: LeaveRoomState) => void;
+};
+type UntypedEvents = Omit<AllEvents, keyof TypedEvents>;
+type SessionEventsType = TypedEvents & UntypedEvents;
+
+type ErrorCallback = (error: Error) => void;
+declare class AudioPlayback {
+    constructor();
+    playTracks(tracks: MediaStreamTrack[]): Promise<void>;
+    setSpeakerDevice(deviceId: string): void;
+    removeTrack(trackId: string): void;
+    play(): Promise<void>;
+    onError(callback: ErrorCallback): void;
+}
+
+declare class AudioPlaybackManager extends AudioPlayback {
+    constructor();
+    addParticipantTrack(participantId: string, track: MediaStreamTrack): void;
+    removeParticipantTrack(participantId: string): void;
+}
+
 type RTKContextState = {
     authToken: string;
     peerId?: string;
@@ -4211,8 +5408,17 @@ type RTKContextState = {
     env?: ClientEnvTypeAll;
     sdkVersion?: string;
     sdkName?: 'web-core';
+    callstats?: InhouseCallStats;
     connectionHandler?: ConnectionHandler;
     cachedUserDetails?: CachedUserDetails;
+    peerSessionStore?: TypedEventEmitter<SessionEventsType>;
+    flagsmith?: ReturnType<typeof createNewFlagsmithInstance>;
+    roomSocketHandler?: RoomSocketHandler;
+    connectedMeetingsSocketHandler?: ConnectedMeetingsSocketHandler;
+    audioPlayback?: AudioPlaybackManager;
+    options?: RealtimeKitClientOptions;
+    self?: RTKSelf;
+    meeting?: RealtimeKitClient;
 };
 interface Context<T extends Record<string, any>> {
     subscribe: (key: keyof T, listener: (value: any) => void) => () => void;
@@ -4393,6 +5599,7 @@ declare class RTKSelf$1 extends RTKSelfMedia {
     show(): void;
     setDevice(device: MediaDeviceInfo): Promise<void>;
     cleanUpTracks(): void;
+    playAudio(): Promise<void>;
     registerVideoElement(videoElem: HTMLVideoElement, isPreview?: boolean): void;
     deregisterVideoElement(videoElem?: HTMLVideoElement, isPreview?: boolean): void;
 }
@@ -4548,71 +5755,6 @@ declare class API {
     setOrganizationId(id: string): void;
 }
 
-interface ConnectedMeetingParticipant {
-    id?: string;
-    customParticipantId?: string;
-    presetId?: string;
-    displayName?: string;
-    displayPictureUrl?: string;
-}
-interface ConnectedMeeting {
-    id?: string;
-    title?: string;
-    participants: ConnectedMeetingParticipant[];
-}
-
-type ConnectedMeetingsEvents = {
-    ['meetingChanged']: (meeting: RealtimeKitClient) => void;
-    ['stateUpdate']: (payload: {
-        meetings: ConnectedMeeting[];
-        parentMeeting: ConnectedMeeting;
-    }) => void;
-    ['changingMeeting']: (meetingId: string) => void;
-    ['*']: (eventName: string, ...args: any[]) => void;
-};
-declare class RTKConnectedMeetings$1 extends RTKTypedEventEmitter<ConnectedMeetingsEvents> {
-    constructor(context: Context<RTKContextState>, meeting: RealtimeKitClient);
-    meetings: ConnectedMeeting[];
-    parentMeeting: ConnectedMeeting;
-    get supportsConnectedMeetings(): boolean;
-    get isActive(): boolean;
-    get currentMeetingId(): string;
-    getConnectedMeetings(): Promise<{
-        parentMeeting: ConnectedMeeting;
-        meetings: ConnectedMeeting[];
-    }>;
-    createMeetings(request: {
-        title: string;
-    }[]): Promise<{
-        id: string;
-        title: string;
-    }[]>;
-    updateMeetings(request: {
-        id: string;
-        title: string;
-    }[]): Promise<void>;
-    deleteMeetings(meetingIds: string[]): Promise<{
-        id: string;
-    }[]>;
-    moveParticipants(sourceMeetingId: string, destinationMeetingId: string, participantIds: string[]): Promise<{
-        success: boolean;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-    }>;
-    moveParticipantsWithCustomPreset(sourceMeetingId: string, destinationMeetingId: string, participants: {
-        id: string;
-        presetId: string;
-    }[]): Promise<{
-        success: boolean;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-    }>;
-}
-
 interface Overrides {
     disableSimulcast?: boolean;
     forceRelay?: boolean;
@@ -4644,6 +5786,7 @@ declare class RealtimeKitClient {
     get livestream(): Readonly<RTKLivestream$1>;
     get stage(): Readonly<RTKStage>;
     get stores(): Readonly<RTKStoreManager>;
+    get audio(): AudioPlaybackManager;
     get __internals__(): Readonly<RTKInternals>;
     joinRoom(): Promise<void>;
     leaveRoom(state?: LeaveRoomState): Promise<void>;