@cloudflare/realtimekit 1.2.0-staging.19 → 1.2.0-staging.20

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,1308 +2953,1234 @@ declare class RTKTypedEventEmitter<Events extends EventMap$1 & WildCardEvent<Eve
     listenerCount<T extends StringKeyOf<Events>>(event: T): number;
 }
 
-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]>;
+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[];
 }
 
-interface GenericHandlerResult {
-    offerSdp: RTCSessionDescriptionInit;
-    callback: (answer: RTCSessionDescriptionInit) => Promise<any>;
-    sender?: RTCRtpSender;
+type ChatChannelSocketMessage = GetChatChannelResponse;
+interface ChatChannel {
+    id: string;
+    displayName: string;
+    memberIds: string[];
+    displayPictureUrl?: string;
+    visibility?: string;
+    isDirectMessage?: boolean;
+    latestMessage?: Message;
+    unreadCount: number;
 }
-type HandlerRunOptions = {
-    direction: 'send' | 'recv';
-    iceServers?: RTCIceServer[];
-    iceTransportPolicy?: RTCIceTransportPolicy;
-    additionalSettings?: any;
-    proprietaryConstraints?: any;
-    onTrackHandler?: (event: RTCTrackEvent) => void;
-};
-type CodecOption = {
-    name: string;
-    parameters?: string[];
-};
-type HandlerSendOptions = {
-    track: MediaStreamTrack | 'audio' | 'video';
-    screenShare?: boolean;
-    encodings?: RTCRtpEncodingParameters[];
-    codecs?: RTCRtpCodecCapability[];
-    codecOptions?: CodecOption[];
-};
-interface HandlerSendResult extends GenericHandlerResult {
-    mid: string;
+interface UpdateChannelRequestPayload {
+    memberIds?: string[];
+    displayName?: string;
+    displayPictureUrl?: string;
+    visibility?: string;
 }
-declare abstract class HandlerInterface<TransportPromiseEvents> extends EnhancedEventEmitter<TransportPromiseEvents> {
-    pc: RTCPeerConnection;
-    enableHighBitrate: boolean;
-    enableStereo: boolean;
-    enableDtx: boolean;
-    get midTransceiverMap(): Map<string, RTCRtpTransceiver>;
-    abstract get name(): string;
-    close(): void;
-    restartIce(): Promise<GenericHandlerResult>;
-    init({ direction, iceServers, iceTransportPolicy, additionalSettings, proprietaryConstraints, onTrackHandler, }: HandlerRunOptions): void;
-    connect(): Promise<GenericHandlerResult>;
-    getTransportStats(): Promise<RTCStatsReport>;
-    getReceiverStats(localId: string): Promise<RTCStatsReport>;
-    stopSending(localId: string): Promise<GenericHandlerResult>;
-    abstract send(options: HandlerSendOptions): Promise<HandlerSendResult>;
-    replaceTrack(localId: string, track: MediaStreamTrack | null): Promise<void>;
-    setMaxSpatialLayer(localId: string, spatialLayer: number): Promise<void>;
-    setRtpEncodingParameters(localId: string, params: any): Promise<void>;
-    getSenderStats(localId: string): Promise<RTCStatsReport>;
-    _addEventListeners(): void;
-    addCustomEventListeners(): void;
+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;
 }
 
-type ConsumerOptions = {
-    id?: string;
-    producerId: string;
-    producingPeerId: string;
-    producingTransportId: string;
-    kind?: 'audio' | 'video';
-    paused?: boolean;
-    appData?: Record<string, unknown>;
-    mimeType?: string;
-    localId: string;
-    handler: HandlerInterface<TransportPromiseEvents>;
-    track?: MediaStreamTrack;
-    rtpReceiver?: RTCRtpReceiver;
-    transceiver: RTCRtpTransceiver;
-    closeTranscieverOnClose?: boolean;
-};
-type MediaKind$1 = 'audio' | 'video';
-declare class Consumer extends EnhancedEventEmitter<TransportPromiseEvents> {
-    readonly rtpReceiver: RTCRtpReceiver;
-    readonly id: string;
-    readonly localId: string;
-    readonly producerId: string;
-    readonly producingTransportId: string;
-    readonly mimeType: string;
-    readonly track: MediaStreamTrack;
-    readonly peerId: string;
-    readonly appData: Record<string, unknown>;
-    readonly transceiver: RTCRtpTransceiver;
-    constructor(context: Context<RTKContextState>, opts: ConsumerOptions);
-    get closed(): boolean;
-    get kind(): MediaKind$1;
-    get paused(): boolean;
-    close(reason?: string, closeTranscieverOnClose?: boolean): void;
-    getStats(): Promise<RTCStatsReport>;
-    pause(): void;
-    resume(): void;
+declare enum ChatMessageType {
+    TEXT = 0,
+    IMAGE = 1,
+    FILE = 2,
+    CUSTOM = 3
 }
-
-type DCMessage = {
-    type: string;
-    payload: Record<string, unknown>;
-};
-
-type TransportPromiseEvents = {
-    'close': {
-        answer: RTCSessionDescriptionInit;
-    };
-    'negotiate': {
-        description: RTCSessionDescriptionInit;
-    };
-};
-
-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<RTKContextState>, 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>;
+type ChatSocketMessage = SendChatMessageToRoomResponse | SendChatMessageToPeersResponse | EditChatMessageResponse | DeleteChatMessageResponse;
+interface SearchFilters {
+    channelId?: string;
+    timestamp?: number;
+    size?: number;
+    reversed?: boolean;
 }
-
-type StageSocketMessage = GetStageRequestsResponse | GetStagePeersResponse | DenyStageAccessRequest | PeerStatusUpdate;
-declare class StageSocketHandler {
-    constructor(socketService: SocketService);
-    getStageRequests(): Promise<GetStageRequestsResponse>;
-    requestAccess(): void;
-    cancelRequestAccess(): void;
-    grantAccess(userIds: string[]): Promise<void>;
-    denyAccess(userIds: string[]): Promise<void>;
-    joinStage(): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    leaveStage(userId: string): Promise<{
+declare class ChatSocketHandler {
+    get telemetry(): Telemetry;
+    get logger(): Logger;
+    constructor(context: Context<ContextState>, socketService: SocketService);
+    getChatMessages(): Promise<{
         id: string;
         payload: Uint8Array;
     }>;
-    kick(userIds: string[]): Promise<{
+    getChatMessagesPaginated(timeStamp: number, size: number, reversed: boolean, offset?: number, channelId?: string): Promise<GetPaginatedChatMessageRoomResponse>;
+    sendMessageToRoom(message: string, messageType: ChatMessageType): void;
+    sendMessageToPeers(message: string, messageType: ChatMessageType, peerIds: string[]): void;
+    sendMessageToChannel(message: string, messageType: ChatMessageType, channelId: string): void;
+    sendMessage(message: string, messageType: ChatMessageType, peerIds?: string[], channelId?: string): void;
+    editMessage(chatId: string, message: string, payloadType: ChatMessageType, channelId?: string, pinned?: boolean): Promise<ChatMessage>;
+    deleteMessage(chatId: string, channelId?: string): Promise<{
+        channelId?: string;
         id: string;
-        payload: Uint8Array;
     }>;
-    on(event: number, handler: (socketMessage: StageSocketMessage, messageId?: string) => void): void;
-    getPeerInfo(peerId: string): Promise<PeerInfoResponse>;
+    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;
 }
 
-type StageStatus = 'OFF_STAGE' | 'REQUESTED_TO_JOIN_STAGE' | 'ACCEPTED_TO_JOIN_STAGE' | 'ON_STAGE';
-interface StageRequestPayload {
-    displayName: string;
-    userId: string;
-    peerId: 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 StageEvents = {
-    ['stageAccessRequestUpdate']: (requests?: StageRequestPayload[]) => void;
-    ['stageStatusUpdate']: (status: StageStatus) => void;
-    ['newStageRequest']: (payload: {
-        count: number;
-    }) => void;
-    ['stageRequestApproved']: () => void;
-    ['stageRequestRejected']: () => void;
+
+type PipEvents = {
+    ['cameraToggled']: () => void;
+    ['micToggled']: () => void;
+    ['hangup']: () => void;
+    ['pipStarted']: () => void;
+    ['pipEnded']: () => void;
     ['*']: (eventName: string, ...args: any[]) => void;
 };
-declare class RTKStage extends RTKTypedEventEmitter<StageEvents> {
-    get telemetry(): RTKTelemetry;
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, participants: RTKParticipants, stageSocketHandler: StageSocketHandler, roomSocketHandler: RoomSocketHandler);
-    get status(): StageStatus;
-    getAccessRequests(): {
-        stageRequests: StageRequestPayload[];
+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 {
+    NEW = "new",
+    CONNECTING = "connecting",
+    RECONNECTING = "reconnecting",
+    DISCONNECTED = "disconnected",
+    CONNECTED = "connected",
+    FAILED = "failed",
+    CLOSED = "closed"
+}
+type MediaConnectionState = {
+    recv: {
+        state: `${TransportState}`;
     };
-    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<{
+    send: {
+        state: `${TransportState}`;
+    };
+};
+
+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'>>;
 }
 
-interface ResponseStatus {
-    success: boolean;
-    message: string;
+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 MediaPermission$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE' | 'CANCELED';
-
-declare const localMediaEvents: readonly ["AUDIO_TRACK_CHANGE", "VIDEO_TRACK_CHANGE", "SCREENSHARE_TRACK_CHANGE", "SCREENSHARE_ENDED", "AUDIO_TRACK_SILENT", "FORCE_MUTE_AUDIO", "FORCE_MUTE_VIDEO", "DEVICE_CHANGE", "DEVICE_LIST_UPDATED"];
-type LocalMediaEvents = (typeof localMediaEvents)[number];
-type ParticipantEvents = {
-    ['videoUpdate']: (payload: {
-        videoEnabled: boolean;
-        videoTrack: MediaStreamTrack;
-    }) => void;
-    ['audioUpdate']: (payload: {
-        audioEnabled: boolean;
-        audioTrack: MediaStreamTrack;
-    }) => void;
-    ['screenShareUpdate']: (payload: {
-        screenShareEnabled: boolean;
-        screenShareTracks: {
-            audio: MediaStreamTrack;
-            video: MediaStreamTrack;
-        };
-    }) => void;
-    ['pinned']: (payload: RTKParticipant) => void;
-    ['unpinned']: (payload: RTKParticipant) => void;
+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;
-        kind: string;
-    }) => void;
-    ['stageStatusUpdate']: (payload: RTKParticipant) => void;
-    ['mediaScoreUpdate']: (payload: {
-        kind: MediaKind$1;
-        isScreenshare: boolean;
-        score: number;
-        participantId: string;
-        scoreStats: ConsumerScoreStats;
-    }) => void;
-    ['kicked']: () => void;
-    ['*']: (event: string, ...args: any[]) => void;
-};
-type SelfEvents = {
-    ['toggleTile']: (payload: {
-        hidden: boolean;
-    }) => void;
-    ['videoUpdate']: (payload: {
-        videoEnabled: boolean;
-        videoTrack: MediaStreamTrack;
-    }) => void;
-    ['audioUpdate']: (payload: {
-        audioEnabled: boolean;
-        audioTrack: MediaStreamTrack;
-    }) => void;
-    ['screenShareUpdate']: (payload: {
-        screenShareEnabled: boolean;
-        screenShareTracks: {
-            audio?: MediaStreamTrack;
-            video?: MediaStreamTrack;
-        };
-    }) => void;
-    ['deviceUpdate']: ({ device }: {
-        device: MediaDeviceInfo;
-    }) => void;
-    ['deviceListUpdate']: (changedDevices: {
-        added: MediaDeviceInfo[];
-        removed: MediaDeviceInfo[];
-        devices: MediaDeviceInfo[];
-    }) => void;
-    ['pinned']: (payload: RTKSelf) => void;
-    ['unpinned']: (payload: RTKSelf) => void;
-    ['mediaPermissionUpdate']: (payload: {
-        message: keyof typeof MediaPermission;
-        kind: 'audio' | 'video' | 'screenshare';
-    }) => void;
-    ['mediaPermissionError']: (payload: {
-        message: keyof typeof MediaPermission;
-        constraints: any;
-        kind: 'audio' | 'video' | 'screenshare';
-    }) => void;
-    ['mediaScoreUpdate']: (payload: {
-        kind: MediaKind$1;
-        isScreenshare: boolean;
-        score: number;
-        participantId: string;
-        scoreStats: ProducerScoreStats;
-    }) => void;
-    ['waitlisted']: () => void;
-    ['roomLeft']: (payload: {
-        state: LeaveRoomState;
     }) => void;
-    ['roomJoined']: (payload: {
-        reconnected: boolean;
+    ['meetingStartTimeUpdate']: (payload: {
+        meetingStartedTimestamp: Date;
     }) => void;
-    ['autoplayError']: (error: Error) => 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;
+}
 
-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>;
+interface MapEvents<T extends EventMap$1> {
+    onAddEvent?: keyof T;
+    onDeleteEvent?: keyof T;
+    onClearEvent?: keyof T;
 }
-
-declare enum MediaPermission {
-    NOT_REQUESTED = 0,
-    ACCEPTED = 1,
-    DENIED = 2,
-    CANCELED = 3,
-    SYSTEM_DENIED = 4,
-    COULD_NOT_START = 5,
-    NO_DEVICES_AVAILABLE = 6
+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[];
 }
 
-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;
+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[];
+};
+type HandlerSendOptions = {
+    track: MediaStreamTrack | 'audio' | 'video';
+    screenShare?: boolean;
+    encodings?: RTCRtpEncodingParameters[];
+    codecs?: RTCRtpCodecCapability[];
+    codecOptions?: CodecOption[];
 };
+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;
+    get midTransceiverMap(): Map<string, RTCRtpTransceiver>;
+    abstract get name(): string;
+    close(): void;
+    restartIce(): Promise<GenericHandlerResult>;
+    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>;
+    replaceTrack(localId: string, track: MediaStreamTrack | null): Promise<void>;
+    setMaxSpatialLayer(localId: string, spatialLayer: number): Promise<void>;
+    setRtpEncodingParameters(localId: string, params: any): Promise<void>;
+    getSenderStats(localId: string): Promise<RTCStatsReport>;
+    _addEventListeners(): void;
+    addCustomEventListeners(): void;
+}
 
-type PresetMediaConstraints = PresetV2CamelCased['config']['media'];
-type AudioQualityConstraints = {
-    echoCancellation?: boolean;
-    noiseSupression?: boolean;
-    autoGainControl?: boolean;
-    enableStereo?: boolean;
-    enableHighBitrate?: boolean;
+type DCMessage = {
+    type: string;
+    payload: Record<string, unknown>;
 };
-type VideoQualityConstraints = {
-    width: {
-        ideal: number;
-    };
-    height: {
-        ideal: number;
+
+type TransportPromiseEvents = {
+    'close': {
+        answer: RTCSessionDescriptionInit;
     };
-    frameRate?: {
-        ideal: number;
+    'negotiate': {
+        description: RTCSessionDescriptionInit;
     };
 };
-type ScreenshareQualityConstraints = {
-    width?: {
-        max: number;
-    };
-    height?: {
-        max: number;
-    };
-    frameRate?: {
-        ideal: number;
-        max: number;
-    };
-    displaySurface?: 'window' | 'monitor' | 'browser';
-    selfBrowserSurface?: 'include' | 'exclude';
+
+type ConsumerOptions = {
+    id?: string;
+    producerId: string;
+    producingPeerId: string;
+    producingTransportId: string;
+    kind?: 'audio' | 'video';
+    paused?: boolean;
+    appData?: Record<string, unknown>;
+    mimeType?: string;
+    localId: string;
+    handler: HandlerInterface<TransportPromiseEvents>;
+    track?: MediaStreamTrack;
+    rtpReceiver?: RTCRtpReceiver;
+    transceiver: RTCRtpTransceiver;
+    closeTranscieverOnClose?: boolean;
 };
-interface RTKMediaTrackConstraints extends MediaTrackConstraints {
-    optional?: Array<object>;
-}
-interface RTKMediaStreamConstraints extends MediaStreamConstraints {
-    audio?: boolean | RTKMediaTrackConstraints;
+type MediaKind$1 = 'audio' | 'video';
+declare class Consumer extends EnhancedEventEmitter<TransportPromiseEvents> {
+    readonly rtpReceiver: RTCRtpReceiver;
+    readonly id: string;
+    readonly localId: string;
+    readonly producerId: string;
+    readonly producingTransportId: string;
+    readonly mimeType: string;
+    readonly track: MediaStreamTrack;
+    readonly peerId: string;
+    readonly appData: Record<string, unknown>;
+    readonly transceiver: RTCRtpTransceiver;
+    constructor(context: Context<ContextState>, opts: ConsumerOptions);
+    get closed(): boolean;
+    get kind(): MediaKind$1;
+    get paused(): boolean;
+    close(reason?: string, closeTranscieverOnClose?: boolean): void;
+    getStats(): Promise<RTCStatsReport>;
+    pause(): void;
+    resume(): void;
 }
-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;
+declare const localMediaEvents: readonly ["AUDIO_TRACK_CHANGE", "VIDEO_TRACK_CHANGE", "SCREENSHARE_TRACK_CHANGE", "SCREENSHARE_ENDED", "AUDIO_TRACK_SILENT", "FORCE_MUTE_AUDIO", "FORCE_MUTE_VIDEO", "DEVICE_CHANGE", "DEVICE_LIST_UPDATED"];
+type LocalMediaEvents = (typeof localMediaEvents)[number];
+type ParticipantEvents = {
+    ['videoUpdate']: (payload: {
+        videoEnabled: boolean;
+        videoTrack: MediaStreamTrack;
+    }) => void;
+    ['audioUpdate']: (payload: {
+        audioEnabled: boolean;
+        audioTrack: MediaStreamTrack;
+    }) => void;
+    ['screenShareUpdate']: (payload: {
+        screenShareEnabled: boolean;
+        screenShareTracks: {
+            audio: MediaStreamTrack;
+            video: MediaStreamTrack;
         };
-        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;
-                editCutoffTimeSeconds: number;
-            };
-        };
-        isRecorder?: boolean;
-        recorderType: RecorderType$1;
-        hiddenParticipant: boolean;
-        showParticipantList: boolean;
-        canChangeParticipantPermissions: boolean;
-        connectedMeetings: {
-            canAlterConnectedMeetings: boolean;
-            canSwitchConnectedMeetings: boolean;
-            canSwitchToParentMeeting: boolean;
-        };
-        acceptStageRequests?: boolean;
-        stageEnabled?: boolean;
-        stageAccess?: MediaProductionPermissionType;
-        transcriptionEnabled: boolean;
-    };
-    ui: {
-        designTokens: {
-            borderRadius: BorderRadius;
-            borderWidth: BorderWidth;
-            colors: {
-                brand: {
-                    300: string;
-                    400: string;
-                    500: string;
-                    600: string;
-                    700: string;
-                };
-                background: {
-                    600: string;
-                    700: string;
-                    800: string;
-                    900: string;
-                    1000: string;
-                };
-                danger: string;
-                success: string;
-                textOnBrand: string;
-                text: string;
-                videoBg: string;
-                warning: string;
-            };
-            fontFamily?: string;
-            googleFont?: string;
-            logo?: string;
-            spacingBase: number;
-            theme: Theme;
-        };
-        configDiff: any;
-    };
-    version?: string;
-    id?: string;
-    name?: string;
+    }) => void;
+    ['pinned']: (payload: Participant) => void;
+    ['unpinned']: (payload: Participant) => void;
+    ['poorConnection']: (payload: {
+        score: number;
+        kind: string;
+    }) => void;
+    ['stageStatusUpdate']: (payload: Participant) => void;
+    ['mediaScoreUpdate']: (payload: {
+        kind: MediaKind$1;
+        isScreenshare: boolean;
+        score: number;
+        participantId: string;
+        scoreStats: ConsumerScoreStats;
+    }) => void;
+    ['kicked']: () => void;
+    ['*']: (event: string, ...args: any[]) => void;
 };
-type MaxVideoStreams = PresetV2CamelCased['config']['maxVideoStreams'];
-declare class RTKThemePreset$1 {
-    private constructor();
-    static fromResponse(preset: PresetV2CamelCased): RTKThemePreset$1;
-    static default(): RTKThemePreset$1;
-    static init(preset?: PresetV2CamelCased, useDefault?: boolean): RTKThemePreset$1;
-    get setupScreen(): Readonly<{
-        isEnabled: boolean;
-    }>;
-    get waitingRoom(): Readonly<{
-        isEnabled: boolean;
-    }>;
-    get controlBar(): Readonly<{
-        isEnabled: boolean;
-        elements?: {
-            chat?: boolean;
-            fullscreen?: boolean;
-            invite?: boolean;
-            layout?: boolean;
-            participants?: boolean;
-            plugins?: boolean;
-            polls?: boolean;
-            reactions?: boolean;
-            screenshare?: boolean;
-        };
-    }>;
-    get header(): Readonly<{
-        isEnabled: boolean;
-        elements: {
-            logo: string;
-            timer: boolean;
-            title: boolean;
-            participantCount: boolean;
-            changeLayout: boolean;
+type SelfEvents = {
+    ['toggleTile']: (payload: {
+        hidden: boolean;
+    }) => void;
+    ['videoUpdate']: (payload: {
+        videoEnabled: boolean;
+        videoTrack: MediaStreamTrack;
+    }) => void;
+    ['audioUpdate']: (payload: {
+        audioEnabled: boolean;
+        audioTrack: MediaStreamTrack;
+    }) => void;
+    ['screenShareUpdate']: (payload: {
+        screenShareEnabled: boolean;
+        screenShareTracks: {
+            audio?: MediaStreamTrack;
+            video?: MediaStreamTrack;
         };
-    }>;
-    get pipMode(): Readonly<boolean>;
-    get viewType(): Readonly<ViewType>;
-    get livestreamViewerQualities(): Readonly<LivestreamViewerMediaQualityType[]>;
-    get maxVideoStreams(): Readonly<MaxVideoStreams>;
-    get maxScreenShareCount(): Readonly<number>;
-    get plugins(): Readonly<string[]>;
-    get disabledPlugins(): Readonly<string[]>;
-    get designTokens(): Readonly<PresetV2CamelCased['ui']['designTokens']>;
-    get configDiff(): Readonly<PresetV2CamelCased['ui']['configDiff']>;
-    get mediaConstraints(): Readonly<PresetMediaConstraints>;
-    get name(): string;
-}
-
-type PresetPermissions = PresetV2CamelCased['permissions'];
-type PermissionEvents = {
-    ['chatUpdate']: () => void;
-    ['pollsUpdate']: () => void;
-    ['pluginsUpdate']: () => void;
-    ['permissionsUpdate']: (patch: PresetUpdates) => void;
-    ['*']: () => void;
+    }) => void;
+    ['deviceUpdate']: ({ device }: {
+        device: MediaDeviceInfo;
+    }) => void;
+    ['deviceListUpdate']: (changedDevices: {
+        added: MediaDeviceInfo[];
+        removed: MediaDeviceInfo[];
+        devices: MediaDeviceInfo[];
+    }) => void;
+    ['pinned']: (payload: Self) => void;
+    ['unpinned']: (payload: Self) => void;
+    ['mediaPermissionUpdate']: (payload: {
+        message: keyof typeof MediaPermission;
+        kind: 'audio' | 'video' | 'screenshare';
+    }) => void;
+    ['mediaPermissionError']: (payload: {
+        message: keyof typeof MediaPermission;
+        constraints: any;
+        kind: 'audio' | 'video' | 'screenshare';
+    }) => void;
+    ['mediaScoreUpdate']: (payload: {
+        kind: MediaKind$1;
+        isScreenshare: boolean;
+        score: number;
+        participantId: string;
+        scoreStats: ProducerScoreStats;
+    }) => void;
+    ['waitlisted']: () => void;
+    ['roomLeft']: (payload: {
+        state: LeaveRoomState;
+    }) => void;
+    ['roomJoined']: (payload: {
+        reconnected: boolean;
+    }) => void;
+    ['autoplayError']: (error: Error) => void;
+    ['*']: (event: string, ...args: any[]) => void;
 };
-declare class RTKPermissionsPreset$1 extends RTKTypedEventEmitter<PermissionEvents> {
-    private constructor();
-    static fromResponse(response: PresetPermissions, viewType: ViewType, context: Context<RTKContextState>): RTKPermissionsPreset$1;
-    static default(context: Context<RTKContextState>, viewType: ViewType): RTKPermissionsPreset$1;
-    static init(context: Context<RTKContextState>, viewType: ViewType, response?: PresetPermissions): RTKPermissionsPreset$1;
-    get mediaRoomType(): string;
-    get stageEnabled(): Readonly<boolean>;
-    get acceptStageRequests(): Readonly<boolean>;
-    get stageAccess(): Readonly<MediaProductionPermissionType>;
-    get acceptWaitingRequests(): Readonly<boolean>;
-    get requestProduceVideo(): Readonly<boolean>;
-    get requestProduceAudio(): Readonly<boolean>;
-    get requestProduceScreenshare(): Readonly<boolean>;
-    get canAllowParticipantAudio(): Readonly<boolean>;
-    get canAllowParticipantScreensharing(): Readonly<boolean>;
-    get canAllowParticipantVideo(): Readonly<boolean>;
-    get canDisableParticipantAudio(): Readonly<boolean>;
-    get canDisableParticipantVideo(): Readonly<boolean>;
-    get kickParticipant(): Readonly<boolean>;
-    get pinParticipant(): Readonly<boolean>;
-    get canRecord(): Readonly<boolean>;
-    get waitingRoomType(): Readonly<WaitingRoomTypes>;
-    get waitingRoomBehaviour(): Readonly<WaitingRoomTypes>;
-    get plugins(): Readonly<PresetPermissions['plugins']>;
-    get polls(): Readonly<PresetPermissions['polls']>;
-    get produceVideo(): Readonly<MediaProductionPermissionType>;
-    get requestProduce(): Readonly<boolean>;
-    get canProduceVideo(): Readonly<MediaProductionPermissionType>;
-    get produceScreenshare(): Readonly<MediaProductionPermissionType>;
-    get canProduceScreenshare(): Readonly<MediaProductionPermissionType>;
-    get produceAudio(): Readonly<MediaProductionPermissionType>;
-    get canProduceAudio(): Readonly<MediaProductionPermissionType>;
-    get chatPublic(): Readonly<PresetPermissions['chat']['public']>;
-    get chatPrivate(): Readonly<PresetPermissions['chat']['private']>;
-    get chatChannel(): Readonly<PresetPermissions['chat']['channel']>;
-    get chatMessage(): Readonly<PresetPermissions['chat']['message']>;
-    get connectedMeetings(): Readonly<PresetPermissions['connectedMeetings']>;
-    get hiddenParticipant(): Readonly<boolean>;
-    get showParticipantList(): Readonly<boolean>;
-    get canChangeParticipantRole(): Readonly<boolean>;
-    get canChangeParticipantPermissions(): Readonly<boolean>;
-    get canChangeTheme(): Readonly<boolean>;
-    get canPresent(): Readonly<boolean>;
-    get acceptPresentRequests(): Readonly<boolean>;
-    get canEditDisplayName(): Readonly<boolean>;
-    get maxScreenShareCount(): Readonly<number>;
-    get isRecorder(): Readonly<boolean>;
-    get canSpotlight(): Readonly<boolean>;
-    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>;
+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 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;
+
+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;
     }>;
-    setVideoMiddlewareGlobalConfig(config?: VideoMiddlewareGlobalConfig): Promise<void>;
-    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
-        success: boolean;
-        message: string;
+    leaveStage(userId: string): Promise<{
+        id: string;
+        payload: Uint8Array;
     }>;
-    removeAllVideoMiddlewares(): Promise<{
-        success: boolean;
-        message: string;
+    kick(userIds: string[]): Promise<{
+        id: string;
+        payload: Uint8Array;
     }>;
-    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>;
+    on(event: number, handler: (socketMessage: StageSocketMessage, messageId?: string) => void): void;
+    getPeerInfo(peerId: string): Promise<PeerInfoResponse>;
 }
 
-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;
+type StageStatus = 'OFF_STAGE' | 'REQUESTED_TO_JOIN_STAGE' | 'ACCEPTED_TO_JOIN_STAGE' | 'ON_STAGE';
+interface StageRequestPayload {
+    displayName: string;
     userId: string;
-    organizationId: string;
-    supportsRemoteControl: boolean;
-    device: DeviceConfig;
-    get telemetry(): RTKTelemetry;
-    hidden: boolean;
-    get stageStatus(): StageStatus;
-    get producers(): Producer[];
-    get id(): string;
+    peerId: string;
+}
+type StageEvents = {
+    ['stageAccessRequestUpdate']: (requests?: StageRequestPayload[]) => void;
+    ['stageStatusUpdate']: (status: StageStatus) => void;
+    ['newStageRequest']: (payload: {
+        count: number;
+    }) => void;
+    ['stageRequestApproved']: () => void;
+    ['stageRequestRejected']: () => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
+};
+declare class Stage extends TypedEventEmitter$1<StageEvents> {
+    get telemetry(): Telemetry;
+    constructor(context: Context<ContextState>, self: Self, participants: Participants, stageSocketHandler: StageSocketHandler, roomSocketHandler: RoomSocketHandler);
+    get status(): StageStatus;
+    private setupEvents;
+    getAccessRequests(): {
+        stageRequests: StageRequestPayload[];
+    };
+    requestAccess(): Promise<void>;
+    cancelRequestAccess(): Promise<void>;
+    grantAccess(userIds: string[]): Promise<void>;
+    denyAccess(userIds: string[]): Promise<void>;
     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;
+    join(): Promise<void>;
+    leave(): Promise<void>;
+    kick(userIds: string[]): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
 }
 
-interface RTKBasicParticipant {
-    userId: string;
-    name?: string;
-    picture?: string;
-    customParticipantId: string;
+declare const modes: readonly ["ACTIVE_GRID", "PAGINATED", "MANUAL"];
+type ViewMode = (typeof modes)[number];
+interface BroadcastMessagePayload {
+    [key: string]: boolean | number | string | Date | ActiveTab;
 }
-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[];
+interface PeerProducerConfig {
+    audio: boolean;
+    video: boolean;
+    screenshareAudio: boolean;
+    screenshareVideo: boolean;
 }
-
-type ChatChannelSocketMessage = GetChatChannelResponse;
-interface ChatChannel {
+type BroadcastMessageTarget = {
+    participantIds: string[];
+} | {
+    presetNames: string[];
+} | {
+    meetingIds: string[];
+};
+type JoinedPeer = {
     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;
+    userId: string;
+    name: string;
+    stageType?: StageStatus;
+    customParticipantId?: string;
+    presetId?: string;
+    picture?: string;
+    waitlisted: boolean;
+    recorderType?: string;
+    stageStatus?: StageStatus;
+    metadata?: {
+        preset_name?: string;
+    };
+    flags?: {
+        hiddenParticipant?: boolean;
+        recorder?: boolean;
+    };
+};
+type ParticipantsEvents = {
+    ['viewModeChanged']: (payload: {
+        viewMode: string;
+        currentPage: number;
+        pageCount: number;
+    }) => void;
+    ['activeSpeaker']: (payload: {
+        peerId: string;
+        volume: number;
+    }) => void;
+    ['broadcastedMessage']: (payload: {
+        type: string;
+        payload: BroadcastMessagePayload;
+        timestamp: number;
+    }) => void;
+    ['poorConnection']: (payload: {
+        participantId: string;
+        score: number;
+        kind: string;
+    }) => void;
+    ['pageChanged']: (payload: {
+        viewMode: string;
+        currentPage: number;
+        pageCount: number;
+    }) => void;
+    ['mediaScoreUpdate']: (payload: {
+        kind: string;
+        isScreenshare: boolean;
+        score: number;
+        participantId: string;
+        scoreStats: ConsumerScoreStats;
+    }) => void;
+    ['media_decode_error']: (payload: {
+        reason: string;
+        code: '1702' | '1703';
+    }) => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+declare class Participants extends TypedEventEmitter$1<ParticipantsEvents> {
+    readonly waitlisted: Readonly<ParticipantMap<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;
+    };
+    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;
+        };
+        recorderType: string;
+        flags: {
+            hiddenParticipant: boolean;
+            hidden_participant: boolean;
+            recorder: boolean;
+        };
+    }[]>;
+    updatePermissions(participantIds: string[], permissions: PresetUpdates): Promise<void>;
+    getParticipantsInMeetingPreJoin(): Promise<RoomPeersInfoResponse>;
 }
 
-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;
+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>;
 }
-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;
+interface FetchResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    config: FetchRequestConfig;
 }
-
-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[];
+declare class FetchClient {
+    defaults: {
+        baseURL: string;
+        headers: {
+            common: Record<string, string>;
+        };
+        timeout: number;
+        retry: number;
+        retryDelay: number;
+    };
+    constructor(options: {
+        baseURL: string;
+        timeout: number;
+        retry: number;
+        retryDelay: number;
+        responseType?: string;
+    });
+    private buildURL;
+    request<T = any>(config: FetchRequestConfig): Promise<FetchResponse<T>>;
+    get<T = any>(url: string, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
+    post<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
+    put<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
 }
 
-type PipEvents = {
-    ['cameraToggled']: () => void;
-    ['micToggled']: () => void;
-    ['hangup']: () => void;
-    ['pipStarted']: () => void;
-    ['pipEnded']: () => void;
-    ['*']: (eventName: string, ...args: any[]) => void;
-};
-declare class RTKPip extends RTKTypedEventEmitter<PipEvents> {
-    private constructor();
-    static _init(context: Context<RTKContextState>, self: RTKSelf$1): Promise<RTKPip>;
-    overrideIcon(icon: 'handRaise' | 'pin', value: string): Promise<void>;
-    isSupported(): boolean;
-    get isActive(): boolean;
-    init({ height, width }?: {
-        height?: number;
-        width?: number;
-    }): void;
-    enableSource(source: string): void;
-    disableSource(source: string): void;
-    addSource(id: string, element: HTMLVideoElement, enabled: boolean, pinned?: boolean, displayText?: string, imageUrl?: string, handRaised?: boolean): void;
-    updateSource(id: string, source: any): void;
-    removeSource(id: string): void;
-    removePinnedSource(): void;
-    removeAllSources(): void;
-    enable(): void;
-    disable: (partial?: boolean) => void;
+interface ResponseStatus {
+    success: boolean;
+    message: string;
 }
 
-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 MediaPermission$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE' | 'CANCELED';
 
-declare enum TransportState {
-    NEW = "new",
-    CONNECTING = "connecting",
-    RECONNECTING = "reconnecting",
-    DISCONNECTED = "disconnected",
-    CONNECTED = "connected",
-    FAILED = "failed",
-    CLOSED = "closed"
-}
-type MediaConnectionState = {
-    recv: {
-        state: `${TransportState}`;
+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;
     };
-    send: {
-        state: `${TransportState}`;
+    get permissions(): {
+        audio?: MediaPermission$1;
+        video?: MediaPermission$1;
+        screenshare?: MediaPermission$1;
     };
-};
-
-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;
+    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>;
 }
 
-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[];
+declare enum MediaPermission {
+    NOT_REQUESTED = 0,
+    ACCEPTED = 1,
+    DENIED = 2,
+    CANCELED = 3,
+    SYSTEM_DENIED = 4,
+    COULD_NOT_START = 5,
+    NO_DEVICES_AVAILABLE = 6
 }
 
-type ParticipantMapEvents = {
-    ['participantJoined']: (payload: RTKParticipant$1) => void;
-    ['participantLeft']: (payload: RTKParticipant$1) => void;
-    ['participantsCleared']: () => void;
-    ['participantsUpdate']: () => void;
-    ['kicked']: (payload: {
-        id: string;
-    }) => void;
+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;
 };
-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 PresetMediaConstraints = PresetV2CamelCased['config']['media'];
+type AudioQualityConstraints = {
+    echoCancellation?: boolean;
+    noiseSupression?: boolean;
+    autoGainControl?: boolean;
+    enableStereo?: boolean;
+    enableHighBitrate?: boolean;
 };
-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;
+type VideoQualityConstraints = {
+    width: {
+        ideal: number;
     };
-    flags?: {
-        hiddenParticipant?: boolean;
-        recorder?: boolean;
+    height: {
+        ideal: number;
+    };
+    frameRate?: {
+        ideal: number;
     };
 };
-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 ScreenshareQualityConstraints = {
+    width?: {
+        max: number;
+    };
+    height?: {
+        max: number;
+    };
+    frameRate?: {
+        ideal: number;
+        max: number;
+    };
+    displaySurface?: 'window' | 'monitor' | 'browser';
+    selfBrowserSurface?: 'include' | 'exclude';
 };
-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;
+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;
+                editCutoffTimeSeconds: number;
+            };
+        };
+        isRecorder?: boolean;
+        recorderType: RecorderType$1;
+        hiddenParticipant: boolean;
+        showParticipantList: boolean;
+        canChangeParticipantPermissions: boolean;
+        connectedMeetings: {
+            canAlterConnectedMeetings: boolean;
+            canSwitchConnectedMeetings: boolean;
+            canSwitchToParentMeeting: boolean;
+        };
+        acceptStageRequests?: boolean;
+        stageEnabled?: boolean;
+        stageAccess?: MediaProductionPermissionType;
+        transcriptionEnabled: boolean;
     };
-    get rateLimits(): {
-        maxInvocations: number;
-        period: number;
+    ui: {
+        designTokens: {
+            borderRadius: BorderRadius;
+            borderWidth: BorderWidth;
+            colors: {
+                brand: {
+                    300: string;
+                    400: string;
+                    500: string;
+                    600: string;
+                    700: string;
+                };
+                background: {
+                    600: string;
+                    700: string;
+                    800: string;
+                    900: string;
+                    1000: string;
+                };
+                danger: string;
+                success: string;
+                textOnBrand: string;
+                text: string;
+                videoBg: string;
+                warning: string;
+            };
+            fontFamily?: string;
+            googleFont?: string;
+            logo?: string;
+            spacingBase: number;
+            theme: Theme;
+        };
+        configDiff: any;
     };
-    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;
+    version?: string;
+    id?: string;
+    name?: string;
+};
+type MaxVideoStreams = PresetV2CamelCased['config']['maxVideoStreams'];
+declare class ThemePreset {
+    private constructor();
+    static fromResponse(preset: PresetV2CamelCased): ThemePreset;
+    static default(): ThemePreset;
+    static init(preset?: PresetV2CamelCased, useDefault?: boolean): ThemePreset;
+    get setupScreen(): Readonly<{
+        isEnabled: boolean;
+    }>;
+    get waitingRoom(): Readonly<{
+        isEnabled: boolean;
+    }>;
+    get controlBar(): Readonly<{
+        isEnabled: boolean;
+        elements?: {
+            chat?: boolean;
+            fullscreen?: boolean;
+            invite?: boolean;
+            layout?: boolean;
+            participants?: boolean;
+            plugins?: boolean;
+            polls?: boolean;
+            reactions?: boolean;
+            screenshare?: boolean;
         };
-        recorderType: string;
-        flags: {
-            hiddenParticipant: boolean;
-            hidden_participant: boolean;
-            recorder: boolean;
+    }>;
+    get header(): Readonly<{
+        isEnabled: boolean;
+        elements: {
+            logo: string;
+            timer: boolean;
+            title: boolean;
+            participantCount: boolean;
+            changeLayout: boolean;
         };
-    }[]>;
-    updatePermissions(participantIds: string[], permissions: PresetUpdates): Promise<void>;
-    getParticipantsInMeetingPreJoin(): Promise<RoomPeersInfoResponse>;
+    }>;
+    get pipMode(): Readonly<boolean>;
+    get viewType(): Readonly<ViewType>;
+    get livestreamViewerQualities(): Readonly<LivestreamViewerMediaQualityType[]>;
+    get maxVideoStreams(): Readonly<MaxVideoStreams>;
+    get maxScreenShareCount(): Readonly<number>;
+    get plugins(): Readonly<string[]>;
+    get disabledPlugins(): Readonly<string[]>;
+    get designTokens(): Readonly<PresetV2CamelCased['ui']['designTokens']>;
+    get configDiff(): Readonly<PresetV2CamelCased['ui']['configDiff']>;
+    get mediaConstraints(): Readonly<PresetMediaConstraints>;
+    get name(): string;
 }
 
-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>;
+type PresetPermissions = PresetV2CamelCased['permissions'];
+type PermissionEvents = {
+    ['chatUpdate']: () => void;
+    ['pollsUpdate']: () => void;
+    ['pluginsUpdate']: () => void;
+    ['permissionsUpdate']: (patch: PresetUpdates) => void;
+    ['*']: () => void;
+};
+declare class PermissionPreset extends TypedEventEmitter$1<PermissionEvents> {
+    private constructor();
+    private setupEvents;
+    static fromResponse(response: PresetPermissions, viewType: ViewType, context: Context<ContextState>): PermissionPreset;
+    static default(context: Context<ContextState>, viewType: ViewType): PermissionPreset;
+    static init(context: Context<ContextState>, viewType: ViewType, response?: PresetPermissions): PermissionPreset;
+    get mediaRoomType(): string;
+    get stageEnabled(): Readonly<boolean>;
+    get acceptStageRequests(): Readonly<boolean>;
+    get stageAccess(): Readonly<MediaProductionPermissionType>;
+    get acceptWaitingRequests(): Readonly<boolean>;
+    get requestProduceVideo(): Readonly<boolean>;
+    get requestProduceAudio(): Readonly<boolean>;
+    get requestProduceScreenshare(): Readonly<boolean>;
+    get canAllowParticipantAudio(): Readonly<boolean>;
+    get canAllowParticipantScreensharing(): Readonly<boolean>;
+    get canAllowParticipantVideo(): Readonly<boolean>;
+    get canDisableParticipantAudio(): Readonly<boolean>;
+    get canDisableParticipantVideo(): Readonly<boolean>;
+    get kickParticipant(): Readonly<boolean>;
+    get pinParticipant(): Readonly<boolean>;
+    get canRecord(): Readonly<boolean>;
+    get waitingRoomType(): Readonly<WaitingRoomTypes>;
+    get waitingRoomBehaviour(): Readonly<WaitingRoomTypes>;
+    get plugins(): Readonly<PresetPermissions['plugins']>;
+    get polls(): Readonly<PresetPermissions['polls']>;
+    get produceVideo(): Readonly<MediaProductionPermissionType>;
+    get requestProduce(): Readonly<boolean>;
+    get canProduceVideo(): Readonly<MediaProductionPermissionType>;
+    get produceScreenshare(): Readonly<MediaProductionPermissionType>;
+    get canProduceScreenshare(): Readonly<MediaProductionPermissionType>;
+    get produceAudio(): Readonly<MediaProductionPermissionType>;
+    get canProduceAudio(): Readonly<MediaProductionPermissionType>;
+    get chatPublic(): Readonly<PresetPermissions['chat']['public']>;
+    get chatPrivate(): Readonly<PresetPermissions['chat']['private']>;
+    get chatChannel(): Readonly<PresetPermissions['chat']['channel']>;
+    get chatMessage(): Readonly<PresetPermissions['chat']['message']>;
+    get connectedMeetings(): Readonly<PresetPermissions['connectedMeetings']>;
+    get hiddenParticipant(): Readonly<boolean>;
+    get showParticipantList(): Readonly<boolean>;
+    get canChangeParticipantRole(): Readonly<boolean>;
+    get canChangeParticipantPermissions(): Readonly<boolean>;
+    get canChangeTheme(): Readonly<boolean>;
+    get canPresent(): Readonly<boolean>;
+    get acceptPresentRequests(): Readonly<boolean>;
+    get canEditDisplayName(): Readonly<boolean>;
+    get maxScreenShareCount(): Readonly<number>;
+    get isRecorder(): Readonly<boolean>;
+    get canSpotlight(): Readonly<boolean>;
+    get canLivestream(): Readonly<boolean>;
+    get transcriptionEnabled(): Readonly<boolean>;
 }
-interface FetchResponse<T = any> {
-    data: T;
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    config: FetchRequestConfig;
+
+interface UserDetailsResponseV2 {
+    participant: UserDetailsResponse;
+    preset: PresetV2CamelCased;
 }
-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>>;
+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';
@@ -4192,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>;
@@ -4233,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;
@@ -4315,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;
@@ -4336,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>;
@@ -4364,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<{
@@ -4489,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;
@@ -4528,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;
@@ -4573,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: {
@@ -4597,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';
@@ -4620,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;
@@ -4694,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;
@@ -4725,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;
@@ -4757,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 {
@@ -4783,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>, options: MediaNodeClientOptions);
+    get telemetry(): Telemetry;
+    get logger(): Logger;
+    constructor(context: Context<ContextState>, options: MediaNodeClientOptions);
     get mediaJoined(): boolean;
     set mediaJoined(joined: boolean);
     reset(): void;
@@ -4905,7 +5001,7 @@ declare class ConnectedMeetingsSocketHandler {
 }
 
 type ConnectedMeetingsEvents = {
-    ['meetingChanged']: (meeting: RealtimeKitClient) => void;
+    ['meetingChanged']: (meeting: Client) => void;
     ['stateUpdate']: (payload: {
         meetings: ConnectedMeeting[];
         parentMeeting: ConnectedMeeting;
@@ -4913,12 +5009,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[];
@@ -4953,6 +5050,7 @@ declare class RTKConnectedMeetings$1 extends RTKTypedEventEmitter<ConnectedMeeti
         success: boolean;
         error: any;
     }>;
+    private moveSuccessHandler;
 }
 
 interface Modules {
@@ -4989,7 +5087,7 @@ interface DefaultOptions {
     video?: boolean;
     audio?: boolean;
     recording?: RecordingConfig;
-    mediaHandler?: RTKSelfMedia$1;
+    mediaHandler?: SelfMedia;
     autoSwitchAudioDevice?: boolean;
     mediaConfiguration?: {
         video?: VideoQualityConstraints;
@@ -5003,6 +5101,9 @@ interface RoomDetails {
     meetingTitle: string;
     useHiveMedia: boolean;
 }
+interface ControllerOptions {
+    peerId?: string;
+}
 
 declare class ConnectionHandler {
     mediaJoined: boolean;
@@ -5013,7 +5114,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;
 }
 
@@ -5106,9 +5207,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 = {
@@ -5211,7 +5312,7 @@ type TypedEvents = {
         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;
@@ -5246,12 +5347,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;
@@ -5264,7 +5365,7 @@ type RTKContextState = {
     meetingId?: string;
     roomName?: string;
     socketService?: SocketService;
-    pip?: RTKPip;
+    pip?: Pip;
     roomNodeClient?: MediaNodeClient;
     viewType?: ViewType;
     env?: ClientEnvTypeAll;
@@ -5278,11 +5379,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>> {
@@ -5294,107 +5395,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 {
@@ -5414,7 +5524,7 @@ interface ProducerState {
     mimeType?: string;
     consumer?: Partial<Consumer>;
 }
-interface Participant {
+interface IParticipant {
     id: string;
     userId: string;
     displayName: string;
@@ -5437,7 +5547,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;
@@ -5463,22 +5573,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): {
@@ -5501,7 +5613,7 @@ type LogData$2 = {
     };
     devices?: string | MediaDeviceInfo[];
     debuggingHint?: string;
-    constraints?: string | RTKMediaStreamConstraints;
+    constraints?: string | ClientMediaStreamConstraints;
     timeout?: number;
     execTime?: number;
     country?: string;
@@ -5565,7 +5677,7 @@ type LogData$2 = {
             property: string;
         };
     };
-    dyteClientInitOptions?: RealtimeKitClientOptions;
+    clientInitOptions?: ClientOptions;
     plugin?: {
         id?: string;
         name?: string;
@@ -5662,15 +5774,15 @@ 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;
     };
@@ -5719,7 +5831,7 @@ type LogData$2 = {
     performanceObserver?: {
         api: PerformanceEntry;
     };
-    dyteLocker?: {
+    locker?: {
         methodName: string;
         lockName: string;
     };
@@ -5764,7 +5876,7 @@ interface MeetingMetadata {
     visitedUrl?: string;
     userId?: string;
 }
-declare class RTKTelemetry {
+declare class Telemetry {
     logsCache: {
         [key: string]: any;
     }[];
@@ -5779,7 +5891,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;
@@ -5789,9 +5901,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;
@@ -5807,7 +5919,7 @@ interface IceServerInformation {
 }
 interface CachedUserDetails {
     peerId?: string;
-    pluginInformation: RTKPluginResponse[];
+    pluginInformation: PluginResponse[];
     userDetails: UserDetailsResponseV2;
     roomDetails: RoomDetails;
     iceServers: IceServerInformation[];
@@ -5822,10 +5934,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;
@@ -5844,40 +5966,41 @@ interface Overrides {
     forceRelay?: boolean;
     [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>;
 }
@@ -5886,35 +6009,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 {
@@ -5925,12 +6050,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, 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 };