@cloudflare/realtimekit 1.2.0-staging.2 → 1.2.0-staging.21

package/dist/ts3.4/dist/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import * as _dyteinternals_utils from '@dyteinternals/utils';
-import { MediaVideoQualityType, ViewType, LivestreamViewerMediaQualityType, MediaProductionPermissionType, WaitingRoomTypes, createNewFlagsmithInstance, PresetTypeV2, MediaScreenShareQualityType, PluginAccessControls, RecorderType as RecorderType$1, BorderRadius, BorderWidth, Theme } from '@dyteinternals/utils';
+import { PresetTypeV2, MediaVideoQualityType, ViewType, MediaScreenShareQualityType, LivestreamViewerMediaQualityType, PluginAccessControls, WaitingRoomTypes, MediaProductionPermissionType, RecorderType as RecorderType$1, BorderRadius, BorderWidth, Theme, createNewFlagsmithInstance } from '@dyteinternals/utils';
 import { MessageType as MessageType$1 } from '@protobuf-ts/runtime';
 import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
 import * as WorkerTimers from 'worker-timers';
@@ -2217,16 +2217,16 @@ interface PeerMetaData$1 {
 }
 /** 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;
+interface InhouseCallStatsInitializeParams {
+    peerId: string;
+    engineName: string;
+    env?: ClientEnvTypeAll;
+    iceServers: any[];
+    apiBase?: string;
+    flags: Record<string, Record<'enabled' | 'value', any>>;
+    logger?: DyteLogger;
+    apiHostnames: ApiHostnames;
+    skipConnectivityChecks: boolean;
 }
 /**
  * Note(ravindra-dyte):
@@ -2235,12 +2235,12 @@ interface InhouseCallStatsInitializeParams {
 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 interface DyteLogger {
+    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",
@@ -2535,14 +2535,19 @@ interface IVSPlayerLiveLatencyEntry extends EventEntryBase {
     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 {
-    constructor({ logger, peerId, apiHostnames, }: {
-        logger: RTKLogger$2;
-        peerId: string;
-        apiHostnames: ApiHostnames;
-    });
-    callEvent(entry: EventEntry): void;
-    flush(): Promise<boolean>;
+declare class EventHandler extends EventEmitter {
+    private logger;
+    private peerId;
+    private eventStore;
+    private apiEndpoint;
+    constructor({ logger, peerId, apiHostnames, }: {
+        logger: DyteLogger;
+        peerId: string;
+        apiHostnames: ApiHostnames;
+    });
+    private sendEventsChunkToServer;
+    callEvent(entry: EventEntry): void;
+    flush(): Promise<boolean>;
 }
 interface ParsedProducerStats {
     outboundVideoRtpId: string[];
@@ -2640,12 +2645,20 @@ declare abstract class Measurements extends EventEmitter {
     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;
+    deregisterConsumer(consumer: any): void;
+    protected getIceCandidateStats(stats: any): IceCandidateStats;
+    getWorkingSimulcastVideoStats(videoStatsList: OutboundVideoStreamStats[]): OutboundVideoStreamStats;
+    protected parseRTCReport(report: RTCStatsReport, filters?: string[], onceOnly?: boolean, ownerId?: string, transportInfo?: {
+        id: string;
+        producing: boolean;
+        consuming: boolean;
+    }): ParsedRTCStats;
     getProducersReport(producers: any[]): Promise<ProducerStatistics[]>;
     getConsumersReport(consumers: any[]): Promise<ConsumerStatistics[]>;
     getTransportReport(transport: any): Promise<any>;
-    getProcessedStats(transport: any, consuming: boolean, producing: boolean): Promise<ProcessedStatsReport>;
+    getProcessedStats(transport: any, consuming: boolean, producing: boolean): Promise<ProcessedStatsReport>;
+    protected getProducerStatsFromReport(report: ParsedRTCStats): ProducerStatistics[];
+    protected getConsumerStatsFromReport(report: ParsedRTCStats): ConsumerStatistics[];
     getUserLocation(): Promise<GeoLocation>;
     getConnectivity(iceServers: IceServerInfo[]): Promise<{
         host: boolean;
@@ -2657,129 +2670,198 @@ declare abstract class Measurements extends EventEmitter {
     getNetworkQuality(iceServers: IceServerInfo[]): Promise<NetworkQualityInformation>;
     getNetworkInfo(iceServers: IceServerInfo[], skipConnectivityChecks?: boolean): Promise<NetworkInformation | NetworkInformationWithoutConnectivityData>;
 }
-declare class CallStats extends EventEmitter {
-    observer: EventEmitter;
-    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 {
-    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;
+declare class CallStats extends EventEmitter {
+    observer: EventEmitter;
+    eventHandler: EventHandler;
+    protected measurements: Measurements;
+    protected producingTransport: any;
+    protected consumingTransport: any;
+    producers: Map<string, any>;
+    protected consumers: Map<string, any>;
+    protected iceServers: IceServerInfo[];
+    protected connectionInfoPromise: Promise<NetworkInformation | NetworkInformationWithoutConnectivityData>;
+    protected pingStatsTimeout: NodeJS.Timeout;
+    logger: DyteLogger;
+    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: DyteLogger, peerId: string, apiHostnames: ApiHostnames);
+    registerIceServers(servers: IceServerInfo[]): void;
+    protected registerConsumer(consumer: any): void;
+    protected registerProducer(producer: any): void;
+    sendConsumerSharedMediaStateEvent(consumerId: string, statusObj: {
+        audio?: boolean;
+        video?: boolean;
+        screen?: boolean;
+    }): void;
+    registerProducingTransport(transport: any): void;
+    registerConsumingTransport(transport: any): void;
+    protected deRegisterConsumer(consumer: any): void;
+    protected deRegisterProducer(producer: any): void;
+    disconnectConsumingTransport(): void;
+    disconnectProducingTransport(): void;
+    protected callEvent(entry: EventEntry): 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 {
+    stats: any;
+    peerId: string;
+    backend: CallStats;
+    iceServers: IceServerInfo[];
+    initialized: boolean;
+    stalled: boolean;
+    ipInformation: Object;
+    logger: DyteLogger;
+    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;
+    private onSafeInitialization;
+    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;
+}
+type SocketServiceCapability = keyof typeof Capabilities;
+type SocketStateEvent = 'connected' | 'disconnected' | 'reconnected' | 'errored' | 'reconnecting' | 'reconnectAttempt' | 'reconnectFailure' | 'failed';
+type SocketServiceCapabilities = SocketServiceCapability[];
+interface SocketConnectionState {
+    state: Extract<SocketStateEvent, 'connected' | 'disconnected' | 'reconnecting' | 'failed'>;
+    reconnected: boolean;
+    reconnectionAttempt: number;
+}
+declare class SocketService {
+    readonly roomName: string;
+    readonly authToken: string;
+    readonly capabilities: SocketServiceCapabilities;
+    joinAttempted: boolean;
+    readonly telemetry: Telemetry;
+    readonly logger: Logger;
+    readonly peerId: string;
+    constructor(context: Context<ContextState>, { peerId, meetingId, authToken, capabilities, }: {
+        peerId: string;
+        meetingId: string;
+        authToken: string;
+        capabilities: SocketServiceCapabilities;
+    });
+    updateURL(peerID: string): void;
+    private static getSocketEdgeDomain;
+    readonly url: string;
+    connect(): Promise<void>;
+    disconnect(): void;
+    readonly isConnected: boolean;
+    sendMessage(event: number, protobuf?: Uint8Array, messageId?: string): boolean;
+    sendMessagePromise(event: number, protobuf?: Uint8Array, messageId?: string, resp?: number): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    sendMessagePromiseWithTimeout({ event, timeout, protobuf, messageId, resp, }: {
+        timeout: number;
+        event: number;
+        protobuf?: Uint8Array;
+        messageId?: string;
+        resp?: number;
+    }): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    on(event: number, listener: (message: {
+        id?: string;
+        payload?: Uint8Array;
+    }) => void): void;
+    onStateEvent(event: SocketStateEvent, listener: (...args: any) => void): void;
+    removeListener(event: number, listener: (message: {
+        id?: string;
+        payload?: Uint8Array;
+    }) => void): void;
+    removeListeners(event: number): void;
+    flush(): any;
+    handleSocketConnectionEvents(): void;
 }
 declare global {
     interface SymbolConstructor {
@@ -2811,20 +2893,20 @@ type StringKeysOfFoo = StringKeyOf<Foo>;
 @category Object
 */
 type StringKeyOf<BaseType> = string;
-declare class RTKEventEmitter<T extends string | symbol> extends EventEmitter$1 {
-    logger: RTKLogger$1 | undefined;
-    constructor(logger: RTKLogger$1);
-    emit(event: T, ...args: any[]): boolean;
-    on(event: T, callback: (...args: any[]) => void): this;
-    addListener(event: T, callback: (...args: any[]) => any): this;
-    off(event: T, callback: (...args: any[]) => any): this;
-    once(event: T, callback: (...args: any[]) => any): this;
-    prependListener(event: T, callback: (...args: any[]) => any): this;
-    prependOnceListener(event: T, callback: (...args: any[]) => any): this;
-    removeListener(event: T, callback: (...args: any[]) => any): this;
-    removeAllListeners(event?: T): this;
-    listeners(event: T): Function[];
-    listenerCount(event: T): number;
+declare class CustomEventEmitter<T extends string | symbol> extends EventEmitter$1 {
+    logger: Logger | undefined;
+    constructor(logger: Logger);
+    emit(event: T, ...args: any[]): boolean;
+    on(event: T, callback: (...args: any[]) => void): this;
+    addListener(event: T, callback: (...args: any[]) => any): this;
+    off(event: T, callback: (...args: any[]) => any): this;
+    once(event: T, callback: (...args: any[]) => any): this;
+    prependListener(event: T, callback: (...args: any[]) => any): this;
+    prependOnceListener(event: T, callback: (...args: any[]) => any): this;
+    removeListener(event: T, callback: (...args: any[]) => any): this;
+    removeAllListeners(event?: T): this;
+    listeners(event: T): Function[];
+    listenerCount(event: T): number;
 }
 type EventMap$1 = {
     [key: string]: (...args: any[]) => void;
@@ -2832,90 +2914,162 @@ type EventMap$1 = {
 type WildCardEvent<T> = {
     ['*']: (event: StringKeyOf<T>, ...args: any) => void;
 };
-declare class RTKTypedEventEmitter<Events extends EventMap$1 & WildCardEvent<Events>> extends EventEmitter$1 {
-    logger: RTKLogger$1 | undefined;
-    constructor(logger: RTKLogger$1);
-    emit<E extends StringKeyOf<Events>>(event: E, ...args: Parameters<Events[E]>): boolean;
-    on<E extends StringKeyOf<Events>>(event: E, callback: Events[E]): this;
-    addListener<E extends StringKeyOf<Events>>(event: E, callback: Events[E]): this;
-    off<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
-    once<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
-    prependListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
-    prependOnceListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
-    removeListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
-    removeAllListeners<T extends StringKeyOf<Events>>(event?: T): this;
-    listeners<T extends StringKeyOf<Events>>(event: T): Function[];
-    listenerCount<T extends StringKeyOf<Events>>(event: T): number;
+declare class TypedEventEmitter$1<Events extends EventMap$1 & WildCardEvent<Events>> extends EventEmitter$1 {
+    logger: Logger | undefined;
+    constructor(logger: Logger);
+    emit<E extends StringKeyOf<Events>>(event: E, ...args: Parameters<Events[E]>): boolean;
+    on<E extends StringKeyOf<Events>>(event: E, callback: Events[E]): this;
+    addListener<E extends StringKeyOf<Events>>(event: E, callback: Events[E]): this;
+    off<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
+    once<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
+    prependListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
+    prependOnceListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
+    removeListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
+    removeAllListeners<T extends StringKeyOf<Events>>(event?: T): this;
+    listeners<T extends StringKeyOf<Events>>(event: T): Function[];
+    listenerCount<T extends StringKeyOf<Events>>(event: T): number;
+}
+interface BasicParticipant {
+    userId: string;
+    name?: string;
+    picture?: string;
+    customParticipantId: string;
 }
-type StageSocketMessage = GetStageRequestsResponse | GetStagePeersResponse | DenyStageAccessRequest | PeerStatusUpdate;
-declare class StageSocketHandler {
-    constructor(socketService: SocketService);
-    getStageRequests(): Promise<GetStageRequestsResponse>;
-    requestAccess(): void;
-    cancelRequestAccess(): void;
-    grantAccess(userIds: string[]): Promise<void>;
-    denyAccess(userIds: string[]): Promise<void>;
-    joinStage(): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    leaveStage(userId: string): Promise<{
+declare class BasicParticipantsMap extends CustomEventEmitter<'participantsUpdate'> {
+    constructor(logger: Logger);
+    __set(objId: string, obj: BasicParticipant): Map<string, BasicParticipant>;
+    __clear(): void;
+    get(objId: string): BasicParticipant;
+    toArray(): BasicParticipant[];
+}
+type ChatChannelSocketMessage = GetChatChannelResponse;
+interface ChatChannel {
+    id: string;
+    displayName: string;
+    memberIds: string[];
+    displayPictureUrl?: string;
+    visibility?: string;
+    isDirectMessage?: boolean;
+    latestMessage?: Message;
+    unreadCount: number;
+}
+interface UpdateChannelRequestPayload {
+    memberIds?: string[];
+    displayName?: string;
+    displayPictureUrl?: string;
+    visibility?: string;
+}
+declare class ChatChannelSocketHandler {
+    readonly telemetry: Telemetry;
+    readonly logger: Logger;
+    constructor(context: Context<ContextState>, socketService: SocketService);
+    createChannel(displayName: string, memberIds: string[], displayPictureUrl?: string, visibility?: string, isDirectMessage?: boolean): Promise<ChatChannel>;
+    updateChannel(channelId: string, payload: UpdateChannelRequestPayload): Promise<ChatChannel>;
+    static formatChannel(socketChannel: ChatChannel$1): ChatChannel;
+    getChannelMembers(channelId: string): Promise<BasicParticipant[]>;
+    on(event: number, handler: (socketMessage: ChatChannelSocketMessage) => void): void;
+}
+declare enum ChatMessageType {
+    TEXT = 0,
+    IMAGE = 1,
+    FILE = 2,
+    CUSTOM = 3
+}
+type ChatSocketMessage = SendChatMessageToRoomResponse | SendChatMessageToPeersResponse | EditChatMessageResponse | DeleteChatMessageResponse;
+interface SearchFilters {
+    channelId?: string;
+    timestamp?: number;
+    size?: number;
+    reversed?: boolean;
+}
+declare class ChatSocketHandler {
+    readonly telemetry: Telemetry;
+    readonly logger: Logger;
+    constructor(context: Context<ContextState>, socketService: SocketService);
+    getChatMessages(): Promise<{
         id: string;
         payload: Uint8Array;
     }>;
-    kick(userIds: string[]): Promise<{
+    getChatMessagesPaginated(timeStamp: number, size: number, reversed: boolean, offset?: number, channelId?: string): Promise<GetPaginatedChatMessageRoomResponse>;
+    sendMessageToRoom(message: string, messageType: ChatMessageType): void;
+    sendMessageToPeers(message: string, messageType: ChatMessageType, peerIds: string[]): void;
+    sendMessageToChannel(message: string, messageType: ChatMessageType, channelId: string): void;
+    sendMessage(message: string, messageType: ChatMessageType, peerIds?: string[], channelId?: string): void;
+    editMessage(chatId: string, message: string, payloadType: ChatMessageType, channelId?: string, pinned?: boolean): Promise<ChatMessage>;
+    deleteMessage(chatId: string, channelId?: string): Promise<{
+        channelId?: string;
         id: string;
-        payload: Uint8Array;
     }>;
-    on(event: number, handler: (socketMessage: StageSocketMessage, messageId?: string) => void): void;
-    getPeerInfo(peerId: string): Promise<PeerInfoResponse>;
-}
-type StageStatus = 'OFF_STAGE' | 'REQUESTED_TO_JOIN_STAGE' | 'ACCEPTED_TO_JOIN_STAGE' | 'ON_STAGE';
-interface StageRequestPayload {
-    displayName: string;
-    userId: string;
-    peerId: string;
+    searchMessages(query: string, filters: SearchFilters): Promise<ChatMessage[]>;
+    getAllChannels(): Promise<ChatChannel[]>;
+    markLastReadMessage(channelId: string, message: Message): Promise<string>;
+    setPinState(message: Message, pin: boolean): Promise<PinChatMessageResponse>;
+    on(event: number, handler: (socketMessage: ChatSocketMessage) => void): void;
+}
+declare class SelectedPeers {
+    private readonly _activeSpeakerPeers;
+    private readonly _compulsoryPeers;
+    constructor();
+    add(peerId: string, priority: number, context: Context<ContextState>): number;
+    delete(peerId: string, context: Context<ContextState>): void;
+    index(peerId: string): number;
+    readonly peers: string[];
+    readonly compulsoryPeers: string[];
+    readonly activeSpeakerPeers: string[];
+    private _removeFromCompulsoryPeer;
 }
-type StageEvents = {
-    ['stageAccessRequestUpdate']: (requests?: StageRequestPayload[]) => void;
-    ['stageStatusUpdate']: (status: StageStatus) => void;
-    ['newStageRequest']: (payload: {
-        count: number;
-    }) => void;
-    ['stageRequestApproved']: () => void;
-    ['stageRequestRejected']: () => void;
+type PipEvents = {
+    ['cameraToggled']: () => void;
+    ['micToggled']: () => void;
+    ['hangup']: () => void;
+    ['pipStarted']: () => void;
+    ['pipEnded']: () => void;
     ['*']: (eventName: string, ...args: any[]) => void;
 };
-declare class RTKStage extends RTKTypedEventEmitter<StageEvents> {
-    readonly telemetry: RTKTelemetry;
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, participants: RTKParticipants, stageSocketHandler: StageSocketHandler, roomSocketHandler: RoomSocketHandler);
-    readonly status: StageStatus;
-    getAccessRequests(): {
-        stageRequests: StageRequestPayload[];
-    };
-    requestAccess(): Promise<void>;
-    cancelRequestAccess(): Promise<void>;
-    grantAccess(userIds: string[]): Promise<void>;
-    denyAccess(userIds: string[]): Promise<void>;
-    readonly peerId: string;
-    join(): Promise<void>;
-    leave(): Promise<void>;
-    kick(userIds: string[]): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-}
-interface ResponseStatus {
-    success: boolean;
-    message: string;
-}
-type MediaPermission$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE' | 'CANCELED';
-declare class EnhancedEventEmitter<TransportPromiseEvents> extends EventEmitter$1 {
-    readonly logger: RTKLogger$1;
-    constructor(context: Context<RTKContextState>);
-    safeEmit(event: string, ...args: any[]): boolean;
-    safeEmitAsPromise<T extends keyof TransportPromiseEvents>(event: T, ...args: any[]): Promise<TransportPromiseEvents[T]>;
-    safeEmitAsPromiseWithTimeout<T extends keyof TransportPromiseEvents>(event: T, timeout: number, ...args: any[]): Promise<TransportPromiseEvents[T]>;
+declare class Pip extends TypedEventEmitter$1<PipEvents> {
+    private constructor();
+    static _init(context: Context<ContextState>, self: Self): Promise<Pip>;
+    private setupIcon;
+    overrideIcon(icon: 'handRaise' | 'pin', value: string): Promise<void>;
+    private constructImage;
+    private createVideoContainer;
+    private setupEventListeners;
+    private cleanupEventListeners;
+    private enablePipMediaControls;
+    private onSelfVideoUpdateListener;
+    private onSelfAudioUpdateListener;
+    private handlePipMediaControls;
+    private createCanvas;
+    private eventCallback;
+    private setupMediaSessionEvents;
+    private mountAudioEvents;
+    private mountVideoEvents;
+    private unmountEvents;
+    private getSources;
+    private drawEmptyTile;
+    private drawIcons;
+    private drawTile;
+    private calcGridElemSize;
+    private paintCanvas;
+    private animate;
+    isSupported(): boolean;
+    readonly isActive: boolean;
+    private cleanup;
+    init({ height, width }?: {
+        height?: number;
+        width?: number;
+    }): void;
+    private updateMediaSession;
+    enableSource(source: string): void;
+    disableSource(source: string): void;
+    private generateAvatar;
+    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;
 }
 declare enum TransportState {
     NEW = "new",
@@ -2926,11 +3080,6 @@ declare enum TransportState {
     FAILED = "failed",
     CLOSED = "closed"
 }
-declare enum MediaNodeType {
-    HIVE = 1,
-    ROOM_NODE = 2,
-    CF = 3
-}
 type MediaConnectionState = {
     recv: {
         state: string;
@@ -2939,6 +3088,193 @@ type MediaConnectionState = {
         state: string;
     };
 };
+type EventHandlerTypes = PeerInfoResponse | GetWaitingRoomRequests | RecordingEvent | UpdatePeersPresetResponse | PeerJoinBroadcastResponse | PeerJoinCompleteResponse | GlobalPeerPinningBroadcastResponse | PeerLeaveResponse | SelectedPeersResponse | SelectedPeersDiffResponse;
+declare class RoomSocketHandler {
+    socket: SocketService;
+    readonly telemetry: Telemetry;
+    readonly logger: Logger;
+    cleanup(): void;
+    constructor(context: Context<ContextState>, socketService: SocketService);
+    joinRoom(opts: {
+        name: string;
+        id: string;
+        userId: string;
+        customParticipantId: string;
+        picture?: string;
+    }): Promise<{
+        peer: Peer;
+    }>;
+    getAllAddedParticipants(): Promise<BasicParticipant[]>;
+    getRoomPeers(searchQuery: string, limit: number, offset: number): Promise<RoomPeersInfoResponse>;
+    getRoomPeersNonPaginated(): Promise<RoomPeersInfoResponse>;
+    getStagePeers(): Promise<RoomPeersInfoResponse>;
+    getPeerInfo(peerId: string): Promise<PeerInfoResponse>;
+    getRoomState(): Promise<RoomInfoResponse>;
+    getRoomStageState(): Promise<GetRoomStageStateResponse>;
+    broadcastMessage(type: string, payload: BroadcastMessagePayload): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    broadcastToMeetings(type: string, meetingIds: string[], payload: BroadcastMessagePayload): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    broadcastToPeers(type: string, peerIds: string[], payload: BroadcastMessagePayload): Promise<boolean>;
+    leaveRoom(): Promise<void>;
+    kick(peerId: string): Promise<void>;
+    kickAll(propagateKickAll?: boolean): Promise<void>;
+    getWaitingRoomRequests(): void;
+    acceptWaitingRoomRequest(userIds: string[]): void;
+    rejectWaitingRoomRequest(userIds: string[]): void;
+    updatePermissions(userIds: string[], patch: PresetUpdates): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    private handleSocketEvents;
+    on(event: number, handler: (message: EventHandlerTypes) => void): void;
+    getUserPermissions(userId: string): Promise<Pick<PresetTypeV2['permissions'], 'chat' | 'polls' | 'plugins'>>;
+}
+type TranscriptionData = {
+    id: string;
+    name: string;
+    peerId: string;
+    userId: string;
+    customParticipantId: string;
+    transcript: string;
+    isPartialTranscript: boolean;
+    date: Date;
+};
+type AiEvents = {
+    ['transcript']: (t: TranscriptionData) => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+declare class Ai extends TypedEventEmitter$1<AiEvents> {
+    transcripts: TranscriptionData[];
+    readonly telemetry: Telemetry;
+    constructor(context: Context<ContextState>);
+    static init(context: Context<ContextState>, transcriptionEnabled: boolean): Promise<Ai>;
+    static parseTranscript(transcriptData: string, isPartialTranscript?: boolean): TranscriptionData | undefined;
+    static parseTranscripts(transcriptData: string): TranscriptionData[];
+    getActiveTranscript(): Promise<void>;
+    onTranscript(transcript: TranscriptionData): Promise<void>;
+}
+type ActiveTabType = 'screenshare' | 'plugin';
+interface ActiveTab {
+    type: ActiveTabType;
+    id: string;
+}
+declare enum TabChangeSource {
+    User = 0,
+    Meeting = 1
+}
+interface MediaConnectionUpdate {
+    transport: 'consuming' | 'producing';
+    state: string;
+    reconnected: boolean;
+}
+type MetaEvents = {
+    ['mediaConnectionUpdate']: (payload: MediaConnectionUpdate) => void;
+    ['socketConnectionUpdate']: (state: SocketConnectionState) => void;
+    ['poorConnection']: (payload: {
+        score: number;
+    }) => void;
+    ['meetingStartTimeUpdate']: (payload: {
+        meetingStartedTimestamp: Date;
+    }) => void;
+    ['transcript']: (t: TranscriptionData) => void;
+    ['activeTabUpdate']: (tab: ActiveTab) => void;
+    ['selfTabUpdate']: (tab: ActiveTab) => void;
+    ['broadcastTabChangesUpdate']: (broadcastTabChanges: boolean) => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+declare class Meta extends TypedEventEmitter$1<MetaEvents> {
+    selfActiveTab: ActiveTab | undefined;
+    readonly socketState: SocketConnectionState;
+    readonly mediaState: MediaConnectionState;
+    broadcastTabChanges: boolean;
+    viewType: string;
+    meetingStartedTimestamp: Date;
+    meetingTitle: string;
+    sessionId: string;
+    constructor(context: Context<ContextState>, self: Self, viewType: string, roomSocketHandler: RoomSocketHandler, meetingTitle: string);
+    readonly meetingId: string;
+    setBroadcastTabChanges(broadcastTabChanges: boolean): void;
+    setSelfActiveTab(spotlightTab: ActiveTab, tabChangeSource: TabChangeSource): void;
+    private assertActiveTabToRoom;
+}
+interface MapEvents<T extends EventMap$1> {
+    onAddEvent?: keyof T;
+    onDeleteEvent?: keyof T;
+    onClearEvent?: keyof T;
+}
+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 ClientMap<T extends (EventMap$1 & WildCardEvent<T>), U extends {
+    id: string;
+} & TypedEventEmitter$1<T>, V extends EventMap$1> extends Map<string, U> {
+    readonly onAddEvent: keyof V;
+    readonly onDeleteEvent: keyof V;
+    readonly onClearEvent: keyof V;
+    constructor(options: MapEvents<V>, logger?: Logger);
+    emit<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, ...args: Parameters<(V | ModifyPrependObject<T, U>)[E]>): boolean;
+    on<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): TypedEventEmitter$1<{
+        [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
+    } & {
+        "*": (event: String, ...args: any[]) => void;
+    } & V>;
+    addListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): TypedEventEmitter$1<{
+        [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
+    } & {
+        "*": (event: String, ...args: any[]) => void;
+    } & V>;
+    off<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): TypedEventEmitter$1<{
+        [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
+    } & {
+        "*": (event: String, ...args: any[]) => void;
+    } & V>;
+    once<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): TypedEventEmitter$1<{
+        [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
+    } & {
+        "*": (event: String, ...args: any[]) => void;
+    } & V>;
+    prependListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): TypedEventEmitter$1<{
+        [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
+    } & {
+        "*": (event: String, ...args: any[]) => void;
+    } & V>;
+    prependOnceListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): TypedEventEmitter$1<{
+        [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
+    } & {
+        "*": (event: String, ...args: any[]) => void;
+    } & V>;
+    removeListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): TypedEventEmitter$1<{
+        [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
+    } & {
+        "*": (event: String, ...args: any[]) => void;
+    } & V>;
+    removeAllListeners<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event?: E): TypedEventEmitter$1<{
+        [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
+    } & {
+        "*": (event: String, ...args: any[]) => void;
+    } & V>;
+    listeners<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E): Function[];
+    listenerCount<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E): number;
+    getMaxListeners(): number;
+    setMaxListeners(n: number): TypedEventEmitter$1<{
+        [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
+    } & {
+        "*": (event: String, ...args: any[]) => void;
+    } & V>;
+    eventNames(): (string | symbol)[];
+    add(obj: U, emitEvent?: boolean): this;
+    set(objId: string, obj: U, emitEvent?: boolean): this;
+    delete(objId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
+    clear(emitEvent?: boolean, removeListeners?: boolean): void;
+    toArray(): U[];
+}
 interface GenericHandlerResult {
     offerSdp: RTCSessionDescriptionInit;
     callback: (answer: RTCSessionDescriptionInit) => Promise<any>;
@@ -2967,18 +3303,24 @@ interface HandlerSendResult extends GenericHandlerResult {
     mid: string;
 }
 declare abstract class HandlerInterface<TransportPromiseEvents> extends EnhancedEventEmitter<TransportPromiseEvents> {
-    pc: RTCPeerConnection;
+    protected _sendWebStream: MediaStream;
+    protected _sendScreenShareStream: MediaStream;
+    protected _direction?: 'send' | 'recv';
+    pc: RTCPeerConnection;
+    protected _transportReady: boolean;
+    private readonly _mapMidTransceiver;
     enableHighBitrate: boolean;
     enableStereo: boolean;
     enableDtx: boolean;
-    sfu: MediaNodeType;
     readonly midTransceiverMap: Map<string, RTCRtpTransceiver>;
     abstract readonly name: string;
     close(): void;
     restartIce(): Promise<GenericHandlerResult>;
     init({ direction, iceServers, iceTransportPolicy, additionalSettings, proprietaryConstraints, onTrackHandler, }: HandlerRunOptions): void;
     connect(): Promise<GenericHandlerResult>;
-    getTransportStats(): Promise<RTCStatsReport>;
+    getTransportStats(): Promise<RTCStatsReport>;
+    protected _assertSendDirection(): void;
+    protected _assertRecvDirection(): void;
     getReceiverStats(localId: string): Promise<RTCStatsReport>;
     stopSending(localId: string): Promise<GenericHandlerResult>;
     abstract send(options: HandlerSendOptions): Promise<HandlerSendResult>;
@@ -2989,7 +3331,6 @@ declare abstract class HandlerInterface<TransportPromiseEvents> extends Enhanced
     _addEventListeners(): void;
     addCustomEventListeners(): void;
 }
-type MediaKind$1 = 'audio' | 'video';
 type DCMessage = {
     type: string;
     payload: Record<string, unknown>;
@@ -3018,26 +3359,26 @@ type ConsumerOptions = {
     transceiver: RTCRtpTransceiver;
     closeTranscieverOnClose?: boolean;
 };
-type MediaKind = 'audio' | 'video';
-declare class Consumer extends EnhancedEventEmitter<TransportPromiseEvents> {
-    readonly rtpReceiver: RTCRtpReceiver;
-    readonly id: string;
-    readonly localId: string;
-    readonly producerId: string;
-    readonly producingTransportId: string;
-    readonly mimeType: string;
-    readonly track: MediaStreamTrack;
-    readonly peerId: string;
-    readonly appData: Record<string, unknown>;
-    readonly transceiver: RTCRtpTransceiver;
-    constructor(context: Context<RTKContextState>, opts: ConsumerOptions);
-    readonly closed: boolean;
-    readonly kind: MediaKind;
-    readonly paused: boolean;
-    close(reason?: string, closeTranscieverOnClose?: boolean): void;
-    getStats(): Promise<RTCStatsReport>;
-    pause(): void;
-    resume(): void;
+type MediaKind$1 = 'audio' | 'video';
+declare class Consumer extends EnhancedEventEmitter<TransportPromiseEvents> {
+    readonly rtpReceiver: RTCRtpReceiver;
+    readonly id: string;
+    readonly localId: string;
+    readonly producerId: string;
+    readonly producingTransportId: string;
+    readonly mimeType: string;
+    readonly track: MediaStreamTrack;
+    readonly peerId: string;
+    readonly appData: Record<string, unknown>;
+    readonly transceiver: RTCRtpTransceiver;
+    constructor(context: Context<ContextState>, opts: ConsumerOptions);
+    readonly closed: boolean;
+    readonly kind: MediaKind$1;
+    readonly paused: boolean;
+    close(reason?: string, closeTranscieverOnClose?: boolean): void;
+    getStats(): Promise<RTCStatsReport>;
+    pause(): void;
+    resume(): void;
 }
 declare const localMediaEvents: readonly [
     "AUDIO_TRACK_CHANGE",
@@ -3051,173 +3392,447 @@ declare const localMediaEvents: readonly [
     "DEVICE_LIST_UPDATED"
 ];
 type LocalMediaEvents = (typeof localMediaEvents)[number];
-type ParticipantEvents = {
-    ['videoUpdate']: (payload: {
-        videoEnabled: boolean;
-        videoTrack: MediaStreamTrack;
-    }) => void;
-    ['audioUpdate']: (payload: {
-        audioEnabled: boolean;
-        audioTrack: MediaStreamTrack;
-    }) => void;
-    ['screenShareUpdate']: (payload: {
-        screenShareEnabled: boolean;
-        screenShareTracks: {
-            audio: MediaStreamTrack;
-            video: MediaStreamTrack;
-        };
-    }) => void;
-    ['pinned']: (payload: RTKParticipant) => void;
-    ['unpinned']: (payload: RTKParticipant) => void;
-    ['poorConnection']: (payload: {
-        score: number;
-        kind: string;
-    }) => void;
-    ['stageStatusUpdate']: (payload: RTKParticipant) => void;
-    ['mediaScoreUpdate']: (payload: {
-        kind: MediaKind;
-        isScreenshare: boolean;
-        score: number;
-        participantId: string;
-        scoreStats: ConsumerScoreStats;
-    }) => void;
-    ['kicked']: () => void;
-    ['*']: (event: string, ...args: any[]) => void;
+type ParticipantEvents = {
+    ['videoUpdate']: (payload: {
+        videoEnabled: boolean;
+        videoTrack: MediaStreamTrack;
+    }) => void;
+    ['audioUpdate']: (payload: {
+        audioEnabled: boolean;
+        audioTrack: MediaStreamTrack;
+    }) => void;
+    ['screenShareUpdate']: (payload: {
+        screenShareEnabled: boolean;
+        screenShareTracks: {
+            audio: MediaStreamTrack;
+            video: MediaStreamTrack;
+        };
+    }) => void;
+    ['pinned']: (payload: Participant) => void;
+    ['unpinned']: (payload: Participant) => void;
+    ['poorConnection']: (payload: {
+        score: number;
+        kind: string;
+    }) => void;
+    ['stageStatusUpdate']: (payload: Participant) => void;
+    ['mediaScoreUpdate']: (payload: {
+        kind: MediaKind$1;
+        isScreenshare: boolean;
+        score: number;
+        participantId: string;
+        scoreStats: ConsumerScoreStats;
+    }) => void;
+    ['kicked']: () => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+type SelfEvents = {
+    ['toggleTile']: (payload: {
+        hidden: boolean;
+    }) => void;
+    ['videoUpdate']: (payload: {
+        videoEnabled: boolean;
+        videoTrack: MediaStreamTrack;
+    }) => void;
+    ['audioUpdate']: (payload: {
+        audioEnabled: boolean;
+        audioTrack: MediaStreamTrack;
+    }) => void;
+    ['screenShareUpdate']: (payload: {
+        screenShareEnabled: boolean;
+        screenShareTracks: {
+            audio?: MediaStreamTrack;
+            video?: MediaStreamTrack;
+        };
+    }) => void;
+    ['deviceUpdate']: ({ device }: {
+        device: MediaDeviceInfo;
+    }) => void;
+    ['deviceListUpdate']: (changedDevices: {
+        added: MediaDeviceInfo[];
+        removed: MediaDeviceInfo[];
+        devices: MediaDeviceInfo[];
+    }) => void;
+    ['pinned']: (payload: Self) => void;
+    ['unpinned']: (payload: Self) => void;
+    ['mediaPermissionUpdate']: (payload: {
+        message: keyof typeof MediaPermission;
+        kind: 'audio' | 'video' | 'screenshare';
+    }) => void;
+    ['mediaPermissionError']: (payload: {
+        message: keyof typeof MediaPermission;
+        constraints: any;
+        kind: 'audio' | 'video' | 'screenshare';
+    }) => void;
+    ['mediaScoreUpdate']: (payload: {
+        kind: MediaKind$1;
+        isScreenshare: boolean;
+        score: number;
+        participantId: string;
+        scoreStats: ProducerScoreStats;
+    }) => void;
+    ['waitlisted']: () => void;
+    ['roomLeft']: (payload: {
+        state: LeaveRoomState;
+    }) => void;
+    ['roomJoined']: (payload: {
+        reconnected: boolean;
+    }) => void;
+    ['autoplayError']: (error: Error) => void;
+    ['*']: (event: string, ...args: any[]) => void;
 };
-type SelfEvents = {
-    ['toggleTile']: (payload: {
-        hidden: boolean;
-    }) => void;
-    ['videoUpdate']: (payload: {
-        videoEnabled: boolean;
-        videoTrack: MediaStreamTrack;
-    }) => void;
-    ['audioUpdate']: (payload: {
-        audioEnabled: boolean;
-        audioTrack: MediaStreamTrack;
-    }) => void;
-    ['screenShareUpdate']: (payload: {
-        screenShareEnabled: boolean;
-        screenShareTracks: {
-            audio?: MediaStreamTrack;
-            video?: MediaStreamTrack;
-        };
-    }) => void;
-    ['deviceUpdate']: ({ device }: {
-        device: MediaDeviceInfo;
-    }) => void;
-    ['deviceListUpdate']: (changedDevices: {
-        added: MediaDeviceInfo[];
-        removed: MediaDeviceInfo[];
-        devices: MediaDeviceInfo[];
-    }) => void;
-    ['pinned']: (payload: RTKSelf) => void;
-    ['unpinned']: (payload: RTKSelf) => void;
-    ['mediaPermissionUpdate']: (payload: {
-        message: keyof typeof MediaPermission;
-        kind: 'audio' | 'video' | 'screenshare';
-    }) => void;
-    ['mediaPermissionError']: (payload: {
-        message: keyof typeof MediaPermission;
-        constraints: any;
-        kind: 'audio' | 'video' | 'screenshare';
-    }) => void;
-    ['mediaScoreUpdate']: (payload: {
-        kind: MediaKind;
-        isScreenshare: boolean;
-        score: number;
-        participantId: string;
-        scoreStats: ProducerScoreStats;
-    }) => void;
-    ['waitlisted']: () => void;
-    ['roomLeft']: (payload: {
-        state: LeaveRoomState;
-    }) => void;
-    ['roomJoined']: (payload: {
-        reconnected: boolean;
-    }) => void;
-    ['autoplayError']: (error: Error) => void;
-    ['*']: (event: string, ...args: any[]) => void;
+type ParticipantMapEvents = {
+    ['participantJoined']: (payload: Participant) => void;
+    ['participantLeft']: (payload: Participant) => void;
+    ['participantsCleared']: () => void;
+    ['participantsUpdate']: () => void;
+    ['kicked']: (payload: {
+        id: string;
+    }) => void;
 };
-declare class LocalMediaHandler extends RTKEventEmitter<LocalMediaEvents> {
-    readonly telemetry: RTKTelemetry;
-    audioUpdateInProgress: boolean;
-    videoUpdateInProgress: boolean;
-    constructor(context: Context<RTKContextState>, mediaConstraints: MediaConstraints, isNonPreferredDevice?: (media: MediaDeviceInfo) => boolean, autoSwitchDevice?: boolean);
-    context: Context<RTKContextState>;
-    repopulateAvailableDevices(): Promise<boolean>;
-    setupStreams({ audio, video, }: {
-        audio: boolean;
-        video: boolean;
-    }): Promise<void>;
-    getCurrentDevices(): {
-        audio: MediaDeviceInfo;
-        video: MediaDeviceInfo;
-        speaker: MediaDeviceInfo;
-    };
-    readonly permissions: {
-        audio?: MediaPermission$1;
-        video?: MediaPermission$1;
-        screenshare?: MediaPermission$1;
-    };
-    getAllDevices(): Promise<InputDeviceInfo[]>;
-    getDeviceById(deviceId: string, kind?: 'audioinput' | 'audiooutput' | 'videoinput'): Promise<MediaDeviceInfo>;
-    readonly rawAudioTrack: MediaStreamTrack;
-    readonly audioTrack: MediaStreamTrack;
-    readonly audioEnabled: boolean;
-    enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
-    disableAudio(): void;
-    getAudioDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
-    setAudioDevice(device: MediaDeviceInfo): Promise<void>;
-    setupSpeaker(): Promise<void>;
-    setSpeakerDevice(device: MediaDeviceInfo): Promise<void>;
-    readonly rawVideoTrack: MediaStreamTrack;
-    readonly videoTrack: MediaStreamTrack;
-    readonly videoEnabled: boolean;
-    enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
-    disableVideo(): void;
-    getVideoDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
-    setVideoDevice(device: MediaDeviceInfo): Promise<void>;
-    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
-    readonly screenShareTracks: {
-        audio: MediaStreamTrack;
-        video: MediaStreamTrack;
-    };
-    readonly screenShareEnabled: boolean;
-    enableScreenShare(): Promise<void>;
-    disableScreenShare(): Promise<void>;
-    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
-    getSpeakerDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
-    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
-    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
-    removeAllAudioMiddlewares(): Promise<ResponseStatus>;
-    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
-    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
-    removeAllVideoMiddlewares(): Promise<ResponseStatus>;
-    setVideoMiddlewareGlobalConfig(config: VideoMiddlewareGlobalConfig): Promise<void>;
-    destruct(): void;
-    onDeviceChange(changedDevices: {
-        added: MediaDeviceInfo[];
-        removed: MediaDeviceInfo[];
-        devices: MediaDeviceInfo[];
-    }, skipDeviceChange: boolean): Promise<void>;
-    removeAllTracks(): void;
-    removeAudioTrack(): void;
-    removeVideoTrack(): void;
-    removeDocumentEventListeners(): Promise<void>;
+declare class ParticipantMap<T extends Pick<Participant, 'id' | keyof TypedEventEmitter$1<ParticipantEvents>> = Participant> extends ClientMap<ParticipantEvents, T, ParticipantMapEvents> {
+    constructor(logger: Logger, options?: MapEvents<ParticipantMapEvents>);
+    add(participant: T, emitEvent?: boolean): this;
+    clear(emitEvent?: boolean, removeListeners?: boolean): void;
+    delete(participantId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
 }
-declare enum MediaPermission {
-    NOT_REQUESTED = 0,
-    ACCEPTED = 1,
-    DENIED = 2,
-    CANCELED = 3,
-    SYSTEM_DENIED = 4,
-    COULD_NOT_START = 5,
-    NO_DEVICES_AVAILABLE = 6
+type StageSocketMessage = GetStageRequestsResponse | GetStagePeersResponse | DenyStageAccessRequest | PeerStatusUpdate;
+declare class StageSocketHandler {
+    constructor(socketService: SocketService);
+    getStageRequests(): Promise<GetStageRequestsResponse>;
+    requestAccess(): void;
+    cancelRequestAccess(): void;
+    grantAccess(userIds: string[]): Promise<void>;
+    denyAccess(userIds: string[]): Promise<void>;
+    joinStage(): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    leaveStage(userId: string): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    kick(userIds: string[]): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    on(event: number, handler: (socketMessage: StageSocketMessage, messageId?: string) => void): void;
+    getPeerInfo(peerId: string): Promise<PeerInfoResponse>;
 }
-type AudioMiddleware = (audioContext: AudioContext) => Promise<ScriptProcessorNode | AudioWorkletNode>;
-type VideoMiddleware = (() => Promise<(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D) => Promise<void>>) | ((helpers: {
-    canvas: HTMLCanvasElement;
+type StageStatus = 'OFF_STAGE' | 'REQUESTED_TO_JOIN_STAGE' | 'ACCEPTED_TO_JOIN_STAGE' | 'ON_STAGE';
+interface StageRequestPayload {
+    displayName: string;
+    userId: string;
+    peerId: string;
+}
+type StageEvents = {
+    ['stageAccessRequestUpdate']: (requests?: StageRequestPayload[]) => void;
+    ['stageStatusUpdate']: (status: StageStatus) => void;
+    ['newStageRequest']: (payload: {
+        count: number;
+    }) => void;
+    ['stageRequestApproved']: () => void;
+    ['stageRequestRejected']: () => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
+};
+declare class Stage extends TypedEventEmitter$1<StageEvents> {
+    readonly telemetry: Telemetry;
+    constructor(context: Context<ContextState>, self: Self, participants: Participants, stageSocketHandler: StageSocketHandler, roomSocketHandler: RoomSocketHandler);
+    readonly status: StageStatus;
+    private setupEvents;
+    getAccessRequests(): {
+        stageRequests: StageRequestPayload[];
+    };
+    requestAccess(): Promise<void>;
+    cancelRequestAccess(): Promise<void>;
+    grantAccess(userIds: string[]): Promise<void>;
+    denyAccess(userIds: string[]): Promise<void>;
+    readonly peerId: string;
+    join(): Promise<void>;
+    leave(): Promise<void>;
+    kick(userIds: string[]): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+}
+declare const modes: readonly [
+    "ACTIVE_GRID",
+    "PAGINATED",
+    "MANUAL"
+];
+type ViewMode = (typeof modes)[number];
+interface BroadcastMessagePayload {
+    [key: string]: boolean | number | string | Date | ActiveTab;
+}
+interface PeerProducerConfig {
+    audio: boolean;
+    video: boolean;
+    screenshareAudio: boolean;
+    screenshareVideo: boolean;
+}
+type BroadcastMessageTarget = {
+    participantIds: string[];
+} | {
+    presetNames: string[];
+} | {
+    meetingIds: string[];
+};
+type JoinedPeer = {
+    id: string;
+    userId: string;
+    name: string;
+    stageType?: StageStatus;
+    customParticipantId?: string;
+    presetId?: string;
+    picture?: string;
+    waitlisted: boolean;
+    recorderType?: string;
+    stageStatus?: StageStatus;
+    metadata?: {
+        preset_name?: string;
+    };
+    flags?: {
+        hiddenParticipant?: boolean;
+        recorder?: boolean;
+    };
+};
+type ParticipantsEvents = {
+    ['viewModeChanged']: (payload: {
+        viewMode: string;
+        currentPage: number;
+        pageCount: number;
+    }) => void;
+    ['activeSpeaker']: (payload: {
+        peerId: string;
+        volume: number;
+    }) => void;
+    ['broadcastedMessage']: (payload: {
+        type: string;
+        payload: BroadcastMessagePayload;
+        timestamp: number;
+    }) => void;
+    ['poorConnection']: (payload: {
+        participantId: string;
+        score: number;
+        kind: string;
+    }) => void;
+    ['pageChanged']: (payload: {
+        viewMode: string;
+        currentPage: number;
+        pageCount: number;
+    }) => void;
+    ['mediaScoreUpdate']: (payload: {
+        kind: string;
+        isScreenshare: boolean;
+        score: number;
+        participantId: string;
+        scoreStats: ConsumerScoreStats;
+    }) => void;
+    ['media_decode_error']: (payload: {
+        reason: string;
+        code: '1702' | '1703';
+    }) => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+declare class Participants extends TypedEventEmitter$1<ParticipantsEvents> {
+    readonly waitlisted: Readonly<ParticipantMap<Pick<Participant, Exclude<keyof Participant, 'audioTrack' | 'videoTrack' | 'screenShareTracks'>>>>;
+    readonly joined: Readonly<ParticipantMap>;
+    readonly active: Readonly<ParticipantMap>;
+    readonly videoSubscribed: Readonly<ParticipantMap>;
+    readonly audioSubscribed: Readonly<ParticipantMap>;
+    readonly pinned: Readonly<ParticipantMap>;
+    readonly all: Readonly<BasicParticipantsMap>;
+    readonly pip: Pip;
+    rateLimitConfig: {
+        maxInvocations: number;
+        period: number;
+    };
+    readonly rateLimits: {
+        maxInvocations: number;
+        period: number;
+    };
+    updateRateLimits(num: number, period: number): void;
+    readonly telemetry: Telemetry;
+    viewMode: ViewMode;
+    currentPage: number;
+    lastActiveSpeaker: string;
+    selectedPeers: SelectedPeers;
+    constructor(context: Context<ContextState>, self: Self, roomSocketHandler: RoomSocketHandler);
+    setupEvents(): void;
+    readonly count: number;
+    readonly maxActiveParticipantsCount: number;
+    setMaxActiveParticipantsCount(limit: number): void;
+    readonly pageCount: number;
+    acceptWaitingRoomRequest(id: string): void;
+    acceptAllWaitingRoomRequest(userIds: string[]): Promise<void>;
+    rejectWaitingRoomRequest(id: string): Promise<void>;
+    setViewMode(viewMode: ViewMode): Promise<void>;
+    subscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
+    unsubscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
+    getPeerIdsForCurrentPage(): string[];
+    setPage(page: number): Promise<void>;
+    disableAllAudio(allowUnmute: boolean): Promise<void>;
+    disableAllVideo(): Promise<void>;
+    disableAudio(participantId: string): Promise<void>;
+    disableVideo(participantId: string): Promise<void>;
+    kick(participantId: string): Promise<void>;
+    kickAll(): Promise<void>;
+    broadcastMessage(type: Exclude<string, 'spotlight'>, payload: BroadcastMessagePayload, target?: BroadcastMessageTarget): Promise<void>;
+    getAllJoinedPeers(searchQuery: string, limit: number, offset: number): Promise<{
+        id: string;
+        userId: string;
+        name: string;
+        displayName: string;
+        stageType: StageStatus;
+        customParticipantId: string;
+        presetId: string;
+        picture: string;
+        waitlisted: boolean;
+        stageStatus: StageStatus;
+        metadata: {
+            preset_name: string;
+        };
+        recorderType: string;
+        flags: {
+            hiddenParticipant: boolean;
+            hidden_participant: boolean;
+            recorder: boolean;
+        };
+    }[]>;
+    updatePermissions(participantIds: string[], permissions: PresetUpdates): Promise<void>;
+    getParticipantsInMeetingPreJoin(): Promise<RoomPeersInfoResponse>;
+}
+interface FetchRequestConfig {
+    baseURL?: string;
+    url?: string;
+    method?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retry?: number;
+    retryDelay?: number;
+    responseType?: string;
+    data?: any;
+    params?: Record<string, string>;
+}
+interface FetchResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    config: FetchRequestConfig;
+}
+declare class FetchClient {
+    defaults: {
+        baseURL: string;
+        headers: {
+            common: Record<string, string>;
+        };
+        timeout: number;
+        retry: number;
+        retryDelay: number;
+    };
+    constructor(options: {
+        baseURL: string;
+        timeout: number;
+        retry: number;
+        retryDelay: number;
+        responseType?: string;
+    });
+    private buildURL;
+    request<T = any>(config: FetchRequestConfig): Promise<FetchResponse<T>>;
+    get<T = any>(url: string, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
+    post<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
+    put<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
+}
+interface ResponseStatus {
+    success: boolean;
+    message: string;
+}
+type MediaPermission$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE' | 'CANCELED';
+declare class LocalMediaHandler extends CustomEventEmitter<LocalMediaEvents> {
+    readonly telemetry: Telemetry;
+    audioUpdateInProgress: boolean;
+    videoUpdateInProgress: boolean;
+    constructor(context: Context<ContextState>, mediaConstraints: MediaConstraints, isNonPreferredDevice?: (media: MediaDeviceInfo) => boolean, autoSwitchDevice?: boolean);
+    context: Context<ContextState>;
+    private onVisibilityChange;
+    repopulateAvailableDevices(): Promise<boolean>;
+    setupStreams({ audio, video, }: {
+        audio: boolean;
+        video: boolean;
+    }): Promise<void>;
+    getCurrentDevices(): {
+        audio: MediaDeviceInfo;
+        video: MediaDeviceInfo;
+        speaker: MediaDeviceInfo;
+    };
+    readonly permissions: {
+        audio?: MediaPermission$1;
+        video?: MediaPermission$1;
+        screenshare?: MediaPermission$1;
+    };
+    getAllDevices(): Promise<InputDeviceInfo[]>;
+    getDeviceById(deviceId: string, kind?: 'audioinput' | 'audiooutput' | 'videoinput'): Promise<MediaDeviceInfo>;
+    private onAudioTrackMuted;
+    private onAudioTrackChanged;
+    readonly rawAudioTrack: MediaStreamTrack;
+    readonly audioTrack: MediaStreamTrack;
+    readonly audioEnabled: boolean;
+    enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
+    disableAudio(): void;
+    getAudioDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    setAudioDevice(device: MediaDeviceInfo): Promise<void>;
+    setupSpeaker(): Promise<void>;
+    setSpeakerDevice(device: MediaDeviceInfo): Promise<void>;
+    private onVideoTrackChanged;
+    private onVideoTrackEnded;
+    readonly rawVideoTrack: MediaStreamTrack;
+    readonly videoTrack: MediaStreamTrack;
+    readonly videoEnabled: boolean;
+    enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
+    disableVideo(): void;
+    getVideoDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    setVideoDevice(device: MediaDeviceInfo): Promise<void>;
+    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    private onScreenShareEnded;
+    readonly screenShareTracks: {
+        audio: MediaStreamTrack;
+        video: MediaStreamTrack;
+    };
+    readonly screenShareEnabled: boolean;
+    enableScreenShare(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    getSpeakerDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
+    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
+    removeAllAudioMiddlewares(): Promise<ResponseStatus>;
+    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
+    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
+    removeAllVideoMiddlewares(): Promise<ResponseStatus>;
+    setVideoMiddlewareGlobalConfig(config: VideoMiddlewareGlobalConfig): Promise<void>;
+    destruct(): void;
+    onDeviceChange(changedDevices: {
+        added: MediaDeviceInfo[];
+        removed: MediaDeviceInfo[];
+        devices: MediaDeviceInfo[];
+    }, skipDeviceChange: boolean): Promise<void>;
+    removeAllTracks(): void;
+    removeAudioTrack(): void;
+    removeVideoTrack(): void;
+    removeDocumentEventListeners(): Promise<void>;
+}
+declare enum MediaPermission {
+    NOT_REQUESTED = 0,
+    ACCEPTED = 1,
+    DENIED = 2,
+    CANCELED = 3,
+    SYSTEM_DENIED = 4,
+    COULD_NOT_START = 5,
+    NO_DEVICES_AVAILABLE = 6
+}
+type AudioMiddleware = (audioContext: AudioContext) => Promise<ScriptProcessorNode | AudioWorkletNode>;
+type VideoMiddleware = (() => Promise<(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D) => Promise<void>>) | ((helpers: {
+    canvas: HTMLCanvasElement;
     WorkerTimers: typeof WorkerTimers;
 }) => Promise<void>);
 type VideoMiddlewareGlobalConfig = {
@@ -3256,11 +3871,11 @@ type ScreenshareQualityConstraints = {
     displaySurface?: 'window' | 'monitor' | 'browser';
     selfBrowserSurface?: 'include' | 'exclude';
 };
-interface RTKMediaTrackConstraints extends MediaTrackConstraints {
-    optional?: Array<object>;
+interface ClientMediaTrackConstraints extends MediaTrackConstraints {
+    optional?: Array<object>;
 }
-interface RTKMediaStreamConstraints extends MediaStreamConstraints {
-    audio?: boolean | RTKMediaTrackConstraints;
+interface ClientMediaStreamConstraints extends MediaStreamConstraints {
+    audio?: boolean | ClientMediaTrackConstraints;
 }
 type MediaConstraints = {
     audio?: AudioQualityConstraints;
@@ -3404,725 +4019,147 @@ type PresetV2CamelCased = {
             spacingBase: number;
             theme: Theme;
         };
-        configDiff: any;
-    };
-    version?: string;
-    id?: string;
-    name?: string;
-};
-type MaxVideoStreams = PresetV2CamelCased['config']['maxVideoStreams'];
-declare class RTKThemePreset$1 {
-    private constructor();
-    static fromResponse(preset: PresetV2CamelCased): RTKThemePreset$1;
-    static default(): RTKThemePreset$1;
-    static init(preset?: PresetV2CamelCased, useDefault?: boolean): RTKThemePreset$1;
-    readonly setupScreen: Readonly<{
-        isEnabled: boolean;
-    }>;
-    readonly waitingRoom: Readonly<{
-        isEnabled: boolean;
-    }>;
-    readonly controlBar: Readonly<{
-        isEnabled: boolean;
-        elements?: {
-            chat?: boolean;
-            fullscreen?: boolean;
-            invite?: boolean;
-            layout?: boolean;
-            participants?: boolean;
-            plugins?: boolean;
-            polls?: boolean;
-            reactions?: boolean;
-            screenshare?: boolean;
-        };
-    }>;
-    readonly header: Readonly<{
-        isEnabled: boolean;
-        elements: {
-            logo: string;
-            timer: boolean;
-            title: boolean;
-            participantCount: boolean;
-            changeLayout: boolean;
-        };
-    }>;
-    readonly pipMode: Readonly<boolean>;
-    readonly viewType: Readonly<ViewType>;
-    readonly livestreamViewerQualities: Readonly<LivestreamViewerMediaQualityType[]>;
-    readonly maxVideoStreams: Readonly<MaxVideoStreams>;
-    readonly maxScreenShareCount: Readonly<number>;
-    readonly plugins: Readonly<string[]>;
-    readonly disabledPlugins: Readonly<string[]>;
-    readonly designTokens: Readonly<PresetV2CamelCased['ui']['designTokens']>;
-    readonly configDiff: Readonly<PresetV2CamelCased['ui']['configDiff']>;
-    readonly mediaConstraints: Readonly<PresetMediaConstraints>;
-    readonly name: string;
-}
-type PresetPermissions = PresetV2CamelCased['permissions'];
-type MediaRoomType = 'HIVE' | 'CF';
-type PermissionEvents = {
-    ['chatUpdate']: () => void;
-    ['pollsUpdate']: () => void;
-    ['pluginsUpdate']: () => void;
-    ['permissionsUpdate']: (patch: PresetUpdates) => void;
-    ['*']: () => void;
-};
-declare class RTKPermissionsPreset$1 extends RTKTypedEventEmitter<PermissionEvents> {
-    private constructor();
-    static fromResponse(response: PresetPermissions, viewType: ViewType, context: Context<RTKContextState>): RTKPermissionsPreset$1;
-    static default(context: Context<RTKContextState>, viewType: ViewType): RTKPermissionsPreset$1;
-    static init(context: Context<RTKContextState>, viewType: ViewType, response?: PresetPermissions): RTKPermissionsPreset$1;
-    readonly mediaRoomType: Readonly<MediaRoomType>;
-    readonly stageEnabled: Readonly<boolean>;
-    readonly acceptStageRequests: Readonly<boolean>;
-    readonly stageAccess: Readonly<MediaProductionPermissionType>;
-    readonly acceptWaitingRequests: Readonly<boolean>;
-    readonly requestProduceVideo: Readonly<boolean>;
-    readonly requestProduceAudio: Readonly<boolean>;
-    readonly requestProduceScreenshare: Readonly<boolean>;
-    readonly canAllowParticipantAudio: Readonly<boolean>;
-    readonly canAllowParticipantScreensharing: Readonly<boolean>;
-    readonly canAllowParticipantVideo: Readonly<boolean>;
-    readonly canDisableParticipantAudio: Readonly<boolean>;
-    readonly canDisableParticipantVideo: Readonly<boolean>;
-    readonly kickParticipant: Readonly<boolean>;
-    readonly pinParticipant: Readonly<boolean>;
-    readonly canRecord: Readonly<boolean>;
-    readonly waitingRoomType: Readonly<WaitingRoomTypes>;
-    readonly waitingRoomBehaviour: Readonly<WaitingRoomTypes>;
-    readonly plugins: Readonly<PresetPermissions['plugins']>;
-    readonly polls: Readonly<PresetPermissions['polls']>;
-    readonly produceVideo: Readonly<MediaProductionPermissionType>;
-    readonly requestProduce: Readonly<boolean>;
-    readonly canProduceVideo: Readonly<MediaProductionPermissionType>;
-    readonly produceScreenshare: Readonly<MediaProductionPermissionType>;
-    readonly canProduceScreenshare: Readonly<MediaProductionPermissionType>;
-    readonly produceAudio: Readonly<MediaProductionPermissionType>;
-    readonly canProduceAudio: Readonly<MediaProductionPermissionType>;
-    readonly chatPublic: Readonly<PresetPermissions['chat']['public']>;
-    readonly chatPrivate: Readonly<PresetPermissions['chat']['private']>;
-    readonly chatChannel: Readonly<PresetPermissions['chat']['channel']>;
-    readonly chatMessage: Readonly<PresetPermissions['chat']['message']>;
-    readonly connectedMeetings: Readonly<PresetPermissions['connectedMeetings']>;
-    readonly hiddenParticipant: Readonly<boolean>;
-    readonly showParticipantList: Readonly<boolean>;
-    readonly canChangeParticipantRole: Readonly<boolean>;
-    readonly canChangeParticipantPermissions: Readonly<boolean>;
-    readonly canChangeTheme: Readonly<boolean>;
-    readonly canPresent: Readonly<boolean>;
-    readonly acceptPresentRequests: Readonly<boolean>;
-    readonly canEditDisplayName: Readonly<boolean>;
-    readonly maxScreenShareCount: Readonly<number>;
-    readonly isRecorder: Readonly<boolean>;
-    readonly canSpotlight: Readonly<boolean>;
-    readonly canLivestream: Readonly<boolean>;
-    readonly transcriptionEnabled: Readonly<boolean>;
-}
-interface UserDetailsResponseV2 {
-    participant: UserDetailsResponse;
-    preset: PresetV2CamelCased;
-}
-type LeaveRoomState = 'kicked' | 'ended' | 'left' | 'rejected' | 'connected-meeting' | 'disconnected' | 'failed' | 'stageLeft';
-declare class SelfController {
-    readonly self: RTKSelf$1;
-    readonly authToken: string;
-    readonly peerId: string;
-    viewType: ViewType;
-    readonly telemetry: RTKTelemetry;
-    readonly logger: RTKLogger$1;
-    readonly mediaJoined: boolean;
-    private constructor();
-    static init(context: Context<RTKContextState>, roomSocketHandler: RoomSocketHandler, participant: UserDetailsResponseV2['participant'], permissions: RTKPermissionsPreset$1, theme: RTKThemePreset$1): Promise<SelfController>;
-    shareMediaTracks(): Promise<void>;
-    resetSelf(shouldAutoJoin: boolean): Promise<void>;
-    joinRoom(reconnected?: boolean): Promise<void>;
-    leaveRoom(state?: LeaveRoomState): Promise<void>;
-}
-declare class RTKSelfMedia$1 extends RTKTypedEventEmitter<SelfEvents> {
-    readonly peerId: string;
-    init(options?: {
-            video?: boolean;
-            audio?: boolean;
-            constraints?: MediaConstraints;
-        }, skipAwaits?: boolean, context?: Context<RTKContextState>): Promise<void>;
-    context: Context<RTKContextState>;
-    readonly audioTrack: MediaStreamTrack;
-    readonly rawAudioTrack: MediaStreamTrack;
-    readonly mediaPermissions: {
-        audio?: MediaPermission$1;
-        video?: MediaPermission$1;
-        screenshare?: MediaPermission$1;
-    };
-    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    removeAllAudioMiddlewares(): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    readonly videoTrack: MediaStreamTrack;
-    readonly rawVideoTrack: MediaStreamTrack;
-    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    setVideoMiddlewareGlobalConfig(config?: VideoMiddlewareGlobalConfig): Promise<void>;
-    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    removeAllVideoMiddlewares(): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    readonly screenShareTracks: {
-        audio: MediaStreamTrack;
-        video: MediaStreamTrack;
-    };
-    readonly audioEnabled: boolean;
-    readonly videoEnabled: boolean;
-    readonly screenShareEnabled: boolean;
-    enableAudio(): Promise<void>;
-    enableVideo(): Promise<void>;
-    disableAudio(): Promise<void>;
-    enableScreenShare(): Promise<void>;
-    disableScreenShare(): Promise<void>;
-    disableVideo(): Promise<void>;
-    getCurrentDevices(): {
-        audio: MediaDeviceInfo;
-        video: MediaDeviceInfo;
-        speaker: MediaDeviceInfo;
-    };
-    getAudioDevices(): Promise<MediaDeviceInfo[]>;
-    getVideoDevices(): Promise<MediaDeviceInfo[]>;
-    getSpeakerDevices(): Promise<MediaDeviceInfo[]>;
-    getDeviceById(deviceId: string, kind: 'audio' | 'video' | 'speaker'): Promise<MediaDeviceInfo>;
-    setDevice(device: MediaDeviceInfo): Promise<void>;
-}
-interface UserDetailsResponse {
-    id: string;
-    name: string;
-    email: string;
-    picture?: string;
-    loggedIn?: boolean;
-    scope?: string[];
-    clientSpecificId?: string;
-    customParticipantId?: string;
-    organizationId?: string;
-}
-declare class RTKSelf$1 extends RTKSelfMedia$1 {
-    name: string;
-    picture: string;
-    customParticipantId: string;
-    waitlistStatus: 'accepted' | 'waiting' | 'rejected' | 'none';
-    role: any;
-    userId: string;
-    organizationId: string;
-    supportsRemoteControl: boolean;
-    device: DeviceConfig;
-    readonly telemetry: RTKTelemetry;
-    hidden: boolean;
-    readonly stageStatus: StageStatus;
-    readonly id: string;
-    readonly peerId: string;
-    presetName: string;
-    roomState: 'init' | 'joined' | 'waitlisted' | LeaveRoomState;
-    private constructor();
-    static __init__(context: Context<RTKContextState>, details: UserDetailsResponse, permissions: RTKPermissionsPreset$1, theme: RTKThemePreset$1, presetName: string, skipAwaits?: boolean): Promise<RTKSelf$1>;
-    cleanupEvents(): void;
-    readonly permissions: RTKPermissionsPreset$1;
-    readonly config: RTKThemePreset$1;
-    readonly roomJoined: boolean;
-    setName(name: string): void;
-    setupTracks(options?: {
-        video?: boolean;
-        audio?: boolean;
-        forceReset?: boolean;
-    }): Promise<void>;
-    destructMediaHandler(): Promise<void>;
-    removeDocumentEventListeners(): Promise<void>;
-    enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
-    enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
-    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
-    enableScreenShare(): Promise<void>;
-    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
-    disableAudio(): Promise<void>;
-    disableVideo(): Promise<void>;
-    disableScreenShare(): Promise<void>;
-    getAllDevices(): Promise<InputDeviceInfo[]>;
-    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
-    readonly isPinned: boolean;
-    pin(): Promise<void>;
-    unpin(): Promise<void>;
-    hide(): Promise<void>;
-    show(): void;
-    setDevice(device: MediaDeviceInfo): Promise<void>;
-    cleanUpTracks(): void;
-    playAudio(): Promise<void>;
-    registerVideoElement(videoElem: HTMLVideoElement, isPreview?: boolean): void;
-    deregisterVideoElement(videoElem?: HTMLVideoElement, isPreview?: boolean): void;
-}
-interface RTKBasicParticipant {
-    userId: string;
-    name?: string;
-    picture?: string;
-    customParticipantId: string;
-}
-declare class RTKBasicParticipantsMap extends RTKEventEmitter<'participantsUpdate'> {
-    constructor(logger: RTKLogger$1);
-    __set(objId: string, obj: RTKBasicParticipant): Map<string, RTKBasicParticipant>;
-    __clear(): void;
-    get(objId: string): RTKBasicParticipant;
-    toArray(): RTKBasicParticipant[];
-}
-type ChatChannelSocketMessage = GetChatChannelResponse;
-interface ChatChannel {
-    id: string;
-    displayName: string;
-    memberIds: string[];
-    displayPictureUrl?: string;
-    visibility?: string;
-    isDirectMessage?: boolean;
-    latestMessage?: Message;
-    unreadCount: number;
-}
-interface UpdateChannelRequestPayload {
-    memberIds?: string[];
-    displayName?: string;
-    displayPictureUrl?: string;
-    visibility?: string;
-}
-declare class ChatChannelSocketHandler {
-    readonly telemetry: RTKTelemetry;
-    readonly logger: RTKLogger$1;
-    constructor(context: Context<RTKContextState>, socketService: SocketService);
-    createChannel(displayName: string, memberIds: string[], displayPictureUrl?: string, visibility?: string, isDirectMessage?: boolean): Promise<ChatChannel>;
-    updateChannel(channelId: string, payload: UpdateChannelRequestPayload): Promise<ChatChannel>;
-    static formatChannel(socketChannel: ChatChannel$1): ChatChannel;
-    getChannelMembers(channelId: string): Promise<RTKBasicParticipant[]>;
-    on(event: number, handler: (socketMessage: ChatChannelSocketMessage) => void): void;
-}
-declare enum ChatMessageType {
-    TEXT = 0,
-    IMAGE = 1,
-    FILE = 2,
-    CUSTOM = 3
-}
-type ChatSocketMessage = SendChatMessageToRoomResponse | SendChatMessageToPeersResponse | EditChatMessageResponse | DeleteChatMessageResponse;
-interface SearchFilters {
-    channelId?: string;
-    timestamp?: number;
-    size?: number;
-    reversed?: boolean;
-}
-declare class ChatSocketHandler {
-    readonly telemetry: RTKTelemetry;
-    readonly logger: RTKLogger$1;
-    constructor(context: Context<RTKContextState>, socketService: SocketService);
-    getChatMessages(): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    getChatMessagesPaginated(timeStamp: number, size: number, reversed: boolean, offset?: number, channelId?: string): Promise<GetPaginatedChatMessageRoomResponse>;
-    sendMessageToRoom(message: string, messageType: ChatMessageType): void;
-    sendMessageToPeers(message: string, messageType: ChatMessageType, peerIds: string[]): void;
-    sendMessageToChannel(message: string, messageType: ChatMessageType, channelId: string): void;
-    sendMessage(message: string, messageType: ChatMessageType, peerIds?: string[], channelId?: string): void;
-    editMessage(chatId: string, message: string, payloadType: ChatMessageType, channelId?: string, pinned?: boolean): Promise<ChatMessage>;
-    deleteMessage(chatId: string, channelId?: string): Promise<{
-        channelId?: string;
-        id: string;
-    }>;
-    searchMessages(query: string, filters: SearchFilters): Promise<ChatMessage[]>;
-    getAllChannels(): Promise<ChatChannel[]>;
-    markLastReadMessage(channelId: string, message: Message): Promise<string>;
-    setPinState(message: Message, pin: boolean): Promise<PinChatMessageResponse>;
-    on(event: number, handler: (socketMessage: ChatSocketMessage) => void): void;
-}
-declare class RTKSelectedPeers {
-    constructor();
-    add(peerId: string, priority: number, context: Context<RTKContextState>): number;
-    delete(peerId: string, context: Context<RTKContextState>): void;
-    index(peerId: string): number;
-    readonly peers: string[];
-    readonly compulsoryPeers: string[];
-    readonly activeSpeakerPeers: string[];
-}
-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;
-    readonly 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 TranscriptionData = {
-    id: string;
-    name: string;
-    peerId: string;
-    userId: string;
-    customParticipantId: string;
-    transcript: string;
-    isPartialTranscript: boolean;
-    date: Date;
-};
-type AiEvents = {
-    ['transcript']: (t: TranscriptionData) => void;
-    ['*']: (event: string, ...args: any[]) => void;
-};
-declare class RTKAi extends RTKTypedEventEmitter<AiEvents> {
-    transcripts: TranscriptionData[];
-    readonly telemetry: RTKTelemetry;
-    constructor(context: Context<RTKContextState>);
-    static init(context: Context<RTKContextState>, transcriptionEnabled: boolean): Promise<RTKAi>;
-    static parseTranscript(transcriptData: string, isPartialTranscript?: boolean): TranscriptionData | undefined;
-    static parseTranscripts(transcriptData: string): TranscriptionData[];
-    getActiveTranscript(): Promise<void>;
-    onTranscript(transcript: TranscriptionData): Promise<void>;
-}
-type ActiveTabType = 'screenshare' | 'plugin';
-interface ActiveTab {
-    type: ActiveTabType;
-    id: string;
-}
-declare enum TabChangeSource {
-    User = 0,
-    Meeting = 1
-}
-interface MediaConnectionUpdate {
-    transport: 'consuming' | 'producing';
-    state: string;
-    reconnected: boolean;
-}
-type MetaEvents = {
-    ['mediaConnectionUpdate']: (payload: MediaConnectionUpdate) => void;
-    ['socketConnectionUpdate']: (state: SocketConnectionState) => void;
-    ['poorConnection']: (payload: {
-        score: number;
-    }) => void;
-    ['meetingStartTimeUpdate']: (payload: {
-        meetingStartedTimestamp: Date;
-    }) => void;
-    ['transcript']: (t: TranscriptionData) => void;
-    ['activeTabUpdate']: (tab: ActiveTab) => void;
-    ['selfTabUpdate']: (tab: ActiveTab) => void;
-    ['broadcastTabChangesUpdate']: (broadcastTabChanges: boolean) => void;
-    ['*']: (event: string, ...args: any[]) => void;
-};
-declare class RTKMeta$1 extends RTKTypedEventEmitter<MetaEvents> {
-    selfActiveTab: ActiveTab | undefined;
-    readonly socketState: SocketConnectionState;
-    readonly mediaState: MediaConnectionState;
-    broadcastTabChanges: boolean;
-    viewType: string;
-    meetingStartedTimestamp: Date;
-    meetingTitle: string;
-    sessionId: string;
-    constructor(context: Context<RTKContextState>, self: RTKSelf, viewType: string, roomSocketHandler: RoomSocketHandler, meetingTitle: string);
-    readonly meetingId: string;
-    setBroadcastTabChanges(broadcastTabChanges: boolean): void;
-    setSelfActiveTab(spotlightTab: ActiveTab, tabChangeSource: TabChangeSource): void;
-}
-interface RTKMapEvents<T extends EventMap$1> {
-    onAddEvent?: keyof T;
-    onDeleteEvent?: keyof T;
-    onClearEvent?: keyof T;
-}
-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$1 & WildCardEvent<T>), U extends {
-        id: string;
-    } & RTKTypedEventEmitter<T>, V extends EventMap$1> extends Map<string, U> {
-    readonly onAddEvent: keyof V;
-    readonly onDeleteEvent: keyof V;
-    readonly onClearEvent: keyof V;
-    constructor(options: RTKMapEvents<V>, logger?: RTKLogger$1);
-    emit<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, ...args: Parameters<(V | ModifyPrependObject<T, U>)[E]>): boolean;
-    on<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    addListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    off<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    once<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    prependListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    prependOnceListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    removeListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    removeAllListeners<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event?: E): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    listeners<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E): Function[];
-    listenerCount<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E): number;
-    getMaxListeners(): number;
-    setMaxListeners(n: number): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    eventNames(): (string | symbol)[];
-    add(obj: U, emitEvent?: boolean): this;
-    set(objId: string, obj: U, emitEvent?: boolean): this;
-    delete(objId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
-    clear(emitEvent?: boolean, removeListeners?: boolean): void;
-    toArray(): U[];
-}
-type ParticipantMapEvents = {
-    ['participantJoined']: (payload: RTKParticipant$1) => void;
-    ['participantLeft']: (payload: RTKParticipant$1) => void;
-    ['participantsCleared']: () => void;
-    ['participantsUpdate']: () => void;
-    ['kicked']: (payload: {
-        id: string;
-    }) => void;
-};
-declare class RTKParticipantMap$1<T extends Pick<RTKParticipant$1, 'id' | keyof RTKTypedEventEmitter<ParticipantEvents>> = RTKParticipant$1> extends RTKMap<ParticipantEvents, T, ParticipantMapEvents> {
-    constructor(logger: RTKLogger, options?: RTKMapEvents<ParticipantMapEvents>);
-    add(participant: T, emitEvent?: boolean): this;
-    clear(emitEvent?: boolean, removeListeners?: boolean): void;
-    delete(participantId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
-}
-declare const modes: readonly [
-    "ACTIVE_GRID",
-    "PAGINATED",
-    "MANUAL"
-];
-type ViewMode = (typeof modes)[number];
-interface BroadcastMessagePayload {
-    [key: string]: boolean | number | string | Date | ActiveTab;
-}
-interface PeerProducerConfig {
-    audio: boolean;
-    video: boolean;
-    screenshareAudio: boolean;
-    screenshareVideo: boolean;
-}
-type BroadcastMessageTarget = {
-    participantIds: string[];
-} | {
-    presetNames: string[];
-} | {
-    meetingIds: string[];
-};
-type JoinedPeer = {
-    id: string;
-    userId: string;
-    name: string;
-    stageType?: StageStatus;
-    customParticipantId?: string;
-    presetId?: string;
-    picture?: string;
-    waitlisted: boolean;
-    recorderType?: string;
-    stageStatus?: StageStatus;
-    metadata?: {
-        preset_name?: string;
-    };
-    flags?: {
-        hiddenParticipant?: boolean;
-        recorder?: boolean;
-    };
-};
-type ParticipantsEvents = {
-    ['viewModeChanged']: (payload: {
-        viewMode: string;
-        currentPage: number;
-        pageCount: number;
-    }) => void;
-    ['activeSpeaker']: (payload: {
-        peerId: string;
-        volume: number;
-    }) => void;
-    ['broadcastedMessage']: (payload: {
-        type: string;
-        payload: BroadcastMessagePayload;
-        timestamp: number;
-    }) => void;
-    ['poorConnection']: (payload: {
-        participantId: string;
-        score: number;
-        kind: string;
-    }) => void;
-    ['pageChanged']: (payload: {
-        viewMode: string;
-        currentPage: number;
-        pageCount: number;
-    }) => void;
-    ['mediaScoreUpdate']: (payload: {
-        kind: string;
-        isScreenshare: boolean;
-        score: number;
-        participantId: string;
-        scoreStats: ConsumerScoreStats;
-    }) => void;
-    ['media_decode_error']: (payload: {
-        reason: string;
-        code: '1702' | '1703';
-    }) => void;
-    ['*']: (event: string, ...args: any[]) => void;
-};
-declare class RTKParticipants$1 extends RTKTypedEventEmitter<ParticipantsEvents> {
-    readonly waitlisted: Readonly<RTKParticipantMap$1<Pick<RTKParticipant$1, Exclude<keyof RTKParticipant$1, 'audioTrack' | 'videoTrack' | 'screenShareTracks'>>>>;
-    readonly joined: Readonly<RTKParticipantMap$1>;
-    readonly active: Readonly<RTKParticipantMap$1>;
-    readonly videoSubscribed: Readonly<RTKParticipantMap$1>;
-    readonly audioSubscribed: Readonly<RTKParticipantMap$1>;
-    readonly pinned: Readonly<RTKParticipantMap$1>;
-    readonly all: Readonly<RTKBasicParticipantsMap>;
-    readonly pip: RTKPip;
-    rateLimitConfig: {
-        maxInvocations: number;
-        period: number;
-    };
-    readonly rateLimits: {
-        maxInvocations: number;
-        period: number;
-    };
-    updateRateLimits(num: number, period: number): void;
-    readonly telemetry: RTKTelemetry;
-    viewMode: ViewMode;
-    currentPage: number;
-    lastActiveSpeaker: string;
-    selectedPeers: RTKSelectedPeers;
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, roomSocketHandler: RoomSocketHandler);
-    setupEvents(): void;
-    readonly count: number;
-    readonly maxActiveParticipantsCount: number;
-    setMaxActiveParticipantsCount(limit: number): void;
-    readonly pageCount: number;
-    acceptWaitingRoomRequest(id: string): void;
-    acceptAllWaitingRoomRequest(userIds: string[]): Promise<void>;
-    rejectWaitingRoomRequest(id: string): Promise<void>;
-    setViewMode(viewMode: ViewMode): Promise<void>;
-    subscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
-    unsubscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
-    getPeerIdsForCurrentPage(): string[];
-    setPage(page: number): Promise<void>;
-    disableAllAudio(allowUnmute: boolean): Promise<void>;
-    disableAllVideo(): Promise<void>;
-    disableAudio(participantId: string): Promise<void>;
-    disableVideo(participantId: string): Promise<void>;
-    kick(participantId: string): Promise<void>;
-    kickAll(): Promise<void>;
-    broadcastMessage(type: Exclude<string, 'spotlight'>, payload: BroadcastMessagePayload, target?: BroadcastMessageTarget): Promise<void>;
-    getAllJoinedPeers(searchQuery: string, limit: number, offset: number): Promise<{
-        id: string;
-        userId: string;
-        name: string;
-        displayName: string;
-        stageType: StageStatus;
-        customParticipantId: string;
-        presetId: string;
-        picture: string;
-        waitlisted: boolean;
-        stageStatus: StageStatus;
-        metadata: {
-            preset_name: string;
-        };
-        recorderType: string;
-        flags: {
-            hiddenParticipant: boolean;
-            hidden_participant: boolean;
-            recorder: boolean;
-        };
-    }[]>;
-    updatePermissions(participantIds: string[], permissions: PresetUpdates): Promise<void>;
-    getParticipantsInMeetingPreJoin(): Promise<RoomPeersInfoResponse>;
-}
-interface FetchRequestConfig {
-    baseURL?: string;
-    url?: string;
-    method?: string;
-    headers?: Record<string, string>;
-    timeout?: number;
-    retry?: number;
-    retryDelay?: number;
-    responseType?: string;
-    data?: any;
-    params?: Record<string, string>;
-}
-interface FetchResponse<T = any> {
-    data: T;
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    config: FetchRequestConfig;
-}
-declare class FetchClient {
-    defaults: {
-        baseURL: string;
-        headers: {
-            common: Record<string, string>;
-        };
-        timeout: number;
-        retry: number;
-        retryDelay: number;
+        configDiff: any;
     };
-    constructor(options: {
-        baseURL: string;
-        timeout: number;
-        retry: number;
-        retryDelay: number;
-        responseType?: string;
-    });
-    request<T = any>(config: FetchRequestConfig): Promise<FetchResponse<T>>;
-    get<T = any>(url: string, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
-    post<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
-    put<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
+    version?: string;
+    id?: string;
+    name?: string;
+};
+type MaxVideoStreams = PresetV2CamelCased['config']['maxVideoStreams'];
+declare class ThemePreset {
+    private constructor();
+    static fromResponse(preset: PresetV2CamelCased): ThemePreset;
+    static default(): ThemePreset;
+    static init(preset?: PresetV2CamelCased, useDefault?: boolean): ThemePreset;
+    readonly setupScreen: Readonly<{
+        isEnabled: boolean;
+    }>;
+    readonly waitingRoom: Readonly<{
+        isEnabled: boolean;
+    }>;
+    readonly controlBar: Readonly<{
+        isEnabled: boolean;
+        elements?: {
+            chat?: boolean;
+            fullscreen?: boolean;
+            invite?: boolean;
+            layout?: boolean;
+            participants?: boolean;
+            plugins?: boolean;
+            polls?: boolean;
+            reactions?: boolean;
+            screenshare?: boolean;
+        };
+    }>;
+    readonly header: Readonly<{
+        isEnabled: boolean;
+        elements: {
+            logo: string;
+            timer: boolean;
+            title: boolean;
+            participantCount: boolean;
+            changeLayout: boolean;
+        };
+    }>;
+    readonly pipMode: Readonly<boolean>;
+    readonly viewType: Readonly<ViewType>;
+    readonly livestreamViewerQualities: Readonly<LivestreamViewerMediaQualityType[]>;
+    readonly maxVideoStreams: Readonly<MaxVideoStreams>;
+    readonly maxScreenShareCount: Readonly<number>;
+    readonly plugins: Readonly<string[]>;
+    readonly disabledPlugins: Readonly<string[]>;
+    readonly designTokens: Readonly<PresetV2CamelCased['ui']['designTokens']>;
+    readonly configDiff: Readonly<PresetV2CamelCased['ui']['configDiff']>;
+    readonly mediaConstraints: Readonly<PresetMediaConstraints>;
+    readonly name: string;
+}
+type PresetPermissions = PresetV2CamelCased['permissions'];
+type PermissionEvents = {
+    ['chatUpdate']: () => void;
+    ['pollsUpdate']: () => void;
+    ['pluginsUpdate']: () => void;
+    ['permissionsUpdate']: (patch: PresetUpdates) => void;
+    ['*']: () => void;
+};
+declare class PermissionPreset extends TypedEventEmitter$1<PermissionEvents> {
+    private constructor();
+    private setupEvents;
+    static fromResponse(response: PresetPermissions, viewType: ViewType, context: Context<ContextState>): PermissionPreset;
+    static default(context: Context<ContextState>, viewType: ViewType): PermissionPreset;
+    static init(context: Context<ContextState>, viewType: ViewType, response?: PresetPermissions): PermissionPreset;
+    readonly mediaRoomType: string;
+    readonly stageEnabled: Readonly<boolean>;
+    readonly acceptStageRequests: Readonly<boolean>;
+    readonly stageAccess: Readonly<MediaProductionPermissionType>;
+    readonly acceptWaitingRequests: Readonly<boolean>;
+    readonly requestProduceVideo: Readonly<boolean>;
+    readonly requestProduceAudio: Readonly<boolean>;
+    readonly requestProduceScreenshare: Readonly<boolean>;
+    readonly canAllowParticipantAudio: Readonly<boolean>;
+    readonly canAllowParticipantScreensharing: Readonly<boolean>;
+    readonly canAllowParticipantVideo: Readonly<boolean>;
+    readonly canDisableParticipantAudio: Readonly<boolean>;
+    readonly canDisableParticipantVideo: Readonly<boolean>;
+    readonly kickParticipant: Readonly<boolean>;
+    readonly pinParticipant: Readonly<boolean>;
+    readonly canRecord: Readonly<boolean>;
+    readonly waitingRoomType: Readonly<WaitingRoomTypes>;
+    readonly waitingRoomBehaviour: Readonly<WaitingRoomTypes>;
+    readonly plugins: Readonly<PresetPermissions['plugins']>;
+    readonly polls: Readonly<PresetPermissions['polls']>;
+    readonly produceVideo: Readonly<MediaProductionPermissionType>;
+    readonly requestProduce: Readonly<boolean>;
+    readonly canProduceVideo: Readonly<MediaProductionPermissionType>;
+    readonly produceScreenshare: Readonly<MediaProductionPermissionType>;
+    readonly canProduceScreenshare: Readonly<MediaProductionPermissionType>;
+    readonly produceAudio: Readonly<MediaProductionPermissionType>;
+    readonly canProduceAudio: Readonly<MediaProductionPermissionType>;
+    readonly chatPublic: Readonly<PresetPermissions['chat']['public']>;
+    readonly chatPrivate: Readonly<PresetPermissions['chat']['private']>;
+    readonly chatChannel: Readonly<PresetPermissions['chat']['channel']>;
+    readonly chatMessage: Readonly<PresetPermissions['chat']['message']>;
+    readonly connectedMeetings: Readonly<PresetPermissions['connectedMeetings']>;
+    readonly hiddenParticipant: Readonly<boolean>;
+    readonly showParticipantList: Readonly<boolean>;
+    readonly canChangeParticipantRole: Readonly<boolean>;
+    readonly canChangeParticipantPermissions: Readonly<boolean>;
+    readonly canChangeTheme: Readonly<boolean>;
+    readonly canPresent: Readonly<boolean>;
+    readonly acceptPresentRequests: Readonly<boolean>;
+    readonly canEditDisplayName: Readonly<boolean>;
+    readonly maxScreenShareCount: Readonly<number>;
+    readonly isRecorder: Readonly<boolean>;
+    readonly canSpotlight: Readonly<boolean>;
+    readonly canLivestream: Readonly<boolean>;
+    readonly transcriptionEnabled: Readonly<boolean>;
+}
+interface UserDetailsResponseV2 {
+    participant: UserDetailsResponse;
+    preset: PresetV2CamelCased;
+}
+type LeaveRoomState = 'kicked' | 'ended' | 'left' | 'rejected' | 'connected-meeting' | 'disconnected' | 'failed' | 'stageLeft';
+declare class SelfController {
+    readonly self: Self;
+    readonly authToken: string;
+    readonly peerId: string;
+    viewType: ViewType;
+    readonly telemetry: Telemetry;
+    readonly logger: Logger;
+    readonly mediaJoined: boolean;
+    private constructor();
+    static init(context: Context<ContextState>, roomSocketHandler: RoomSocketHandler, participant: UserDetailsResponseV2['participant'], permissions: PermissionPreset, theme: ThemePreset): Promise<SelfController>;
+    shareMediaTracks(): Promise<void>;
+    private kickHandler;
+    private waitlistedHandler;
+    private waitlistAcceptHandler;
+    private waitlistRejectedHandler;
+    resetSelf(shouldAutoJoin: boolean): Promise<void>;
+    private setupEvents;
+    joinRoom(reconnected?: boolean): Promise<void>;
+    leaveRoom(state?: LeaveRoomState): Promise<void>;
+    private joinMediaRoom;
+    private leaveMediaRoom;
+    private cleanupSelf;
 }
 type LivestreamState = 'IDLE' | 'STARTING' | 'WAITING_ON_MANUAL_INGESTION' | 'LIVESTREAMING' | 'STOPPING';
 type LivestreamEvents = {
@@ -4143,59 +4180,60 @@ type LivestreamResponse = {
     manualIngest: boolean;
     ingestionCredentials?: LivestreamIngestionCredentials;
 };
-declare class RTKLivestream$1 extends RTKTypedEventEmitter<LivestreamEvents> {
-    state: LivestreamState;
-    playbackUrl: string | undefined;
-    ingestionCredentials: LivestreamIngestionCredentials;
-    viewerCount: number;
-    readonly telemetry: RTKTelemetry;
-    constructor(context: Context<RTKContextState>, self: RTKSelf);
-    setLivestreamState(livestreamState: LivestreamState): void;
-    start(livestreamConfig?: StartLivestreamConfig): Promise<void>;
-    stop(): Promise<void>;
+declare class Livestream extends TypedEventEmitter$1<LivestreamEvents> {
+    state: LivestreamState;
+    playbackUrl: string | undefined;
+    ingestionCredentials: LivestreamIngestionCredentials;
+    viewerCount: number;
+    readonly telemetry: Telemetry;
+    constructor(context: Context<ContextState>, self: Self);
+    setLivestreamState(livestreamState: LivestreamState): void;
+    private emitCurrentLivestreamState;
+    start(livestreamConfig?: StartLivestreamConfig): Promise<void>;
+    stop(): Promise<void>;
 }
 type PluginSocketMessage = DisablePluginResponse | EnablePluginResponse | PluginEventResponse | PluginStoreResponse | SendChatMessageToPeersResponse | SendChatMessageToRoomResponse;
-declare class PluginSocketHandler {
-    constructor(context: Context<RTKContextState>, socketService: SocketService);
-    readonly logger: RTKLogger$1;
-    addPlugin(pluginId: string, staggered: boolean): void;
-    removePlugin(pluginId: string): void;
-    getActivePlugins(): Promise<EnablePluginsResponse>;
-    customPluginEventToRoom(pluginId: string, data: any, messageId?: string): void;
-    customPluginEventToPeers(pluginId: string, peerIds: string[], data: any, messageId?: string): void;
-    enablePluginForRoom(pluginId: string, messageId?: string): void;
-    enablePluginForPeers(pluginId: string, peerIds: string[], messageId?: string): void;
-    disablePluginForRoom(pluginId: string, messageId?: string): void;
-    disablePluginForPeers(pluginId: string, peerIds: string[], messageId?: string): void;
-    storeInsertKeys(pluginId: string, store: string, insertKeys: {
-        key: string;
-        payload?: any;
-    }[], messageId?: string): void;
-    storeGetKeys(pluginId: string, store: string, getKeys: {
-        key: string;
-    }[], messageId?: string): void;
-    storeDeleteKeys(pluginId: string, store: string, deleteKeys: {
-        key: string;
-    }[], messageId?: string): void;
-    storeDelete(pluginId: string, store: string, messageId?: string): void;
-    getPluginDataOld(pluginId: string, store: string): void;
-    storePluginDataOld(pluginId: string, store: string, data: any): void;
-    on(event: number, handler: (socketMessage: PluginSocketMessage, messageId?: string) => void): void;
-}
-interface RTKPluginResponse {
-    baseURL: string;
-    createdAt: string;
-    description: string;
-    id: string;
-    name: string;
-    organizationId: string;
-    picture: string;
-    private: boolean;
-    published: boolean;
-    staggered: boolean;
-    tags: string[];
-    type: string;
-    updatedAt: string;
+declare class PluginSocketHandler {
+    constructor(context: Context<ContextState>, socketService: SocketService);
+    readonly logger: Logger;
+    addPlugin(pluginId: string, staggered: boolean): void;
+    removePlugin(pluginId: string): void;
+    getActivePlugins(): Promise<EnablePluginsResponse>;
+    customPluginEventToRoom(pluginId: string, data: any, messageId?: string): void;
+    customPluginEventToPeers(pluginId: string, peerIds: string[], data: any, messageId?: string): void;
+    enablePluginForRoom(pluginId: string, messageId?: string): void;
+    enablePluginForPeers(pluginId: string, peerIds: string[], messageId?: string): void;
+    disablePluginForRoom(pluginId: string, messageId?: string): void;
+    disablePluginForPeers(pluginId: string, peerIds: string[], messageId?: string): void;
+    storeInsertKeys(pluginId: string, store: string, insertKeys: {
+        key: string;
+        payload?: any;
+    }[], messageId?: string): void;
+    storeGetKeys(pluginId: string, store: string, getKeys: {
+        key: string;
+    }[], messageId?: string): void;
+    storeDeleteKeys(pluginId: string, store: string, deleteKeys: {
+        key: string;
+    }[], messageId?: string): void;
+    storeDelete(pluginId: string, store: string, messageId?: string): void;
+    getPluginDataOld(pluginId: string, store: string): void;
+    storePluginDataOld(pluginId: string, store: string, data: any): void;
+    on(event: number, handler: (socketMessage: PluginSocketMessage, messageId?: string) => void): void;
+}
+interface PluginResponse {
+    baseURL: string;
+    createdAt: string;
+    description: string;
+    id: string;
+    name: string;
+    organizationId: string;
+    picture: string;
+    private: boolean;
+    published: boolean;
+    staggered: boolean;
+    tags: string[];
+    type: string;
+    updatedAt: string;
 }
 interface PluginViews {
     [viewId: string]: {
@@ -4264,39 +4302,41 @@ type _string = string & {
     _?: any;
 };
 type PluginEvents$1 = keyof typeof PluginEventKeys | _string;
-declare class RTKPlugin$1 extends RTKEventEmitter<PluginEvents$1> {
-    readonly baseURL: string;
-    readonly createdAt: Date;
-    readonly description: string;
-    readonly id: string;
-    readonly name: string;
-    readonly organizationId: string;
-    readonly picture: string;
-    readonly private: boolean;
-    readonly published: boolean;
-    readonly staggered: boolean;
-    readonly tags: string[];
-    readonly type: string;
-    readonly updatedAt: Date;
-    config?: PluginConfig;
-    active: boolean;
-    iframes: Map<string, {
-        iframe: HTMLIFrameElement | ReactNativeWebView;
-        listener?: (message: MessageEvent) => void;
-    }>;
-    enabledBy: string;
-    readonly telemetry: RTKTelemetry;
-    constructor(context: Context<RTKContextState>, { baseURL, createdAt, description, id, name, organizationId, picture, private: isPrivate, published, staggered, tags, type, updatedAt, }: RTKPluginResponse, pluginSocketHandler: PluginSocketHandler, self: RTKSelf$1, participants: RTKParticipants$1, chat: Readonly<RTKChat$1>, meetingTitle: string);
-    sendIframeEvent(message: PluginIframeMessage): void;
-    sendData(payload: SendDataOptions): void;
-    removePluginView(viewId?: string): void;
-    addPluginView(iframe: HTMLIFrameElement | ReactNativeWebView, viewId?: string): void;
-    activateForSelf(): Promise<void>;
-    deactivateForSelf(): void;
-    enable(): Promise<void>;
-    disable(): void;
-    activate(): Promise<void>;
-    deactivate(): Promise<void>;
+declare class Plugin extends CustomEventEmitter<PluginEvents$1> {
+    readonly baseURL: string;
+    readonly createdAt: Date;
+    readonly description: string;
+    readonly id: string;
+    readonly name: string;
+    readonly organizationId: string;
+    readonly picture: string;
+    readonly private: boolean;
+    readonly published: boolean;
+    readonly staggered: boolean;
+    readonly tags: string[];
+    readonly type: string;
+    readonly updatedAt: Date;
+    config?: PluginConfig;
+    active: boolean;
+    iframes: Map<string, {
+        iframe: HTMLIFrameElement | ReactNativeWebView;
+        listener?: (message: MessageEvent) => void;
+    }>;
+    enabledBy: string;
+    readonly telemetry: Telemetry;
+    constructor(context: Context<ContextState>, { baseURL, createdAt, description, id, name, organizationId, picture, private: isPrivate, published, staggered, tags, type, updatedAt, }: PluginResponse, pluginSocketHandler: PluginSocketHandler, self: Self, participants: Participants, chat: Readonly<Chat>, meetingTitle: string);
+    sendIframeEvent(message: PluginIframeMessage): void;
+    private handleIframeMessage;
+    sendData(payload: SendDataOptions): void;
+    removePluginView(viewId?: string): void;
+    addPluginView(iframe: HTMLIFrameElement | ReactNativeWebView, viewId?: string): void;
+    private setActive;
+    activateForSelf(): Promise<void>;
+    deactivateForSelf(): void;
+    enable(): Promise<void>;
+    disable(): void;
+    activate(): Promise<void>;
+    deactivate(): Promise<void>;
 }
 interface RecordingConfig {
     fileNamePrefix?: string;
@@ -4311,34 +4351,34 @@ interface ReactNativeFile {
     name: string;
     type: string;
 }
-declare class APIClient extends API {
-    telemetry: RTKTelemetry;
-    constructor(context: Context<RTKContextState>, options?: APIOptions);
-    getIPDetails(): Promise<any>;
-    getICEServers(): Promise<any>;
-    getPlugins(): Promise<any[]>;
-    getPluginDetails(pluginId: string): Promise<RTKPluginResponse>;
-    getPluginConfig(pluginBaseUrl: string): Promise<PluginConfig>;
-    authorizePlugin(pluginId: string): Promise<string>;
-    getPresignedUrls(filename: string, viewType: string): Promise<{
-        getLocation: any;
-        putLocation: any;
-    }>;
-    uploadFile(file: File | ReactNativeFile, url: string): Promise<void>;
-    startLivestreaming({ manualIngestion, }: StartLivestreamConfig): Promise<LivestreamResponse>;
-    stopLivestreaming(): Promise<FetchResponse<any>>;
-    getActiveLivestream(): Promise<LivestreamResponse>;
-    getUserDetails(): Promise<UserDetailsResponseV2>;
-    startRecording(config: RecordingConfig, allowMultiple?: boolean): Promise<string>;
-    updateRecording(recordingId: string, action: 'stop' | 'pause' | 'resume'): Promise<FetchResponse<any>>;
-    getActiveRecording(): Promise<{
-        status: string;
-        id: string;
-    }>;
-    getActiveTranscript(): Promise<{
-        transcript: string;
-    }>;
-    getRoomNodeData(): Promise<RoomDetails>;
+declare class APIClient extends API {
+    telemetry: Telemetry;
+    constructor(context: Context<ContextState>, options?: APIOptions);
+    getIPDetails(): Promise<any>;
+    getICEServers(): Promise<any>;
+    getPlugins(): Promise<any[]>;
+    getPluginDetails(pluginId: string): Promise<PluginResponse>;
+    getPluginConfig(pluginBaseUrl: string): Promise<PluginConfig>;
+    authorizePlugin(pluginId: string): Promise<string>;
+    getPresignedUrls(filename: string, viewType: string): Promise<{
+        getLocation: any;
+        putLocation: any;
+    }>;
+    uploadFile(file: File | ReactNativeFile, url: string): Promise<void>;
+    startLivestreaming({ manualIngestion, }: StartLivestreamConfig): Promise<LivestreamResponse>;
+    stopLivestreaming(): Promise<FetchResponse<any>>;
+    getActiveLivestream(): Promise<LivestreamResponse>;
+    getUserDetails(): Promise<UserDetailsResponseV2>;
+    startRecording(config: RecordingConfig, allowMultiple?: boolean): Promise<string>;
+    updateRecording(recordingId: string, action: 'stop' | 'pause' | 'resume'): Promise<FetchResponse<any>>;
+    getActiveRecording(): Promise<{
+        status: string;
+        id: string;
+    }>;
+    getActiveTranscript(): Promise<{
+        transcript: string;
+    }>;
+    getRoomNodeData(): Promise<RoomDetails>;
 }
 declare enum MessageType {
     text = "text",
@@ -4436,62 +4476,66 @@ type ChatEvents = {
     ['channelUpdate']: (channel?: ChatChannel) => void;
     ['*']: (event: string, ...args: any[]) => void;
 };
-declare class RTKChat$1 extends RTKTypedEventEmitter<ChatEvents> {
-    messages: Message[];
-    channels: ChatChannel[];
-    maxTextLimit: number;
-    readonly telemetry: RTKTelemetry;
-    setMaxTextLimit(limit: number): void;
-    constructor(context: Context<RTKContextState>, chatSocketHandler: ChatSocketHandler, chatChannelSocketHandler: ChatChannelSocketHandler, self: RTKSelf$1, participants: RTKParticipants$1);
-    readonly rateLimits: {
-        maxInvocations: number;
-        period: number;
-    };
-    updateRateLimits(num: number, period: number): void;
-    sendTextMessage(message: string, peerIds?: string[]): Promise<void>;
-    sendCustomMessage(message: CustomMessagePayload, peerIds?: string[]): Promise<void>;
-    sendImageMessage(image: File | ReactNativeFile, peerIds?: string[]): Promise<void>;
-    sendFileMessage(file: File | ReactNativeFile, peerIds?: string[]): Promise<void>;
-    sendMessage(message: MessagePayload, participantIds?: string[]): Promise<void>;
-    editTextMessage(messageId: string, message: string, channelId?: string): Promise<void>;
-    editImageMessage(messageId: string, image: File | ReactNativeFile, channelId?: string): Promise<void>;
-    editFileMessage(messageId: string, file: File | ReactNativeFile, channelId?: string): Promise<void>;
-    editMessage(messageId: string, message: MessagePayload, channelId?: string): Promise<void>;
-    deleteMessage(messageId: string, channelId?: string): Promise<void>;
-    getMessagesByUser(userId: string): Message[];
-    getMessagesByType(type: keyof typeof MessageType): Message[];
-    pin(id: string): Promise<void>;
-    unpin(id: string): Promise<void>;
-    getMessages(timeStamp: number, size: number, reversed: boolean, offset?: number, channelId?: string): Promise<{
-        messages: Message[];
-        next: boolean;
-    }>;
-    createChannel(channelName: string, memberIds: string[], options?: {
-        displayPictureUrl?: string;
-        visibility?: string;
-        isDirectMessage?: boolean;
-    }): Promise<ChatChannel>;
-    updateChannel(channelId: string, payload: UpdateChannelRequestPayload): Promise<ChatChannel>;
-    sendMessageToChannel(message: MessagePayload, channelId: string, options?: {
-        replyTo?: Message;
-    }): Promise<void>;
-    getChannelMembers(channelId: string): Promise<RTKBasicParticipant[]>;
-    searchMessages(query: string, filters?: SearchFilters): Promise<Message[]>;
-    markLastReadMessage(channelId: string, message: Message): Promise<void>;
-    readonly pinned: Message[];
-}
-declare class PollSocketHandler {
-    readonly logger: RTKLogger$1;
-    readonly telemetry: RTKTelemetry;
-    constructor(context: Context<RTKContextState>, socketService: SocketService);
-    getPolls(): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    createPoll(question: string, options: string[], anonymous?: boolean, hideVotes?: boolean): boolean;
-    votePoll(id: string, index: number): boolean;
-    on(event: number, handler: (message: UpdatePollResponse) => void): void;
-    removeListeners(event: number): void;
+declare class Chat extends TypedEventEmitter$1<ChatEvents> {
+    messages: Message[];
+    channels: ChatChannel[];
+    maxTextLimit: number;
+    readonly telemetry: Telemetry;
+    setMaxTextLimit(limit: number): void;
+    constructor(context: Context<ContextState>, chatSocketHandler: ChatSocketHandler, chatChannelSocketHandler: ChatChannelSocketHandler, self: Self, participants: Participants);
+    private sendMessageInternal;
+    private sendTextMessageInternal;
+    private sendImageMessageInternal;
+    private sendFileMessageInternal;
+    readonly rateLimits: {
+        maxInvocations: number;
+        period: number;
+    };
+    updateRateLimits(num: number, period: number): void;
+    sendTextMessage(message: string, peerIds?: string[]): Promise<void>;
+    sendCustomMessage(message: CustomMessagePayload, peerIds?: string[]): Promise<void>;
+    sendImageMessage(image: File | ReactNativeFile, peerIds?: string[]): Promise<void>;
+    sendFileMessage(file: File | ReactNativeFile, peerIds?: string[]): Promise<void>;
+    sendMessage(message: MessagePayload, participantIds?: string[]): Promise<void>;
+    editTextMessage(messageId: string, message: string, channelId?: string): Promise<void>;
+    editImageMessage(messageId: string, image: File | ReactNativeFile, channelId?: string): Promise<void>;
+    editFileMessage(messageId: string, file: File | ReactNativeFile, channelId?: string): Promise<void>;
+    editMessage(messageId: string, message: MessagePayload, channelId?: string): Promise<void>;
+    deleteMessage(messageId: string, channelId?: string): Promise<void>;
+    getMessagesByUser(userId: string): Message[];
+    getMessagesByType(type: keyof typeof MessageType): Message[];
+    pin(id: string): Promise<void>;
+    unpin(id: string): Promise<void>;
+    getMessages(timeStamp: number, size: number, reversed: boolean, offset?: number, channelId?: string): Promise<{
+        messages: Message[];
+        next: boolean;
+    }>;
+    createChannel(channelName: string, memberIds: string[], options?: {
+        displayPictureUrl?: string;
+        visibility?: string;
+        isDirectMessage?: boolean;
+    }): Promise<ChatChannel>;
+    updateChannel(channelId: string, payload: UpdateChannelRequestPayload): Promise<ChatChannel>;
+    sendMessageToChannel(message: MessagePayload, channelId: string, options?: {
+        replyTo?: Message;
+    }): Promise<void>;
+    getChannelMembers(channelId: string): Promise<BasicParticipant[]>;
+    searchMessages(query: string, filters?: SearchFilters): Promise<Message[]>;
+    markLastReadMessage(channelId: string, message: Message): Promise<void>;
+    readonly pinned: Message[];
+}
+declare class PollSocketHandler {
+    readonly logger: Logger;
+    readonly telemetry: Telemetry;
+    constructor(context: Context<ContextState>, socketService: SocketService);
+    getPolls(): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    createPoll(question: string, options: string[], anonymous?: boolean, hideVotes?: boolean): boolean;
+    votePoll(id: string, index: number): boolean;
+    on(event: number, handler: (message: UpdatePollResponse) => void): void;
+    removeListeners(event: number): void;
 }
 interface PollOption {
     text: string;
@@ -4518,15 +4562,15 @@ type PollsEvents = {
     }) => void;
     ['*']: (eventName: string, ...args: any[]) => void;
 };
-declare class RTKPolls$1 extends RTKTypedEventEmitter<PollsEvents> {
-    items: Poll[];
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, pollSocketHandler: PollSocketHandler);
-    create(question: string, options: string[], anonymous?: boolean, hideVotes?: boolean): Promise<void>;
-    vote(id: string, index: number): Promise<void>;
-}
-type PluginMapEvents = {
-    ['pluginAdded']: (plugin: RTKPlugin$1) => void;
-    ['pluginDeleted']: (plugin: RTKPlugin$1) => void;
+declare class Polls extends TypedEventEmitter$1<PollsEvents> {
+    items: Poll[];
+    constructor(context: Context<ContextState>, self: Self, pollSocketHandler: PollSocketHandler);
+    create(question: string, options: string[], anonymous?: boolean, hideVotes?: boolean): Promise<void>;
+    vote(id: string, index: number): Promise<void>;
+}
+type PluginMapEvents = {
+    ['pluginAdded']: (plugin: Plugin) => void;
+    ['pluginDeleted']: (plugin: Plugin) => void;
 };
 type PluginEvents = {
     ['stateUpdate']: (payload: {
@@ -4541,15 +4585,87 @@ type PluginEvents = {
     ['enabled']: () => void;
     ['*']: (eventName: string, ...args: any[]) => void;
 };
-declare class RTKPluginMap$1<T extends RTKPlugin$1 = RTKPlugin$1> extends RTKMap<PluginEvents, T, PluginMapEvents> {
-    constructor(logger: RTKLogger$1);
-    add(plugin: T, emitEvent?: boolean): this;
-    delete(pluginId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
-}
-declare class RTKPlugins$1 {
-    readonly all: RTKPluginMap$1;
-    readonly active: RTKPluginMap$1;
-    constructor(logger: RTKLogger);
+declare class PluginMap<T extends Plugin = Plugin> extends ClientMap<PluginEvents, T, PluginMapEvents> {
+    constructor(logger: Logger);
+    add(plugin: T, emitEvent?: boolean): this;
+    delete(pluginId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
+}
+declare class Plugins {
+    readonly all: PluginMap;
+    readonly active: PluginMap;
+    constructor(logger: Logger);
+}
+declare class SelfMedia extends TypedEventEmitter$1<SelfEvents> {
+    protected localMediaHandler: LocalMediaHandler;
+    protected updatePermission(): Promise<void>;
+    protected populateMediaPermissionsInCallstats({ message, kind, }: {
+        message: keyof typeof MediaPermission;
+        kind: 'audio' | 'video' | 'screenshare';
+    }): Promise<void>;
+    readonly peerId: string;
+    init(options?: {
+        video?: boolean;
+        audio?: boolean;
+        constraints?: MediaConstraints;
+    }, skipAwaits?: boolean, context?: Context<ContextState>): Promise<void>;
+    context: Context<ContextState>;
+    readonly audioTrack: MediaStreamTrack;
+    readonly rawAudioTrack: MediaStreamTrack;
+    readonly mediaPermissions: {
+        audio?: MediaPermission$1;
+        video?: MediaPermission$1;
+        screenshare?: MediaPermission$1;
+    };
+    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    removeAllAudioMiddlewares(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    readonly videoTrack: MediaStreamTrack;
+    readonly rawVideoTrack: MediaStreamTrack;
+    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    setVideoMiddlewareGlobalConfig(config?: VideoMiddlewareGlobalConfig): Promise<void>;
+    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    removeAllVideoMiddlewares(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    readonly screenShareTracks: {
+        audio: MediaStreamTrack;
+        video: MediaStreamTrack;
+    };
+    readonly audioEnabled: boolean;
+    readonly videoEnabled: boolean;
+    readonly screenShareEnabled: boolean;
+    enableAudio(): Promise<void>;
+    enableVideo(): Promise<void>;
+    disableAudio(): Promise<void>;
+    enableScreenShare(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    disableVideo(): Promise<void>;
+    getCurrentDevices(): {
+        audio: MediaDeviceInfo;
+        video: MediaDeviceInfo;
+        speaker: MediaDeviceInfo;
+    };
+    getAudioDevices(): Promise<MediaDeviceInfo[]>;
+    getVideoDevices(): Promise<MediaDeviceInfo[]>;
+    getSpeakerDevices(): Promise<MediaDeviceInfo[]>;
+    getDeviceById(deviceId: string, kind: 'audio' | 'video' | 'speaker'): Promise<MediaDeviceInfo>;
+    setDevice(device: MediaDeviceInfo): Promise<void>;
 }
 type RecordingState = 'IDLE' | 'STARTING' | 'RECORDING' | 'PAUSED' | 'STOPPING';
 type RecordingType = 'BROWSER' | 'TRACK' | 'COMPOSITE';
@@ -4562,19 +4678,19 @@ type RecordingEvents = {
     ['recordingUpdate']: (state: RecordingState) => void;
     ['*']: (eventName: string, ...args: any[]) => void;
 };
-declare class RTKRecording$1 extends RTKTypedEventEmitter<RecordingEvents> {
-    recordingPeerIds: string[];
-    readonly recordingState: RecordingState;
-    recordings: RecordingInfo[];
-    constructor(context: Context<RTKContextState>, self: RTKSelf);
-    readonly telemetry: RTKTelemetry;
-    updateRecordings(recordings: RecordingInfo[]): void;
-    start(opts?: {
-        allowMultiple: boolean;
-    }): Promise<void>;
-    stop(recordingId?: string): Promise<void>;
-    pause(recordingId?: string): Promise<void>;
-    resume(recordingId?: string): Promise<void>;
+declare class Recording extends TypedEventEmitter$1<RecordingEvents> {
+    recordingPeerIds: string[];
+    readonly recordingState: RecordingState;
+    recordings: RecordingInfo[];
+    constructor(context: Context<ContextState>, self: Self);
+    readonly telemetry: Telemetry;
+    updateRecordings(recordings: RecordingInfo[]): void;
+    start(opts?: {
+        allowMultiple: boolean;
+    }): Promise<void>;
+    stop(recordingId?: string): Promise<void>;
+    pause(recordingId?: string): Promise<void>;
+    resume(recordingId?: string): Promise<void>;
 }
 declare class BrowserDetection {
     _bowser: any;
@@ -4633,70 +4749,76 @@ declare class BrowserCapabilities extends BrowserDetection {
     _getChromiumBasedVersion(): number;
     isIOSMobile(): boolean;
 }
-declare class RTKFeatures {
-    constructor(context: Context<RTKContextState>);
-    hasFeature(featureName: string): boolean;
-    getFeatureValue(featureName: string): _dyteinternals_utils.RTKFlagValues;
-    getAllFeatures(): {
-            [x: string]: _dyteinternals_utils.RTKFlagsEntry;
-        };
-}
-declare class RTKInternals {
-    logger: RTKLogger$1;
-    features: RTKFeatures;
-    browserSpecs: BrowserCapabilities;
-    callStats: InhouseCallStats;
-    constructor(logger: RTKLogger$1, features: RTKFeatures, callStats: InhouseCallStats);
-    static init(context: Context<RTKContextState>): RTKInternals;
+declare class Features {
+    constructor(context: Context<ContextState>);
+    hasFeature(featureName: string): boolean;
+    getFeatureValue(featureName: string): _dyteinternals_utils.DyteFlagValues;
+    getAllFeatures(): {
+        [x: string]: _dyteinternals_utils.DyteFlagsEntry;
+    };
+}
+declare class Internals {
+    logger: Logger;
+    features: Features;
+    browserSpecs: BrowserCapabilities;
+    callStats: InhouseCallStats;
+    constructor(logger: Logger, features: Features, callStats: InhouseCallStats);
+    static init(context: Context<ContextState>): Internals;
 }
 type StoreData = {
     [type: string]: any;
 };
-declare class RTKStore$1 {
-    name: string;
-    rateLimitConfig: {
-        maxInvocations: number;
-        period: number;
-    };
-    bulkRateLimitConfig: {
-        maxInvocations: number;
-        period: number;
-    };
-    constructor({ name, socketHandler, meetingId }: {
-        name: string;
-        socketHandler: PluginSocketHandler;
-        meetingId: string;
-    });
-    set(key: string, value: any, sync?: boolean, emit?: boolean): Promise<void>;
-    bulkSet(data: {
-        key: string;
-        payload: any;
-    }[]): Promise<void>;
-    update(key: string, value: any, sync?: boolean): Promise<void>;
-    delete(key: string, sync?: boolean, emit?: boolean): Promise<void>;
-    bulkDelete(data: {
-        key: string;
-    }[]): Promise<void>;
-    get(key: string): any;
-    getAll(): StoreData;
-    readonly rateLimits: {
-        maxInvocations: number;
-        period: number;
-    };
-    updateRateLimits(num: number, period: number): void;
-    readonly bulkRateLimits: {
-        maxInvocations: number;
-        period: number;
-    };
-    updateBulkRateLimits(num: number, period: number): void;
-    subscribe(key: string | '*', cb: (value: any) => any): void;
-    unsubscribe(key: string | '*', cb?: (value: any) => any): void;
-    populate(data: StoreData): void;
-}
-declare class RTKStoreManager {
-    stores: Map<String, RTKStore$1>;
-    constructor(context: Context<RTKContextState>, handler: PluginSocketHandler);
-    create(name: string): Promise<RTKStore$1>;
+type RateLimitConfig = {
+    maxInvocations: number;
+    period: number;
+};
+declare class Store {
+    name: string;
+    rateLimitConfig: {
+        maxInvocations: number;
+        period: number;
+    };
+    bulkRateLimitConfig: {
+        maxInvocations: number;
+        period: number;
+    };
+    private listeners;
+    constructor({ name, socketHandler, meetingId }: {
+        name: string;
+        socketHandler: PluginSocketHandler;
+        meetingId: string;
+    });
+    set(key: string, value: any, sync?: boolean, emit?: boolean): Promise<void>;
+    private remoteSet;
+    bulkSet(data: {
+        key: string;
+        payload: any;
+    }[]): Promise<void>;
+    update(key: string, value: any, sync?: boolean): Promise<void>;
+    delete(key: string, sync?: boolean, emit?: boolean): Promise<void>;
+    bulkDelete(data: {
+        key: string;
+    }[]): Promise<void>;
+    get(key: string): any;
+    getAll(): StoreData;
+    readonly rateLimits: {
+        maxInvocations: number;
+        period: number;
+    };
+    updateRateLimits(num: number, period: number): void;
+    readonly bulkRateLimits: {
+        maxInvocations: number;
+        period: number;
+    };
+    updateBulkRateLimits(num: number, period: number): void;
+    subscribe(key: string | '*', cb: (value: any) => any): void;
+    unsubscribe(key: string | '*', cb?: (value: any) => any): void;
+    populate(data: StoreData): void;
+}
+declare class StoreManager {
+    stores: Map<String, Store>;
+    constructor(context: Context<ContextState>, handler: PluginSocketHandler);
+    create(name: string): Promise<Store>;
 }
 declare const enum PRODUCERS_TYPE {
     WEBCAM = "webcam",
@@ -4719,66 +4841,66 @@ interface MediaNodeClientOptions {
     peerId: string;
     socket: SocketService;
 }
-declare class MediaNodeClient {
-    readonly context: Context<RTKContextState>;
-    readonly authToken: string;
-    readonly e2ee: boolean;
-    readonly peerId: string;
-    readonly telemetry: RTKTelemetry;
-    readonly logger: RTKLogger$1;
-    constructor(context: Context<RTKContextState>, nodeType: MediaNodeType, options: MediaNodeClientOptions);
-    mediaJoined: boolean;
-    reset(): void;
-    joinRoom(displayName: string, roomUuid: string, forceFullReset?: boolean, rejoining?: boolean, permissions?: MediaPermissions): Promise<{
-        roomJoined: boolean;
-    }>;
-    initializeConnection(displayName: string, roomUuid: string, rejoining?: boolean, permissions?: MediaPermissions): Promise<void>;
-    getConsumers(): Map<string, Consumer>;
-    leaveRoom(): Promise<void>;
-    activatePeers(producers: ProducerState[]): Promise<void>;
-    createConsumers(producers: ProducerState[]): Promise<void>;
-    closeConsumers(producers: ProducerState[]): Promise<void>;
-    _shareWebcam(videoTrack: MediaStreamTrack & {
-        originalSettings?: {
-            width: number;
-        };
-    }, codec: VideoCodec): Promise<MediaStreamTrack>;
-    shareWebcam(videoTrack: MediaStreamTrack): Promise<MediaStreamTrack | null>;
-    shareScreen(tracks: {
-        video?: MediaStreamTrack;
-        audio?: MediaStreamTrack;
-    }): Promise<void>;
-    shareMic(audioTrack: MediaStreamTrack): Promise<void>;
-    pauseMic(): Promise<void>;
-    pauseWebcam(): Promise<void>;
-    resumeMic(): Promise<void>;
-    resumeWebcam(producerType?: PRODUCERS_TYPE): Promise<void>;
-    disableWebcam(codec: VideoCodec): Promise<void>;
-    disableMic(): Promise<void>;
-    disableScreenShare(): Promise<void>;
-    muteSelf(): Promise<void>;
-    unmuteSelf(): Promise<void>;
-    resetVideoProducers(videoTrack: MediaStreamTrack, screenShareTrack?: MediaStreamTrack): Promise<void>;
-    changeDisplayName(displayName: string, peerId?: string): Promise<void>;
-    kick(peerId: string): void;
-    kickAll(): void;
-    muteAll(_allowUnMute: boolean): Promise<void>;
-    muteAllVideo(): Promise<void>;
-    disableAudio(peerId: string): Promise<void>;
-    disableVideo(peerId: string): Promise<void>;
-    pinPeer(peerId: string | null): Promise<void>;
-    validateScreenShare(payload: {
-        peerId: string;
-        consumerId: string;
-        screenShare: boolean;
-        producerId: string;
-        consumerPeerId: string;
-    }): number;
-    switchConsumersToLayer(consumerIds: string[], layer: number): Promise<void>;
-    handleSocketEvents(): Promise<void>;
-    handleCallstatsEvents(): void;
-    handlePeerCapabilities(peerId: string, capabilities: PeerRtpCapabilitites): void;
-    handlePeerLeaving(peerId: string): void;
+declare class MediaNodeClient {
+    readonly context: Context<ContextState>;
+    readonly authToken: string;
+    readonly e2ee: boolean;
+    readonly peerId: string;
+    readonly telemetry: Telemetry;
+    readonly logger: Logger;
+    constructor(context: Context<ContextState>, options: MediaNodeClientOptions);
+    mediaJoined: boolean;
+    reset(): void;
+    joinRoom(displayName: string, roomUuid: string, forceFullReset?: boolean, rejoining?: boolean, permissions?: MediaPermissions): Promise<{
+        roomJoined: boolean;
+    }>;
+    initializeConnection(displayName: string, roomUuid: string, rejoining?: boolean, permissions?: MediaPermissions): Promise<void>;
+    getConsumers(): Map<string, Consumer>;
+    getProducers(): Map<string, Producer>;
+    leaveRoom(): Promise<void>;
+    activatePeers(producers: ProducerState[]): Promise<void>;
+    createConsumers(producers: ProducerState[]): Promise<void>;
+    closeConsumers(producers: ProducerState[]): Promise<void>;
+    _shareWebcam(videoTrack: MediaStreamTrack & {
+        originalSettings?: {
+            width: number;
+        };
+    }, codec: VideoCodec): Promise<MediaStreamTrack>;
+    shareWebcam(videoTrack: MediaStreamTrack): Promise<MediaStreamTrack | null>;
+    shareScreen(tracks: {
+        video?: MediaStreamTrack;
+        audio?: MediaStreamTrack;
+    }): Promise<void>;
+    shareMic(audioTrack: MediaStreamTrack): Promise<void>;
+    pauseMic(): Promise<void>;
+    pauseWebcam(): Promise<void>;
+    resumeMic(): Promise<void>;
+    resumeWebcam(producerType?: PRODUCERS_TYPE): Promise<void>;
+    disableWebcam(codec: VideoCodec): Promise<void>;
+    disableMic(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    muteSelf(): Promise<void>;
+    resetVideoProducers(videoTrack: MediaStreamTrack, screenShareTrack?: MediaStreamTrack): Promise<void>;
+    changeDisplayName(displayName: string, peerId?: string): Promise<void>;
+    kick(peerId: string): void;
+    kickAll(): void;
+    muteAll(_allowUnMute: boolean): Promise<void>;
+    muteAllVideo(): Promise<void>;
+    disableAudio(peerId: string): Promise<void>;
+    disableVideo(peerId: string): Promise<void>;
+    pinPeer(peerId: string | null): Promise<void>;
+    validateScreenShare(payload: {
+        peerId: string;
+        consumerId: string;
+        screenShare: boolean;
+        producerId: string;
+        consumerPeerId: string;
+    }): number;
+    switchConsumersToLayer(consumerIds: string[], layer: number): Promise<void>;
+    handleSocketEvents(): Promise<void>;
+    handleCallstatsEvents(): void;
+    handlePeerCapabilities(peerId: string, capabilities: PeerRtpCapabilitites): void;
+    handlePeerLeaving(peerId: string): void;
 }
 interface SocketServicePayload {
     payload: any;
@@ -4837,55 +4959,57 @@ declare class ConnectedMeetingsSocketHandler {
         error: any;
     }>;
 }
-type ConnectedMeetingsEvents = {
-    ['meetingChanged']: (meeting: RealtimeKitClient) => void;
-    ['stateUpdate']: (payload: {
-        meetings: ConnectedMeeting[];
-        parentMeeting: ConnectedMeeting;
-    }) => void;
-    ['changingMeeting']: (meetingId: string) => void;
-    ['*']: (eventName: string, ...args: any[]) => void;
+type ConnectedMeetingsEvents = {
+    ['meetingChanged']: (meeting: Client) => 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;
-    readonly supportsConnectedMeetings: boolean;
-    readonly 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;
-    }>;
+declare class ConnectedMeetings extends TypedEventEmitter$1<ConnectedMeetingsEvents> {
+    constructor(context: Context<ContextState>);
+    meetings: ConnectedMeeting[];
+    parentMeeting: ConnectedMeeting;
+    readonly supportsConnectedMeetings: boolean;
+    readonly isActive: boolean;
+    private validateConnectedMeetingsAction;
+    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;
+    }>;
+    private moveSuccessHandler;
 }
 interface Modules {
     pip?: boolean;
@@ -4917,36 +5041,36 @@ interface Modules {
     };
     experimentalAudioPlayback?: boolean;
 }
-interface DefaultOptions {
-    video?: boolean;
-    audio?: boolean;
-    recording?: RecordingConfig;
-    mediaHandler?: RTKSelfMedia$1;
-    autoSwitchAudioDevice?: boolean;
-    mediaConfiguration?: {
-        video?: VideoQualityConstraints;
-        audio?: AudioQualityConstraints;
-        screenshare?: ScreenshareQualityConstraints;
-    };
-    isNonPreferredDevice?: (device: MediaDeviceInfo) => boolean;
+interface DefaultOptions {
+    video?: boolean;
+    audio?: boolean;
+    recording?: RecordingConfig;
+    mediaHandler?: SelfMedia;
+    autoSwitchAudioDevice?: boolean;
+    mediaConfiguration?: {
+        video?: VideoQualityConstraints;
+        audio?: AudioQualityConstraints;
+        screenshare?: ScreenshareQualityConstraints;
+    };
+    isNonPreferredDevice?: (device: MediaDeviceInfo) => boolean;
 }
 interface RoomDetails {
-    sfu: MediaNodeType;
-    roomNodeUrl: string;
     meetingTitle: string;
-    useHiveMedia: boolean;
-}
-declare class ConnectionHandler {
-    mediaJoined: boolean;
-    socketJoined: boolean;
-    socketJoinAttempted: boolean;
-    mediaJoinAttempted: boolean;
-    socketState: SocketConnectionState;
-    mediaState: MediaConnectionState;
-    readonly joinAttempted: boolean;
-    readonly roomJoined: boolean;
-    constructor(context: Context<RTKContextState>);
-    updateSocketConnectionState(state: SocketStateEvent, attempt?: number): void;
+}
+interface ControllerOptions {
+    peerId?: string;
+}
+declare class ConnectionHandler {
+    mediaJoined: boolean;
+    socketJoined: boolean;
+    socketJoinAttempted: boolean;
+    mediaJoinAttempted: boolean;
+    socketState: SocketConnectionState;
+    mediaState: MediaConnectionState;
+    readonly joinAttempted: boolean;
+    readonly roomJoined: boolean;
+    constructor(context: Context<ContextState>);
+    updateSocketConnectionState(state: SocketStateEvent, attempt?: number): void;
 }
 declare const ERROR_CODES: {
     '0000': string;
@@ -5037,9 +5161,9 @@ declare const ERROR_CODES: {
     '2006': string;
     '9900': string;
 };
-declare class RTKError extends Error {
-    code: keyof typeof ERROR_CODES;
-    constructor(message: string, code?: keyof typeof ERROR_CODES, logger?: RTKLogger$1 | undefined, log?: boolean);
+declare class ClientError extends Error {
+    code: keyof typeof ERROR_CODES;
+    constructor(message: string, code?: keyof typeof ERROR_CODES, logger?: Logger | undefined, log?: boolean);
 }
 type EventMap = {
     [key: string]: (...args: any[]) => void;
@@ -5066,7 +5190,6 @@ interface TypedEventEmitter<Events extends EventMap> {
 }
 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",
@@ -5081,11 +5204,9 @@ declare enum SessionEvents {
     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",
@@ -5097,18 +5218,10 @@ declare enum SessionEvents {
     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",
+    PRODUCER_TOGGLE = "cf/producer-toggle",
     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",
+    RESET_PRODUCER_STATE = "cf/reset-producer-state",
     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",
@@ -5129,31 +5242,32 @@ declare enum SessionEvents {
 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 TypedEvents = {
+    [SessionEvents.UPDATE_PERMISSIONS]: (p: PresetUpdates) => void;
+    [SessionEvents.MAX_SPATIAL_LAYER_CHANGE]: (p: {
+        peerId: string;
+        maxSpatialLayer: number;
+    }) => void;
+    [SessionEvents.UPDATE_ACTIVE]: (p?: {
+        viewMode?: ViewMode;
+        page?: number;
+        createAllConsumers?: boolean;
+    }) => void;
+    [SessionEvents.PEER_JOINED_INTERNAL]: (p: Participant) => 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 = Pick<AllEvents, Exclude<keyof AllEvents, keyof TypedEvents>>;
 type SessionEventsType = TypedEvents & UntypedEvents;
@@ -5171,47 +5285,44 @@ declare class AudioPlaybackManager extends AudioPlayback {
     addParticipantTrack(participantId: string, track: MediaStreamTrack): void;
     removeParticipantTrack(participantId: string): void;
 }
-type RTKContextState = {
-    authToken?: string;
-    peerId?: string;
-    apiBase?: string;
-    baseURI?: string;
-    onError?: (error: RTKError) => void;
-    stageStatus?: StageStatus;
-    organizationId?: string;
-    presetName?: string;
-    maxPreferredStreams?: number;
-    defaults?: DefaultOptions;
-    modules?: Modules;
-    overrides?: Overrides;
-    apiClient?: APIClient;
-    userId?: string;
-    meetingId?: string;
-    roomName?: string;
-    socketService?: SocketService;
-    pip?: RTKPip;
-    roomNodeOptions?: {
-        sfu: MediaNodeType;
-    };
-    roomNodeClient?: MediaNodeClient;
-    viewType?: ViewType;
-    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;
-    telemetry?: RTKTelemetry;
-    logger?: RTKLogger$1;
-    meeting?: RealtimeKitClient;
-    selfController?: SelfController;
+type ContextState = {
+    authToken?: string;
+    peerId?: string;
+    apiBase?: string;
+    baseURI?: string;
+    onError?: (error: ClientError) => void;
+    stageStatus?: StageStatus;
+    organizationId?: string;
+    presetName?: string;
+    maxPreferredStreams?: number;
+    defaults?: DefaultOptions;
+    modules?: Modules;
+    overrides?: Overrides;
+    apiClient?: APIClient;
+    userId?: string;
+    meetingId?: string;
+    roomName?: string;
+    socketService?: SocketService;
+    pip?: Pip;
+    roomNodeClient?: MediaNodeClient;
+    viewType?: ViewType;
+    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?: ClientOptions;
+    self?: Self;
+    telemetry?: Telemetry;
+    logger?: Logger;
+    meeting?: Client;
+    selfController?: SelfController;
 };
 interface Context<T extends Record<string, any>> {
     subscribe: (key: keyof T, listener: (value: any) => void) => () => void;
@@ -5221,105 +5332,114 @@ interface Context<T extends Record<string, any>> {
     getValue: <K extends keyof T>(key: K) => T[K];
     getAllValues: () => T;
 }
-type SocketServiceCapability = keyof typeof Capabilities;
-type SocketStateEvent = 'connected' | 'disconnected' | 'reconnected' | 'errored' | 'reconnecting' | 'reconnectAttempt' | 'reconnectFailure' | 'failed';
-type SocketServiceCapabilities = SocketServiceCapability[];
-interface SocketConnectionState {
-    state: Extract<SocketStateEvent, 'connected' | 'disconnected' | 'reconnecting' | 'failed'>;
-    reconnected: boolean;
-    reconnectionAttempt: number;
+declare class EnhancedEventEmitter<TransportPromiseEvents> extends EventEmitter$1 {
+    readonly logger: Logger;
+    constructor(context: Context<ContextState>);
+    safeEmit(event: string, ...args: any[]): boolean;
+    safeEmitAsPromise<T extends keyof TransportPromiseEvents>(event: T, ...args: any[]): Promise<TransportPromiseEvents[T]>;
+    safeEmitAsPromiseWithTimeout<T extends keyof TransportPromiseEvents>(event: T, timeout: number, ...args: any[]): Promise<TransportPromiseEvents[T]>;
 }
-declare class SocketService {
-    readonly roomName: string;
-    readonly authToken: string;
-    readonly capabilities: SocketServiceCapabilities;
-    joinAttempted: boolean;
-    readonly telemetry: RTKTelemetry;
-    readonly logger: RTKLogger$1;
-    readonly peerId: string;
-    constructor(context: Context<RTKContextState>, { peerId, meetingId, authToken, capabilities, }: {
-            peerId: string;
-            meetingId: string;
-            authToken: string;
-            capabilities: SocketServiceCapabilities;
-        });
-    updateURL(peerID: string): void;
-    readonly url: string;
-    connect(): Promise<void>;
-    disconnect(): void;
-    readonly isConnected: boolean;
-    sendMessage(event: number, protobuf?: Uint8Array, messageId?: string): boolean;
-    sendMessagePromise(event: number, protobuf?: Uint8Array, messageId?: string, resp?: number): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    sendMessagePromiseWithTimeout({ event, timeout, protobuf, messageId, resp, }: {
-        timeout: number;
-        event: number;
-        protobuf?: Uint8Array;
-        messageId?: string;
-        resp?: number;
-    }): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    on(event: number, listener: (message: {
-        id?: string;
-        payload?: Uint8Array;
-    }) => void): void;
-    onStateEvent(event: SocketStateEvent, listener: (...args: any) => void): void;
-    removeListener(event: number, listener: (message: {
-        id?: string;
-        payload?: Uint8Array;
-    }) => void): void;
-    removeListeners(event: number): void;
-    flush(): any;
-    handleSocketConnectionEvents(): void;
+type MediaKind = 'audio' | 'video';
+type ProducerConstructorOptions = {
+    id: string;
+    localId: string;
+    track?: MediaStreamTrack;
+    stopTracks: boolean;
+    disableTrackOnPause: boolean;
+    zeroRtpOnPause: boolean;
+    handler: HandlerInterface<TransportPromiseEvents>;
+    appData?: Record<string, unknown>;
+    rtpSender?: RTCRtpSender;
+};
+declare class Producer extends EnhancedEventEmitter<TransportPromiseEvents> {
+    readonly id: string;
+    readonly localId: string;
+    readonly kind: MediaKind;
+    readonly appData: Record<string, unknown>;
+    readonly rtpSender: RTCRtpSender;
+    constructor(context: Context<ContextState>, opt: ProducerConstructorOptions);
+    readonly closed: boolean;
+    readonly track: MediaStreamTrack | null;
+    readonly paused: boolean;
+    readonly maxSpatialLayer: number | undefined;
+    close(reason?: string): Promise<void>;
+    getStats(): Promise<RTCStatsReport>;
+    pause(): void;
+    resume(): void;
+    replaceTrack({ track, }: {
+        track: MediaStreamTrack | null;
+    }): Promise<void>;
+    setMaxSpatialLayer(spatialLayer: number): Promise<void>;
+    setRtpEncodingParameters(params: RTCRtpEncodingParameters): Promise<void>;
+    private _onTrackEnded;
+    private _handleTrack;
+    private _destroyTrack;
 }
-type EventHandlerTypes = PeerInfoResponse | GetWaitingRoomRequests | RecordingEvent | UpdatePeersPresetResponse | PeerJoinBroadcastResponse | PeerJoinCompleteResponse | GlobalPeerPinningBroadcastResponse | PeerLeaveResponse | SelectedPeersResponse | SelectedPeersDiffResponse;
-declare class RoomSocketHandler {
-    socket: SocketService;
-    readonly telemetry: RTKTelemetry;
-    readonly logger: RTKLogger$1;
-    cleanup(): void;
-    constructor(context: Context<RTKContextState>, socketService: SocketService);
-    joinRoom(opts: {
-        name: string;
-        id: string;
-        userId: string;
-        customParticipantId: string;
-        picture?: string;
-    }): Promise<{
-        peer: Peer;
-    }>;
-    getAllAddedParticipants(): Promise<RTKBasicParticipant[]>;
-    getRoomPeers(searchQuery: string, limit: number, offset: number): Promise<RoomPeersInfoResponse>;
-    getRoomPeersNonPaginated(): Promise<RoomPeersInfoResponse>;
-    getStagePeers(): Promise<RoomPeersInfoResponse>;
-    getPeerInfo(peerId: string): Promise<PeerInfoResponse>;
-    getRoomState(): Promise<RoomInfoResponse>;
-    getRoomStageState(): Promise<GetRoomStageStateResponse>;
-    broadcastMessage(type: string, payload: BroadcastMessagePayload): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    broadcastToMeetings(type: string, meetingIds: string[], payload: BroadcastMessagePayload): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    broadcastToPeers(type: string, peerIds: string[], payload: BroadcastMessagePayload): Promise<boolean>;
-    leaveRoom(): Promise<void>;
-    kick(peerId: string): Promise<void>;
-    kickAll(propagateKickAll?: boolean): Promise<void>;
-    getWaitingRoomRequests(): void;
-    acceptWaitingRoomRequest(userIds: string[]): void;
-    rejectWaitingRoomRequest(userIds: string[]): void;
-    updatePermissions(userIds: string[], patch: PresetUpdates): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    on(event: number, handler: (message: EventHandlerTypes) => void): void;
-    getUserPermissions(userId: string): Promise<Pick<PresetTypeV2['permissions'], 'chat' | 'polls' | 'plugins'>>;
+interface UserDetailsResponse {
+    id: string;
+    name: string;
+    email: string;
+    picture?: string;
+    loggedIn?: boolean;
+    scope?: string[];
+    clientSpecificId?: string;
+    customParticipantId?: string;
+    organizationId?: string;
+}
+declare class Self extends SelfMedia {
+    name: string;
+    picture: string;
+    customParticipantId: string;
+    waitlistStatus: 'accepted' | 'waiting' | 'rejected' | 'none';
+    role: any;
+    userId: string;
+    organizationId: string;
+    supportsRemoteControl: boolean;
+    device: DeviceConfig;
+    readonly telemetry: Telemetry;
+    hidden: boolean;
+    readonly stageStatus: StageStatus;
+    readonly producers: Producer[];
+    readonly id: string;
+    readonly peerId: string;
+    presetName: string;
+    roomState: 'init' | 'joined' | 'waitlisted' | LeaveRoomState;
+    private constructor();
+    static __init__(context: Context<ContextState>, details: UserDetailsResponse, permissions: PermissionPreset, theme: ThemePreset, presetName: string, skipAwaits?: boolean): Promise<Self>;
+    cleanupEvents(): void;
+    private setupEvents;
+    readonly permissions: PermissionPreset;
+    readonly config: ThemePreset;
+    readonly roomJoined: boolean;
+    setName(name: string): void;
+    setupTracks(options?: {
+        video?: boolean;
+        audio?: boolean;
+        forceReset?: boolean;
+    }): Promise<void>;
+    destructMediaHandler(): Promise<void>;
+    removeDocumentEventListeners(): Promise<void>;
+    enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
+    enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
+    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    enableScreenShare(): Promise<void>;
+    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    disableAudio(): Promise<void>;
+    disableVideo(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    getAllDevices(): Promise<InputDeviceInfo[]>;
+    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
+    readonly isPinned: boolean;
+    pin(): Promise<void>;
+    unpin(): Promise<void>;
+    hide(): Promise<void>;
+    show(): void;
+    setDevice(device: MediaDeviceInfo): Promise<void>;
+    cleanUpTracks(): void;
+    playAudio(): Promise<void>;
+    registerVideoElement(videoElem: HTMLVideoElement, isPreview?: boolean): void;
+    deregisterVideoElement(videoElem?: HTMLVideoElement, isPreview?: boolean): void;
+    private updateVideo;
 }
 interface DeviceConfig {
     browserName: string;
@@ -5338,7 +5458,7 @@ interface ProducerState {
     mimeType?: string;
     consumer?: Partial<Consumer>;
 }
-interface Participant {
+interface IParticipant {
     id: string;
     userId: string;
     displayName: string;
@@ -5361,48 +5481,50 @@ interface Participant {
     };
     recorderType?: string;
 }
-declare class RTKParticipant$1 extends RTKTypedEventEmitter<ParticipantEvents> {
-    id: string;
-    userId: string;
-    name: string;
-    picture: string;
-    isHost: boolean;
-    customParticipantId?: string;
-    readonly clientSpecificId: string;
-    flags: {
-        [key: string]: string | boolean;
-    };
-    device: DeviceConfig;
-    videoTrack: MediaStreamTrack;
-    audioTrack: MediaStreamTrack;
-    screenShareTracks: {
-        audio: MediaStreamTrack;
-        video: MediaStreamTrack;
-    };
-    videoEnabled: boolean;
-    audioEnabled: boolean;
-    screenShareEnabled: boolean;
-    producers: ProducerState[];
-    manualProducerConfig: PeerProducerConfig;
-    supportsRemoteControl: boolean;
-    presetName?: string;
-    readonly stageStatus: StageStatus;
-    readonly telemetry: RTKTelemetry;
-    constructor(context: Context<RTKContextState>, participant: Participant, self: RTKSelf, roomSocket: RoomSocketHandler);
-    setVideoEnabled(videoEnabled: boolean, emitEvent?: boolean): void;
-    setAudioEnabled(audioEnabled: boolean, emitEvent?: boolean): void;
-    setScreenShareEnabled(screenShareEnabled: boolean, emitEvent?: boolean): void;
-    pin(): Promise<void>;
-    unpin(): Promise<void>;
-    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
-    disableAudio(): Promise<void>;
-    kick(): Promise<void>;
-    disableVideo(): Promise<void>;
-    getPermissions(): Promise<Pick<_dyteinternals_utils.Permissions, "plugins" | "polls" | "chat">>;
-    setStageStatus(stageStatus: StageStatus): void;
-    readonly isPinned: boolean;
-    registerVideoElement(videoElem: HTMLVideoElement): void;
-    deregisterVideoElement(videoElem?: HTMLVideoElement): void;
+declare class Participant extends TypedEventEmitter$1<ParticipantEvents> {
+    id: string;
+    userId: string;
+    name: string;
+    picture: string;
+    isHost: boolean;
+    customParticipantId?: string;
+    readonly clientSpecificId: string;
+    flags: {
+        [key: string]: string | boolean;
+    };
+    device: DeviceConfig;
+    videoTrack: MediaStreamTrack;
+    audioTrack: MediaStreamTrack;
+    screenShareTracks: {
+        audio: MediaStreamTrack;
+        video: MediaStreamTrack;
+    };
+    videoEnabled: boolean;
+    audioEnabled: boolean;
+    screenShareEnabled: boolean;
+    producers: ProducerState[];
+    manualProducerConfig: PeerProducerConfig;
+    supportsRemoteControl: boolean;
+    presetName?: string;
+    readonly stageStatus: StageStatus;
+    readonly telemetry: Telemetry;
+    constructor(context: Context<ContextState>, participant: IParticipant, self: Self, roomSocket: RoomSocketHandler);
+    setVideoEnabled(videoEnabled: boolean, emitEvent?: boolean): void;
+    setAudioEnabled(audioEnabled: boolean, emitEvent?: boolean): void;
+    setScreenShareEnabled(screenShareEnabled: boolean, emitEvent?: boolean): void;
+    private setupEvents;
+    pin(): Promise<void>;
+    unpin(): Promise<void>;
+    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
+    disableAudio(): Promise<void>;
+    kick(): Promise<void>;
+    disableVideo(): Promise<void>;
+    getPermissions(): Promise<Pick<_dyteinternals_utils.Permissions, "chat" | "polls" | "plugins">>;
+    setStageStatus(stageStatus: StageStatus): void;
+    readonly isPinned: boolean;
+    registerVideoElement(videoElem: HTMLVideoElement): void;
+    deregisterVideoElement(videoElem?: HTMLVideoElement): void;
+    private updateVideo;
 }
 declare function createSafeToLogError(ex: any): {
     stack?: string;
@@ -5412,266 +5534,267 @@ declare function createSafeToLogError(ex: any): {
     code?: number | string;
 };
 type SupportedEventSeverities = 'info' | 'error' | 'debug' | 'log' | 'warn';
-type LogData$2 = {
-    error?: ReturnType<typeof createSafeToLogError>;
-    peers?: string;
-    flags?: string | {
-        [key: string]: {
-            enabled: boolean;
-            value: string | number | boolean;
-        };
-    };
-    devices?: string | MediaDeviceInfo[];
-    debuggingHint?: string;
-    constraints?: string | RTKMediaStreamConstraints;
-    timeout?: number;
-    execTime?: number;
-    country?: string;
-    media?: {
-        audio?: {
-            enabled: boolean;
-            deviceName?: string;
-            deviceId?: string;
-            trackId?: string;
-            permission?: keyof typeof MediaPermission;
-            canProduce?: MediaProductionPermissionType;
-        };
-        video?: {
-            enabled?: boolean;
-            deviceName?: string;
-            deviceId?: string;
-            trackId?: string;
-            permission?: keyof typeof MediaPermission;
-            canProduce?: MediaProductionPermissionType;
-            layer?: number;
-        };
-        screenshare?: {
-            enabled: boolean;
-            count?: number;
-            maxAllowedCount?: number;
-            permission?: keyof typeof MediaPermission;
-            deviceName?: string;
-            deviceId?: string;
-            audio?: {
-                enabled: boolean;
-                trackId?: string;
-            };
-            video?: {
-                enabled: boolean;
-                trackId?: string;
-            };
-            canProduce?: MediaProductionPermissionType;
-        };
-    };
-    producerInfo?: {
-        peerId: string;
-        producers: ProducerState[];
-    };
-    preferredDevice?: {
-        kind: 'audio' | 'video';
-        preferredDeviceId?: string;
-        lastUsedPreferredDeviceId?: string;
-    };
-    mediaPermissionsErrors?: {
-        kind: 'audio' | 'video' | 'screenshare';
-        message: string;
-        deviceId?: string;
-    };
-    pip?: {
-        id: string;
-        handRaised?: boolean;
-        source?: any;
-    };
-    memoize?: {
-        doubleInvoked?: {
-            property: string;
-        };
-    };
-    dyteClientInitOptions?: RealtimeKitClientOptions;
-    plugin?: {
-        id?: string;
-        name?: string;
-        enabledBy?: string;
-        duration?: number;
-        storeName?: string;
-        data?: any;
-    };
-    roomJoined?: boolean;
-    transport?: {
-        id?: string;
-        type?: 'send' | 'recv';
-        status?: RTCPeerConnectionState | 'reconnecting';
-        lastDisconnectedTime?: string;
-        lastDisconnectedTimeOffset?: number;
-        durationPassed?: number;
-        remoteOfferAnswer?: RTCSessionDescriptionInit;
-        serverId?: string;
-    };
-    iceCandidate?: RTCIceCandidate;
-    iceRestart?: {
-        status?: RTCPeerConnectionState | 'reconnecting';
-        isSendTransport?: boolean;
-        isRecvTransport?: boolean;
-        currentAttempt?: number;
-    };
-    producer?: {
-        id: string;
-        peerId?: string;
-        kind: 'audio' | 'video' | PRODUCERS_TYPE;
-        status?: 'initializing' | 'producing' | 'paused' | 'failed' | 'closing' | 'closed' | 'UNKNOWN';
-        appData: {
-            screenShare?: boolean;
-            supportsRemoteControl?: boolean;
-        };
-        error?: string;
-        closureReason?: string;
-        remoteAnswer?: SessionDescription;
-        trackId?: string;
-    };
-    consumer?: {
-        id: string;
-        peerId?: string;
-        kind?: string;
-        appData?: {
-            screenShare?: boolean;
-            supportsRemoteControl?: boolean;
-        };
-        remotelyPaused?: boolean;
-        producerId?: string;
-        closureReason?: string;
-        sessionDescription?: RTCSessionDescriptionInit;
-    };
-    consumerIds?: string[];
-    consumerState?: ConsumerState;
-    consumerStateMap?: {
-        [key: string]: ConsumerState;
-    };
-    rtcChannel?: {
-        label?: string;
-        message?: DCMessage;
-        messageStringified?: string;
-    };
-    localStorage?: {
-        key?: string;
-        value?: string;
-    };
-    spotlight?: {
-        spotlighter?: {
-            id?: string;
-        };
-        currentTab?: {
-            id?: string;
-            type?: ActiveTabType;
-        };
-    };
-    networkCall?: {
-        status?: number;
-        statusText?: string;
-        baseURL?: string;
-        url?: string;
-        retries?: number;
-        method?: string;
-        isOnline?: string;
-        ip?: any;
-        timezone?: string;
-    };
-    ipInfo?: {
-        city: string;
-        country: string;
-        region: string;
-        loc: string;
-        timezone: string;
-        ip: string;
-        postal: string;
-    };
-    dytePolls?: {
-        hasQuestion?: boolean;
-        optionsLength?: number;
-    };
-    dyteChat?: {
-        imageType?: string;
-        messageType?: string;
-    };
-    dyteParticipant?: {
-        id: string;
-    };
-    actions?: {
-        disableAllAudio?: {
-            allowUnmute?: boolean;
-        };
-        trackRobustness?: {
-            reacquireTrack?: boolean;
-            eventType?: string;
-        };
-    };
-    recording?: {
-        id?: string;
-        state?: RecordingState;
-    };
-    selectedPeer?: {
-        oldIndex?: number;
-        newIndex?: number;
-        peerId?: string;
-    };
-    pageNavigation?: {
-        viewMode: ViewMode;
-        currentPage: number;
-        pageCount: number;
-        maxActiveParticipantsCount: number;
-        settingPage?: number;
-    };
-    connectedMeetings?: {
-        movement?: {
-            sourceMeetingId?: string;
-            destinationMeetingId?: string;
-            totalParticipantsToMove?: number;
-        };
-    };
-    webinar?: {
-        stageStatus?: StageStatus;
-    };
-    livestream?: {
-        stageStatus?: StageStatus;
-        latency?: number;
-    };
-    moduleExists?: {
-        self?: boolean;
-    };
-    performanceObserver?: {
-        api: PerformanceEntry;
-    };
-    dyteLocker?: {
-        methodName: string;
-        lockName: string;
-    };
-    socket?: {
-        retryAttempt: number;
-    };
-    connectionState?: {
-        joinAttempted: boolean;
-    };
-    source?: string;
-    eventListener?: {
-        eventName: string;
-        listenerCount: number;
-    };
-    dataChannelMessageChunk?: {
-        id: string;
-        count: number;
-        chunkIndex: number;
-        chunk: string;
-        transprtId: string;
-    };
-    peerIds?: string[];
-    producers?: ProducerState[];
-    sdp?: RTCSessionDescription['sdp'];
-    awaitQueueTask?: {
-        id?: string | number;
-        metadata?: Record<string, unknown>;
-        queueSizeAtStart?: number;
-        taskStartTime?: number;
-        execTime?: number;
-    };
+type LogData$2 = {
+    error?: ReturnType<typeof createSafeToLogError>;
+    peers?: string;
+    flags?: string | {
+        [key: string]: {
+            enabled: boolean;
+            value: string | number | boolean;
+        };
+    };
+    devices?: string | MediaDeviceInfo[];
+    debuggingHint?: string;
+    constraints?: string | ClientMediaStreamConstraints;
+    timeout?: number;
+    execTime?: number;
+    country?: string;
+    media?: {
+        audio?: {
+            enabled: boolean;
+            deviceName?: string;
+            deviceId?: string;
+            trackId?: string;
+            permission?: keyof typeof MediaPermission;
+            canProduce?: MediaProductionPermissionType;
+        };
+        video?: {
+            enabled?: boolean;
+            deviceName?: string;
+            deviceId?: string;
+            trackId?: string;
+            permission?: keyof typeof MediaPermission;
+            canProduce?: MediaProductionPermissionType;
+            layer?: number;
+        };
+        screenshare?: {
+            enabled: boolean;
+            count?: number;
+            maxAllowedCount?: number;
+            permission?: keyof typeof MediaPermission;
+            deviceName?: string;
+            deviceId?: string;
+            audio?: {
+                enabled: boolean;
+                trackId?: string;
+            };
+            video?: {
+                enabled: boolean;
+                trackId?: string;
+            };
+            canProduce?: MediaProductionPermissionType;
+        };
+    };
+    producerInfo?: {
+        peerId: string;
+        producers: ProducerState[];
+    };
+    preferredDevice?: {
+        kind: 'audio' | 'video';
+        preferredDeviceId?: string;
+        lastUsedPreferredDeviceId?: string;
+    };
+    mediaPermissionsErrors?: {
+        kind: 'audio' | 'video' | 'screenshare';
+        message: string;
+        deviceId?: string;
+    };
+    pip?: {
+        id: string;
+        handRaised?: boolean;
+        source?: any;
+    };
+    memoize?: {
+        doubleInvoked?: {
+            property: string;
+        };
+    };
+    clientInitOptions?: ClientOptions;
+    plugin?: {
+        id?: string;
+        name?: string;
+        enabledBy?: string;
+        duration?: number;
+        storeName?: string;
+        data?: any;
+    };
+    roomJoined?: boolean;
+    transport?: {
+        id?: string;
+        type?: 'send' | 'recv';
+        status?: RTCPeerConnectionState | 'reconnecting';
+        lastDisconnectedTime?: string;
+        lastDisconnectedTimeOffset?: number;
+        durationPassed?: number;
+        remoteOfferAnswer?: RTCSessionDescriptionInit;
+        serverId?: string;
+    };
+    iceCandidate?: RTCIceCandidate;
+    iceRestart?: {
+        status?: RTCPeerConnectionState | 'reconnecting';
+        isSendTransport?: boolean;
+        isRecvTransport?: boolean;
+        currentAttempt?: number;
+    };
+    producer?: {
+        id: string;
+        peerId?: string;
+        kind: 'audio' | 'video' | PRODUCERS_TYPE;
+        status?: 'not_initialized' | 'initializing' | 'producing' | 'paused' | 'failed' | 'closing' | 'closed' | 'UNKNOWN';
+        appData: {
+            screenShare?: boolean;
+            supportsRemoteControl?: boolean;
+        };
+        error?: string;
+        closureReason?: string;
+        remoteAnswer?: SessionDescription;
+        trackId?: string;
+    };
+    consumer?: {
+        id: string;
+        peerId?: string;
+        kind?: string;
+        appData?: {
+            screenShare?: boolean;
+            supportsRemoteControl?: boolean;
+        };
+        remotelyPaused?: boolean;
+        producerId?: string;
+        closureReason?: string;
+        sessionDescription?: RTCSessionDescriptionInit;
+    };
+    consumerIds?: string[];
+    consumerState?: ConsumerState;
+    consumerStateMap?: {
+        [key: string]: ConsumerState;
+    };
+    rtcChannel?: {
+        label?: string;
+        message?: DCMessage;
+        messageStringified?: string;
+    };
+    localStorage?: {
+        key?: string;
+        value?: string;
+    };
+    spotlight?: {
+        spotlighter?: {
+            id?: string;
+        };
+        currentTab?: {
+            id?: string;
+            type?: ActiveTabType;
+        };
+    };
+    networkCall?: {
+        status?: number;
+        statusText?: string;
+        baseURL?: string;
+        url?: string;
+        retries?: number;
+        method?: string;
+        isOnline?: string;
+        ip?: any;
+        timezone?: string;
+    };
+    ipInfo?: {
+        city: string;
+        country: string;
+        region: string;
+        loc: string;
+        timezone: string;
+        ip: string;
+        postal: string;
+    };
+    polls?: {
+        hasQuestion?: boolean;
+        optionsLength?: number;
+    };
+    chat?: {
+        imageType?: string;
+        messageType?: string;
+    };
+    participant?: {
+        id: string;
+        maskedName?: string;
+    };
+    actions?: {
+        disableAllAudio?: {
+            allowUnmute?: boolean;
+        };
+        trackRobustness?: {
+            reacquireTrack?: boolean;
+            eventType?: string;
+        };
+    };
+    recording?: {
+        id?: string;
+        state?: RecordingState;
+    };
+    selectedPeer?: {
+        oldIndex?: number;
+        newIndex?: number;
+        peerId?: string;
+    };
+    pageNavigation?: {
+        viewMode: ViewMode;
+        currentPage: number;
+        pageCount: number;
+        maxActiveParticipantsCount: number;
+        settingPage?: number;
+    };
+    connectedMeetings?: {
+        movement?: {
+            sourceMeetingId?: string;
+            destinationMeetingId?: string;
+            totalParticipantsToMove?: number;
+        };
+    };
+    webinar?: {
+        stageStatus?: StageStatus;
+    };
+    livestream?: {
+        stageStatus?: StageStatus;
+        latency?: number;
+    };
+    moduleExists?: {
+        self?: boolean;
+    };
+    performanceObserver?: {
+        api: PerformanceEntry;
+    };
+    locker?: {
+        methodName: string;
+        lockName: string;
+    };
+    socket?: {
+        retryAttempt: number;
+    };
+    connectionState?: {
+        joinAttempted: boolean;
+    };
+    source?: string;
+    eventListener?: {
+        eventName: string;
+        listenerCount: number;
+    };
+    dataChannelMessageChunk?: {
+        id: string;
+        count: number;
+        chunkIndex: number;
+        chunk: string;
+        transprtId: string;
+    };
+    peerIds?: string[];
+    producers?: ProducerState[];
+    sdp?: RTCSessionDescription['sdp'];
+    awaitQueueTask?: {
+        id?: string | number;
+        metadata?: Record<string, unknown>;
+        queueSizeAtStart?: number;
+        taskStartTime?: number;
+        execTime?: number;
+    };
 };
 type EventSeverities = SupportedEventSeverities;
 type LogData$1 = LogData$2;
@@ -5684,38 +5807,38 @@ interface MeetingMetadata {
     visitedUrl?: string;
     userId?: string;
 }
-declare class RTKTelemetry {
-    logsCache: {
-        [key: string]: any;
-    }[];
-    logsProcessorTimer: NodeJS.Timer;
-    static location: {
-        country: string;
-    };
-    readonly logsEndpoint: string;
-    tracingEnabled: boolean;
-    initialized: boolean;
-    readonly logsProcessingInterval = 7000;
-    logExclusionList: string[];
-    meetingMetadata: MeetingMetadata;
-    resetPeerId(peerId: string): void;
-    init(context: Context<RTKContextState>, options: MeetingMetadata, enableTracing: boolean): void;
-    static trace(spanName: string, metadata?: LogData$1 | undefined): (_target: Object, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    injectContext(injectionReceiver: any): void;
-    addLogInCurrentSpan(eventSeverity: EventSeverities, eventName: string, metadata?: LogData$1, noCache?: boolean): void;
-    sendOtelLogsToNewRelic(logs: object[]): void;
-    processCachedLogs(): void;
-    destruct(): void;
+declare class Telemetry {
+    logsCache: {
+        [key: string]: any;
+    }[];
+    logsProcessorTimer: NodeJS.Timer;
+    static location: {
+        country: string;
+    };
+    readonly logsEndpoint: string;
+    tracingEnabled: boolean;
+    initialized: boolean;
+    readonly logsProcessingInterval = 7000;
+    logExclusionList: string[];
+    meetingMetadata: MeetingMetadata;
+    resetPeerId(peerId: string): void;
+    init(context: Context<ContextState>, options: MeetingMetadata, enableTracing: boolean): void;
+    static trace(spanName: string, metadata?: LogData$1 | undefined): (_target: Object, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    injectContext(injectionReceiver: any): void;
+    addLogInCurrentSpan(eventSeverity: EventSeverities, eventName: string, metadata?: LogData$1, noCache?: boolean): void;
+    sendOtelLogsToNewRelic(logs: object[]): void;
+    processCachedLogs(): void;
+    destruct(): void;
 }
 type LogData = LogData$1;
-declare class RTKLogger$1 {
-    readonly telemetry: RTKTelemetry;
-    init(context: Context<RTKContextState>): void;
-    info(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
-    error(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
-    debug(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
-    log(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
-    warn(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
+declare class Logger {
+    readonly telemetry: Telemetry;
+    init(context: Context<ContextState>): void;
+    info(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
+    error(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
+    debug(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
+    log(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
+    warn(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
 }
 interface IceServerInformation {
     url: string;
@@ -5723,12 +5846,12 @@ interface IceServerInformation {
     urls: string;
     credential?: string;
 }
-interface CachedUserDetails {
-    peerId?: string;
-    pluginInformation: RTKPluginResponse[];
-    userDetails: UserDetailsResponseV2;
-    roomDetails: RoomDetails;
-    iceServers: IceServerInformation[];
+interface CachedUserDetails {
+    peerId?: string;
+    pluginInformation: PluginResponse[];
+    userDetails: UserDetailsResponseV2;
+    roomDetails: RoomDetails;
+    iceServers: IceServerInformation[];
 }
 interface APIOptions {
     baseURL?: string;
@@ -5738,101 +5861,117 @@ interface APIOptions {
     retryDelay?: number;
     cachedUserDetails?: CachedUserDetails;
 }
-declare class API {
-    ipInfo: any;
-    readonly peerId: string;
-    context: Context<RTKContextState>;
-    readonly logger: RTKLogger$1;
-    constructor(context: Context<RTKContextState>, options?: APIOptions);
-    setAuthToken(token: string, options?: {
-        bearer?: boolean;
-    }): void;
-    setHeader(key: string, value: string): void;
-    setRoomName(name: string): void;
-    setRoomUUID(id: string): void;
-    setOrganizationId(id: string): void;
+declare class API {
+    ipInfo: any;
+    protected fetchClient: FetchClient;
+    protected requests: FetchClient;
+    protected roomName: string;
+    protected roomUUID: string;
+    protected authToken: string;
+    protected organizationId: string;
+    protected iceServers: IceServerInformation[];
+    protected pluginInformation: PluginResponse[];
+    protected userDetails: UserDetailsResponseV2;
+    protected roomDetails: RoomDetails;
+    readonly peerId: string;
+    context: Context<ContextState>;
+    readonly logger: Logger;
+    constructor(context: Context<ContextState>, options?: APIOptions);
+    setAuthToken(token: string, options?: {
+        bearer?: boolean;
+    }): void;
+    setHeader(key: string, value: string): void;
+    setRoomName(name: string): void;
+    setRoomUUID(id: string): void;
+    setOrganizationId(id: string): void;
 }
 interface Overrides {
     disableSimulcast?: boolean;
+    simulcastConfig?: {
+        disable?: boolean;
+        encodings?: RTCRtpEncodingParameters[];
+    };
     forceRelay?: boolean;
-    [key: string]: boolean | string | number;
-}
-interface RealtimeKitClientOptions {
-    authToken: string;
-    defaults?: DefaultOptions;
-    modules?: Modules;
-    overrides?: Overrides;
-    baseURI?: string;
-    onError?: (error: RTKError) => void;
-    cachedUserDetails?: CachedUserDetails;
-}
-declare class RealtimeKitClient {
-    private constructor();
-    readonly peerId: string;
-    static initMedia(options?: {
-            video?: boolean;
-            audio?: boolean;
-            constraints?: MediaConstraints;
-        }, skipAwaits?: boolean, cachedUserDetails?: CachedUserDetails): RTKSelfMedia$1;
-    static init(options: RealtimeKitClientOptions): Promise<RealtimeKitClient>;
-    join(): Promise<void>;
-    leave(state?: LeaveRoomState): Promise<void>;
-    readonly participants: Readonly<RTKParticipants$1>;
-    readonly self: Readonly<RTKSelf$1>;
-    readonly meta: Readonly<RTKMeta$1>;
-    readonly ai: Readonly<RTKAi>;
-    readonly plugins: Readonly<RTKPlugins$1>;
-    readonly chat: Readonly<RTKChat$1>;
-    readonly polls: Readonly<RTKPolls$1>;
-    readonly connectedMeetings: Readonly<RTKConnectedMeetings$1>;
-    readonly recording: Readonly<RTKRecording$1>;
-    readonly livestream: Readonly<RTKLivestream$1>;
-    readonly stage: Readonly<RTKStage>;
-    readonly stores: Readonly<RTKStoreManager>;
-    readonly audio: AudioPlaybackManager;
-    readonly __internals__: Readonly<RTKInternals>;
-    joinRoom(): Promise<void>;
-    leaveRoom(state?: LeaveRoomState): Promise<void>;
+    [key: string]: boolean | string | number | Record<string, any>;
+}
+interface ClientOptions {
+    authToken: string;
+    defaults?: DefaultOptions;
+    modules?: Modules;
+    overrides?: Overrides;
+    baseURI?: string;
+    onError?: (error: ClientError) => void;
+    cachedUserDetails?: CachedUserDetails;
+}
+declare class Client {
+    private constructor();
+    readonly peerId: string;
+    static initMedia(options?: {
+        video?: boolean;
+        audio?: boolean;
+        constraints?: MediaConstraints;
+    }, skipAwaits?: boolean, cachedUserDetails?: CachedUserDetails): SelfMedia;
+    static init(options: ClientOptions): Promise<Client>;
+    private static setupContext;
+    join(): Promise<void>;
+    leave(state?: LeaveRoomState): Promise<void>;
+    readonly participants: Readonly<Participants>;
+    readonly self: Readonly<Self>;
+    readonly meta: Readonly<Meta>;
+    readonly ai: Readonly<Ai>;
+    readonly plugins: Readonly<Plugins>;
+    readonly chat: Readonly<Chat>;
+    readonly polls: Readonly<Polls>;
+    readonly connectedMeetings: Readonly<ConnectedMeetings>;
+    readonly recording: Readonly<Recording>;
+    readonly livestream: Readonly<Livestream>;
+    readonly stage: Readonly<Stage>;
+    readonly stores: Readonly<StoreManager>;
+    readonly audio: AudioPlaybackManager;
+    readonly __internals__: Readonly<Internals>;
+    joinRoom(): Promise<void>;
+    leaveRoom(state?: LeaveRoomState): Promise<void>;
 }
 declare enum RequestToJoinType {
     PRESENT = "REQUEST_TO_PRESENT"
 }
-type RTKParticipant = Readonly<RTKParticipant$1>;
-type RTKParticipants = Readonly<RTKParticipants$1>;
-type RTKParticipantMap = Readonly<RTKParticipantMap$1>;
-type RTKPlugin = Readonly<RTKPlugin$1>;
-type RTKPlugins = Readonly<RTKPlugins$1>;
-type RTKPluginMap = Readonly<RTKPluginMap$1>;
-type RTKMeta = Readonly<RTKMeta$1>;
-type RTKSelf = Readonly<RTKSelf$1>;
-type RTKSelfMedia = Readonly<RTKSelfMedia$1>;
-type RTKChat = Readonly<RTKChat$1>;
-type RTKPolls = Readonly<RTKPolls$1>;
-type RTKRecording = Readonly<RTKRecording$1>;
-type RTKLivestream = Readonly<RTKLivestream$1>;
-type RTKStore = RTKStore$1;
-type RTKConnectedMeetings = Readonly<RTKConnectedMeetings$1>;
-type RTKPermissionsPreset = Readonly<RTKPermissionsPreset$1>;
-type RTKThemePreset = Readonly<RTKThemePreset$1>;
-type RTKLogger = RTKLogger$1;
-type RTKType = {
-    callStats?: unknown;
-    RTKTelemetry?: typeof RTKTelemetry;
+type RTKConfigOptions = Pick<ControllerOptions, Exclude<keyof ControllerOptions, 'peerId'>>;
+type RTKParticipant = Readonly<Participant>;
+type RTKParticipants = Readonly<Participants>;
+type RTKParticipantMap = Readonly<ParticipantMap>;
+type RTKPlugin = Readonly<Plugin>;
+type RTKPlugins = Readonly<Plugins>;
+type RTKPluginMap = Readonly<PluginMap>;
+type RTKMeta = Readonly<Meta>;
+type RTKSelf = Readonly<Self>;
+type RTKSelfMedia = Readonly<SelfMedia>;
+type RTKChat = Readonly<Chat>;
+type RTKPolls = Readonly<Polls>;
+type RTKRecording = Readonly<Recording>;
+type RTKLivestream = Readonly<Livestream>;
+type RTKStore = Store;
+type RTKConnectedMeetings = Readonly<ConnectedMeetings>;
+type RTKPermissionsPreset = Readonly<PermissionPreset>;
+type RTKThemePreset = Readonly<ThemePreset>;
+type RTKLogger = Logger;
+type ClientType = {
+    callStats?: unknown;
+    Telemetry?: typeof Telemetry;
 };
-declare global {
-    interface Navigator {
-        RNLocalMediaHandlerImpl?: any;
-        RNAudioSampleHandlerImpl?: any;
-        RNBackgroundTimerImpl?: any;
-        RNDeviceInfoImpl?: any;
-        isReactNative?: boolean;
-    }
-    interface Window {
-        RTK?: RTKType;
-        FAST_DYTE?: boolean;
-        MediaStreamTrackProcessor?: any;
-        MediaStreamTrackGenerator?: any;
-        TransformStream?: any;
-    }
-}
-export { ActiveTab, ActiveTabType, AudioConsumerScoreStats, AudioMiddleware, AudioProducerScoreStats, BroadcastMessagePayload, ChatChannel, ChatUpdateParams, CustomMessage, DeviceConfig, RTKBasicParticipant, RTKChat, RealtimeKitClientOptions, RTKConnectedMeetings, RTKLivestream, RTKMeta, RTKParticipant, RTKParticipantMap, RTKParticipants, RTKPermissionsPreset, RTKPlugin, RTKPluginMap, RTKPlugins, RTKPolls, RTKRecording, RTKSelf, RTKSelfMedia, RTKStore, RTKThemePreset, FileMessage, ImageMessage, JoinedPeer, LeaveRoomState, LivestreamIngestionCredentials, LivestreamState, LogData, MediaConnectionState, MediaConnectionUpdate, MediaKind$1 as MediaKind, MediaPermission, Message, ProducerScoreStats, RecordingState, RequestToJoinType, SocketConnectionState, StageStatus, StartLivestreamConfig, TextMessage, VideoConsumerScoreStats, VideoMiddleware, VideoProducerScoreStats, VideoQualityConstraints, RealtimeKitClient as default, LeaveRoomState as leaveRoomState };
+declare global {
+    interface Navigator {
+        RNLocalMediaHandlerImpl?: any;
+        RNAudioSampleHandlerImpl?: any;
+        RNBackgroundTimerImpl?: any;
+        RNDeviceInfoImpl?: any;
+        isReactNative?: boolean;
+    }
+    interface Window {
+        RTK?: ClientType;
+        FAST_RTK?: boolean;
+        MediaStreamTrackProcessor?: any;
+        MediaStreamTrackGenerator?: any;
+        TransformStream?: any;
+    }
+}
+export { ActiveTab, ActiveTabType, AudioConsumerScoreStats, AudioMiddleware, AudioProducerScoreStats, BroadcastMessagePayload, CachedUserDetails, ChatChannel, ChatUpdateParams, ClientError, ConsumerScoreStats, CustomMessage, DeviceConfig, FileMessage, ImageMessage, JoinedPeer, LeaveRoomState, LivestreamIngestionCredentials, LivestreamState, LogData, MediaConnectionState, MediaConnectionUpdate, MediaConstraints, MediaKind, MediaPermission, Message, ProducerScoreStats, BasicParticipant as RTKBasicParticipant, BasicParticipantsMap as RTKBasicParticipantsMap, RTKChat, ClientOptions as RTKClientOptions, RTKConfigOptions, RTKConnectedMeetings, RTKLivestream, RTKLogger, RTKMeta, RTKParticipant, RTKParticipantMap, RTKParticipants, RTKPermissionsPreset, RTKPlugin, RTKPluginMap, RTKPlugins, RTKPolls, RTKRecording, RTKSelf, RTKSelfMedia, RTKStore, StoreData as RTKStoreData, RateLimitConfig as RTKStoreRateLimitConfig, RTKThemePreset, RecordingState, RequestToJoinType, SocketConnectionState, StageStatus, StartLivestreamConfig, TextMessage, UserDetailsResponseV2, VideoConsumerScoreStats, VideoMiddleware, VideoProducerScoreStats, VideoQualityConstraints, Client as default, LeaveRoomState as leaveRoomState };