@cloudflare/realtimekit 1.2.0-staging.9 → 1.2.1-staging.1

package/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';
@@ -2237,7 +2237,7 @@ interface InhouseCallStatsInitializeParams {
     iceServers: any[];
     apiBase?: string;
     flags: Record<string, Record<'enabled' | 'value', any>>;
-    logger?: RTKLogger$2;
+    logger?: DyteLogger;
     apiHostnames: ApiHostnames;
     skipConnectivityChecks: boolean;
 }
@@ -2248,7 +2248,7 @@ interface InhouseCallStatsInitializeParams {
 declare type LogData$3 = {
     [key: string]: string | number | boolean | null | undefined | LogData$3;
 };
-declare interface RTKLogger$2 {
+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;
@@ -2551,11 +2551,16 @@ interface IVSPlayerLiveLatencyEntry extends EventEntryBase {
 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 {
+    private logger;
+    private peerId;
+    private eventStore;
+    private apiEndpoint;
     constructor({ logger, peerId, apiHostnames, }: {
-        logger: RTKLogger$2;
+        logger: DyteLogger;
         peerId: string;
         apiHostnames: ApiHostnames;
     });
+    private sendEventsChunkToServer;
     callEvent(entry: EventEntry): void;
     flush(): Promise<boolean>;
 }
@@ -2657,11 +2662,19 @@ declare abstract class Measurements extends EventEmitter {
     generateConsumerStreamMap(consumer: any, parse?: boolean): Promise<ConsumerStatistics>;
     deregisterProducer(producer: any): void;
     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>;
+    protected getProducerStatsFromReport(report: ParsedRTCStats): ProducerStatistics[];
+    protected getConsumerStatsFromReport(report: ParsedRTCStats): ConsumerStatistics[];
     getUserLocation(): Promise<GeoLocation>;
     getConnectivity(iceServers: IceServerInfo[]): Promise<{
         host: boolean;
@@ -2677,8 +2690,15 @@ declare abstract class Measurements extends EventEmitter {
 declare class CallStats extends EventEmitter {
     observer: EventEmitter;
     eventHandler: EventHandler;
+    protected measurements: Measurements;
+    protected producingTransport: any;
+    protected consumingTransport: any;
     producers: Map<string, any>;
-    logger: RTKLogger$2;
+    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;
@@ -2692,8 +2712,10 @@ declare class CallStats extends EventEmitter {
         video?: boolean;
         screen?: boolean;
     };
-    constructor(backendUrl: string, engineName: string, env: ClientEnvTypeAll, flags: InhouseCallStatsInitializeParams['flags'], logger: RTKLogger$2, peerId: string, apiHostnames: ApiHostnames);
+    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;
@@ -2701,8 +2723,11 @@ declare class CallStats extends EventEmitter {
     }): 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;
@@ -2753,7 +2778,7 @@ declare class InhouseCallStats extends EventEmitter {
     initialized: boolean;
     stalled: boolean;
     ipInformation: Object;
-    logger: RTKLogger$2;
+    logger: DyteLogger;
     initialize({ peerId, engineName, env, iceServers, apiBase, flags, logger, apiHostnames, skipConnectivityChecks, }: InhouseCallStatsInitializeParams): Promise<void>;
     configureSendTransport(sendTransport: any): void;
     configureRecvTransport(recvTransport: any): void;
@@ -2792,6 +2817,7 @@ declare class InhouseCallStats extends EventEmitter {
     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;
@@ -2800,6 +2826,64 @@ declare class InhouseCallStats extends EventEmitter {
     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;
+    get joinAttempted(): boolean;
+    set joinAttempted(value: boolean);
+    get telemetry(): Telemetry;
+    get logger(): Logger;
+    get 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;
+    get url(): string;
+    connect(): Promise<void>;
+    disconnect(): void;
+    get 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 {
 		readonly observable: symbol;
@@ -2832,9 +2916,9 @@ type StringKeysOfFoo = StringKeyOf<Foo>;
 */
 type StringKeyOf<BaseType> = `${Extract<keyof BaseType, string | number>}`;
 
-declare class RTKEventEmitter<T extends string | symbol> extends EventEmitter$1 {
-    logger: RTKLogger$1 | undefined;
-    constructor(logger: RTKLogger$1);
+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;
@@ -2853,9 +2937,9 @@ 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);
+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;
@@ -2869,79 +2953,151 @@ declare class RTKTypedEventEmitter<Events extends EventMap$1 & WildCardEvent<Eve
     listenerCount<T extends StringKeyOf<Events>>(event: T): number;
 }
 
-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>;
+interface BasicParticipant {
+    userId: string;
+    name?: string;
+    picture?: string;
+    customParticipantId: string;
+}
+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 StageStatus = 'OFF_STAGE' | 'REQUESTED_TO_JOIN_STAGE' | 'ACCEPTED_TO_JOIN_STAGE' | 'ON_STAGE';
-interface StageRequestPayload {
+type ChatChannelSocketMessage = GetChatChannelResponse;
+interface ChatChannel {
+    id: string;
     displayName: string;
-    userId: string;
-    peerId: string;
+    memberIds: string[];
+    displayPictureUrl?: string;
+    visibility?: string;
+    isDirectMessage?: boolean;
+    latestMessage?: Message;
+    unreadCount: number;
 }
-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 RTKStage extends RTKTypedEventEmitter<StageEvents> {
-    get telemetry(): RTKTelemetry;
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, participants: RTKParticipants, stageSocketHandler: StageSocketHandler, roomSocketHandler: RoomSocketHandler);
-    get status(): StageStatus;
-    getAccessRequests(): {
-        stageRequests: StageRequestPayload[];
-    };
-    requestAccess(): Promise<void>;
-    cancelRequestAccess(): Promise<void>;
-    grantAccess(userIds: string[]): Promise<void>;
-    denyAccess(userIds: string[]): Promise<void>;
-    get peerId(): string;
-    join(): Promise<void>;
-    leave(): Promise<void>;
-    kick(userIds: string[]): Promise<{
+interface UpdateChannelRequestPayload {
+    memberIds?: string[];
+    displayName?: string;
+    displayPictureUrl?: string;
+    visibility?: string;
+}
+declare class ChatChannelSocketHandler {
+    get telemetry(): Telemetry;
+    get 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 {
+    get telemetry(): Telemetry;
+    get logger(): Logger;
+    constructor(context: Context<ContextState>, 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;
 }
 
-interface ResponseStatus {
-    success: boolean;
-    message: string;
+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;
+    get peers(): string[];
+    get compulsoryPeers(): string[];
+    get activeSpeakerPeers(): string[];
+    private _removeFromCompulsoryPeer;
 }
 
-type MediaPermission$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE' | 'CANCELED';
-
-declare class EnhancedEventEmitter<TransportPromiseEvents> extends EventEmitter$1 {
-    get 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]>;
+type PipEvents = {
+    ['cameraToggled']: () => void;
+    ['micToggled']: () => void;
+    ['hangup']: () => void;
+    ['pipStarted']: () => void;
+    ['pipEnded']: () => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
+};
+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;
+    get 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 {
@@ -2953,11 +3109,6 @@ declare enum TransportState {
     FAILED = "failed",
     CLOSED = "closed"
 }
-declare enum MediaNodeType {
-    HIVE = 1,
-    ROOM_NODE = 2,
-    CF = 3
-}
 type MediaConnectionState = {
     recv: {
         state: `${TransportState}`;
@@ -2967,20 +3118,193 @@ type MediaConnectionState = {
     };
 };
 
-interface GenericHandlerResult {
-    offerSdp: RTCSessionDescriptionInit;
-    callback: (answer: RTCSessionDescriptionInit) => Promise<any>;
-    sender?: RTCRtpSender;
+type EventHandlerTypes = PeerInfoResponse | GetWaitingRoomRequests | RecordingEvent | UpdatePeersPresetResponse | PeerJoinBroadcastResponse | PeerJoinCompleteResponse | GlobalPeerPinningBroadcastResponse | PeerLeaveResponse | SelectedPeersResponse | SelectedPeersDiffResponse;
+declare class RoomSocketHandler {
+    socket: SocketService;
+    get telemetry(): Telemetry;
+    get 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 HandlerRunOptions = {
-    direction: 'send' | 'recv';
-    iceServers?: RTCIceServer[];
-    iceTransportPolicy?: RTCIceTransportPolicy;
-    additionalSettings?: any;
-    proprietaryConstraints?: any;
-    onTrackHandler?: (event: RTCTrackEvent) => void;
-};
-type CodecOption = {
+
+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[];
+    get 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: `${TransportState}`;
+    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;
+    get socketState(): SocketConnectionState;
+    get mediaState(): MediaConnectionState;
+    broadcastTabChanges: boolean;
+    viewType: string;
+    meetingStartedTimestamp: Date;
+    meetingTitle: string;
+    sessionId: string;
+    constructor(context: Context<ContextState>, self: Self, viewType: string, roomSocketHandler: RoomSocketHandler, meetingTitle: string);
+    get 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>;
+    sender?: RTCRtpSender;
+}
+type HandlerRunOptions = {
+    direction: 'send' | 'recv';
+    iceServers?: RTCIceServer[];
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    additionalSettings?: any;
+    proprietaryConstraints?: any;
+    onTrackHandler?: (event: RTCTrackEvent) => void;
+};
+type CodecOption = {
     name: string;
     parameters?: string[];
 };
@@ -2995,11 +3319,15 @@ interface HandlerSendResult extends GenericHandlerResult {
     mid: string;
 }
 declare abstract class HandlerInterface<TransportPromiseEvents> extends EnhancedEventEmitter<TransportPromiseEvents> {
+    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;
     get midTransceiverMap(): Map<string, RTCRtpTransceiver>;
     abstract get name(): string;
     close(): void;
@@ -3007,6 +3335,8 @@ declare abstract class HandlerInterface<TransportPromiseEvents> extends Enhanced
     init({ direction, iceServers, iceTransportPolicy, additionalSettings, proprietaryConstraints, onTrackHandler, }: HandlerRunOptions): void;
     connect(): Promise<GenericHandlerResult>;
     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>;
@@ -3018,8 +3348,6 @@ declare abstract class HandlerInterface<TransportPromiseEvents> extends Enhanced
     addCustomEventListeners(): void;
 }
 
-type MediaKind$1 = 'audio' | 'video';
-
 type DCMessage = {
     type: string;
     payload: Record<string, unknown>;
@@ -3050,7 +3378,7 @@ type ConsumerOptions = {
     transceiver: RTCRtpTransceiver;
     closeTranscieverOnClose?: boolean;
 };
-type MediaKind = 'audio' | 'video';
+type MediaKind$1 = 'audio' | 'video';
 declare class Consumer extends EnhancedEventEmitter<TransportPromiseEvents> {
     readonly rtpReceiver: RTCRtpReceiver;
     readonly id: string;
@@ -3062,9 +3390,9 @@ declare class Consumer extends EnhancedEventEmitter<TransportPromiseEvents> {
     readonly peerId: string;
     readonly appData: Record<string, unknown>;
     readonly transceiver: RTCRtpTransceiver;
-    constructor(context: Context<RTKContextState>, opts: ConsumerOptions);
+    constructor(context: Context<ContextState>, opts: ConsumerOptions);
     get closed(): boolean;
-    get kind(): MediaKind;
+    get kind(): MediaKind$1;
     get paused(): boolean;
     close(reason?: string, closeTranscieverOnClose?: boolean): void;
     getStats(): Promise<RTCStatsReport>;
@@ -3090,15 +3418,15 @@ type ParticipantEvents = {
             video: MediaStreamTrack;
         };
     }) => void;
-    ['pinned']: (payload: RTKParticipant) => void;
-    ['unpinned']: (payload: RTKParticipant) => void;
+    ['pinned']: (payload: Participant) => void;
+    ['unpinned']: (payload: Participant) => void;
     ['poorConnection']: (payload: {
         score: number;
         kind: string;
     }) => void;
-    ['stageStatusUpdate']: (payload: RTKParticipant) => void;
+    ['stageStatusUpdate']: (payload: Participant) => void;
     ['mediaScoreUpdate']: (payload: {
-        kind: MediaKind;
+        kind: MediaKind$1;
         isScreenshare: boolean;
         score: number;
         participantId: string;
@@ -3134,8 +3462,8 @@ type SelfEvents = {
         removed: MediaDeviceInfo[];
         devices: MediaDeviceInfo[];
     }) => void;
-    ['pinned']: (payload: RTKSelf) => void;
-    ['unpinned']: (payload: RTKSelf) => void;
+    ['pinned']: (payload: Self) => void;
+    ['unpinned']: (payload: Self) => void;
     ['mediaPermissionUpdate']: (payload: {
         message: keyof typeof MediaPermission;
         kind: 'audio' | 'video' | 'screenshare';
@@ -3146,7 +3474,7 @@ type SelfEvents = {
         kind: 'audio' | 'video' | 'screenshare';
     }) => void;
     ['mediaScoreUpdate']: (payload: {
-        kind: MediaKind;
+        kind: MediaKind$1;
         isScreenshare: boolean;
         score: number;
         participantId: string;
@@ -3163,223 +3491,500 @@ type SelfEvents = {
     ['*']: (event: string, ...args: any[]) => void;
 };
 
-declare class LocalMediaHandler extends RTKEventEmitter<LocalMediaEvents> {
-    get telemetry(): RTKTelemetry;
-    audioUpdateInProgress: boolean;
-    videoUpdateInProgress: boolean;
-    constructor(context: Context<RTKContextState>, mediaConstraints: MediaConstraints, isNonPreferredDevice?: (media: MediaDeviceInfo) => boolean, autoSwitchDevice?: boolean);
-    set context(context: Context<RTKContextState>);
-    repopulateAvailableDevices(): Promise<boolean>;
-    setupStreams({ audio, video, }: {
-        audio: boolean;
-        video: boolean;
-    }): Promise<void>;
-    getCurrentDevices(): {
-        audio: MediaDeviceInfo;
-        video: MediaDeviceInfo;
-        speaker: MediaDeviceInfo;
-    };
-    get permissions(): {
-        audio?: MediaPermission$1;
-        video?: MediaPermission$1;
-        screenshare?: MediaPermission$1;
-    };
-    getAllDevices(): Promise<InputDeviceInfo[]>;
-    getDeviceById(deviceId: string, kind?: 'audioinput' | 'audiooutput' | 'videoinput'): Promise<MediaDeviceInfo>;
-    get rawAudioTrack(): MediaStreamTrack;
-    get audioTrack(): MediaStreamTrack;
-    get 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>;
-    get rawVideoTrack(): MediaStreamTrack;
-    get videoTrack(): MediaStreamTrack;
-    get videoEnabled(): boolean;
-    enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
-    disableVideo(): void;
-    getVideoDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
-    setVideoDevice(device: MediaDeviceInfo): Promise<void>;
-    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
-    get screenShareTracks(): {
-        audio: MediaStreamTrack;
-        video: MediaStreamTrack;
-    };
-    get 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>;
+type ParticipantMapEvents = {
+    ['participantJoined']: (payload: Participant) => void;
+    ['participantLeft']: (payload: Participant) => void;
+    ['participantsCleared']: () => void;
+    ['participantsUpdate']: () => void;
+    ['kicked']: (payload: {
+        id: string;
+    }) => 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;
-    WorkerTimers: typeof WorkerTimers;
-}) => Promise<void>);
-type VideoMiddlewareGlobalConfig = {
-    disablePerFrameCanvasRendering: boolean;
-};
-
-type PresetMediaConstraints = PresetV2CamelCased['config']['media'];
-type AudioQualityConstraints = {
-    echoCancellation?: boolean;
-    noiseSupression?: boolean;
-    autoGainControl?: boolean;
-    enableStereo?: boolean;
-    enableHighBitrate?: boolean;
-};
-type VideoQualityConstraints = {
-    width: {
-        ideal: number;
-    };
-    height: {
-        ideal: number;
-    };
-    frameRate?: {
-        ideal: number;
-    };
+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;
 };
-type ScreenshareQualityConstraints = {
-    width?: {
-        max: number;
+declare class Stage extends TypedEventEmitter$1<StageEvents> {
+    get telemetry(): Telemetry;
+    constructor(context: Context<ContextState>, self: Self, participants: Participants, stageSocketHandler: StageSocketHandler, roomSocketHandler: RoomSocketHandler);
+    get status(): StageStatus;
+    private setupEvents;
+    getAccessRequests(): {
+        stageRequests: StageRequestPayload[];
     };
-    height?: {
-        max: number;
+    requestAccess(): Promise<void>;
+    cancelRequestAccess(): Promise<void>;
+    grantAccess(userIds: string[]): Promise<void>;
+    denyAccess(userIds: string[]): Promise<void>;
+    get 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;
     };
-    frameRate?: {
-        ideal: number;
-        max: number;
+    flags?: {
+        hiddenParticipant?: boolean;
+        recorder?: boolean;
     };
-    displaySurface?: 'window' | 'monitor' | 'browser';
-    selfBrowserSurface?: 'include' | 'exclude';
 };
-interface RTKMediaTrackConstraints extends MediaTrackConstraints {
-    optional?: Array<object>;
-}
-interface RTKMediaStreamConstraints extends MediaStreamConstraints {
-    audio?: boolean | RTKMediaTrackConstraints;
-}
-type MediaConstraints = {
-    audio?: AudioQualityConstraints;
-    video?: MediaVideoQualityType | VideoQualityConstraints;
-    screenshare?: ScreenshareQualityConstraints;
+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;
 };
-
-type PresetV2CamelCased = {
-    config: {
-        viewType: ViewType;
-        media: {
-            audio: {
-                enableStereo: boolean;
-                enableHighBitrate: boolean;
-            };
-            video: {
-                quality: MediaVideoQualityType;
-                frameRate: number;
-            };
-            screenshare: {
-                quality: MediaScreenShareQualityType;
-                frameRate: number;
-            };
-        };
-        livestreamViewerQualities: LivestreamViewerMediaQualityType[];
-        maxVideoStreams: {
-            mobile: number;
-            desktop: number;
-        };
-        maxScreenshareCount: number;
+declare class Participants extends TypedEventEmitter$1<ParticipantsEvents> {
+    readonly waitlisted: Readonly<ParticipantMap<Omit<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>;
+    get pip(): Pip;
+    rateLimitConfig: {
+        maxInvocations: number;
+        period: number;
     };
-    permissions: {
-        acceptWaitingRequests: boolean;
-        canAcceptProductionRequests: boolean;
-        canEditDisplayName: boolean;
-        canRecord: boolean;
-        canLivestream: boolean;
-        canSpotlight?: boolean;
-        disableParticipantAudio: boolean;
-        disableParticipantScreensharing: boolean;
-        disableParticipantVideo: boolean;
-        kickParticipant: boolean;
-        pinParticipant: boolean;
-        plugins: {
-            canClose: boolean;
-            canStart: boolean;
-            canEditConfig?: boolean;
-            config: {
-                [pluginId: string]: Partial<{
-                    accessControl: PluginAccessControls.FULL_ACCESS | PluginAccessControls.VIEW_ONLY;
-                    disabled: boolean;
-                    handlesViewOnly: boolean;
-                }>;
-            };
+    get rateLimits(): {
+        maxInvocations: number;
+        period: number;
+    };
+    updateRateLimits(num: number, period: number): void;
+    get telemetry(): Telemetry;
+    viewMode: ViewMode;
+    currentPage: number;
+    lastActiveSpeaker: string;
+    selectedPeers: SelectedPeers;
+    constructor(context: Context<ContextState>, self: Self, roomSocketHandler: RoomSocketHandler);
+    setupEvents(): void;
+    get count(): number;
+    get maxActiveParticipantsCount(): number;
+    setMaxActiveParticipantsCount(limit: number): void;
+    get 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;
         };
-        waitingRoomType: WaitingRoomTypes;
-        polls: {
-            canCreate: boolean;
-            canVote: boolean;
-            canView: boolean;
+        recorderType: string;
+        flags: {
+            hiddenParticipant: boolean;
+            hidden_participant: boolean;
+            recorder: boolean;
         };
-        media: {
-            video: {
-                canProduce: MediaProductionPermissionType;
-            };
-            audio: {
-                canProduce: MediaProductionPermissionType;
-            };
-            screenshare: {
-                canProduce: MediaProductionPermissionType;
-            };
+    }[]>;
+    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>;
         };
-        chat: {
-            public: {
-                canSend: boolean;
-                text: boolean;
-                files: boolean;
-            };
-            private?: {
-                canSend: boolean;
-                canReceive: boolean;
-                text: boolean;
-                files: boolean;
-            };
-            channel?: {
-                canCreate: 'NONE' | 'PRIVATE' | 'PUBLIC' | 'ALL';
-                canDelete: 'NONE' | 'PRIVATE' | 'PUBLIC' | 'ALL';
-                canUpdate: 'NONE' | 'PRIVATE' | 'PUBLIC' | 'ALL';
-                canReadAll: boolean;
-            };
-            message?: {
+        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> {
+    get telemetry(): Telemetry;
+    audioUpdateInProgress: boolean;
+    videoUpdateInProgress: boolean;
+    constructor(context: Context<ContextState>, mediaConstraints: MediaConstraints, isNonPreferredDevice?: (media: MediaDeviceInfo) => boolean, autoSwitchDevice?: boolean);
+    set context(context: Context<ContextState>);
+    private onVisibilityChange;
+    repopulateAvailableDevices(): Promise<boolean>;
+    setupStreams({ audio, video, }: {
+        audio: boolean;
+        video: boolean;
+    }): Promise<void>;
+    getCurrentDevices(): {
+        audio: MediaDeviceInfo;
+        video: MediaDeviceInfo;
+        speaker: MediaDeviceInfo;
+    };
+    get 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;
+    get rawAudioTrack(): MediaStreamTrack;
+    get audioTrack(): MediaStreamTrack;
+    get 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;
+    get rawVideoTrack(): MediaStreamTrack;
+    get videoTrack(): MediaStreamTrack;
+    get 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;
+    get screenShareTracks(): {
+        audio: MediaStreamTrack;
+        video: MediaStreamTrack;
+    };
+    get 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 = {
+    disablePerFrameCanvasRendering: boolean;
+};
+
+type PresetMediaConstraints = PresetV2CamelCased['config']['media'];
+type AudioQualityConstraints = {
+    echoCancellation?: boolean;
+    noiseSupression?: boolean;
+    autoGainControl?: boolean;
+    enableStereo?: boolean;
+    enableHighBitrate?: boolean;
+};
+type VideoQualityConstraints = {
+    width: {
+        ideal: number;
+    };
+    height: {
+        ideal: number;
+    };
+    frameRate?: {
+        ideal: number;
+    };
+};
+type ScreenshareQualityConstraints = {
+    width?: {
+        max: number;
+    };
+    height?: {
+        max: number;
+    };
+    frameRate?: {
+        ideal: number;
+        max: number;
+    };
+    displaySurface?: 'window' | 'monitor' | 'browser';
+    selfBrowserSurface?: 'include' | 'exclude';
+};
+interface ClientMediaTrackConstraints extends MediaTrackConstraints {
+    optional?: Array<object>;
+}
+interface ClientMediaStreamConstraints extends MediaStreamConstraints {
+    audio?: boolean | ClientMediaTrackConstraints;
+}
+type MediaConstraints = {
+    audio?: AudioQualityConstraints;
+    video?: MediaVideoQualityType | VideoQualityConstraints;
+    screenshare?: ScreenshareQualityConstraints;
+};
+
+type PresetV2CamelCased = {
+    config: {
+        viewType: ViewType;
+        media: {
+            audio: {
+                enableStereo: boolean;
+                enableHighBitrate: boolean;
+            };
+            video: {
+                quality: MediaVideoQualityType;
+                frameRate: number;
+            };
+            screenshare: {
+                quality: MediaScreenShareQualityType;
+                frameRate: number;
+            };
+        };
+        livestreamViewerQualities: LivestreamViewerMediaQualityType[];
+        maxVideoStreams: {
+            mobile: number;
+            desktop: number;
+        };
+        maxScreenshareCount: number;
+    };
+    permissions: {
+        acceptWaitingRequests: boolean;
+        canAcceptProductionRequests: boolean;
+        canEditDisplayName: boolean;
+        canRecord: boolean;
+        canLivestream: boolean;
+        canSpotlight?: boolean;
+        disableParticipantAudio: boolean;
+        disableParticipantScreensharing: boolean;
+        disableParticipantVideo: boolean;
+        kickParticipant: boolean;
+        pinParticipant: boolean;
+        plugins: {
+            canClose: boolean;
+            canStart: boolean;
+            canEditConfig?: boolean;
+            config: {
+                [pluginId: string]: Partial<{
+                    accessControl: PluginAccessControls.FULL_ACCESS | PluginAccessControls.VIEW_ONLY;
+                    disabled: boolean;
+                    handlesViewOnly: boolean;
+                }>;
+            };
+        };
+        waitingRoomType: WaitingRoomTypes;
+        polls: {
+            canCreate: boolean;
+            canVote: boolean;
+            canView: boolean;
+        };
+        media: {
+            video: {
+                canProduce: MediaProductionPermissionType;
+            };
+            audio: {
+                canProduce: MediaProductionPermissionType;
+            };
+            screenshare: {
+                canProduce: MediaProductionPermissionType;
+            };
+        };
+        chat: {
+            public: {
+                canSend: boolean;
+                text: boolean;
+                files: boolean;
+            };
+            private?: {
+                canSend: boolean;
+                canReceive: boolean;
+                text: boolean;
+                files: boolean;
+            };
+            channel?: {
+                canCreate: 'NONE' | 'PRIVATE' | 'PUBLIC' | 'ALL';
+                canDelete: 'NONE' | 'PRIVATE' | 'PUBLIC' | 'ALL';
+                canUpdate: 'NONE' | 'PRIVATE' | 'PUBLIC' | 'ALL';
+                canReadAll: boolean;
+            };
+            message?: {
                 canDelete: 'NONE' | 'SELF' | 'ALL';
                 canEdit: 'NONE' | 'SELF' | 'ALL';
                 deleteCutoffTimeSeconds: number;
@@ -3440,11 +4045,11 @@ type PresetV2CamelCased = {
     name?: string;
 };
 type MaxVideoStreams = PresetV2CamelCased['config']['maxVideoStreams'];
-declare class RTKThemePreset$1 {
+declare class ThemePreset {
     private constructor();
-    static fromResponse(preset: PresetV2CamelCased): RTKThemePreset$1;
-    static default(): RTKThemePreset$1;
-    static init(preset?: PresetV2CamelCased, useDefault?: boolean): RTKThemePreset$1;
+    static fromResponse(preset: PresetV2CamelCased): ThemePreset;
+    static default(): ThemePreset;
+    static init(preset?: PresetV2CamelCased, useDefault?: boolean): ThemePreset;
     get setupScreen(): Readonly<{
         isEnabled: boolean;
     }>;
@@ -3489,7 +4094,6 @@ declare class RTKThemePreset$1 {
 }
 
 type PresetPermissions = PresetV2CamelCased['permissions'];
-type MediaRoomType = 'HIVE' | 'CF';
 type PermissionEvents = {
     ['chatUpdate']: () => void;
     ['pollsUpdate']: () => void;
@@ -3497,12 +4101,13 @@ type PermissionEvents = {
     ['permissionsUpdate']: (patch: PresetUpdates) => void;
     ['*']: () => void;
 };
-declare class RTKPermissionsPreset$1 extends RTKTypedEventEmitter<PermissionEvents> {
+declare class PermissionPreset extends TypedEventEmitter$1<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;
-    get mediaRoomType(): Readonly<MediaRoomType>;
+    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;
+    get mediaRoomType(): string;
     get stageEnabled(): Readonly<boolean>;
     get acceptStageRequests(): Readonly<boolean>;
     get stageAccess(): Readonly<MediaProductionPermissionType>;
@@ -3548,603 +4153,34 @@ declare class RTKPermissionsPreset$1 extends RTKTypedEventEmitter<PermissionEven
     get canLivestream(): Readonly<boolean>;
     get 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;
-    get peerId(): string;
-    viewType: ViewType;
-    get telemetry(): RTKTelemetry;
-    get logger(): RTKLogger$1;
-    get 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> {
-    get peerId(): string;
-    init(options?: {
-            video?: boolean;
-            audio?: boolean;
-            constraints?: MediaConstraints;
-        }, skipAwaits?: boolean, context?: Context<RTKContextState>): Promise<void>;
-    set context(context: Context<RTKContextState>);
-    get audioTrack(): MediaStreamTrack;
-    get rawAudioTrack(): MediaStreamTrack;
-    get 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;
-    }>;
-    get videoTrack(): MediaStreamTrack;
-    get 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;
-    }>;
-    get screenShareTracks(): {
-        audio: MediaStreamTrack;
-        video: MediaStreamTrack;
-    };
-    get audioEnabled(): boolean;
-    get videoEnabled(): boolean;
-    get 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;
-    get telemetry(): RTKTelemetry;
-    hidden: boolean;
-    get stageStatus(): StageStatus;
-    get id(): string;
-    get 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;
-    get permissions(): RTKPermissionsPreset$1;
-    get config(): RTKThemePreset$1;
-    get 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;
-    get 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 {
-    get telemetry(): RTKTelemetry;
-    get 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 {
-    get telemetry(): RTKTelemetry;
-    get 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;
-    get peers(): string[];
-    get compulsoryPeers(): string[];
-    get 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;
-    get isActive(): boolean;
-    init({ height, width }?: {
-        height?: number;
-        width?: number;
-    }): void;
-    enableSource(source: string): void;
-    disableSource(source: string): void;
-    addSource(id: string, element: HTMLVideoElement, enabled: boolean, pinned?: boolean, displayText?: string, imageUrl?: string, handRaised?: boolean): void;
-    updateSource(id: string, source: any): void;
-    removeSource(id: string): void;
-    removePinnedSource(): void;
-    removeAllSources(): void;
-    enable(): void;
-    disable: (partial?: boolean) => void;
-}
-
-type 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[];
-    get 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: `${TransportState}`;
-    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;
-    get socketState(): SocketConnectionState;
-    get mediaState(): MediaConnectionState;
-    broadcastTabChanges: boolean;
-    viewType: string;
-    meetingStartedTimestamp: Date;
-    meetingTitle: string;
-    sessionId: string;
-    constructor(context: Context<RTKContextState>, self: RTKSelf, viewType: string, roomSocketHandler: RoomSocketHandler, meetingTitle: string);
-    get 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<Omit<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>;
-    get pip(): RTKPip;
-    rateLimitConfig: {
-        maxInvocations: number;
-        period: number;
-    };
-    get rateLimits(): {
-        maxInvocations: number;
-        period: number;
-    };
-    updateRateLimits(num: number, period: number): void;
-    get telemetry(): RTKTelemetry;
-    viewMode: ViewMode;
-    currentPage: number;
-    lastActiveSpeaker: string;
-    selectedPeers: RTKSelectedPeers;
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, roomSocketHandler: RoomSocketHandler);
-    setupEvents(): void;
-    get count(): number;
-    get maxActiveParticipantsCount(): number;
-    setMaxActiveParticipantsCount(limit: number): void;
-    get 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;
-    });
-    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 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;
+    get peerId(): string;
+    viewType: ViewType;
+    get telemetry(): Telemetry;
+    get logger(): Logger;
+    get 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';
@@ -4166,22 +4202,23 @@ type LivestreamResponse = {
     manualIngest: boolean;
     ingestionCredentials?: LivestreamIngestionCredentials;
 };
-declare class RTKLivestream$1 extends RTKTypedEventEmitter<LivestreamEvents> {
+declare class Livestream extends TypedEventEmitter$1<LivestreamEvents> {
     state: LivestreamState;
     playbackUrl: string | undefined;
     ingestionCredentials: LivestreamIngestionCredentials;
     viewerCount: number;
-    get telemetry(): RTKTelemetry;
-    constructor(context: Context<RTKContextState>, self: RTKSelf);
+    get 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);
-    get logger(): RTKLogger$1;
+    constructor(context: Context<ContextState>, socketService: SocketService);
+    get logger(): Logger;
     addPlugin(pluginId: string, staggered: boolean): void;
     removePlugin(pluginId: string): void;
     getActivePlugins(): Promise<EnablePluginsResponse>;
@@ -4207,7 +4244,7 @@ declare class PluginSocketHandler {
     on(event: number, handler: (socketMessage: PluginSocketMessage, messageId?: string) => void): void;
 }
 
-interface RTKPluginResponse {
+interface PluginResponse {
     baseURL: string;
     createdAt: string;
     description: string;
@@ -4289,7 +4326,7 @@ type _string = string & {
     _?: any;
 };
 type PluginEvents$1 = keyof typeof PluginEventKeys | _string;
-declare class RTKPlugin$1 extends RTKEventEmitter<PluginEvents$1> {
+declare class Plugin extends CustomEventEmitter<PluginEvents$1> {
     readonly baseURL: string;
     readonly createdAt: Date;
     readonly description: string;
@@ -4310,12 +4347,14 @@ declare class RTKPlugin$1 extends RTKEventEmitter<PluginEvents$1> {
         listener?: (message: MessageEvent) => void;
     }>;
     enabledBy: string;
-    get 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);
+    get 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>;
@@ -4338,12 +4377,12 @@ interface ReactNativeFile {
     type: string;
 }
 declare class APIClient extends API {
-    telemetry: RTKTelemetry;
-    constructor(context: Context<RTKContextState>, options?: APIOptions);
+    telemetry: Telemetry;
+    constructor(context: Context<ContextState>, options?: APIOptions);
     getIPDetails(): Promise<any>;
     getICEServers(): Promise<any>;
     getPlugins(): Promise<any[]>;
-    getPluginDetails(pluginId: string): Promise<RTKPluginResponse>;
+    getPluginDetails(pluginId: string): Promise<PluginResponse>;
     getPluginConfig(pluginBaseUrl: string): Promise<PluginConfig>;
     authorizePlugin(pluginId: string): Promise<string>;
     getPresignedUrls(filename: string, viewType: string): Promise<{
@@ -4463,13 +4502,17 @@ type ChatEvents = {
     ['channelUpdate']: (channel?: ChatChannel) => void;
     ['*']: (event: string, ...args: any[]) => void;
 };
-declare class RTKChat$1 extends RTKTypedEventEmitter<ChatEvents> {
+declare class Chat extends TypedEventEmitter$1<ChatEvents> {
     messages: Message[];
     channels: ChatChannel[];
     maxTextLimit: number;
-    get telemetry(): RTKTelemetry;
+    get telemetry(): Telemetry;
     setMaxTextLimit(limit: number): void;
-    constructor(context: Context<RTKContextState>, chatSocketHandler: ChatSocketHandler, chatChannelSocketHandler: ChatChannelSocketHandler, self: RTKSelf$1, participants: RTKParticipants$1);
+    constructor(context: Context<ContextState>, chatSocketHandler: ChatSocketHandler, chatChannelSocketHandler: ChatChannelSocketHandler, self: Self, participants: Participants);
+    private sendMessageInternal;
+    private sendTextMessageInternal;
+    private sendImageMessageInternal;
+    private sendFileMessageInternal;
     get rateLimits(): {
         maxInvocations: number;
         period: number;
@@ -4502,16 +4545,16 @@ declare class RTKChat$1 extends RTKTypedEventEmitter<ChatEvents> {
     sendMessageToChannel(message: MessagePayload, channelId: string, options?: {
         replyTo?: Message;
     }): Promise<void>;
-    getChannelMembers(channelId: string): Promise<RTKBasicParticipant[]>;
+    getChannelMembers(channelId: string): Promise<BasicParticipant[]>;
     searchMessages(query: string, filters?: SearchFilters): Promise<Message[]>;
     markLastReadMessage(channelId: string, message: Message): Promise<void>;
     get pinned(): Message[];
 }
 
 declare class PollSocketHandler {
-    get logger(): RTKLogger$1;
-    get telemetry(): RTKTelemetry;
-    constructor(context: Context<RTKContextState>, socketService: SocketService);
+    get logger(): Logger;
+    get telemetry(): Telemetry;
+    constructor(context: Context<ContextState>, socketService: SocketService);
     getPolls(): Promise<{
         id: string;
         payload: Uint8Array;
@@ -4547,16 +4590,16 @@ type PollsEvents = {
     }) => void;
     ['*']: (eventName: string, ...args: any[]) => void;
 };
-declare class RTKPolls$1 extends RTKTypedEventEmitter<PollsEvents> {
+declare class Polls extends TypedEventEmitter$1<PollsEvents> {
     items: Poll[];
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, pollSocketHandler: PollSocketHandler);
+    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: RTKPlugin$1) => void;
-    ['pluginDeleted']: (plugin: RTKPlugin$1) => void;
+    ['pluginAdded']: (plugin: Plugin) => void;
+    ['pluginDeleted']: (plugin: Plugin) => void;
 };
 type PluginEvents = {
     ['stateUpdate']: (payload: {
@@ -4571,16 +4614,89 @@ 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);
+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 RTKPlugins$1 {
-    readonly all: RTKPluginMap$1;
-    readonly active: RTKPluginMap$1;
-    constructor(logger: RTKLogger);
+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>;
+    get peerId(): string;
+    init(options?: {
+        video?: boolean;
+        audio?: boolean;
+        constraints?: MediaConstraints;
+    }, skipAwaits?: boolean, context?: Context<ContextState>): Promise<void>;
+    set context(context: Context<ContextState>);
+    get audioTrack(): MediaStreamTrack;
+    get rawAudioTrack(): MediaStreamTrack;
+    get 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;
+    }>;
+    get videoTrack(): MediaStreamTrack;
+    get 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;
+    }>;
+    get screenShareTracks(): {
+        audio: MediaStreamTrack;
+        video: MediaStreamTrack;
+    };
+    get audioEnabled(): boolean;
+    get videoEnabled(): boolean;
+    get 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';
@@ -4594,12 +4710,12 @@ type RecordingEvents = {
     ['recordingUpdate']: (state: RecordingState) => void;
     ['*']: (eventName: string, ...args: any[]) => void;
 };
-declare class RTKRecording$1 extends RTKTypedEventEmitter<RecordingEvents> {
+declare class Recording extends TypedEventEmitter$1<RecordingEvents> {
     recordingPeerIds: string[];
     get recordingState(): RecordingState;
     recordings: RecordingInfo[];
-    constructor(context: Context<RTKContextState>, self: RTKSelf);
-    get telemetry(): RTKTelemetry;
+    constructor(context: Context<ContextState>, self: Self);
+    get telemetry(): Telemetry;
     updateRecordings(recordings: RecordingInfo[]): void;
     start(opts?: {
         allowMultiple: boolean;
@@ -4668,28 +4784,32 @@ declare class BrowserCapabilities extends BrowserDetection {
     isIOSMobile(): boolean;
 }
 
-declare class RTKFeatures {
-    constructor(context: Context<RTKContextState>);
+declare class Features {
+    constructor(context: Context<ContextState>);
     hasFeature(featureName: string): boolean;
-    getFeatureValue(featureName: string): _dyteinternals_utils.RTKFlagValues;
+    getFeatureValue(featureName: string): _dyteinternals_utils.DyteFlagValues;
     getAllFeatures(): {
-            [x: string]: _dyteinternals_utils.RTKFlagsEntry;
-        };
+        [x: string]: _dyteinternals_utils.DyteFlagsEntry;
+    };
 }
 
-declare class RTKInternals {
-    logger: RTKLogger$1;
-    features: RTKFeatures;
+declare class Internals {
+    logger: Logger;
+    features: Features;
     browserSpecs: BrowserCapabilities;
     callStats: InhouseCallStats;
-    constructor(logger: RTKLogger$1, features: RTKFeatures, callStats: InhouseCallStats);
-    static init(context: Context<RTKContextState>): RTKInternals;
+    constructor(logger: Logger, features: Features, callStats: InhouseCallStats);
+    static init(context: Context<ContextState>): Internals;
 }
 
 type StoreData = {
     [type: string]: any;
 };
-declare class RTKStore$1 {
+type RateLimitConfig = {
+    maxInvocations: number;
+    period: number;
+};
+declare class Store {
     name: string;
     rateLimitConfig: {
         maxInvocations: number;
@@ -4699,12 +4819,14 @@ declare class RTKStore$1 {
         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;
@@ -4731,10 +4853,10 @@ declare class RTKStore$1 {
     populate(data: StoreData): void;
 }
 
-declare class RTKStoreManager {
-    stores: Map<String, RTKStore$1>;
-    constructor(context: Context<RTKContextState>, handler: PluginSocketHandler);
-    create(name: string): Promise<RTKStore$1>;
+declare class StoreManager {
+    stores: Map<String, Store>;
+    constructor(context: Context<ContextState>, handler: PluginSocketHandler);
+    create(name: string): Promise<Store>;
 }
 
 declare const enum PRODUCERS_TYPE {
@@ -4757,13 +4879,13 @@ interface MediaNodeClientOptions {
     socket: SocketService;
 }
 declare class MediaNodeClient {
-    readonly context: Context<RTKContextState>;
+    readonly context: Context<ContextState>;
     readonly authToken: string;
     readonly e2ee: boolean;
     get peerId(): string;
-    get telemetry(): RTKTelemetry;
-    get logger(): RTKLogger$1;
-    constructor(context: Context<RTKContextState>, nodeType: MediaNodeType, options: MediaNodeClientOptions);
+    get telemetry(): Telemetry;
+    get logger(): Logger;
+    constructor(context: Context<ContextState>, options: MediaNodeClientOptions);
     get mediaJoined(): boolean;
     set mediaJoined(joined: boolean);
     reset(): void;
@@ -4772,6 +4894,7 @@ declare class MediaNodeClient {
     }>;
     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>;
@@ -4795,7 +4918,6 @@ declare class MediaNodeClient {
     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;
@@ -4878,7 +5000,7 @@ declare class ConnectedMeetingsSocketHandler {
 }
 
 type ConnectedMeetingsEvents = {
-    ['meetingChanged']: (meeting: RealtimeKitClient) => void;
+    ['meetingChanged']: (meeting: Client) => void;
     ['stateUpdate']: (payload: {
         meetings: ConnectedMeeting[];
         parentMeeting: ConnectedMeeting;
@@ -4886,12 +5008,13 @@ type ConnectedMeetingsEvents = {
     ['changingMeeting']: (meetingId: string) => void;
     ['*']: (eventName: string, ...args: any[]) => void;
 };
-declare class RTKConnectedMeetings$1 extends RTKTypedEventEmitter<ConnectedMeetingsEvents> {
-    constructor(context: Context<RTKContextState>);
+declare class ConnectedMeetings extends TypedEventEmitter$1<ConnectedMeetingsEvents> {
+    constructor(context: Context<ContextState>);
     meetings: ConnectedMeeting[];
     parentMeeting: ConnectedMeeting;
     get supportsConnectedMeetings(): boolean;
     get isActive(): boolean;
+    private validateConnectedMeetingsAction;
     getConnectedMeetings(): Promise<{
         parentMeeting: ConnectedMeeting;
         meetings: ConnectedMeeting[];
@@ -4926,6 +5049,7 @@ declare class RTKConnectedMeetings$1 extends RTKTypedEventEmitter<ConnectedMeeti
         success: boolean;
         error: any;
     }>;
+    private moveSuccessHandler;
 }
 
 interface Modules {
@@ -4962,7 +5086,7 @@ interface DefaultOptions {
     video?: boolean;
     audio?: boolean;
     recording?: RecordingConfig;
-    mediaHandler?: RTKSelfMedia$1;
+    mediaHandler?: SelfMedia;
     autoSwitchAudioDevice?: boolean;
     mediaConfiguration?: {
         video?: VideoQualityConstraints;
@@ -4972,10 +5096,10 @@ interface DefaultOptions {
     isNonPreferredDevice?: (device: MediaDeviceInfo) => boolean;
 }
 interface RoomDetails {
-    sfu: MediaNodeType;
-    roomNodeUrl: string;
     meetingTitle: string;
-    useHiveMedia: boolean;
+}
+interface ControllerOptions {
+    peerId?: string;
 }
 
 declare class ConnectionHandler {
@@ -4987,7 +5111,7 @@ declare class ConnectionHandler {
     mediaState: MediaConnectionState;
     get joinAttempted(): boolean;
     get roomJoined(): boolean;
-    constructor(context: Context<RTKContextState>);
+    constructor(context: Context<ContextState>);
     updateSocketConnectionState(state: SocketStateEvent, attempt?: number): void;
 }
 
@@ -5080,9 +5204,9 @@ declare const ERROR_CODES: {
     '2006': string;
     '9900': string;
 };
-declare class RTKError extends Error {
+declare class ClientError extends Error {
     code: keyof typeof ERROR_CODES;
-    constructor(message: string, code?: keyof typeof ERROR_CODES, logger?: RTKLogger$1 | undefined, log?: boolean);
+    constructor(message: string, code?: keyof typeof ERROR_CODES, logger?: Logger | undefined, log?: boolean);
 }
 
 type EventMap = {
@@ -5111,7 +5235,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",
@@ -5126,11 +5249,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",
@@ -5142,18 +5263,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",
@@ -5181,10 +5294,11 @@ type TypedEvents = {
         maxSpatialLayer: number;
     }) => void;
     [SessionEvents.UPDATE_ACTIVE]: (p?: {
+        viewMode?: ViewMode;
         page?: number;
         createAllConsumers?: boolean;
     }) => void;
-    [SessionEvents.PEER_JOINED_INTERNAL]: (p: RTKParticipant$1) => void;
+    [SessionEvents.PEER_JOINED_INTERNAL]: (p: Participant) => void;
     [SessionEvents.UPDATE_PEER_STAGE_STATUS]: (p: {
         id: string;
         status: string;
@@ -5219,12 +5333,12 @@ declare class AudioPlaybackManager extends AudioPlayback {
     removeParticipantTrack(participantId: string): void;
 }
 
-type RTKContextState = {
+type ContextState = {
     authToken?: string;
     peerId?: string;
     apiBase?: string;
     baseURI?: string;
-    onError?: (error: RTKError) => void;
+    onError?: (error: ClientError) => void;
     stageStatus?: StageStatus;
     organizationId?: string;
     presetName?: string;
@@ -5237,10 +5351,7 @@ type RTKContextState = {
     meetingId?: string;
     roomName?: string;
     socketService?: SocketService;
-    pip?: RTKPip;
-    roomNodeOptions?: {
-        sfu: MediaNodeType;
-    };
+    pip?: Pip;
     roomNodeClient?: MediaNodeClient;
     viewType?: ViewType;
     env?: ClientEnvTypeAll;
@@ -5254,11 +5365,11 @@ type RTKContextState = {
     roomSocketHandler?: RoomSocketHandler;
     connectedMeetingsSocketHandler?: ConnectedMeetingsSocketHandler;
     audioPlayback?: AudioPlaybackManager;
-    options?: RealtimeKitClientOptions;
-    self?: RTKSelf;
-    telemetry?: RTKTelemetry;
-    logger?: RTKLogger$1;
-    meeting?: RealtimeKitClient;
+    options?: ClientOptions;
+    self?: Self;
+    telemetry?: Telemetry;
+    logger?: Logger;
+    meeting?: Client;
     selfController?: SelfController;
 };
 interface Context<T extends Record<string, any>> {
@@ -5270,107 +5381,116 @@ interface Context<T extends Record<string, any>> {
     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 {
+    get 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;
-    get joinAttempted(): boolean;
-    set joinAttempted(value: boolean);
-    get telemetry(): RTKTelemetry;
-    get logger(): RTKLogger$1;
-    get peerId(): string;
-    constructor(context: Context<RTKContextState>, { peerId, meetingId, authToken, capabilities, }: {
-            peerId: string;
-            meetingId: string;
-            authToken: string;
-            capabilities: SocketServiceCapabilities;
-        });
-    updateURL(peerID: string): void;
-    get url(): string;
-    connect(): Promise<void>;
-    disconnect(): void;
-    get 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);
+    get closed(): boolean;
+    get track(): MediaStreamTrack | null;
+    get paused(): boolean;
+    get 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;
-    get telemetry(): RTKTelemetry;
-    get 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;
+    get telemetry(): Telemetry;
+    hidden: boolean;
+    get stageStatus(): StageStatus;
+    get producers(): Producer[];
+    get id(): string;
+    get 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;
+    get permissions(): PermissionPreset;
+    get config(): ThemePreset;
+    get 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;
+    get 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 {
@@ -5390,7 +5510,7 @@ interface ProducerState {
     mimeType?: string;
     consumer?: Partial<Consumer>;
 }
-interface Participant {
+interface IParticipant {
     id: string;
     userId: string;
     displayName: string;
@@ -5413,7 +5533,7 @@ interface Participant {
     };
     recorderType?: string;
 }
-declare class RTKParticipant$1 extends RTKTypedEventEmitter<ParticipantEvents> {
+declare class Participant extends TypedEventEmitter$1<ParticipantEvents> {
     id: string;
     userId: string;
     name: string;
@@ -5439,22 +5559,24 @@ declare class RTKParticipant$1 extends RTKTypedEventEmitter<ParticipantEvents> {
     supportsRemoteControl: boolean;
     presetName?: string;
     get stageStatus(): StageStatus;
-    get telemetry(): RTKTelemetry;
-    constructor(context: Context<RTKContextState>, participant: Participant, self: RTKSelf, roomSocket: RoomSocketHandler);
+    get 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, "plugins" | "polls" | "chat">>;
+    getPermissions(): Promise<Pick<_dyteinternals_utils.Permissions, "chat" | "polls" | "plugins">>;
     setStageStatus(stageStatus: StageStatus): void;
     get isPinned(): boolean;
     registerVideoElement(videoElem: HTMLVideoElement): void;
     deregisterVideoElement(videoElem?: HTMLVideoElement): void;
+    private updateVideo;
 }
 
 declare function createSafeToLogError(ex: any): {
@@ -5477,7 +5599,7 @@ type LogData$2 = {
     };
     devices?: string | MediaDeviceInfo[];
     debuggingHint?: string;
-    constraints?: string | RTKMediaStreamConstraints;
+    constraints?: string | ClientMediaStreamConstraints;
     timeout?: number;
     execTime?: number;
     country?: string;
@@ -5541,7 +5663,7 @@ type LogData$2 = {
             property: string;
         };
     };
-    dyteClientInitOptions?: RealtimeKitClientOptions;
+    clientInitOptions?: ClientOptions;
     plugin?: {
         id?: string;
         name?: string;
@@ -5572,7 +5694,7 @@ type LogData$2 = {
         id: string;
         peerId?: string;
         kind: 'audio' | 'video' | PRODUCERS_TYPE;
-        status?: 'initializing' | 'producing' | 'paused' | 'failed' | 'closing' | 'closed' | 'UNKNOWN';
+        status?: 'not_initialized' | 'initializing' | 'producing' | 'paused' | 'failed' | 'closing' | 'closed' | 'UNKNOWN';
         appData: {
             screenShare?: boolean;
             supportsRemoteControl?: boolean;
@@ -5638,16 +5760,17 @@ type LogData$2 = {
         ip: string;
         postal: string;
     };
-    dytePolls?: {
+    polls?: {
         hasQuestion?: boolean;
         optionsLength?: number;
     };
-    dyteChat?: {
+    chat?: {
         imageType?: string;
         messageType?: string;
     };
-    dyteParticipant?: {
+    participant?: {
         id: string;
+        maskedName?: string;
     };
     actions?: {
         disableAllAudio?: {
@@ -5694,7 +5817,7 @@ type LogData$2 = {
     performanceObserver?: {
         api: PerformanceEntry;
     };
-    dyteLocker?: {
+    locker?: {
         methodName: string;
         lockName: string;
     };
@@ -5739,7 +5862,7 @@ interface MeetingMetadata {
     visitedUrl?: string;
     userId?: string;
 }
-declare class RTKTelemetry {
+declare class Telemetry {
     logsCache: {
         [key: string]: any;
     }[];
@@ -5754,7 +5877,7 @@ declare class RTKTelemetry {
     logExclusionList: string[];
     meetingMetadata: MeetingMetadata;
     resetPeerId(peerId: string): void;
-    init(context: Context<RTKContextState>, options: MeetingMetadata, enableTracing: boolean): 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;
@@ -5764,9 +5887,9 @@ declare class RTKTelemetry {
 }
 
 type LogData = LogData$1;
-declare class RTKLogger$1 {
-    get telemetry(): RTKTelemetry;
-    init(context: Context<RTKContextState>): void;
+declare class Logger {
+    get 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;
@@ -5782,7 +5905,7 @@ interface IceServerInformation {
 }
 interface CachedUserDetails {
     peerId?: string;
-    pluginInformation: RTKPluginResponse[];
+    pluginInformation: PluginResponse[];
     userDetails: UserDetailsResponseV2;
     roomDetails: RoomDetails;
     iceServers: IceServerInformation[];
@@ -5797,10 +5920,20 @@ interface APIOptions {
 }
 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;
     get peerId(): string;
-    context: Context<RTKContextState>;
-    get logger(): RTKLogger$1;
-    constructor(context: Context<RTKContextState>, options?: APIOptions);
+    context: Context<ContextState>;
+    get logger(): Logger;
+    constructor(context: Context<ContextState>, options?: APIOptions);
     setAuthToken(token: string, options?: {
         bearer?: boolean;
     }): void;
@@ -5812,43 +5945,48 @@ declare class API {
 
 interface Overrides {
     disableSimulcast?: boolean;
+    simulcastConfig?: {
+        disable?: boolean;
+        encodings?: RTCRtpEncodingParameters[];
+    };
     forceRelay?: boolean;
-    [key: string]: boolean | string | number;
+    [key: string]: boolean | string | number | Record<string, any>;
 }
-interface RealtimeKitClientOptions {
+interface ClientOptions {
     authToken: string;
     defaults?: DefaultOptions;
     modules?: Modules;
     overrides?: Overrides;
     baseURI?: string;
-    onError?: (error: RTKError) => void;
+    onError?: (error: ClientError) => void;
     cachedUserDetails?: CachedUserDetails;
 }
-declare class RealtimeKitClient {
+declare class Client {
     private constructor();
     get peerId(): string;
     static initMedia(options?: {
-            video?: boolean;
-            audio?: boolean;
-            constraints?: MediaConstraints;
-        }, skipAwaits?: boolean, cachedUserDetails?: CachedUserDetails): RTKSelfMedia$1;
-    static init(options: RealtimeKitClientOptions): Promise<RealtimeKitClient>;
+        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>;
-    get participants(): Readonly<RTKParticipants$1>;
-    get self(): Readonly<RTKSelf$1>;
-    get meta(): Readonly<RTKMeta$1>;
-    get ai(): Readonly<RTKAi>;
-    get plugins(): Readonly<RTKPlugins$1>;
-    get chat(): Readonly<RTKChat$1>;
-    get polls(): Readonly<RTKPolls$1>;
-    get connectedMeetings(): Readonly<RTKConnectedMeetings$1>;
-    get recording(): Readonly<RTKRecording$1>;
-    get livestream(): Readonly<RTKLivestream$1>;
-    get stage(): Readonly<RTKStage>;
-    get stores(): Readonly<RTKStoreManager>;
+    get participants(): Readonly<Participants>;
+    get self(): Readonly<Self>;
+    get meta(): Readonly<Meta>;
+    get ai(): Readonly<Ai>;
+    get plugins(): Readonly<Plugins>;
+    get chat(): Readonly<Chat>;
+    get polls(): Readonly<Polls>;
+    get connectedMeetings(): Readonly<ConnectedMeetings>;
+    get recording(): Readonly<Recording>;
+    get livestream(): Readonly<Livestream>;
+    get stage(): Readonly<Stage>;
+    get stores(): Readonly<StoreManager>;
     get audio(): AudioPlaybackManager;
-    get __internals__(): Readonly<RTKInternals>;
+    get __internals__(): Readonly<Internals>;
     joinRoom(): Promise<void>;
     leaveRoom(state?: LeaveRoomState): Promise<void>;
 }
@@ -5857,35 +5995,37 @@ declare enum RequestToJoinType {
     PRESENT = "REQUEST_TO_PRESENT"
 }
 
-type RTKParticipant = Readonly<RTKParticipant$1>;
+type RTKConfigOptions = Omit<ControllerOptions, 'peerId'>;
+
+type RTKParticipant = Readonly<Participant>;
 
-type RTKParticipants = Readonly<RTKParticipants$1>;
-type RTKParticipantMap = Readonly<RTKParticipantMap$1>;
+type RTKParticipants = Readonly<Participants>;
+type RTKParticipantMap = Readonly<ParticipantMap>;
 
-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 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<RTKLivestream$1>;
+type RTKLivestream = Readonly<Livestream>;
 
-type RTKStore = RTKStore$1;
+type RTKStore = Store;
 
-type RTKConnectedMeetings = Readonly<RTKConnectedMeetings$1>;
+type RTKConnectedMeetings = Readonly<ConnectedMeetings>;
 
-type RTKPermissionsPreset = Readonly<RTKPermissionsPreset$1>;
-type RTKThemePreset = Readonly<RTKThemePreset$1>;
+type RTKPermissionsPreset = Readonly<PermissionPreset>;
+type RTKThemePreset = Readonly<ThemePreset>;
 
-type RTKLogger = RTKLogger$1;
+type RTKLogger = Logger;
 
-type RTKType = {
+type ClientType = {
     callStats?: unknown;
-    RTKTelemetry?: typeof RTKTelemetry;
+    Telemetry?: typeof Telemetry;
 };
 declare global {
     interface Navigator {
@@ -5896,12 +6036,12 @@ declare global {
         isReactNative?: boolean;
     }
     interface Window {
-        RTK?: RTKType;
-        FAST_DYTE?: boolean;
+        RTK?: ClientType;
+        FAST_RTK?: 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 };
+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 };