@cloudflare/realtimekit 1.1.0-staging.12 → 1.1.0-staging.17

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

@@ -1,73 +1,9 @@
 /// <reference types="node" />
-import EventEmitter$1, { EventEmitter } from 'events';
-import { MessageType as MessageType$1 } from '@protobuf-ts/runtime';
 import * as _dyteinternals_utils from '@dyteinternals/utils';
-import { ViewType, createNewFlagsmithInstance, PresetTypeV2, MediaVideoQualityType, LivestreamViewerMediaQualityType, MediaProductionPermissionType, WaitingRoomTypes, MediaScreenShareQualityType, PluginAccessControls, RecorderType as RecorderType$1, BorderRadius, BorderWidth, Theme } from '@dyteinternals/utils';
+import { MediaVideoQualityType, ViewType, LivestreamViewerMediaQualityType, MediaProductionPermissionType, WaitingRoomTypes, createNewFlagsmithInstance, PresetTypeV2, MediaScreenShareQualityType, PluginAccessControls, RecorderType as RecorderType$1, BorderRadius, BorderWidth, Theme } 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';
-declare global {
-    interface SymbolConstructor {
-        readonly observable: symbol;
-    }
-}
-/**
-Get keys of the given type as strings.
-
-Number keys are converted to strings.
-
-Use-cases:
-- Get string keys from a type which may have number keys.
-- Makes it possible to index using strings retrieved from template types.
-
-@example
-```
-import type {StringKeyOf} from 'type-fest';
-
-type Foo = {
-    1: number,
-    stringKey: string,
-};
-
-type StringKeysOfFoo = StringKeyOf<Foo>;
-//=> '1' | 'stringKey'
-```
-
-@category Object
-*/
-type StringKeyOf<BaseType> = string;
-declare class RTKEventEmitter<T extends string | symbol> extends EventEmitter {
-    constructor();
-    emit(event: T, ...args: any[]): boolean;
-    on(event: T, callback: (...args: any[]) => void): this;
-    addListener(event: T, callback: (...args: any[]) => any): this;
-    off(event: T, callback: (...args: any[]) => any): this;
-    once(event: T, callback: (...args: any[]) => any): this;
-    prependListener(event: T, callback: (...args: any[]) => any): this;
-    prependOnceListener(event: T, callback: (...args: any[]) => any): this;
-    removeListener(event: T, callback: (...args: any[]) => any): this;
-    removeAllListeners(event?: T): this;
-    listeners(event: T): Function[];
-    listenerCount(event: T): number;
-}
-type EventMap$1 = {
-    [key: string]: (...args: any[]) => void;
-};
-type WildCardEvent<T> = {
-    ['*']: (event: StringKeyOf<T>, ...args: any) => void;
-};
-declare class RTKTypedEventEmitter<Events extends EventMap$1 & WildCardEvent<Events>> extends EventEmitter {
-    constructor();
-    emit<E extends StringKeyOf<Events>>(event: E, ...args: Parameters<Events[E]>): boolean;
-    on<E extends StringKeyOf<Events>>(event: E, callback: Events[E]): this;
-    addListener<E extends StringKeyOf<Events>>(event: E, callback: Events[E]): this;
-    off<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
-    once<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
-    prependListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
-    prependOnceListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
-    removeListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
-    removeAllListeners<T extends StringKeyOf<Events>>(event?: T): this;
-    listeners<T extends StringKeyOf<Events>>(event: T): Function[];
-    listenerCount<T extends StringKeyOf<Events>>(event: T): number;
-}
 /**
  * protolint:disable ENUM_FIELD_NAMES_PREFIX
  *
@@ -2599,7 +2535,7 @@ interface IVSPlayerLiveLatencyEntry extends EventEntryBase {
     metaData: IVSPlayerLiveLatencyData;
 }
 type EventEntry = CallJoinBeginEntry | NetworkQualityTestBeginEntry | NetworkQualityTestEndEntry | BrowserForegroundedEntry | PingStatsEntry | PreCallTestBeginEntry | PreCallTestCompletedEntry | WebSocketConnectedEntry | TransportConnectedEntry | AudioToggleEntry | VideoToggleEntry | ScreenShareToggleEntry | DisconnectEntry | ReconnectEntry | ParticipantRoleToggleEntry | DominantSpeakerEntry | DevicesEntry | SelectedDeviceEntry | MediaPermissionEntry | MediaPlaybackFailureEntry | MediaTrackFailureEntry | ScreenShareRequestedEntry | ExpectedVideoResolutionEntry | ExpectedScreenshareResolutionEntry | TabChangeEntry | BrowserBackgroundedEntry | LegacySwitchEntry | IVSPlayerRebufferingEntry | IVSPlayerAudioBlockedEntry | IVSPlayerPlaybackBlockedEntry | IVSPlayerNetworkUnavailableEntry | IVSPlayerInitializedEntry | IVSPlayerErrorEntry | IVSPlayerRecoverableErrorEntry | IVSPlayerAnalyticsEventEntry | IVSPlayerLiveLatencyEntry | IVSPlayerPlaybackRateChangedEntry | IVSPlayerQualityChangedEntry | IVSPlayerWorkerErrorEntry;
-declare class EventHandler extends EventEmitter$1 {
+declare class EventHandler extends EventEmitter {
     constructor({ logger, peerId, apiHostnames, }: {
         logger: RTKLogger$2;
         peerId: string;
@@ -2629,8 +2565,8 @@ declare class ParsedRTCStats {
     staleProducerStreamMap: boolean;
     staleConsumerStreamMap: boolean;
 }
-declare abstract class Measurements extends EventEmitter$1 {
-    observer: EventEmitter$1;
+declare abstract class Measurements extends EventEmitter {
+    observer: EventEmitter;
     outboundProducerMap: Map<string, string>;
     inboundConsumerMap: Map<string, string>;
     consumerPeerIdMap: Map<string, {
@@ -2721,8 +2657,8 @@ declare abstract class Measurements extends EventEmitter$1 {
     getNetworkQuality(iceServers: IceServerInfo[]): Promise<NetworkQualityInformation>;
     getNetworkInfo(iceServers: IceServerInfo[], skipConnectivityChecks?: boolean): Promise<NetworkInformation | NetworkInformationWithoutConnectivityData>;
 }
-declare class CallStats extends EventEmitter$1 {
-    observer: EventEmitter$1;
+declare class CallStats extends EventEmitter {
+    observer: EventEmitter;
     eventHandler: EventHandler;
     producers: Map<string, any>;
     logger: RTKLogger$2;
@@ -2791,7 +2727,7 @@ declare class CallStats extends EventEmitter$1 {
     expectedVideoResolution(frameWidth: number, frameHeight: number, timestamp: Date): void;
     expectedScreenshareResolution(frameWidth: number, frameHeight: number, timestamp: Date): void;
 }
-declare class InhouseCallStats extends EventEmitter$1 {
+declare class InhouseCallStats extends EventEmitter {
     stats: any;
     peerId: string;
     backend: CallStats;
@@ -2845,164 +2781,140 @@ declare class InhouseCallStats extends EventEmitter$1 {
     expectedVideoResolution(frameWidth: number, frameHeight: number): void;
     expectedScreenshareResolution(frameWidth: number, frameHeight: number): void;
 }
-interface RTKBasicParticipant {
-    userId: string;
-    name?: string;
-    picture?: string;
-    customParticipantId: string;
-}
-declare class RTKBasicParticipantsMap extends RTKEventEmitter<'participantsUpdate'> {
-    constructor();
-    __set(objId: string, obj: RTKBasicParticipant): Map<string, RTKBasicParticipant>;
-    __clear(): void;
-    get(objId: string): RTKBasicParticipant;
-    toArray(): RTKBasicParticipant[];
-}
-type ChatChannelSocketMessage = GetChatChannelResponse;
-interface ChatChannel {
-    id: string;
-    displayName: string;
-    memberIds: string[];
-    displayPictureUrl?: string;
-    visibility?: string;
-    isDirectMessage?: boolean;
-    latestMessage?: Message;
-    unreadCount: number;
-}
-interface UpdateChannelRequestPayload {
-    memberIds?: string[];
-    displayName?: string;
-    displayPictureUrl?: string;
-    visibility?: string;
-}
-declare class ChatChannelSocketHandler {
-    constructor(socketService: SocketService);
-    createChannel(displayName: string, memberIds: string[], displayPictureUrl?: string, visibility?: string, isDirectMessage?: boolean): Promise<ChatChannel>;
-    updateChannel(channelId: string, payload: UpdateChannelRequestPayload): Promise<ChatChannel>;
-    static formatChannel(socketChannel: ChatChannel$1): ChatChannel;
-    getChannelMembers(channelId: string): Promise<RTKBasicParticipant[]>;
-    on(event: number, handler: (socketMessage: ChatChannelSocketMessage) => void): void;
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
 }
-declare enum ChatMessageType {
-    TEXT = 0,
-    IMAGE = 1,
-    FILE = 2,
-    CUSTOM = 3
+/**
+Get keys of the given type as strings.
+
+Number keys are converted to strings.
+
+Use-cases:
+- Get string keys from a type which may have number keys.
+- Makes it possible to index using strings retrieved from template types.
+
+@example
+```
+import type {StringKeyOf} from 'type-fest';
+
+type Foo = {
+    1: number,
+    stringKey: string,
+};
+
+type StringKeysOfFoo = StringKeyOf<Foo>;
+//=> '1' | 'stringKey'
+```
+
+@category Object
+*/
+type StringKeyOf<BaseType> = string;
+declare class RTKEventEmitter<T extends string | symbol> extends EventEmitter$1 {
+    logger: RTKLogger$1 | undefined;
+    constructor(logger: RTKLogger$1);
+    emit(event: T, ...args: any[]): boolean;
+    on(event: T, callback: (...args: any[]) => void): this;
+    addListener(event: T, callback: (...args: any[]) => any): this;
+    off(event: T, callback: (...args: any[]) => any): this;
+    once(event: T, callback: (...args: any[]) => any): this;
+    prependListener(event: T, callback: (...args: any[]) => any): this;
+    prependOnceListener(event: T, callback: (...args: any[]) => any): this;
+    removeListener(event: T, callback: (...args: any[]) => any): this;
+    removeAllListeners(event?: T): this;
+    listeners(event: T): Function[];
+    listenerCount(event: T): number;
 }
-type ChatSocketMessage = SendChatMessageToRoomResponse | SendChatMessageToPeersResponse | EditChatMessageResponse | DeleteChatMessageResponse;
-interface SearchFilters {
-    channelId?: string;
-    timestamp?: number;
-    size?: number;
-    reversed?: boolean;
+type EventMap$1 = {
+    [key: string]: (...args: any[]) => void;
+};
+type WildCardEvent<T> = {
+    ['*']: (event: StringKeyOf<T>, ...args: any) => void;
+};
+declare class RTKTypedEventEmitter<Events extends EventMap$1 & WildCardEvent<Events>> extends EventEmitter$1 {
+    logger: RTKLogger$1 | undefined;
+    constructor(logger: RTKLogger$1);
+    emit<E extends StringKeyOf<Events>>(event: E, ...args: Parameters<Events[E]>): boolean;
+    on<E extends StringKeyOf<Events>>(event: E, callback: Events[E]): this;
+    addListener<E extends StringKeyOf<Events>>(event: E, callback: Events[E]): this;
+    off<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
+    once<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
+    prependListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
+    prependOnceListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
+    removeListener<T extends StringKeyOf<Events>>(event: T, callback: Events[T]): this;
+    removeAllListeners<T extends StringKeyOf<Events>>(event?: T): this;
+    listeners<T extends StringKeyOf<Events>>(event: T): Function[];
+    listenerCount<T extends StringKeyOf<Events>>(event: T): number;
 }
-declare class ChatSocketHandler {
+type StageSocketMessage = GetStageRequestsResponse | GetStagePeersResponse | DenyStageAccessRequest | PeerStatusUpdate;
+declare class StageSocketHandler {
     constructor(socketService: SocketService);
-    getChatMessages(): Promise<{
+    getStageRequests(): Promise<GetStageRequestsResponse>;
+    requestAccess(): void;
+    cancelRequestAccess(): void;
+    grantAccess(userIds: string[]): Promise<void>;
+    denyAccess(userIds: string[]): Promise<void>;
+    joinStage(): 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;
+    leaveStage(userId: string): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    kick(userIds: string[]): Promise<{
         id: string;
+        payload: Uint8Array;
     }>;
-    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;
+    on(event: number, handler: (socketMessage: StageSocketMessage, messageId?: string) => void): void;
+    getPeerInfo(peerId: string): Promise<PeerInfoResponse>;
 }
-declare class RTKSelectedPeers {
-    constructor();
-    add(peerId: string, priority: number): number;
-    delete(peerId: string): void;
-    index(peerId: string): number;
-    readonly peers: string[];
-    readonly compulsoryPeers: string[];
-    readonly activeSpeakerPeers: string[];
+type StageStatus = 'OFF_STAGE' | 'REQUESTED_TO_JOIN_STAGE' | 'ACCEPTED_TO_JOIN_STAGE' | 'ON_STAGE';
+interface StageRequestPayload {
+    displayName: string;
+    userId: string;
+    peerId: string;
 }
-type PipEvents = {
-    ['cameraToggled']: () => void;
-    ['micToggled']: () => void;
-    ['hangup']: () => void;
-    ['pipStarted']: () => void;
-    ['pipEnded']: () => void;
+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 RTKPip extends RTKTypedEventEmitter<PipEvents> {
-    private constructor();
-    static _init(context: Context<RTKContextState>, self: RTKSelf$1): Promise<RTKPip>;
-    overrideIcon(icon: 'handRaise' | 'pin', value: string): Promise<void>;
-    isSupported(): boolean;
-    readonly isActive: boolean;
-    init({ height, width }?: {
-        height?: number;
-        width?: number;
-    }): void;
-    enableSource(source: string): void;
-    disableSource(source: string): void;
-    addSource(id: string, element: HTMLVideoElement, enabled: boolean, pinned?: boolean, displayText?: string, imageUrl?: string, handRaised?: boolean): void;
-    updateSource(id: string, source: any): void;
-    removeSource(id: string): void;
-    removePinnedSource(): void;
-    removeAllSources(): void;
-    enable(): void;
-    disable: (partial?: boolean) => void;
-}
-type EventHandlerTypes = PeerInfoResponse | GetWaitingRoomRequests | RecordingEvent | UpdatePeersPresetResponse | PeerJoinBroadcastResponse | PeerJoinCompleteResponse | GlobalPeerPinningBroadcastResponse | PeerLeaveResponse | SelectedPeersResponse | SelectedPeersDiffResponse;
-declare class RoomSocketHandler {
-    socket: SocketService;
-    cleanup(): Promise<void>;
-    constructor(context: Context<RTKContextState>, socketService: SocketService);
-    joinRoom(opts: {
-        name: string;
+declare class RTKStage extends RTKTypedEventEmitter<StageEvents> {
+    readonly telemetry: RTKTelemetry;
+    constructor(context: Context<RTKContextState>, self: RTKSelf$1, participants: RTKParticipants, stageSocketHandler: StageSocketHandler, roomSocketHandler: RoomSocketHandler);
+    readonly status: StageStatus;
+    getAccessRequests(): {
+        stageRequests: StageRequestPayload[];
+    };
+    requestAccess(): Promise<void>;
+    cancelRequestAccess(): Promise<void>;
+    grantAccess(userIds: string[]): Promise<void>;
+    denyAccess(userIds: string[]): Promise<void>;
+    join(): Promise<void>;
+    leave(): Promise<void>;
+    kick(userIds: string[]): Promise<{
         id: string;
-        userId: string;
-        customParticipantId: string;
-        picture?: string;
-    }): Promise<{
-        peer: Peer;
+        payload: Uint8Array;
     }>;
-    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'>>;
 }
-declare class EnhancedEventEmitter<TransportPromiseEvents> extends EventEmitter {
-    constructor();
-    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 ResponseStatus {
+    success: boolean;
+    message: string;
+}
+type MediaPermission$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE' | 'CANCELED';
+declare class EnhancedEventEmitter<TransportPromiseEvents> extends EventEmitter$1 {
+    readonly logger: RTKLogger$1;
+    constructor(context: Context<RTKContextState>);
+    safeEmit(event: string, ...args: any[]): boolean;
+    safeEmitAsPromise<T extends keyof TransportPromiseEvents>(event: T, ...args: any[]): Promise<TransportPromiseEvents[T]>;
+    safeEmitAsPromiseWithTimeout<T extends keyof TransportPromiseEvents>(event: T, timeout: number, ...args: any[]): Promise<TransportPromiseEvents[T]>;
 }
 declare enum TransportState {
     NEW = "new",
@@ -3106,25 +3018,25 @@ type ConsumerOptions = {
     closeTranscieverOnClose?: boolean;
 };
 type MediaKind = 'audio' | 'video';
-declare class Consumer extends EnhancedEventEmitter<TransportPromiseEvents> {
-    readonly rtpReceiver: RTCRtpReceiver;
-    readonly id: string;
-    readonly localId: string;
-    readonly producerId: string;
-    readonly producingTransportId: string;
-    readonly mimeType: string;
-    readonly track: MediaStreamTrack;
-    readonly peerId: string;
-    readonly appData: Record<string, unknown>;
-    readonly transceiver: RTCRtpTransceiver;
-    constructor(opts: ConsumerOptions);
-    readonly closed: boolean;
-    readonly kind: MediaKind;
-    readonly paused: boolean;
-    close(reason?: string, closeTranscieverOnClose?: boolean): void;
-    getStats(): Promise<RTCStatsReport>;
-    pause(): void;
-    resume(): void;
+declare class Consumer extends EnhancedEventEmitter<TransportPromiseEvents> {
+    readonly rtpReceiver: RTCRtpReceiver;
+    readonly id: string;
+    readonly localId: string;
+    readonly producerId: string;
+    readonly producingTransportId: string;
+    readonly mimeType: string;
+    readonly track: MediaStreamTrack;
+    readonly peerId: string;
+    readonly appData: Record<string, unknown>;
+    readonly transceiver: RTCRtpTransceiver;
+    constructor(context: Context<RTKContextState>, opts: ConsumerOptions);
+    readonly closed: boolean;
+    readonly kind: MediaKind;
+    readonly paused: boolean;
+    close(reason?: string, closeTranscieverOnClose?: boolean): void;
+    getStats(): Promise<RTCStatsReport>;
+    pause(): void;
+    resume(): void;
 }
 declare const localMediaEvents: readonly [
     "AUDIO_TRACK_CHANGE",
@@ -3226,1589 +3138,1492 @@ type SelfEvents = {
     ['autoplayError']: (error: Error) => void;
     ['*']: (event: string, ...args: any[]) => void;
 };
-interface DeviceConfig {
-    browserName: string;
-    browserVersion: string;
-    isMobile: boolean;
-    engineName: string;
-    osName: string;
-}
-interface ProducerState {
-    producerId: string;
-    kind: 'audio' | 'video';
-    pause: boolean;
-    screenShare: boolean;
-    producingTransportId: string;
-    producingPeerId: string;
-    mimeType?: string;
-}
-interface Participant {
-    id: string;
-    userId: string;
-    displayName: string;
-    device?: DeviceConfig;
-    picture?: string;
-    isHost: boolean;
-    flags: {
-        [key: string]: string | boolean;
-    };
-    clientSpecificId?: string;
-    customParticipantId?: string;
-    stageStatus?: StageStatus;
-    audioMuted: boolean;
-    audioTrack: MediaStreamTrack;
-    videoTrack: MediaStreamTrack;
-    videoEnabled: boolean;
-    producers?: ProducerState[];
-    metadata?: {
-        preset_name?: string;
-    };
-    recorderType?: string;
-}
-declare class RTKParticipant$1 extends RTKTypedEventEmitter<ParticipantEvents> {
-    id: string;
-    userId: string;
-    name: string;
-    picture: string;
-    isHost: boolean;
-    customParticipantId?: string;
-    readonly clientSpecificId: string;
-    flags: {
-        [key: string]: string | boolean;
+declare class LocalMediaHandler extends RTKEventEmitter<LocalMediaEvents> {
+    readonly telemetry: RTKTelemetry;
+    audioUpdateInProgress: boolean;
+    videoUpdateInProgress: boolean;
+    constructor(context: Context<RTKContextState>, mediaConstraints: MediaConstraints, isNonPreferredDevice?: (media: MediaDeviceInfo) => boolean, autoSwitchDevice?: boolean);
+    context: Context<RTKContextState>;
+    repopulateAvailableDevices(): Promise<boolean>;
+    setupStreams({ audio, video, }: {
+        audio: boolean;
+        video: boolean;
+    }): Promise<void>;
+    getCurrentDevices(): {
+        audio: MediaDeviceInfo;
+        video: MediaDeviceInfo;
+        speaker: MediaDeviceInfo;
     };
-    device: DeviceConfig;
-    videoTrack: MediaStreamTrack;
-    audioTrack: MediaStreamTrack;
-    screenShareTracks: {
+    readonly permissions: {
+        audio?: MediaPermission$1;
+        video?: MediaPermission$1;
+        screenshare?: MediaPermission$1;
+    };
+    getAllDevices(): Promise<InputDeviceInfo[]>;
+    getDeviceById(deviceId: string, kind?: 'audioinput' | 'audiooutput' | 'videoinput'): Promise<MediaDeviceInfo>;
+    readonly rawAudioTrack: MediaStreamTrack;
+    readonly audioTrack: MediaStreamTrack;
+    readonly audioEnabled: boolean;
+    enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
+    disableAudio(): void;
+    getAudioDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    setAudioDevice(device: MediaDeviceInfo): Promise<void>;
+    setupSpeaker(): Promise<void>;
+    setSpeakerDevice(device: MediaDeviceInfo): Promise<void>;
+    readonly rawVideoTrack: MediaStreamTrack;
+    readonly videoTrack: MediaStreamTrack;
+    readonly videoEnabled: boolean;
+    enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
+    disableVideo(): void;
+    getVideoDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    setVideoDevice(device: MediaDeviceInfo): Promise<void>;
+    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    readonly screenShareTracks: {
         audio: MediaStreamTrack;
         video: MediaStreamTrack;
     };
-    videoEnabled: boolean;
-    audioEnabled: boolean;
-    screenShareEnabled: boolean;
-    producers: ProducerState[];
-    manualProducerConfig: PeerProducerConfig;
-    supportsRemoteControl: boolean;
-    presetName?: string;
-    readonly stageStatus: StageStatus;
-    constructor(context: Context<RTKContextState>, participant: Participant, self: RTKSelf, roomSocket: RoomSocketHandler);
-    setVideoEnabled(videoEnabled: boolean, emitEvent?: boolean): void;
-    setAudioEnabled(audioEnabled: boolean, emitEvent?: boolean): void;
-    setScreenShareEnabled(screenShareEnabled: boolean, emitEvent?: boolean): void;
-    pin(): Promise<void>;
-    unpin(): Promise<void>;
-    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
-    disableAudio(): Promise<void>;
-    kick(): Promise<void>;
-    disableVideo(): Promise<void>;
-    getPermissions(): Promise<Pick<_dyteinternals_utils.Permissions, "plugins" | "polls" | "chat">>;
-    setStageStatus(stageStatus: StageStatus): void;
-    readonly isPinned: boolean;
-    registerVideoElement(videoElem: HTMLVideoElement): void;
-    deregisterVideoElement(videoElem?: HTMLVideoElement): void;
+    readonly screenShareEnabled: boolean;
+    enableScreenShare(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    getSpeakerDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
+    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
+    removeAllAudioMiddlewares(): Promise<ResponseStatus>;
+    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
+    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
+    removeAllVideoMiddlewares(): Promise<ResponseStatus>;
+    setVideoMiddlewareGlobalConfig(config: VideoMiddlewareGlobalConfig): Promise<void>;
+    destruct(): void;
+    onDeviceChange(changedDevices: {
+        added: MediaDeviceInfo[];
+        removed: MediaDeviceInfo[];
+        devices: MediaDeviceInfo[];
+    }, skipDeviceChange: boolean): Promise<void>;
+    removeAllTracks(): void;
+    removeAudioTrack(): void;
+    removeVideoTrack(): void;
+    removeDocumentEventListeners(): Promise<void>;
 }
-type TranscriptionData = {
-    id: string;
-    name: string;
-    peerId: string;
-    userId: string;
-    customParticipantId: string;
-    transcript: string;
-    isPartialTranscript: boolean;
-    date: Date;
+declare enum MediaPermission {
+    NOT_REQUESTED = 0,
+    ACCEPTED = 1,
+    DENIED = 2,
+    CANCELED = 3,
+    SYSTEM_DENIED = 4,
+    COULD_NOT_START = 5,
+    NO_DEVICES_AVAILABLE = 6
+}
+type AudioMiddleware = (audioContext: AudioContext) => Promise<ScriptProcessorNode | AudioWorkletNode>;
+type VideoMiddleware = (() => Promise<(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D) => Promise<void>>) | ((helpers: {
+    canvas: HTMLCanvasElement;
+    WorkerTimers: typeof WorkerTimers;
+}) => Promise<void>);
+type VideoMiddlewareGlobalConfig = {
+    disablePerFrameCanvasRendering: boolean;
 };
-type AiEvents = {
-    ['transcript']: (t: TranscriptionData) => void;
-    ['*']: (event: string, ...args: any[]) => void;
+type PresetMediaConstraints = PresetV2CamelCased['config']['media'];
+type AudioQualityConstraints = {
+    echoCancellation?: boolean;
+    noiseSupression?: boolean;
+    autoGainControl?: boolean;
+    enableStereo?: boolean;
+    enableHighBitrate?: boolean;
 };
-declare class RTKAi extends RTKTypedEventEmitter<AiEvents> {
-    transcripts: TranscriptionData[];
-    constructor();
-    static init(transcriptionEnabled: boolean): Promise<RTKAi>;
-    static parseTranscript(transcriptData: string, isPartialTranscript?: boolean): TranscriptionData | undefined;
-    static parseTranscripts(transcriptData: string): TranscriptionData[];
-    getActiveTranscript(): Promise<void>;
-    onTranscript(transcript: TranscriptionData): Promise<void>;
-}
-type ActiveTabType = 'screenshare' | 'plugin';
-interface ActiveTab {
-    type: ActiveTabType;
-    id: string;
+type VideoQualityConstraints = {
+    width: {
+        ideal: number;
+    };
+    height: {
+        ideal: number;
+    };
+    frameRate?: {
+        ideal: number;
+    };
+};
+type ScreenshareQualityConstraints = {
+    width?: {
+        max: number;
+    };
+    height?: {
+        max: number;
+    };
+    frameRate?: {
+        ideal: number;
+        max: number;
+    };
+    displaySurface?: 'window' | 'monitor' | 'browser';
+    selfBrowserSurface?: 'include' | 'exclude';
+};
+interface RTKMediaTrackConstraints extends MediaTrackConstraints {
+    optional?: Array<object>;
 }
-declare enum TabChangeSource {
-    User = 0,
-    Meeting = 1
+interface RTKMediaStreamConstraints extends MediaStreamConstraints {
+    audio?: boolean | RTKMediaTrackConstraints;
 }
-interface MediaConnectionUpdate {
-    transport: 'consuming' | 'producing';
-    state: string;
-    reconnected: boolean;
-}
-type MetaEvents = {
-    ['mediaConnectionUpdate']: (payload: MediaConnectionUpdate) => void;
-    ['socketConnectionUpdate']: (state: SocketConnectionState) => void;
-    ['poorConnection']: (payload: {
-        score: number;
-    }) => void;
-    ['meetingStartTimeUpdate']: (payload: {
-        meetingStartedTimestamp: Date;
-    }) => void;
-    ['transcript']: (t: TranscriptionData) => void;
-    ['activeTabUpdate']: (tab: ActiveTab) => void;
-    ['selfTabUpdate']: (tab: ActiveTab) => void;
-    ['broadcastTabChangesUpdate']: (broadcastTabChanges: boolean) => void;
-    ['*']: (event: string, ...args: any[]) => void;
+type MediaConstraints = {
+    audio?: AudioQualityConstraints;
+    video?: MediaVideoQualityType | VideoQualityConstraints;
+    screenshare?: ScreenshareQualityConstraints;
 };
-declare class RTKMeta$1 extends RTKTypedEventEmitter<MetaEvents> {
-    selfActiveTab: ActiveTab | undefined;
-    readonly socketState: SocketConnectionState;
-    readonly mediaState: MediaConnectionState;
-    broadcastTabChanges: boolean;
-    viewType: string;
-    meetingStartedTimestamp: Date;
-    meetingTitle: string;
-    sessionId: string;
-    constructor(context: Context<RTKContextState>, self: RTKSelf, viewType: string, roomSocketHandler: RoomSocketHandler, meetingTitle: string);
-    readonly meetingId: string;
-    setBroadcastTabChanges(broadcastTabChanges: boolean): void;
-    setSelfActiveTab(spotlightTab: ActiveTab, tabChangeSource: TabChangeSource): void;
-}
-interface RTKMapEvents<T extends EventMap$1> {
-    onAddEvent?: keyof T;
-    onDeleteEvent?: keyof T;
-    onClearEvent?: keyof T;
+type 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;
+    };
+    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;
+};
+type MaxVideoStreams = PresetV2CamelCased['config']['maxVideoStreams'];
+declare class RTKThemePreset$1 {
+    private constructor();
+    static fromResponse(preset: PresetV2CamelCased): RTKThemePreset$1;
+    static default(): RTKThemePreset$1;
+    static init(preset?: PresetV2CamelCased, useDefault?: boolean): RTKThemePreset$1;
+    readonly setupScreen: Readonly<{
+        isEnabled: boolean;
+    }>;
+    readonly waitingRoom: Readonly<{
+        isEnabled: boolean;
+    }>;
+    readonly controlBar: Readonly<{
+        isEnabled: boolean;
+        elements?: {
+            chat?: boolean;
+            fullscreen?: boolean;
+            invite?: boolean;
+            layout?: boolean;
+            participants?: boolean;
+            plugins?: boolean;
+            polls?: boolean;
+            reactions?: boolean;
+            screenshare?: boolean;
+        };
+    }>;
+    readonly header: Readonly<{
+        isEnabled: boolean;
+        elements: {
+            logo: string;
+            timer: boolean;
+            title: boolean;
+            participantCount: boolean;
+            changeLayout: boolean;
+        };
+    }>;
+    readonly pipMode: Readonly<boolean>;
+    readonly viewType: Readonly<ViewType>;
+    readonly livestreamViewerQualities: Readonly<LivestreamViewerMediaQualityType[]>;
+    readonly maxVideoStreams: Readonly<MaxVideoStreams>;
+    readonly maxScreenShareCount: Readonly<number>;
+    readonly plugins: Readonly<string[]>;
+    readonly disabledPlugins: Readonly<string[]>;
+    readonly designTokens: Readonly<PresetV2CamelCased['ui']['designTokens']>;
+    readonly configDiff: Readonly<PresetV2CamelCased['ui']['configDiff']>;
+    readonly mediaConstraints: Readonly<PresetMediaConstraints>;
+    readonly name: string;
 }
-type ModifyPrependObject<T extends EventMap$1, U> = {
-    [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-} & {
-    ['*']: (event: String, ...args: any[]) => void;
+type PresetPermissions = PresetV2CamelCased['permissions'];
+type MediaRoomType = 'HIVE' | 'CF';
+type PermissionEvents = {
+    ['chatUpdate']: () => void;
+    ['pollsUpdate']: () => void;
+    ['pluginsUpdate']: () => void;
+    ['permissionsUpdate']: (patch: PresetUpdates) => void;
+    ['*']: () => 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>);
-    emit<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, ...args: Parameters<(V | ModifyPrependObject<T, U>)[E]>): boolean;
-    on<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    addListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    off<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    once<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    prependListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    prependOnceListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    removeListener<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E, callback: (ModifyPrependObject<T, U> & V)[E]): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    removeAllListeners<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event?: E): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    listeners<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E): Function[];
-    listenerCount<E extends StringKeyOf<ModifyPrependObject<T, U> & V>>(event: E): number;
-    getMaxListeners(): number;
-    setMaxListeners(n: number): RTKTypedEventEmitter<{
-            [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>;
-        } & {
-            "*": (event: String, ...args: any[]) => void;
-        } & V>;
-    eventNames(): (string | symbol)[];
-    add(obj: U, emitEvent?: boolean): this;
-    set(objId: string, obj: U, emitEvent?: boolean): this;
-    delete(objId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
-    clear(emitEvent?: boolean, removeListeners?: boolean): void;
-    toArray(): U[];
-}
-type ParticipantMapEvents = {
-    ['participantJoined']: (payload: RTKParticipant$1) => void;
-    ['participantLeft']: (payload: RTKParticipant$1) => void;
-    ['participantsCleared']: () => void;
-    ['participantsUpdate']: () => void;
-    ['kicked']: (payload: {
-        id: string;
-    }) => void;
-};
-declare class RTKParticipantMap$1<T extends Pick<RTKParticipant$1, 'id' | keyof RTKTypedEventEmitter<ParticipantEvents>> = RTKParticipant$1> extends RTKMap<ParticipantEvents, T, ParticipantMapEvents> {
-    constructor(options?: RTKMapEvents<ParticipantMapEvents>);
-    add(participant: T, emitEvent?: boolean): this;
-    clear(emitEvent?: boolean, removeListeners?: boolean): void;
-    delete(participantId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
+declare class RTKPermissionsPreset$1 extends RTKTypedEventEmitter<PermissionEvents> {
+    private constructor();
+    static fromResponse(response: PresetPermissions, viewType: ViewType, context: Context<RTKContextState>): RTKPermissionsPreset$1;
+    static default(context: Context<RTKContextState>, viewType: ViewType): RTKPermissionsPreset$1;
+    static init(context: Context<RTKContextState>, viewType: ViewType, response?: PresetPermissions): RTKPermissionsPreset$1;
+    readonly mediaRoomType: Readonly<MediaRoomType>;
+    readonly stageEnabled: Readonly<boolean>;
+    readonly acceptStageRequests: Readonly<boolean>;
+    readonly stageAccess: Readonly<MediaProductionPermissionType>;
+    readonly acceptWaitingRequests: Readonly<boolean>;
+    readonly requestProduceVideo: Readonly<boolean>;
+    readonly requestProduceAudio: Readonly<boolean>;
+    readonly requestProduceScreenshare: Readonly<boolean>;
+    readonly canAllowParticipantAudio: Readonly<boolean>;
+    readonly canAllowParticipantScreensharing: Readonly<boolean>;
+    readonly canAllowParticipantVideo: Readonly<boolean>;
+    readonly canDisableParticipantAudio: Readonly<boolean>;
+    readonly canDisableParticipantVideo: Readonly<boolean>;
+    readonly kickParticipant: Readonly<boolean>;
+    readonly pinParticipant: Readonly<boolean>;
+    readonly canRecord: Readonly<boolean>;
+    readonly waitingRoomType: Readonly<WaitingRoomTypes>;
+    readonly waitingRoomBehaviour: Readonly<WaitingRoomTypes>;
+    readonly plugins: Readonly<PresetPermissions['plugins']>;
+    readonly polls: Readonly<PresetPermissions['polls']>;
+    readonly produceVideo: Readonly<MediaProductionPermissionType>;
+    readonly requestProduce: Readonly<boolean>;
+    readonly canProduceVideo: Readonly<MediaProductionPermissionType>;
+    readonly produceScreenshare: Readonly<MediaProductionPermissionType>;
+    readonly canProduceScreenshare: Readonly<MediaProductionPermissionType>;
+    readonly produceAudio: Readonly<MediaProductionPermissionType>;
+    readonly canProduceAudio: Readonly<MediaProductionPermissionType>;
+    readonly chatPublic: Readonly<PresetPermissions['chat']['public']>;
+    readonly chatPrivate: Readonly<PresetPermissions['chat']['private']>;
+    readonly chatChannel: Readonly<PresetPermissions['chat']['channel']>;
+    readonly chatMessage: Readonly<PresetPermissions['chat']['message']>;
+    readonly connectedMeetings: Readonly<PresetPermissions['connectedMeetings']>;
+    readonly hiddenParticipant: Readonly<boolean>;
+    readonly showParticipantList: Readonly<boolean>;
+    readonly canChangeParticipantRole: Readonly<boolean>;
+    readonly canChangeParticipantPermissions: Readonly<boolean>;
+    readonly canChangeTheme: Readonly<boolean>;
+    readonly canPresent: Readonly<boolean>;
+    readonly acceptPresentRequests: Readonly<boolean>;
+    readonly canEditDisplayName: Readonly<boolean>;
+    readonly maxScreenShareCount: Readonly<number>;
+    readonly isRecorder: Readonly<boolean>;
+    readonly canSpotlight: Readonly<boolean>;
+    readonly canLivestream: Readonly<boolean>;
+    readonly transcriptionEnabled: Readonly<boolean>;
 }
-declare const modes: readonly [
-    "ACTIVE_GRID",
-    "PAGINATED",
-    "MANUAL"
-];
-type ViewMode = (typeof modes)[number];
-interface BroadcastMessagePayload {
-    [key: string]: boolean | number | string | Date | ActiveTab;
+interface UserDetailsResponseV2 {
+    participant: UserDetailsResponse;
+    preset: PresetV2CamelCased;
 }
-interface PeerProducerConfig {
-    audio: boolean;
-    video: boolean;
-    screenshareAudio: boolean;
-    screenshareVideo: boolean;
+type LeaveRoomState = 'kicked' | 'ended' | 'left' | 'rejected' | 'connected-meeting' | 'disconnected' | 'failed' | 'stageLeft';
+declare class RTKSelfMedia$1 extends RTKTypedEventEmitter<SelfEvents> {
+    readonly peerId: string;
+    init(options?: {
+            video?: boolean;
+            audio?: boolean;
+            constraints?: MediaConstraints;
+        }, skipAwaits?: boolean, context?: Context<RTKContextState>): Promise<void>;
+    context: Context<RTKContextState>;
+    readonly audioTrack: MediaStreamTrack;
+    readonly rawAudioTrack: MediaStreamTrack;
+    readonly mediaPermissions: {
+        audio?: MediaPermission$1;
+        video?: MediaPermission$1;
+        screenshare?: MediaPermission$1;
+    };
+    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    removeAllAudioMiddlewares(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    readonly videoTrack: MediaStreamTrack;
+    readonly rawVideoTrack: MediaStreamTrack;
+    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    setVideoMiddlewareGlobalConfig(config?: VideoMiddlewareGlobalConfig): Promise<void>;
+    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    removeAllVideoMiddlewares(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    readonly screenShareTracks: {
+        audio: MediaStreamTrack;
+        video: MediaStreamTrack;
+    };
+    readonly audioEnabled: boolean;
+    readonly videoEnabled: boolean;
+    readonly screenShareEnabled: boolean;
+    enableAudio(): Promise<void>;
+    enableVideo(): Promise<void>;
+    disableAudio(): Promise<void>;
+    enableScreenShare(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    disableVideo(): Promise<void>;
+    getCurrentDevices(): {
+        audio: MediaDeviceInfo;
+        video: MediaDeviceInfo;
+        speaker: MediaDeviceInfo;
+    };
+    getAudioDevices(): Promise<MediaDeviceInfo[]>;
+    getVideoDevices(): Promise<MediaDeviceInfo[]>;
+    getSpeakerDevices(): Promise<MediaDeviceInfo[]>;
+    getDeviceById(deviceId: string, kind: 'audio' | 'video' | 'speaker'): Promise<MediaDeviceInfo>;
+    setDevice(device: MediaDeviceInfo): Promise<void>;
 }
-type BroadcastMessageTarget = {
-    participantIds: string[];
-} | {
-    presetNames: string[];
-} | {
-    meetingIds: string[];
-};
-type JoinedPeer = {
+interface UserDetailsResponse {
     id: string;
-    userId: string;
     name: string;
-    stageType?: StageStatus;
-    customParticipantId?: string;
-    presetId?: string;
+    email: string;
     picture?: string;
-    waitlisted: boolean;
-    recorderType?: string;
-    stageStatus?: StageStatus;
-    metadata?: {
-        preset_name?: string;
-    };
-    flags?: {
-        hiddenParticipant?: boolean;
-        recorder?: boolean;
-    };
-};
-type ParticipantsEvents = {
-    ['viewModeChanged']: (payload: {
-        viewMode: string;
-        currentPage: number;
-        pageCount: number;
-    }) => void;
-    ['activeSpeaker']: (payload: {
-        peerId: string;
-        volume: number;
-    }) => void;
-    ['broadcastedMessage']: (payload: {
-        type: string;
-        payload: BroadcastMessagePayload;
-        timestamp: number;
-    }) => void;
-    ['poorConnection']: (payload: {
-        participantId: string;
-        score: number;
-        kind: string;
-    }) => void;
-    ['pageChanged']: (payload: {
-        viewMode: string;
-        currentPage: number;
-        pageCount: number;
-    }) => void;
-    ['mediaScoreUpdate']: (payload: {
-        kind: string;
-        isScreenshare: boolean;
-        score: number;
-        participantId: string;
-        scoreStats: ConsumerScoreStats;
-    }) => void;
-    ['media_decode_error']: (payload: {
-        reason: string;
-        code: '1702' | '1703';
-    }) => void;
-    ['*']: (event: string, ...args: any[]) => void;
-};
-declare class RTKParticipants$1 extends RTKTypedEventEmitter<ParticipantsEvents> {
-    readonly waitlisted: Readonly<RTKParticipantMap$1<Pick<RTKParticipant$1, Exclude<keyof RTKParticipant$1, 'audioTrack' | 'videoTrack' | 'screenShareTracks'>>>>;
-    readonly joined: Readonly<RTKParticipantMap$1>;
-    readonly active: Readonly<RTKParticipantMap$1>;
-    readonly videoSubscribed: Readonly<RTKParticipantMap$1>;
-    readonly audioSubscribed: Readonly<RTKParticipantMap$1>;
-    readonly pinned: Readonly<RTKParticipantMap$1>;
-    readonly all: Readonly<RTKBasicParticipantsMap>;
-    readonly pip: RTKPip;
-    rateLimitConfig: {
-        maxInvocations: number;
-        period: number;
-    };
-    readonly rateLimits: {
-        maxInvocations: number;
-        period: number;
-    };
-    updateRateLimits(num: number, period: number): void;
-    viewMode: ViewMode;
-    currentPage: number;
-    lastActiveSpeaker: string;
-    selectedPeers: RTKSelectedPeers;
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, roomSocketHandler: RoomSocketHandler);
-    setupEvents(): void;
-    readonly count: number;
-    readonly maxActiveParticipantsCount: number;
-    setMaxActiveParticipantsCount(limit: number): void;
-    readonly pageCount: number;
-    acceptWaitingRoomRequest(id: string): void;
-    acceptAllWaitingRoomRequest(userIds: string[]): Promise<void>;
-    rejectWaitingRoomRequest(id: string): Promise<void>;
-    setViewMode(viewMode: ViewMode): Promise<void>;
-    subscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
-    unsubscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
-    getPeerIdsForCurrentPage(): string[];
-    setPage(page: number): Promise<void>;
-    disableAllAudio(allowUnmute: boolean): Promise<void>;
-    disableAllVideo(): Promise<void>;
-    disableAudio(participantId: string): Promise<void>;
-    disableVideo(participantId: string): Promise<void>;
-    kick(participantId: string): Promise<void>;
-    kickAll(): Promise<void>;
-    broadcastMessage(type: Exclude<string, 'spotlight'>, payload: BroadcastMessagePayload, target?: BroadcastMessageTarget): Promise<void>;
-    getAllJoinedPeers(searchQuery: string, limit: number, offset: number): Promise<{
-        id: string;
-        userId: string;
-        name: string;
-        displayName: string;
-        stageType: StageStatus;
-        customParticipantId: string;
-        presetId: string;
-        picture: string;
-        waitlisted: boolean;
-        stageStatus: StageStatus;
-        metadata: {
-            preset_name: string;
-        };
-        recorderType: string;
-        flags: {
-            hiddenParticipant: boolean;
-            hidden_participant: boolean;
-            recorder: boolean;
-        };
-    }[]>;
-    updatePermissions(participantIds: string[], permissions: PresetUpdates): Promise<void>;
-    getParticipantsInMeetingPreJoin(): Promise<RoomPeersInfoResponse>;
-}
-interface FetchRequestConfig {
-    baseURL?: string;
-    url?: string;
-    method?: string;
-    headers?: Record<string, string>;
-    timeout?: number;
-    retry?: number;
-    retryDelay?: number;
-    responseType?: string;
-    data?: any;
-    params?: Record<string, string>;
-}
-interface FetchResponse<T = any> {
-    data: T;
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    config: FetchRequestConfig;
-}
-declare class FetchClient {
-    defaults: {
-        baseURL: string;
-        headers: {
-            common: Record<string, string>;
-        };
-        timeout: number;
-        retry: number;
-        retryDelay: number;
-    };
-    constructor(options: {
-        baseURL: string;
-        timeout: number;
-        retry: number;
-        retryDelay: number;
-        responseType?: string;
-    });
-    request<T = any>(config: FetchRequestConfig): Promise<FetchResponse<T>>;
-    get<T = any>(url: string, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
-    post<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
-    put<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
-}
-interface ResponseStatus {
-    success: boolean;
-    message: string;
+    loggedIn?: boolean;
+    scope?: string[];
+    clientSpecificId?: string;
+    customParticipantId?: string;
+    organizationId?: string;
 }
-type MediaPermission$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE' | 'CANCELED';
-declare class LocalMediaHandler extends RTKEventEmitter<LocalMediaEvents> {
-    audioUpdateInProgress: boolean;
-    videoUpdateInProgress: boolean;
-    constructor(context: Context<RTKContextState>, mediaConstraints: MediaConstraints, isNonPreferredDevice?: (media: MediaDeviceInfo) => boolean, autoSwitchDevice?: boolean);
-    repopulateAvailableDevices(): Promise<boolean>;
-    setupStreams({ audio, video, }: {
-        audio: boolean;
-        video: boolean;
+declare class RTKSelf$1 extends RTKSelfMedia$1 {
+    name: string;
+    picture: string;
+    customParticipantId: string;
+    waitlistStatus: 'accepted' | 'waiting' | 'rejected' | 'none';
+    role: any;
+    userId: string;
+    organizationId: string;
+    supportsRemoteControl: boolean;
+    device: DeviceConfig;
+    readonly telemetry: RTKTelemetry;
+    hidden: boolean;
+    readonly stageStatus: StageStatus;
+    readonly id: string;
+    readonly peerId: string;
+    presetName: string;
+    roomState: 'init' | 'joined' | 'waitlisted' | LeaveRoomState;
+    private constructor();
+    static __init__(context: Context<RTKContextState>, details: UserDetailsResponse, permissions: RTKPermissionsPreset$1, theme: RTKThemePreset$1, presetName: string, skipAwaits?: boolean): Promise<RTKSelf$1>;
+    cleanupEvents(): void;
+    readonly permissions: RTKPermissionsPreset$1;
+    readonly config: RTKThemePreset$1;
+    readonly roomJoined: boolean;
+    setName(name: string): void;
+    setupTracks(options?: {
+        video?: boolean;
+        audio?: boolean;
+        forceReset?: boolean;
     }): Promise<void>;
-    getCurrentDevices(): {
-        audio: MediaDeviceInfo;
-        video: MediaDeviceInfo;
-        speaker: MediaDeviceInfo;
-    };
-    readonly permissions: {
-        audio?: MediaPermission$1;
-        video?: MediaPermission$1;
-        screenshare?: MediaPermission$1;
-    };
-    getAllDevices(): Promise<InputDeviceInfo[]>;
-    getDeviceById(deviceId: string, kind?: 'audioinput' | 'audiooutput' | 'videoinput'): Promise<MediaDeviceInfo>;
-    readonly rawAudioTrack: MediaStreamTrack;
-    readonly audioTrack: MediaStreamTrack;
-    readonly audioEnabled: boolean;
+    destructMediaHandler(): Promise<void>;
+    removeDocumentEventListeners(): Promise<void>;
     enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
-    disableAudio(): void;
-    getAudioDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
-    setAudioDevice(device: MediaDeviceInfo): Promise<void>;
-    setupSpeaker(): Promise<void>;
-    setSpeakerDevice(device: MediaDeviceInfo): Promise<void>;
-    readonly rawVideoTrack: MediaStreamTrack;
-    readonly videoTrack: MediaStreamTrack;
-    readonly videoEnabled: boolean;
     enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
-    disableVideo(): void;
-    getVideoDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
-    setVideoDevice(device: MediaDeviceInfo): Promise<void>;
     updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
-    readonly screenShareTracks: {
-        audio: MediaStreamTrack;
-        video: MediaStreamTrack;
-    };
-    readonly screenShareEnabled: boolean;
     enableScreenShare(): Promise<void>;
-    disableScreenShare(): Promise<void>;
     updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
-    getSpeakerDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
-    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
-    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
-    removeAllAudioMiddlewares(): Promise<ResponseStatus>;
-    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
-    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
-    removeAllVideoMiddlewares(): Promise<ResponseStatus>;
-    setVideoMiddlewareGlobalConfig(config: VideoMiddlewareGlobalConfig): Promise<void>;
-    destruct(): void;
-    onDeviceChange(changedDevices: {
-        added: MediaDeviceInfo[];
-        removed: MediaDeviceInfo[];
-        devices: MediaDeviceInfo[];
-    }, skipDeviceChange: boolean): Promise<void>;
-    removeAllTracks(): void;
-    removeAudioTrack(): void;
-    removeVideoTrack(): void;
-    removeDocumentEventListeners(): Promise<void>;
+    disableAudio(): Promise<void>;
+    disableVideo(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    getAllDevices(): Promise<InputDeviceInfo[]>;
+    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
+    readonly isPinned: boolean;
+    pin(): Promise<void>;
+    unpin(): Promise<void>;
+    hide(): Promise<void>;
+    show(): void;
+    setDevice(device: MediaDeviceInfo): Promise<void>;
+    cleanUpTracks(): void;
+    playAudio(): Promise<void>;
+    registerVideoElement(videoElem: HTMLVideoElement, isPreview?: boolean): void;
+    deregisterVideoElement(videoElem?: HTMLVideoElement, isPreview?: boolean): void;
 }
-declare enum MediaPermission {
-    NOT_REQUESTED = 0,
-    ACCEPTED = 1,
-    DENIED = 2,
-    CANCELED = 3,
-    SYSTEM_DENIED = 4,
-    COULD_NOT_START = 5,
-    NO_DEVICES_AVAILABLE = 6
+interface RTKBasicParticipant {
+    userId: string;
+    name?: string;
+    picture?: string;
+    customParticipantId: string;
 }
-type AudioMiddleware = (audioContext: AudioContext) => Promise<ScriptProcessorNode | AudioWorkletNode>;
-type VideoMiddleware = (() => Promise<(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D) => Promise<void>>) | ((helpers: {
-    canvas: HTMLCanvasElement;
-    WorkerTimers: typeof WorkerTimers;
-}) => Promise<void>);
-type VideoMiddlewareGlobalConfig = {
-    disablePerFrameCanvasRendering: boolean;
-};
-type PresetMediaConstraints = PresetV2CamelCased['config']['media'];
-type AudioQualityConstraints = {
-    echoCancellation?: boolean;
-    noiseSupression?: boolean;
-    autoGainControl?: boolean;
-    enableStereo?: boolean;
-    enableHighBitrate?: boolean;
-};
-type VideoQualityConstraints = {
-    width: {
-        ideal: number;
-    };
-    height: {
-        ideal: number;
-    };
-    frameRate?: {
-        ideal: number;
-    };
-};
-type ScreenshareQualityConstraints = {
-    width?: {
-        max: number;
-    };
-    height?: {
-        max: number;
-    };
-    frameRate?: {
-        ideal: number;
-        max: number;
-    };
-    displaySurface?: 'window' | 'monitor' | 'browser';
-    selfBrowserSurface?: 'include' | 'exclude';
-};
-interface RTKMediaTrackConstraints extends MediaTrackConstraints {
-    optional?: Array<object>;
+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 RTKMediaStreamConstraints extends MediaStreamConstraints {
-    audio?: boolean | RTKMediaTrackConstraints;
+type ChatChannelSocketMessage = GetChatChannelResponse;
+interface ChatChannel {
+    id: string;
+    displayName: string;
+    memberIds: string[];
+    displayPictureUrl?: string;
+    visibility?: string;
+    isDirectMessage?: boolean;
+    latestMessage?: Message;
+    unreadCount: number;
 }
-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;
-    };
-    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;
-};
-type MaxVideoStreams = PresetV2CamelCased['config']['maxVideoStreams'];
-declare class RTKThemePreset$1 {
-    private constructor();
-    static fromResponse(preset: PresetV2CamelCased): RTKThemePreset$1;
-    static default(): RTKThemePreset$1;
-    static init(preset?: PresetV2CamelCased, useDefault?: boolean): RTKThemePreset$1;
-    readonly setupScreen: Readonly<{
-        isEnabled: boolean;
-    }>;
-    readonly waitingRoom: Readonly<{
-        isEnabled: boolean;
-    }>;
-    readonly controlBar: Readonly<{
-        isEnabled: boolean;
-        elements?: {
-            chat?: boolean;
-            fullscreen?: boolean;
-            invite?: boolean;
-            layout?: boolean;
-            participants?: boolean;
-            plugins?: boolean;
-            polls?: boolean;
-            reactions?: boolean;
-            screenshare?: boolean;
-        };
+interface UpdateChannelRequestPayload {
+    memberIds?: string[];
+    displayName?: string;
+    displayPictureUrl?: string;
+    visibility?: string;
+}
+declare class ChatChannelSocketHandler {
+    readonly telemetry: RTKTelemetry;
+    readonly logger: RTKLogger$1;
+    constructor(context: Context<RTKContextState>, socketService: SocketService);
+    createChannel(displayName: string, memberIds: string[], displayPictureUrl?: string, visibility?: string, isDirectMessage?: boolean): Promise<ChatChannel>;
+    updateChannel(channelId: string, payload: UpdateChannelRequestPayload): Promise<ChatChannel>;
+    static formatChannel(socketChannel: ChatChannel$1): ChatChannel;
+    getChannelMembers(channelId: string): Promise<RTKBasicParticipant[]>;
+    on(event: number, handler: (socketMessage: ChatChannelSocketMessage) => void): void;
+}
+declare enum ChatMessageType {
+    TEXT = 0,
+    IMAGE = 1,
+    FILE = 2,
+    CUSTOM = 3
+}
+type ChatSocketMessage = SendChatMessageToRoomResponse | SendChatMessageToPeersResponse | EditChatMessageResponse | DeleteChatMessageResponse;
+interface SearchFilters {
+    channelId?: string;
+    timestamp?: number;
+    size?: number;
+    reversed?: boolean;
+}
+declare class ChatSocketHandler {
+    readonly telemetry: RTKTelemetry;
+    readonly logger: RTKLogger$1;
+    constructor(context: Context<RTKContextState>, socketService: SocketService);
+    getChatMessages(): Promise<{
+        id: string;
+        payload: Uint8Array;
     }>;
-    readonly header: Readonly<{
-        isEnabled: boolean;
-        elements: {
-            logo: string;
-            timer: boolean;
-            title: boolean;
-            participantCount: boolean;
-            changeLayout: boolean;
-        };
+    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;
     }>;
-    readonly pipMode: Readonly<boolean>;
-    readonly viewType: Readonly<ViewType>;
-    readonly livestreamViewerQualities: Readonly<LivestreamViewerMediaQualityType[]>;
-    readonly maxVideoStreams: Readonly<MaxVideoStreams>;
-    readonly maxScreenShareCount: Readonly<number>;
-    readonly plugins: Readonly<string[]>;
-    readonly disabledPlugins: Readonly<string[]>;
-    readonly designTokens: Readonly<PresetV2CamelCased['ui']['designTokens']>;
-    readonly configDiff: Readonly<PresetV2CamelCased['ui']['configDiff']>;
-    readonly mediaConstraints: Readonly<PresetMediaConstraints>;
-    readonly name: string;
+    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 PresetPermissions = PresetV2CamelCased['permissions'];
-type MediaRoomType = 'HIVE' | 'CF';
-type PermissionEvents = {
-    ['chatUpdate']: () => void;
-    ['pollsUpdate']: () => void;
-    ['pluginsUpdate']: () => void;
-    ['permissionsUpdate']: (patch: PresetUpdates) => void;
-    ['*']: () => void;
-};
-declare class RTKPermissionsPreset$1 extends RTKTypedEventEmitter<PermissionEvents> {
-    private constructor();
-    static fromResponse(response: PresetPermissions, viewType: ViewType, context: Context<RTKContextState>): RTKPermissionsPreset$1;
-    static default(context: Context<RTKContextState>, viewType: ViewType): RTKPermissionsPreset$1;
-    static init(context: Context<RTKContextState>, viewType: ViewType, response?: PresetPermissions): RTKPermissionsPreset$1;
-    readonly mediaRoomType: Readonly<MediaRoomType>;
-    readonly stageEnabled: Readonly<boolean>;
-    readonly acceptStageRequests: Readonly<boolean>;
-    readonly stageAccess: Readonly<MediaProductionPermissionType>;
-    readonly acceptWaitingRequests: Readonly<boolean>;
-    readonly requestProduceVideo: Readonly<boolean>;
-    readonly requestProduceAudio: Readonly<boolean>;
-    readonly requestProduceScreenshare: Readonly<boolean>;
-    readonly canAllowParticipantAudio: Readonly<boolean>;
-    readonly canAllowParticipantScreensharing: Readonly<boolean>;
-    readonly canAllowParticipantVideo: Readonly<boolean>;
-    readonly canDisableParticipantAudio: Readonly<boolean>;
-    readonly canDisableParticipantVideo: Readonly<boolean>;
-    readonly kickParticipant: Readonly<boolean>;
-    readonly pinParticipant: Readonly<boolean>;
-    readonly canRecord: Readonly<boolean>;
-    readonly waitingRoomType: Readonly<WaitingRoomTypes>;
-    readonly waitingRoomBehaviour: Readonly<WaitingRoomTypes>;
-    readonly plugins: Readonly<PresetPermissions['plugins']>;
-    readonly polls: Readonly<PresetPermissions['polls']>;
-    readonly produceVideo: Readonly<MediaProductionPermissionType>;
-    readonly requestProduce: Readonly<boolean>;
-    readonly canProduceVideo: Readonly<MediaProductionPermissionType>;
-    readonly produceScreenshare: Readonly<MediaProductionPermissionType>;
-    readonly canProduceScreenshare: Readonly<MediaProductionPermissionType>;
-    readonly produceAudio: Readonly<MediaProductionPermissionType>;
-    readonly canProduceAudio: Readonly<MediaProductionPermissionType>;
-    readonly chatPublic: Readonly<PresetPermissions['chat']['public']>;
-    readonly chatPrivate: Readonly<PresetPermissions['chat']['private']>;
-    readonly chatChannel: Readonly<PresetPermissions['chat']['channel']>;
-    readonly chatMessage: Readonly<PresetPermissions['chat']['message']>;
-    readonly connectedMeetings: Readonly<PresetPermissions['connectedMeetings']>;
-    readonly hiddenParticipant: Readonly<boolean>;
-    readonly showParticipantList: Readonly<boolean>;
-    readonly canChangeParticipantRole: Readonly<boolean>;
-    readonly canChangeParticipantPermissions: Readonly<boolean>;
-    readonly canChangeTheme: Readonly<boolean>;
-    readonly canPresent: Readonly<boolean>;
-    readonly acceptPresentRequests: Readonly<boolean>;
-    readonly canEditDisplayName: Readonly<boolean>;
-    readonly maxScreenShareCount: Readonly<number>;
-    readonly isRecorder: Readonly<boolean>;
-    readonly canSpotlight: Readonly<boolean>;
-    readonly canLivestream: Readonly<boolean>;
-    readonly transcriptionEnabled: Readonly<boolean>;
-}
-interface UserDetailsResponseV2 {
-    participant: UserDetailsResponse;
-    preset: PresetV2CamelCased;
+declare class RTKSelectedPeers {
+    constructor();
+    add(peerId: string, priority: number, context: Context<RTKContextState>): number;
+    delete(peerId: string, context: Context<RTKContextState>): void;
+    index(peerId: string): number;
+    readonly peers: string[];
+    readonly compulsoryPeers: string[];
+    readonly activeSpeakerPeers: string[];
 }
-type LeaveRoomState = 'kicked' | 'ended' | 'left' | 'rejected' | 'connected-meeting' | 'disconnected' | 'failed' | 'stageLeft';
-type LivestreamState = 'IDLE' | 'STARTING' | 'WAITING_ON_MANUAL_INGESTION' | 'LIVESTREAMING' | 'STOPPING';
-type LivestreamEvents = {
-    ['livestreamUpdate']: (state: LivestreamState) => void;
-    ['viewerCountUpdate']: (count: number) => void;
+type PipEvents = {
+    ['cameraToggled']: () => void;
+    ['micToggled']: () => void;
+    ['hangup']: () => void;
+    ['pipStarted']: () => void;
+    ['pipEnded']: () => void;
     ['*']: (eventName: string, ...args: any[]) => void;
 };
-type StartLivestreamConfig = {
-    manualIngestion: boolean;
-};
-interface LivestreamIngestionCredentials {
-    ingestionServer: string;
-    streamKey: string;
+declare class RTKPip extends RTKTypedEventEmitter<PipEvents> {
+    private constructor();
+    static _init(context: Context<RTKContextState>, self: RTKSelf$1): Promise<RTKPip>;
+    overrideIcon(icon: 'handRaise' | 'pin', value: string): Promise<void>;
+    isSupported(): boolean;
+    readonly isActive: boolean;
+    init({ height, width }?: {
+        height?: number;
+        width?: number;
+    }): void;
+    enableSource(source: string): void;
+    disableSource(source: string): void;
+    addSource(id: string, element: HTMLVideoElement, enabled: boolean, pinned?: boolean, displayText?: string, imageUrl?: string, handRaised?: boolean): void;
+    updateSource(id: string, source: any): void;
+    removeSource(id: string): void;
+    removePinnedSource(): void;
+    removeAllSources(): void;
+    enable(): void;
+    disable: (partial?: boolean) => void;
 }
-type LivestreamResponse = {
-    status: string;
-    playbackUrl: string;
-    manualIngest: boolean;
-    ingestionCredentials?: LivestreamIngestionCredentials;
+type TranscriptionData = {
+    id: string;
+    name: string;
+    peerId: string;
+    userId: string;
+    customParticipantId: string;
+    transcript: string;
+    isPartialTranscript: boolean;
+    date: Date;
 };
-declare class RTKLivestream$1 extends RTKTypedEventEmitter<LivestreamEvents> {
-    state: LivestreamState;
-    playbackUrl: string | undefined;
-    ingestionCredentials: LivestreamIngestionCredentials;
-    viewerCount: number;
-    constructor(self: RTKSelf);
-    setLivestreamState(livestreamState: LivestreamState): void;
-    start(livestreamConfig?: StartLivestreamConfig): Promise<void>;
-    stop(): Promise<void>;
-}
-interface RecordingConfig {
-    fileNamePrefix?: string;
-    videoConfig?: {
-        height?: number;
-        width?: number;
-        codec?: string;
-    };
+type AiEvents = {
+    ['transcript']: (t: TranscriptionData) => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+declare class RTKAi extends RTKTypedEventEmitter<AiEvents> {
+    transcripts: TranscriptionData[];
+    readonly telemetry: RTKTelemetry;
+    constructor(context: Context<RTKContextState>);
+    static init(context: Context<RTKContextState>, transcriptionEnabled: boolean): Promise<RTKAi>;
+    static parseTranscript(transcriptData: string, isPartialTranscript?: boolean): TranscriptionData | undefined;
+    static parseTranscripts(transcriptData: string): TranscriptionData[];
+    getActiveTranscript(): Promise<void>;
+    onTranscript(transcript: TranscriptionData): Promise<void>;
 }
-interface ReactNativeFile {
-    uri: string;
-    name: string;
-    type: string;
+type ActiveTabType = 'screenshare' | 'plugin';
+interface ActiveTab {
+    type: ActiveTabType;
+    id: string;
 }
-declare class APIClient extends API {
-    constructor(context: Context<RTKContextState>, options?: APIOptions);
-    getIPDetails(): Promise<any>;
-    getICEServers(): Promise<any>;
-    getPlugins(): Promise<any[]>;
-    getPluginDetails(pluginId: string): Promise<RTKPluginResponse>;
-    getPluginConfig(pluginBaseUrl: string): Promise<PluginConfig>;
-    authorizePlugin(pluginId: string): Promise<string>;
-    getPresignedUrls(filename: string, viewType: string): Promise<{
-        getLocation: any;
-        putLocation: any;
-    }>;
-    uploadFile(file: File | ReactNativeFile, url: string): Promise<void>;
-    startLivestreaming({ manualIngestion, }: StartLivestreamConfig): Promise<LivestreamResponse>;
-    stopLivestreaming(): Promise<FetchResponse<any>>;
-    getActiveLivestream(): Promise<LivestreamResponse>;
-    getUserDetails(): Promise<UserDetailsResponseV2>;
-    startRecording(config: RecordingConfig, allowMultiple?: boolean): Promise<string>;
-    updateRecording(recordingId: string, action: 'stop' | 'pause' | 'resume'): Promise<FetchResponse<any>>;
-    getActiveRecording(): Promise<{
-        status: string;
-        id: string;
-    }>;
-    getActiveTranscript(): Promise<{
-        transcript: string;
-    }>;
-    getRoomNodeData(): Promise<RoomDetails>;
+declare enum TabChangeSource {
+    User = 0,
+    Meeting = 1
 }
-declare enum MessageType {
-    text = "text",
-    image = "image",
-    file = "file",
-    custom = "custom",
-    poll = "poll"
+interface MediaConnectionUpdate {
+    transport: 'consuming' | 'producing';
+    state: string;
+    reconnected: boolean;
 }
-interface BaseMessage<T extends MessageType> {
-    type: T;
-    userId: string;
-    displayName: string;
-    time: Date;
-    timeMs?: number;
-    id: string;
-    isEdited?: boolean;
-    read?: boolean;
-    pluginId?: string;
-    pinned?: boolean;
-    targetUserIds?: string[];
-    channelId?: string;
-    channelIndex?: string;
+type MetaEvents = {
+    ['mediaConnectionUpdate']: (payload: MediaConnectionUpdate) => void;
+    ['socketConnectionUpdate']: (state: SocketConnectionState) => void;
+    ['poorConnection']: (payload: {
+        score: number;
+    }) => void;
+    ['meetingStartTimeUpdate']: (payload: {
+        meetingStartedTimestamp: Date;
+    }) => void;
+    ['transcript']: (t: TranscriptionData) => void;
+    ['activeTabUpdate']: (tab: ActiveTab) => void;
+    ['selfTabUpdate']: (tab: ActiveTab) => void;
+    ['broadcastTabChangesUpdate']: (broadcastTabChanges: boolean) => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+declare class RTKMeta$1 extends RTKTypedEventEmitter<MetaEvents> {
+    selfActiveTab: ActiveTab | undefined;
+    readonly socketState: SocketConnectionState;
+    readonly mediaState: MediaConnectionState;
+    broadcastTabChanges: boolean;
+    viewType: string;
+    meetingStartedTimestamp: Date;
+    meetingTitle: string;
+    sessionId: string;
+    constructor(context: Context<RTKContextState>, self: RTKSelf, viewType: string, roomSocketHandler: RoomSocketHandler, meetingTitle: string);
+    readonly meetingId: string;
+    setBroadcastTabChanges(broadcastTabChanges: boolean): void;
+    setSelfActiveTab(spotlightTab: ActiveTab, tabChangeSource: TabChangeSource): void;
 }
-interface TextMessage extends BaseMessage<MessageType.text> {
-    message: string;
+interface RTKMapEvents<T extends EventMap$1> {
+    onAddEvent?: keyof T;
+    onDeleteEvent?: keyof T;
+    onClearEvent?: keyof T;
 }
-interface CustomMessage extends BaseMessage<MessageType.custom> {
-    message?: string;
-    html?: string;
-    files?: {
-        link: string;
-        type?: string;
-        name?: string;
-        size?: number;
-    }[];
-    images?: {
-        link: string;
-        type?: string;
-        name?: string;
-        size?: number;
-    }[];
-    videos?: {
-        link: string;
-        type?: string;
-        name?: string;
-        size?: number;
-    }[];
-}
-interface ImageMessage extends BaseMessage<MessageType.image> {
-    link: string;
-}
-interface FileMessage extends BaseMessage<MessageType.file> {
-    name: string;
-    size: number;
-    link: string;
-}
-type Message = TextMessage | ImageMessage | FileMessage | CustomMessage;
-interface TextMessagePayload {
-    type: 'text';
-    message: string;
-    replyTo?: TextMessage;
+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[];
 }
-interface CustomMessagePayload {
-    type: 'custom';
-    message?: string;
-    html?: string;
-    files?: (File | string)[];
-    images?: (File | string)[];
-    videos?: (File | string)[];
-    replyTo?: TextMessage;
+type ParticipantMapEvents = {
+    ['participantJoined']: (payload: RTKParticipant$1) => void;
+    ['participantLeft']: (payload: RTKParticipant$1) => void;
+    ['participantsCleared']: () => void;
+    ['participantsUpdate']: () => void;
+    ['kicked']: (payload: {
+        id: string;
+    }) => void;
+};
+declare class RTKParticipantMap$1<T extends Pick<RTKParticipant$1, 'id' | keyof RTKTypedEventEmitter<ParticipantEvents>> = RTKParticipant$1> extends RTKMap<ParticipantEvents, T, ParticipantMapEvents> {
+    constructor(logger: RTKLogger, options?: RTKMapEvents<ParticipantMapEvents>);
+    add(participant: T, emitEvent?: boolean): this;
+    clear(emitEvent?: boolean, removeListeners?: boolean): void;
+    delete(participantId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
 }
-interface ImageMessagePayload {
-    type: 'image';
-    image: File;
+declare const modes: readonly [
+    "ACTIVE_GRID",
+    "PAGINATED",
+    "MANUAL"
+];
+type ViewMode = (typeof modes)[number];
+interface BroadcastMessagePayload {
+    [key: string]: boolean | number | string | Date | ActiveTab;
 }
-interface FileMessagePayload {
-    type: 'file';
-    file: File;
+interface PeerProducerConfig {
+    audio: boolean;
+    video: boolean;
+    screenshareAudio: boolean;
+    screenshareVideo: boolean;
 }
-type MessagePayload = TextMessagePayload | ImageMessagePayload | FileMessagePayload | CustomMessagePayload;
-interface ChatUpdateParams {
-    action: 'add' | 'edit' | 'delete';
-    message: Message | {
-        id: string;
-        channelId: string;
+type BroadcastMessageTarget = {
+    participantIds: string[];
+} | {
+    presetNames: string[];
+} | {
+    meetingIds: string[];
+};
+type JoinedPeer = {
+    id: string;
+    userId: string;
+    name: string;
+    stageType?: StageStatus;
+    customParticipantId?: string;
+    presetId?: string;
+    picture?: string;
+    waitlisted: boolean;
+    recorderType?: string;
+    stageStatus?: StageStatus;
+    metadata?: {
+        preset_name?: string;
     };
-    messages: Message[];
-}
-type ChatEvents = {
-    ['chatUpdate']: (payload: ChatUpdateParams) => void;
-    ['pinMessage']: (payload: Pick<ChatUpdateParams, Exclude<keyof ChatUpdateParams, 'action'>>) => void;
-    ['unpinMessage']: (payload: Pick<ChatUpdateParams, Exclude<keyof ChatUpdateParams, 'action'>>) => void;
-    ['channelCreate']: (channel: ChatChannel) => void;
-    ['channelMessageUpdate']: (channel: ChatChannel) => void;
-    ['channelUpdate']: (channel?: ChatChannel) => void;
+    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 RTKChat$1 extends RTKTypedEventEmitter<ChatEvents> {
-    messages: Message[];
-    channels: ChatChannel[];
-    maxTextLimit: number;
-    setMaxTextLimit(limit: number): void;
-    constructor(context: Context<RTKContextState>, chatSocketHandler: ChatSocketHandler, chatChannelSocketHandler: ChatChannelSocketHandler, self: RTKSelf$1, participants: RTKParticipants$1);
+declare class RTKParticipants$1 extends RTKTypedEventEmitter<ParticipantsEvents> {
+    readonly waitlisted: Readonly<RTKParticipantMap$1<Pick<RTKParticipant$1, Exclude<keyof RTKParticipant$1, 'audioTrack' | 'videoTrack' | 'screenShareTracks'>>>>;
+    readonly joined: Readonly<RTKParticipantMap$1>;
+    readonly active: Readonly<RTKParticipantMap$1>;
+    readonly videoSubscribed: Readonly<RTKParticipantMap$1>;
+    readonly audioSubscribed: Readonly<RTKParticipantMap$1>;
+    readonly pinned: Readonly<RTKParticipantMap$1>;
+    readonly all: Readonly<RTKBasicParticipantsMap>;
+    readonly pip: RTKPip;
+    rateLimitConfig: {
+        maxInvocations: number;
+        period: number;
+    };
     readonly rateLimits: {
         maxInvocations: number;
         period: number;
     };
     updateRateLimits(num: number, period: number): void;
-    sendTextMessage(message: string, peerIds?: string[]): Promise<void>;
-    sendCustomMessage(message: CustomMessagePayload, peerIds?: string[]): Promise<void>;
-    sendImageMessage(image: File | ReactNativeFile, peerIds?: string[]): Promise<void>;
-    sendFileMessage(file: File | ReactNativeFile, peerIds?: string[]): Promise<void>;
-    sendMessage(message: MessagePayload, participantIds?: string[]): Promise<void>;
-    editTextMessage(messageId: string, message: string, channelId?: string): Promise<void>;
-    editImageMessage(messageId: string, image: File | ReactNativeFile, channelId?: string): Promise<void>;
-    editFileMessage(messageId: string, file: File | ReactNativeFile, channelId?: string): Promise<void>;
-    editMessage(messageId: string, message: MessagePayload, channelId?: string): Promise<void>;
-    deleteMessage(messageId: string, channelId?: string): Promise<void>;
-    getMessagesByUser(userId: string): Message[];
-    getMessagesByType(type: keyof typeof MessageType): Message[];
-    pin(id: string): Promise<void>;
-    unpin(id: string): Promise<void>;
-    getMessages(timeStamp: number, size: number, reversed: boolean, offset?: number, channelId?: string): Promise<{
-        messages: Message[];
-        next: boolean;
-    }>;
-    createChannel(channelName: string, memberIds: string[], options?: {
-        displayPictureUrl?: string;
-        visibility?: string;
-        isDirectMessage?: boolean;
-    }): Promise<ChatChannel>;
-    updateChannel(channelId: string, payload: UpdateChannelRequestPayload): Promise<ChatChannel>;
-    sendMessageToChannel(message: MessagePayload, channelId: string, options?: {
-        replyTo?: Message;
-    }): Promise<void>;
-    getChannelMembers(channelId: string): Promise<RTKBasicParticipant[]>;
-    searchMessages(query: string, filters?: SearchFilters): Promise<Message[]>;
-    markLastReadMessage(channelId: string, message: Message): Promise<void>;
-    readonly pinned: Message[];
-}
-declare class PollSocketHandler {
-    constructor(socketService: SocketService);
-    getPolls(): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    createPoll(question: string, options: string[], anonymous?: boolean, hideVotes?: boolean): boolean;
-    votePoll(id: string, index: number): boolean;
-    on(event: number, handler: (message: UpdatePollResponse) => void): void;
-    removeListeners(event: number): void;
+    readonly telemetry: RTKTelemetry;
+    viewMode: ViewMode;
+    currentPage: number;
+    lastActiveSpeaker: string;
+    selectedPeers: RTKSelectedPeers;
+    constructor(context: Context<RTKContextState>, self: RTKSelf$1, roomSocketHandler: RoomSocketHandler);
+    setupEvents(): void;
+    readonly count: number;
+    readonly maxActiveParticipantsCount: number;
+    setMaxActiveParticipantsCount(limit: number): void;
+    readonly pageCount: number;
+    acceptWaitingRoomRequest(id: string): void;
+    acceptAllWaitingRoomRequest(userIds: string[]): Promise<void>;
+    rejectWaitingRoomRequest(id: string): Promise<void>;
+    setViewMode(viewMode: ViewMode): Promise<void>;
+    subscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
+    unsubscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
+    getPeerIdsForCurrentPage(): string[];
+    setPage(page: number): Promise<void>;
+    disableAllAudio(allowUnmute: boolean): Promise<void>;
+    disableAllVideo(): Promise<void>;
+    disableAudio(participantId: string): Promise<void>;
+    disableVideo(participantId: string): Promise<void>;
+    kick(participantId: string): Promise<void>;
+    kickAll(): Promise<void>;
+    broadcastMessage(type: Exclude<string, 'spotlight'>, payload: BroadcastMessagePayload, target?: BroadcastMessageTarget): Promise<void>;
+    getAllJoinedPeers(searchQuery: string, limit: number, offset: number): Promise<{
+        id: string;
+        userId: string;
+        name: string;
+        displayName: string;
+        stageType: StageStatus;
+        customParticipantId: string;
+        presetId: string;
+        picture: string;
+        waitlisted: boolean;
+        stageStatus: StageStatus;
+        metadata: {
+            preset_name: string;
+        };
+        recorderType: string;
+        flags: {
+            hiddenParticipant: boolean;
+            hidden_participant: boolean;
+            recorder: boolean;
+        };
+    }[]>;
+    updatePermissions(participantIds: string[], permissions: PresetUpdates): Promise<void>;
+    getParticipantsInMeetingPreJoin(): Promise<RoomPeersInfoResponse>;
 }
-interface PollOption {
-    text: string;
-    votes: {
-        id: string;
-        name: string;
-    }[];
-    count: number;
+interface FetchRequestConfig {
+    baseURL?: string;
+    url?: string;
+    method?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retry?: number;
+    retryDelay?: number;
+    responseType?: string;
+    data?: any;
+    params?: Record<string, string>;
 }
-interface Poll {
-    id: string;
-    question: string;
-    options: PollOption[];
-    anonymous: boolean;
-    hideVotes: boolean;
-    createdBy: string;
-    createdByUserId: string;
-    voted: string[];
+interface FetchResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    config: FetchRequestConfig;
 }
-type PollsEvents = {
-    ['pollsUpdate']: (payload: {
-        polls: Poll[];
-        newPoll: boolean;
-    }) => void;
-    ['*']: (eventName: string, ...args: any[]) => void;
-};
-declare class RTKPolls$1 extends RTKTypedEventEmitter<PollsEvents> {
-    items: Poll[];
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, pollSocketHandler: PollSocketHandler);
-    create(question: string, options: string[], anonymous?: boolean, hideVotes?: boolean): Promise<void>;
-    vote(id: string, index: number): Promise<void>;
+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 PluginMapEvents = {
-    ['pluginAdded']: (plugin: RTKPlugin$1) => void;
-    ['pluginDeleted']: (plugin: RTKPlugin$1) => void;
-};
-type PluginEvents$1 = {
-    ['stateUpdate']: (payload: {
-        active: boolean;
-        pluginId: string;
-        bind?: (...args: any[]) => void;
-        views: any;
-    }) => void;
-    ['ready']: () => void;
-    ['closed']: () => void;
-    ['toggleViewMode']: (...args: any[]) => void;
-    ['enabled']: () => void;
+type LivestreamState = 'IDLE' | 'STARTING' | 'WAITING_ON_MANUAL_INGESTION' | 'LIVESTREAMING' | 'STOPPING';
+type LivestreamEvents = {
+    ['livestreamUpdate']: (state: LivestreamState) => void;
+    ['viewerCountUpdate']: (count: number) => void;
     ['*']: (eventName: string, ...args: any[]) => void;
 };
-declare class RTKPluginMap$1<T extends RTKPlugin$1 = RTKPlugin$1> extends RTKMap<PluginEvents$1, T, PluginMapEvents> {
-    constructor();
-    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();
-}
-type PluginSocketMessage = DisablePluginResponse | EnablePluginResponse | PluginEventResponse | PluginStoreResponse | SendChatMessageToPeersResponse | SendChatMessageToRoomResponse;
-declare class PluginSocketHandler {
-    constructor(socketService: SocketService);
-    addPlugin(pluginId: string, staggered: boolean): void;
-    removePlugin(pluginId: string): void;
-    getActivePlugins(): Promise<EnablePluginsResponse>;
-    customPluginEventToRoom(pluginId: string, data: any, messageId?: string): void;
-    customPluginEventToPeers(pluginId: string, peerIds: string[], data: any, messageId?: string): void;
-    enablePluginForRoom(pluginId: string, messageId?: string): void;
-    enablePluginForPeers(pluginId: string, peerIds: string[], messageId?: string): void;
-    disablePluginForRoom(pluginId: string, messageId?: string): void;
-    disablePluginForPeers(pluginId: string, peerIds: string[], messageId?: string): void;
-    storeInsertKeys(pluginId: string, store: string, insertKeys: {
-        key: string;
-        payload?: any;
-    }[], messageId?: string): void;
-    storeGetKeys(pluginId: string, store: string, getKeys: {
-        key: string;
-    }[], messageId?: string): void;
-    storeDeleteKeys(pluginId: string, store: string, deleteKeys: {
-        key: string;
-    }[], messageId?: string): void;
-    storeDelete(pluginId: string, store: string, messageId?: string): void;
-    getPluginDataOld(pluginId: string, store: string): void;
-    storePluginDataOld(pluginId: string, store: string, data: any): void;
-    on(event: number, handler: (socketMessage: PluginSocketMessage, messageId?: string) => void): void;
-}
-declare class RTKSelfMedia extends RTKTypedEventEmitter<SelfEvents> {
-    init(options?: {
-            video?: boolean;
-            audio?: boolean;
-            constraints?: MediaConstraints;
-        }, skipAwaits?: boolean, context?: Context<RTKContextState>): Promise<void>;
-    readonly audioTrack: MediaStreamTrack;
-    readonly rawAudioTrack: MediaStreamTrack;
-    readonly mediaPermissions: {
-        audio?: MediaPermission$1;
-        video?: MediaPermission$1;
-        screenshare?: MediaPermission$1;
-    };
-    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    removeAllAudioMiddlewares(): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    readonly videoTrack: MediaStreamTrack;
-    readonly rawVideoTrack: MediaStreamTrack;
-    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    setVideoMiddlewareGlobalConfig(config?: VideoMiddlewareGlobalConfig): Promise<void>;
-    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    removeAllVideoMiddlewares(): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    readonly screenShareTracks: {
-        audio: MediaStreamTrack;
-        video: MediaStreamTrack;
-    };
-    readonly audioEnabled: boolean;
-    readonly videoEnabled: boolean;
-    readonly screenShareEnabled: boolean;
-    enableAudio(): Promise<void>;
-    enableVideo(): Promise<void>;
-    disableAudio(): Promise<void>;
-    enableScreenShare(): Promise<void>;
-    disableScreenShare(): Promise<void>;
-    disableVideo(): Promise<void>;
-    getCurrentDevices(): {
-        audio: MediaDeviceInfo;
-        video: MediaDeviceInfo;
-        speaker: MediaDeviceInfo;
-    };
-    getAudioDevices(): Promise<MediaDeviceInfo[]>;
-    getVideoDevices(): Promise<MediaDeviceInfo[]>;
-    getSpeakerDevices(): Promise<MediaDeviceInfo[]>;
-    getDeviceById(deviceId: string, kind: 'audio' | 'video' | 'speaker'): Promise<MediaDeviceInfo>;
-    setDevice(device: MediaDeviceInfo): Promise<void>;
-}
-type RecordingState = 'IDLE' | 'STARTING' | 'RECORDING' | 'PAUSED' | 'STOPPING';
-type RecordingType = 'BROWSER' | 'TRACK' | 'COMPOSITE';
-type RecordingInfo = {
-    state: RecordingState;
-    id: string;
-    type: RecordingType;
+type StartLivestreamConfig = {
+    manualIngestion: boolean;
 };
-type RecordingEvents = {
-    ['recordingUpdate']: (state: RecordingState) => void;
-    ['*']: (eventName: string, ...args: any[]) => void;
+interface LivestreamIngestionCredentials {
+    ingestionServer: string;
+    streamKey: string;
+}
+type LivestreamResponse = {
+    status: string;
+    playbackUrl: string;
+    manualIngest: boolean;
+    ingestionCredentials?: LivestreamIngestionCredentials;
 };
-declare class RTKRecording$1 extends RTKTypedEventEmitter<RecordingEvents> {
-    recordingPeerIds: string[];
-    readonly recordingState: RecordingState;
-    recordings: RecordingInfo[];
+declare class RTKLivestream$1 extends RTKTypedEventEmitter<LivestreamEvents> {
+    state: LivestreamState;
+    playbackUrl: string | undefined;
+    ingestionCredentials: LivestreamIngestionCredentials;
+    viewerCount: number;
+    readonly telemetry: RTKTelemetry;
     constructor(context: Context<RTKContextState>, self: RTKSelf);
-    updateRecordings(recordings: RecordingInfo[]): void;
-    start(opts?: {
-        allowMultiple: boolean;
-    }): Promise<void>;
-    stop(recordingId?: string): Promise<void>;
-    pause(recordingId?: string): Promise<void>;
-    resume(recordingId?: string): Promise<void>;
+    setLivestreamState(livestreamState: LivestreamState): void;
+    start(livestreamConfig?: StartLivestreamConfig): Promise<void>;
+    stop(): Promise<void>;
 }
-declare class BrowserDetection {
-    _bowser: any;
-    _name: any;
-    _version: any;
-    init(browserInfo?: any): void;
-    getName(): any;
-    isChrome(): boolean;
-    isOpera(): boolean;
-    isFirefox(): boolean;
-    isIExplorer(): boolean;
-    isSafari(): boolean;
-    isNWJS(): boolean;
-    isElectron(): boolean;
-    isReactNative(): boolean;
-    getVersion(): any;
-    isMobile(): boolean;
-    getDeviceInfo: () => {
-        isMobile: boolean;
-        browserName: any;
-        osName: any;
-        browserVersion: any;
-        osVersionName: any;
-        engineName: any;
+type PluginSocketMessage = DisablePluginResponse | EnablePluginResponse | PluginEventResponse | PluginStoreResponse | SendChatMessageToPeersResponse | SendChatMessageToRoomResponse;
+declare class PluginSocketHandler {
+    constructor(context: Context<RTKContextState>, socketService: SocketService);
+    readonly logger: RTKLogger$1;
+    addPlugin(pluginId: string, staggered: boolean): void;
+    removePlugin(pluginId: string): void;
+    getActivePlugins(): Promise<EnablePluginsResponse>;
+    customPluginEventToRoom(pluginId: string, data: any, messageId?: string): void;
+    customPluginEventToPeers(pluginId: string, peerIds: string[], data: any, messageId?: string): void;
+    enablePluginForRoom(pluginId: string, messageId?: string): void;
+    enablePluginForPeers(pluginId: string, peerIds: string[], messageId?: string): void;
+    disablePluginForRoom(pluginId: string, messageId?: string): void;
+    disablePluginForPeers(pluginId: string, peerIds: string[], messageId?: string): void;
+    storeInsertKeys(pluginId: string, store: string, insertKeys: {
+        key: string;
+        payload?: any;
+    }[], messageId?: string): void;
+    storeGetKeys(pluginId: string, store: string, getKeys: {
+        key: string;
+    }[], messageId?: string): void;
+    storeDeleteKeys(pluginId: string, store: string, deleteKeys: {
+        key: string;
+    }[], messageId?: string): void;
+    storeDelete(pluginId: string, store: string, messageId?: string): void;
+    getPluginDataOld(pluginId: string, store: string): void;
+    storePluginDataOld(pluginId: string, store: string, data: any): void;
+    on(event: number, handler: (socketMessage: PluginSocketMessage, messageId?: string) => void): void;
+}
+interface RTKPluginResponse {
+    baseURL: string;
+    createdAt: string;
+    description: string;
+    id: string;
+    name: string;
+    organizationId: string;
+    picture: string;
+    private: boolean;
+    published: boolean;
+    staggered: boolean;
+    tags: string[];
+    type: string;
+    updatedAt: string;
+}
+interface PluginViews {
+    [viewId: string]: {
+        url: string;
+        suggestedPosition: string;
     };
-    _checkCondition(checkTree: any): any;
-    isVersionGreaterThan(version: any): any;
-    isVersionLessThan(version: any): any;
-    isVersionEqualTo(version: any): any;
 }
-declare class BrowserCapabilities extends BrowserDetection {
-    doesVideoMuteByStreamRemove(): boolean;
-    supportsP2P(): boolean;
-    isChromiumBased(): boolean;
-    isWebKitBased(): boolean;
-    isSupported(): boolean;
-    isUserInteractionRequiredForUnmute(): any;
-    supportsVideoMuteOnConnInterrupted(): boolean;
-    supportsBandwidthStatistics(): boolean;
-    supportsCodecPreferences(): boolean;
-    supportsDeviceChangeEvent(): boolean;
-    supportsLocalCandidateRttStatistics(): boolean;
-    supportsPerformanceObserver(): boolean;
-    supportsReceiverStats(): boolean;
-    supportsRTTStatistics(): boolean;
-    usesPlanB(): boolean;
-    usesSdpMungingForSimulcast(): boolean;
-    usesUnifiedPlan(): boolean;
-    usesNewGumFlow(): boolean;
-    usesAdapter(): boolean;
-    usesRidsForSimulcast(): boolean;
-    supportsGetDisplayMedia(): boolean;
-    supportsInsertableStreams(): boolean;
-    supportsAudioRed(): boolean;
-    supportsSdpSemantics(): boolean;
-    _getChromiumBasedVersion(): number;
-    isIOSMobile(): boolean;
+interface PluginConfig {
+    name: string;
+    pluginId: string;
+    version: string;
+    description: string;
+    author?: string;
+    repository?: string;
+    tags?: string[];
+    picture?: string;
+    url?: string;
+    files: {
+        include: string[];
+        exclude?: string[];
+    };
+    views?: PluginViews;
+    contentScript?: string;
+    permissions?: {
+        [key: string]: {
+            default: boolean;
+            description: string;
+        };
+    };
+    config?: {
+        [key: string]: string;
+    };
 }
-declare class RTKFeatures {
-    constructor(context: Context<RTKContextState>);
-    hasFeature(featureName: string): boolean;
-    getFeatureValue(featureName: string): _dyteinternals_utils.RTKFlagValues;
-    getAllFeatures(): {
-            [x: string]: _dyteinternals_utils.RTKFlagsEntry;
-        };
+interface PluginIframeMessage {
+    type: number;
+    uuid: string;
+    payload?: any;
 }
-declare function createSafeToLogError(ex: any): {
-    stack?: string;
-    message?: string;
-    name?: string;
-    reason?: string;
-    code?: number | string;
+interface SendDataOptions {
+    eventName: string;
+    data: any;
+}
+interface ReactNativeWebViewEvent {
+    nativeEvent: {
+        data: string;
+    };
+}
+interface ReactNativeWebView {
+    src: string;
+    allow: string;
+    title: string;
+    props: {
+        onMessage: (event: ReactNativeWebViewEvent) => void;
+    };
+    postMessage: (message: string) => void;
+}
+declare const PluginEventKeys: {
+    stateUpdate: string;
+    ready: string;
+    closed: string;
+    toggleViewMode: string;
+    enabled: string;
+    '* ': string;
 };
-declare const enum PRODUCERS_TYPE {
-    WEBCAM = "webcam",
-    WEBCAM_BACKUP = "webcam_backup",
-    MIC = "mic",
-    SCREENSHARE_VIDEO = "screenshare_video",
-    SCREENSHARE_AUDIO = "screenshare_audio"
+type _string = string & {
+    _?: any;
+};
+type PluginEvents$1 = keyof typeof PluginEventKeys | _string;
+declare class RTKPlugin$1 extends RTKEventEmitter<PluginEvents$1> {
+    readonly baseURL: string;
+    readonly createdAt: Date;
+    readonly description: string;
+    readonly id: string;
+    readonly name: string;
+    readonly organizationId: string;
+    readonly picture: string;
+    readonly private: boolean;
+    readonly published: boolean;
+    readonly staggered: boolean;
+    readonly tags: string[];
+    readonly type: string;
+    readonly updatedAt: Date;
+    config?: PluginConfig;
+    active: boolean;
+    iframes: Map<string, {
+        iframe: HTMLIFrameElement | ReactNativeWebView;
+        listener?: (message: MessageEvent) => void;
+    }>;
+    enabledBy: string;
+    readonly telemetry: RTKTelemetry;
+    constructor(context: Context<RTKContextState>, { baseURL, createdAt, description, id, name, organizationId, picture, private: isPrivate, published, staggered, tags, type, updatedAt, }: RTKPluginResponse, pluginSocketHandler: PluginSocketHandler, self: RTKSelf$1, participants: RTKParticipants$1, chat: Readonly<RTKChat$1>, meetingTitle: string);
+    sendIframeEvent(message: PluginIframeMessage): void;
+    sendData(payload: SendDataOptions): void;
+    removePluginView(viewId?: string): void;
+    addPluginView(iframe: HTMLIFrameElement | ReactNativeWebView, viewId?: string): void;
+    activateForSelf(): Promise<void>;
+    deactivateForSelf(): void;
+    enable(): Promise<void>;
+    disable(): void;
+    activate(): Promise<void>;
+    deactivate(): Promise<void>;
 }
-type SupportedEventSeverities = 'info' | 'error' | 'debug' | 'log' | 'warn';
-type LogData$2 = {
-    error?: ReturnType<typeof createSafeToLogError>;
-    peers?: string;
-    flags?: string | {
-        [key: string]: {
-            enabled: boolean;
-            value: string | number | boolean;
-        };
-    };
-    devices?: string | MediaDeviceInfo[];
-    debuggingHint?: string;
-    constraints?: string | RTKMediaStreamConstraints;
-    timeout?: number;
-    execTime?: number;
-    country?: string;
-    media?: {
-        audio?: {
-            enabled: boolean;
-            deviceName?: string;
-            deviceId?: string;
-            trackId?: string;
-            permission?: keyof typeof MediaPermission;
-            canProduce?: MediaProductionPermissionType;
-        };
-        video?: {
-            enabled?: boolean;
-            deviceName?: string;
-            deviceId?: string;
-            trackId?: string;
-            permission?: keyof typeof MediaPermission;
-            canProduce?: MediaProductionPermissionType;
-            layer?: number;
-        };
-        screenshare?: {
-            enabled: boolean;
-            count?: number;
-            maxAllowedCount?: number;
-            permission?: keyof typeof MediaPermission;
-            deviceName?: string;
-            deviceId?: string;
-            audio?: {
-                enabled: boolean;
-                trackId?: string;
-            };
-            video?: {
-                enabled: boolean;
-                trackId?: string;
-            };
-            canProduce?: MediaProductionPermissionType;
-        };
-    };
-    producerInfo?: {
-        peerId: string;
-        producers: ProducerState[];
-    };
-    preferredDevice?: {
-        kind: 'audio' | 'video';
-        preferredDeviceId?: string;
-        lastUsedPreferredDeviceId?: string;
-    };
-    mediaPermissionsErrors?: {
-        kind: 'audio' | 'video' | 'screenshare';
-        message: string;
-        deviceId?: string;
-    };
-    pip?: {
-        id: string;
-        handRaised?: boolean;
-        source?: any;
-    };
-    memoize?: {
-        doubleInvoked?: {
-            property: string;
-        };
-    };
-    dyteClientInitOptions?: RealtimeKitClientOptions;
-    plugin?: {
-        id?: string;
-        name?: string;
-        enabledBy?: string;
-        duration?: number;
-        storeName?: string;
-        data?: any;
-    };
-    roomJoined?: boolean;
-    transport?: {
-        id?: string;
-        type?: 'send' | 'recv';
-        status?: RTCPeerConnectionState | 'reconnecting';
-        lastDisconnectedTime?: string;
-        lastDisconnectedTimeOffset?: number;
-        durationPassed?: number;
-        remoteOfferAnswer?: RTCSessionDescriptionInit;
-        serverId?: string;
-    };
-    iceCandidate?: RTCIceCandidate;
-    iceRestart?: {
-        status?: RTCPeerConnectionState | 'reconnecting';
-        isSendTransport?: boolean;
-        isRecvTransport?: boolean;
-        currentAttempt?: number;
-    };
-    producer?: {
-        id: string;
-        peerId?: string;
-        kind: 'audio' | 'video' | PRODUCERS_TYPE;
-        status?: 'initializing' | 'producing' | 'paused' | 'failed' | 'closing' | 'closed' | 'UNKNOWN';
-        appData: {
-            screenShare?: boolean;
-            supportsRemoteControl?: boolean;
-        };
-        error?: string;
-        closureReason?: string;
-        remoteAnswer?: SessionDescription;
-        trackId?: string;
-    };
-    consumer?: {
-        id: string;
-        peerId?: string;
-        kind?: string;
-        appData?: {
-            screenShare?: boolean;
-            supportsRemoteControl?: boolean;
-        };
-        remotelyPaused?: boolean;
-        producerId?: string;
-        closureReason?: string;
-        sessionDescription?: RTCSessionDescriptionInit;
-    };
-    consumerIds?: string[];
-    consumerState?: ConsumerState;
-    consumerStateMap?: {
-        [key: string]: ConsumerState;
-    };
-    rtcChannel?: {
-        label?: string;
-        message?: DCMessage;
-        messageStringified?: string;
-    };
-    localStorage?: {
-        key?: string;
-        value?: string;
-    };
-    spotlight?: {
-        spotlighter?: {
-            id?: string;
-        };
-        currentTab?: {
-            id?: string;
-            type?: ActiveTabType;
-        };
-    };
-    networkCall?: {
-        status?: number;
-        statusText?: string;
-        baseURL?: string;
-        url?: string;
-        retries?: number;
-        method?: string;
-        isOnline?: string;
-        ip?: any;
-        timezone?: string;
-    };
-    ipInfo?: {
-        city: string;
-        country: string;
-        region: string;
-        loc: string;
-        timezone: string;
-        ip: string;
-        postal: string;
-    };
-    dytePolls?: {
-        hasQuestion?: boolean;
-        optionsLength?: number;
-    };
-    dyteChat?: {
-        imageType?: string;
-        messageType?: string;
-    };
-    dyteParticipant?: {
-        id: string;
-    };
-    actions?: {
-        disableAllAudio?: {
-            allowUnmute?: boolean;
-        };
-        trackRobustness?: {
-            reacquireTrack?: boolean;
-            eventType?: string;
-        };
-    };
-    recording?: {
-        id?: string;
-        state?: RecordingState;
-    };
-    selectedPeer?: {
-        oldIndex?: number;
-        newIndex?: number;
-        peerId?: string;
-    };
-    pageNavigation?: {
-        viewMode: ViewMode;
-        currentPage: number;
-        pageCount: number;
-        maxActiveParticipantsCount: number;
-        settingPage?: number;
-    };
-    connectedMeetings?: {
-        movement?: {
-            sourceMeetingId?: string;
-            destinationMeetingId?: string;
-            totalParticipantsToMove?: number;
-        };
-    };
-    webinar?: {
-        stageStatus?: StageStatus;
-    };
-    livestream?: {
-        stageStatus?: StageStatus;
-        latency?: number;
-    };
-    moduleExists?: {
-        self?: boolean;
-    };
-    performanceObserver?: {
-        api: PerformanceEntry;
-    };
-    dyteLocker?: {
-        methodName: string;
-        lockName: string;
-    };
-    socket?: {
-        retryAttempt: number;
-    };
-    connectionState?: {
-        joinAttempted: boolean;
-    };
-    source?: string;
-    eventListener?: {
-        eventName: string;
-        listenerCount: number;
-    };
-    dataChannelMessageChunk?: {
+interface RecordingConfig {
+    fileNamePrefix?: string;
+    videoConfig?: {
+        height?: number;
+        width?: number;
+        codec?: string;
+    };
+}
+interface ReactNativeFile {
+    uri: string;
+    name: string;
+    type: string;
+}
+declare class APIClient extends API {
+    telemetry: RTKTelemetry;
+    constructor(context: Context<RTKContextState>, options?: APIOptions);
+    getIPDetails(): Promise<any>;
+    getICEServers(): Promise<any>;
+    getPlugins(): Promise<any[]>;
+    getPluginDetails(pluginId: string): Promise<RTKPluginResponse>;
+    getPluginConfig(pluginBaseUrl: string): Promise<PluginConfig>;
+    authorizePlugin(pluginId: string): Promise<string>;
+    getPresignedUrls(filename: string, viewType: string): Promise<{
+        getLocation: any;
+        putLocation: any;
+    }>;
+    uploadFile(file: File | ReactNativeFile, url: string): Promise<void>;
+    startLivestreaming({ manualIngestion, }: StartLivestreamConfig): Promise<LivestreamResponse>;
+    stopLivestreaming(): Promise<FetchResponse<any>>;
+    getActiveLivestream(): Promise<LivestreamResponse>;
+    getUserDetails(): Promise<UserDetailsResponseV2>;
+    startRecording(config: RecordingConfig, allowMultiple?: boolean): Promise<string>;
+    updateRecording(recordingId: string, action: 'stop' | 'pause' | 'resume'): Promise<FetchResponse<any>>;
+    getActiveRecording(): Promise<{
+        status: string;
         id: string;
-        count: number;
-        chunkIndex: number;
-        chunk: string;
-        transprtId: string;
-    };
-    peerIds?: string[];
-    producers?: ProducerState[];
-    sdp?: RTCSessionDescription['sdp'];
-    awaitQueueTask?: {
-        id?: string | number;
-        metadata?: Record<string, unknown>;
-        queueSizeAtStart?: number;
-        taskStartTime?: number;
-        execTime?: number;
-    };
+    }>;
+    getActiveTranscript(): Promise<{
+        transcript: string;
+    }>;
+    getRoomNodeData(): Promise<RoomDetails>;
+}
+declare enum MessageType {
+    text = "text",
+    image = "image",
+    file = "file",
+    custom = "custom",
+    poll = "poll"
+}
+interface BaseMessage<T extends MessageType> {
+    type: T;
+    userId: string;
+    displayName: string;
+    time: Date;
+    timeMs?: number;
+    id: string;
+    isEdited?: boolean;
+    read?: boolean;
+    pluginId?: string;
+    pinned?: boolean;
+    targetUserIds?: string[];
+    channelId?: string;
+    channelIndex?: string;
+}
+interface TextMessage extends BaseMessage<MessageType.text> {
+    message: string;
+}
+interface CustomMessage extends BaseMessage<MessageType.custom> {
+    message?: string;
+    html?: string;
+    files?: {
+        link: string;
+        type?: string;
+        name?: string;
+        size?: number;
+    }[];
+    images?: {
+        link: string;
+        type?: string;
+        name?: string;
+        size?: number;
+    }[];
+    videos?: {
+        link: string;
+        type?: string;
+        name?: string;
+        size?: number;
+    }[];
+}
+interface ImageMessage extends BaseMessage<MessageType.image> {
+    link: string;
+}
+interface FileMessage extends BaseMessage<MessageType.file> {
+    name: string;
+    size: number;
+    link: string;
+}
+type Message = TextMessage | ImageMessage | FileMessage | CustomMessage;
+interface TextMessagePayload {
+    type: 'text';
+    message: string;
+    replyTo?: TextMessage;
+}
+interface CustomMessagePayload {
+    type: 'custom';
+    message?: string;
+    html?: string;
+    files?: (File | string)[];
+    images?: (File | string)[];
+    videos?: (File | string)[];
+    replyTo?: TextMessage;
+}
+interface ImageMessagePayload {
+    type: 'image';
+    image: File;
+}
+interface FileMessagePayload {
+    type: 'file';
+    file: File;
+}
+type MessagePayload = TextMessagePayload | ImageMessagePayload | FileMessagePayload | CustomMessagePayload;
+interface ChatUpdateParams {
+    action: 'add' | 'edit' | 'delete';
+    message: Message | {
+        id: string;
+        channelId: string;
+    };
+    messages: Message[];
+}
+type ChatEvents = {
+    ['chatUpdate']: (payload: ChatUpdateParams) => void;
+    ['pinMessage']: (payload: Pick<ChatUpdateParams, Exclude<keyof ChatUpdateParams, 'action'>>) => void;
+    ['unpinMessage']: (payload: Pick<ChatUpdateParams, Exclude<keyof ChatUpdateParams, 'action'>>) => void;
+    ['channelCreate']: (channel: ChatChannel) => void;
+    ['channelMessageUpdate']: (channel: ChatChannel) => void;
+    ['channelUpdate']: (channel?: ChatChannel) => void;
+    ['*']: (event: string, ...args: any[]) => void;
 };
-type EventSeverities = SupportedEventSeverities;
-type LogData$1 = LogData$2;
-declare class RTKTelemetry {
-    static logsCache: {
-        [key: string]: any;
-    }[];
-    static logsProcessorTimer: NodeJS.Timer;
-    static location: {
-        country: string;
-    };
-    static readonly logsEndpoint: string;
-    static tracingEnabled: boolean;
-    static initialized: boolean;
-    static readonly logsProcessingInterval = 7000;
-    static logExclusionList: string[];
-    static meetingMetadata: {
-        peerId?: string;
-        roomName?: string;
-        organizationId?: string;
-        sdkVersion?: string;
-        deviceInfo?: object;
-        visitedUrl?: string;
-        userId?: string;
+declare class RTKChat$1 extends RTKTypedEventEmitter<ChatEvents> {
+    messages: Message[];
+    channels: ChatChannel[];
+    maxTextLimit: number;
+    readonly telemetry: RTKTelemetry;
+    setMaxTextLimit(limit: number): void;
+    constructor(context: Context<RTKContextState>, chatSocketHandler: ChatSocketHandler, chatChannelSocketHandler: ChatChannelSocketHandler, self: RTKSelf$1, participants: RTKParticipants$1);
+    readonly rateLimits: {
+        maxInvocations: number;
+        period: number;
     };
-    static resetPeerId(peerId: string): void;
-    static init(context: Context<RTKContextState>, enableTracing: boolean): void;
-    static trace(spanName: string, metadata?: LogData$1 | undefined): (_target: Object, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    static injectContext(injectionReceiver: any): void;
-    static addLogInCurrentSpan(eventSeverity: EventSeverities, eventName: string, metadata?: LogData$1, noCache?: boolean): void;
-    static sendOtelLogsToNewRelic(logs: object[]): void;
-    static processCachedLogs(): void;
-    static destruct(): void;
+    updateRateLimits(num: number, period: number): void;
+    sendTextMessage(message: string, peerIds?: string[]): Promise<void>;
+    sendCustomMessage(message: CustomMessagePayload, peerIds?: string[]): Promise<void>;
+    sendImageMessage(image: File | ReactNativeFile, peerIds?: string[]): Promise<void>;
+    sendFileMessage(file: File | ReactNativeFile, peerIds?: string[]): Promise<void>;
+    sendMessage(message: MessagePayload, participantIds?: string[]): Promise<void>;
+    editTextMessage(messageId: string, message: string, channelId?: string): Promise<void>;
+    editImageMessage(messageId: string, image: File | ReactNativeFile, channelId?: string): Promise<void>;
+    editFileMessage(messageId: string, file: File | ReactNativeFile, channelId?: string): Promise<void>;
+    editMessage(messageId: string, message: MessagePayload, channelId?: string): Promise<void>;
+    deleteMessage(messageId: string, channelId?: string): Promise<void>;
+    getMessagesByUser(userId: string): Message[];
+    getMessagesByType(type: keyof typeof MessageType): Message[];
+    pin(id: string): Promise<void>;
+    unpin(id: string): Promise<void>;
+    getMessages(timeStamp: number, size: number, reversed: boolean, offset?: number, channelId?: string): Promise<{
+        messages: Message[];
+        next: boolean;
+    }>;
+    createChannel(channelName: string, memberIds: string[], options?: {
+        displayPictureUrl?: string;
+        visibility?: string;
+        isDirectMessage?: boolean;
+    }): Promise<ChatChannel>;
+    updateChannel(channelId: string, payload: UpdateChannelRequestPayload): Promise<ChatChannel>;
+    sendMessageToChannel(message: MessagePayload, channelId: string, options?: {
+        replyTo?: Message;
+    }): Promise<void>;
+    getChannelMembers(channelId: string): Promise<RTKBasicParticipant[]>;
+    searchMessages(query: string, filters?: SearchFilters): Promise<Message[]>;
+    markLastReadMessage(channelId: string, message: Message): Promise<void>;
+    readonly pinned: Message[];
+}
+declare class PollSocketHandler {
+    readonly logger: RTKLogger$1;
+    readonly telemetry: RTKTelemetry;
+    constructor(context: Context<RTKContextState>, socketService: SocketService);
+    getPolls(): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    createPoll(question: string, options: string[], anonymous?: boolean, hideVotes?: boolean): boolean;
+    votePoll(id: string, index: number): boolean;
+    on(event: number, handler: (message: UpdatePollResponse) => void): void;
+    removeListeners(event: number): void;
+}
+interface PollOption {
+    text: string;
+    votes: {
+        id: string;
+        name: string;
+    }[];
+    count: number;
+}
+interface Poll {
+    id: string;
+    question: string;
+    options: PollOption[];
+    anonymous: boolean;
+    hideVotes: boolean;
+    createdBy: string;
+    createdByUserId: string;
+    voted: string[];
+}
+type PollsEvents = {
+    ['pollsUpdate']: (payload: {
+        polls: Poll[];
+        newPoll: boolean;
+    }) => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
+};
+declare class RTKPolls$1 extends RTKTypedEventEmitter<PollsEvents> {
+    items: Poll[];
+    constructor(context: Context<RTKContextState>, self: RTKSelf$1, pollSocketHandler: PollSocketHandler);
+    create(question: string, options: string[], anonymous?: boolean, hideVotes?: boolean): Promise<void>;
+    vote(id: string, index: number): Promise<void>;
+}
+type PluginMapEvents = {
+    ['pluginAdded']: (plugin: RTKPlugin$1) => void;
+    ['pluginDeleted']: (plugin: RTKPlugin$1) => void;
+};
+type PluginEvents = {
+    ['stateUpdate']: (payload: {
+        active: boolean;
+        pluginId: string;
+        bind?: (...args: any[]) => void;
+        views: any;
+    }) => void;
+    ['ready']: () => void;
+    ['closed']: () => void;
+    ['toggleViewMode']: (...args: any[]) => void;
+    ['enabled']: () => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
+};
+declare class RTKPluginMap$1<T extends RTKPlugin$1 = RTKPlugin$1> extends RTKMap<PluginEvents, T, PluginMapEvents> {
+    constructor(logger: RTKLogger$1);
+    add(plugin: T, emitEvent?: boolean): this;
+    delete(pluginId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
+}
+declare class RTKPlugins$1 {
+    readonly all: RTKPluginMap$1;
+    readonly active: RTKPluginMap$1;
+    constructor(logger: RTKLogger);
+}
+type RecordingState = 'IDLE' | 'STARTING' | 'RECORDING' | 'PAUSED' | 'STOPPING';
+type RecordingType = 'BROWSER' | 'TRACK' | 'COMPOSITE';
+type RecordingInfo = {
+    state: RecordingState;
+    id: string;
+    type: RecordingType;
+};
+type RecordingEvents = {
+    ['recordingUpdate']: (state: RecordingState) => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
+};
+declare class RTKRecording$1 extends RTKTypedEventEmitter<RecordingEvents> {
+    recordingPeerIds: string[];
+    readonly recordingState: RecordingState;
+    recordings: RecordingInfo[];
+    constructor(context: Context<RTKContextState>, self: RTKSelf);
+    readonly telemetry: RTKTelemetry;
+    updateRecordings(recordings: RecordingInfo[]): void;
+    start(opts?: {
+        allowMultiple: boolean;
+    }): Promise<void>;
+    stop(recordingId?: string): Promise<void>;
+    pause(recordingId?: string): Promise<void>;
+    resume(recordingId?: string): Promise<void>;
 }
-type LogData = LogData$1;
-declare class RTKLogger$1 {
-    static info(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
-    static error(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
-    static debug(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
-    static log(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
-    static warn(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
+declare class BrowserDetection {
+    _bowser: any;
+    _name: any;
+    _version: any;
+    init(browserInfo?: any): void;
+    getName(): any;
+    isChrome(): boolean;
+    isOpera(): boolean;
+    isFirefox(): boolean;
+    isIExplorer(): boolean;
+    isSafari(): boolean;
+    isNWJS(): boolean;
+    isElectron(): boolean;
+    isReactNative(): boolean;
+    getVersion(): any;
+    isMobile(): boolean;
+    getDeviceInfo: () => {
+        isMobile: boolean;
+        browserName: any;
+        osName: any;
+        browserVersion: any;
+        osVersionName: any;
+        engineName: any;
+    };
+    _checkCondition(checkTree: any): any;
+    isVersionGreaterThan(version: any): any;
+    isVersionLessThan(version: any): any;
+    isVersionEqualTo(version: any): any;
+}
+declare class BrowserCapabilities extends BrowserDetection {
+    doesVideoMuteByStreamRemove(): boolean;
+    supportsP2P(): boolean;
+    isChromiumBased(): boolean;
+    isWebKitBased(): boolean;
+    isSupported(): boolean;
+    isUserInteractionRequiredForUnmute(): any;
+    supportsVideoMuteOnConnInterrupted(): boolean;
+    supportsBandwidthStatistics(): boolean;
+    supportsCodecPreferences(): boolean;
+    supportsDeviceChangeEvent(): boolean;
+    supportsLocalCandidateRttStatistics(): boolean;
+    supportsPerformanceObserver(): boolean;
+    supportsReceiverStats(): boolean;
+    supportsRTTStatistics(): boolean;
+    usesPlanB(): boolean;
+    usesSdpMungingForSimulcast(): boolean;
+    usesUnifiedPlan(): boolean;
+    usesNewGumFlow(): boolean;
+    usesAdapter(): boolean;
+    usesRidsForSimulcast(): boolean;
+    supportsGetDisplayMedia(): boolean;
+    supportsInsertableStreams(): boolean;
+    supportsAudioRed(): boolean;
+    supportsSdpSemantics(): boolean;
+    _getChromiumBasedVersion(): number;
+    isIOSMobile(): boolean;
+}
+declare class RTKFeatures {
+    constructor(context: Context<RTKContextState>);
+    hasFeature(featureName: string): boolean;
+    getFeatureValue(featureName: string): _dyteinternals_utils.RTKFlagValues;
+    getAllFeatures(): {
+            [x: string]: _dyteinternals_utils.RTKFlagsEntry;
+        };
 }
 declare class RTKInternals {
     logger: typeof RTKLogger$1;
@@ -4867,6 +4682,13 @@ declare class RTKStoreManager {
     constructor(context: Context<RTKContextState>, handler: PluginSocketHandler);
     create(name: string): Promise<RTKStore$1>;
 }
+declare const enum PRODUCERS_TYPE {
+    WEBCAM = "webcam",
+    WEBCAM_BACKUP = "webcam_backup",
+    MIC = "mic",
+    SCREENSHARE_VIDEO = "screenshare_video",
+    SCREENSHARE_AUDIO = "screenshare_audio"
+}
 interface MediaPermissions {
     canProduceAudio?: MediaProductionPermissionType;
     canProduceVideo?: MediaProductionPermissionType;
@@ -4886,6 +4708,8 @@ declare class MediaNodeClient {
     readonly authToken: string;
     readonly e2ee: boolean;
     readonly peerId: string;
+    readonly telemetry: RTKTelemetry;
+    readonly logger: RTKLogger$1;
     constructor(context: Context<RTKContextState>, nodeType: MediaNodeType, options: MediaNodeClientOptions);
     mediaJoined: boolean;
     reset(): void;
@@ -5081,7 +4905,7 @@ interface DefaultOptions {
     video?: boolean;
     audio?: boolean;
     recording?: RecordingConfig;
-    mediaHandler?: RTKSelfMedia;
+    mediaHandler?: RTKSelfMedia$1;
     autoSwitchAudioDevice?: boolean;
     mediaConfiguration?: {
         video?: VideoQualityConstraints;
@@ -5199,7 +5023,7 @@ declare const ERROR_CODES: {
 };
 declare class RTKError extends Error {
     code: keyof typeof ERROR_CODES;
-    constructor(message: string, code?: keyof typeof ERROR_CODES, log?: boolean);
+    constructor(message: string, code?: keyof typeof ERROR_CODES, logger?: RTKLogger$1 | undefined, log?: boolean);
 }
 type EventMap = {
     [key: string]: (...args: any[]) => void;
@@ -5332,7 +5156,7 @@ declare class AudioPlaybackManager extends AudioPlayback {
     removeParticipantTrack(participantId: string): void;
 }
 type RTKContextState = {
-    authToken: string;
+    authToken?: string;
     peerId?: string;
     apiBase?: string;
     baseURI?: string;
@@ -5368,6 +5192,8 @@ type RTKContextState = {
     audioPlayback?: AudioPlaybackManager;
     options?: RealtimeKitClientOptions;
     self?: RTKSelf;
+    telemetry?: RTKTelemetry;
+    logger?: RTKLogger$1;
     meeting?: RealtimeKitClient;
 };
 interface Context<T extends Record<string, any>> {
@@ -5391,277 +5217,487 @@ declare class SocketService {
     readonly authToken: string;
     readonly capabilities: SocketServiceCapabilities;
     joinAttempted: boolean;
+    readonly telemetry: RTKTelemetry;
+    readonly logger: RTKLogger$1;
     readonly peerId: string;
     constructor(context: Context<RTKContextState>, { peerId, meetingId, authToken, capabilities, }: {
+            peerId: string;
+            meetingId: string;
+            authToken: string;
+            capabilities: SocketServiceCapabilities;
+        });
+    updateURL(peerID: string): void;
+    readonly url: string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    readonly isConnected: boolean;
+    sendMessage(event: number, protobuf?: Uint8Array, messageId?: string): boolean;
+    sendMessagePromise(event: number, protobuf?: Uint8Array, messageId?: string, resp?: number): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    sendMessagePromiseWithTimeout({ event, timeout, protobuf, messageId, resp, }: {
+        timeout: number;
+        event: number;
+        protobuf?: Uint8Array;
+        messageId?: string;
+        resp?: number;
+    }): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    on(event: number, listener: (message: {
+        id?: string;
+        payload?: Uint8Array;
+    }) => void): void;
+    onStateEvent(event: SocketStateEvent, listener: (...args: any) => void): void;
+    removeListener(event: number, listener: (message: {
+        id?: string;
+        payload?: Uint8Array;
+    }) => void): void;
+    removeListeners(event: number): void;
+    flush(): any;
+    handleSocketConnectionEvents(): void;
+}
+type EventHandlerTypes = PeerInfoResponse | GetWaitingRoomRequests | RecordingEvent | UpdatePeersPresetResponse | PeerJoinBroadcastResponse | PeerJoinCompleteResponse | GlobalPeerPinningBroadcastResponse | PeerLeaveResponse | SelectedPeersResponse | SelectedPeersDiffResponse;
+declare class RoomSocketHandler {
+    socket: SocketService;
+    readonly telemetry: RTKTelemetry;
+    readonly logger: RTKLogger$1;
+    cleanup(): Promise<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 DeviceConfig {
+    browserName: string;
+    browserVersion: string;
+    isMobile: boolean;
+    engineName: string;
+    osName: string;
+}
+interface ProducerState {
+    producerId: string;
+    kind: 'audio' | 'video';
+    pause: boolean;
+    screenShare: boolean;
+    producingTransportId: string;
+    producingPeerId: string;
+    mimeType?: string;
+}
+interface Participant {
+    id: string;
+    userId: string;
+    displayName: string;
+    device?: DeviceConfig;
+    picture?: string;
+    isHost: boolean;
+    flags: {
+        [key: string]: string | boolean;
+    };
+    clientSpecificId?: string;
+    customParticipantId?: string;
+    stageStatus?: StageStatus;
+    audioMuted: boolean;
+    audioTrack: MediaStreamTrack;
+    videoTrack: MediaStreamTrack;
+    videoEnabled: boolean;
+    producers?: ProducerState[];
+    metadata?: {
+        preset_name?: string;
+    };
+    recorderType?: string;
+}
+declare class RTKParticipant$1 extends RTKTypedEventEmitter<ParticipantEvents> {
+    id: string;
+    userId: string;
+    name: string;
+    picture: string;
+    isHost: boolean;
+    customParticipantId?: string;
+    readonly clientSpecificId: string;
+    flags: {
+        [key: string]: string | boolean;
+    };
+    device: DeviceConfig;
+    videoTrack: MediaStreamTrack;
+    audioTrack: MediaStreamTrack;
+    screenShareTracks: {
+        audio: MediaStreamTrack;
+        video: MediaStreamTrack;
+    };
+    videoEnabled: boolean;
+    audioEnabled: boolean;
+    screenShareEnabled: boolean;
+    producers: ProducerState[];
+    manualProducerConfig: PeerProducerConfig;
+    supportsRemoteControl: boolean;
+    presetName?: string;
+    readonly stageStatus: StageStatus;
+    readonly telemetry: RTKTelemetry;
+    constructor(context: Context<RTKContextState>, participant: Participant, self: RTKSelf, roomSocket: RoomSocketHandler);
+    setVideoEnabled(videoEnabled: boolean, emitEvent?: boolean): void;
+    setAudioEnabled(audioEnabled: boolean, emitEvent?: boolean): void;
+    setScreenShareEnabled(screenShareEnabled: boolean, emitEvent?: boolean): void;
+    pin(): Promise<void>;
+    unpin(): Promise<void>;
+    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
+    disableAudio(): Promise<void>;
+    kick(): Promise<void>;
+    disableVideo(): Promise<void>;
+    getPermissions(): Promise<Pick<_dyteinternals_utils.Permissions, "plugins" | "polls" | "chat">>;
+    setStageStatus(stageStatus: StageStatus): void;
+    readonly isPinned: boolean;
+    registerVideoElement(videoElem: HTMLVideoElement): void;
+    deregisterVideoElement(videoElem?: HTMLVideoElement): void;
+}
+declare function createSafeToLogError(ex: any): {
+    stack?: string;
+    message?: string;
+    name?: string;
+    reason?: string;
+    code?: number | string;
+};
+type SupportedEventSeverities = 'info' | 'error' | 'debug' | 'log' | 'warn';
+type LogData$2 = {
+    error?: ReturnType<typeof createSafeToLogError>;
+    peers?: string;
+    flags?: string | {
+        [key: string]: {
+            enabled: boolean;
+            value: string | number | boolean;
+        };
+    };
+    devices?: string | MediaDeviceInfo[];
+    debuggingHint?: string;
+    constraints?: string | RTKMediaStreamConstraints;
+    timeout?: number;
+    execTime?: number;
+    country?: string;
+    media?: {
+        audio?: {
+            enabled: boolean;
+            deviceName?: string;
+            deviceId?: string;
+            trackId?: string;
+            permission?: keyof typeof MediaPermission;
+            canProduce?: MediaProductionPermissionType;
+        };
+        video?: {
+            enabled?: boolean;
+            deviceName?: string;
+            deviceId?: string;
+            trackId?: string;
+            permission?: keyof typeof MediaPermission;
+            canProduce?: MediaProductionPermissionType;
+            layer?: number;
+        };
+        screenshare?: {
+            enabled: boolean;
+            count?: number;
+            maxAllowedCount?: number;
+            permission?: keyof typeof MediaPermission;
+            deviceName?: string;
+            deviceId?: string;
+            audio?: {
+                enabled: boolean;
+                trackId?: string;
+            };
+            video?: {
+                enabled: boolean;
+                trackId?: string;
+            };
+            canProduce?: MediaProductionPermissionType;
+        };
+    };
+    producerInfo?: {
         peerId: string;
-        meetingId: string;
-        authToken: string;
-        capabilities: SocketServiceCapabilities;
-    });
-    updateURL(peerID: string): void;
-    readonly url: string;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    readonly isConnected: boolean;
-    sendMessage(event: number, protobuf?: Uint8Array, messageId?: string): boolean;
-    sendMessagePromise(event: number, protobuf?: Uint8Array, messageId?: string, resp?: number): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    sendMessagePromiseWithTimeout({ event, timeout, protobuf, messageId, resp, }: {
-        timeout: number;
-        event: number;
-        protobuf?: Uint8Array;
-        messageId?: string;
-        resp?: number;
-    }): Promise<{
+        producers: ProducerState[];
+    };
+    preferredDevice?: {
+        kind: 'audio' | 'video';
+        preferredDeviceId?: string;
+        lastUsedPreferredDeviceId?: string;
+    };
+    mediaPermissionsErrors?: {
+        kind: 'audio' | 'video' | 'screenshare';
+        message: string;
+        deviceId?: string;
+    };
+    pip?: {
         id: string;
-        payload: Uint8Array;
-    }>;
-    on(event: number, listener: (message: {
+        handRaised?: boolean;
+        source?: any;
+    };
+    memoize?: {
+        doubleInvoked?: {
+            property: string;
+        };
+    };
+    dyteClientInitOptions?: RealtimeKitClientOptions;
+    plugin?: {
         id?: string;
-        payload?: Uint8Array;
-    }) => void): void;
-    onStateEvent(event: SocketStateEvent, listener: (...args: any) => void): void;
-    removeListener(event: number, listener: (message: {
+        name?: string;
+        enabledBy?: string;
+        duration?: number;
+        storeName?: string;
+        data?: any;
+    };
+    roomJoined?: boolean;
+    transport?: {
         id?: string;
-        payload?: Uint8Array;
-    }) => void): void;
-    removeListeners(event: number): void;
-    flush(): any;
-    handleSocketConnectionEvents(): void;
-}
-type StageSocketMessage = GetStageRequestsResponse | GetStagePeersResponse | DenyStageAccessRequest | PeerStatusUpdate;
-declare class StageSocketHandler {
-    constructor(socketService: SocketService);
-    getStageRequests(): Promise<GetStageRequestsResponse>;
-    requestAccess(): void;
-    cancelRequestAccess(): void;
-    grantAccess(userIds: string[]): Promise<void>;
-    denyAccess(userIds: string[]): Promise<void>;
-    joinStage(): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    leaveStage(userId: string): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    kick(userIds: string[]): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    on(event: number, handler: (socketMessage: StageSocketMessage, messageId?: string) => void): void;
-    getPeerInfo(peerId: string): Promise<PeerInfoResponse>;
-}
-type StageStatus = 'OFF_STAGE' | 'REQUESTED_TO_JOIN_STAGE' | 'ACCEPTED_TO_JOIN_STAGE' | 'ON_STAGE';
-interface StageRequestPayload {
-    displayName: string;
-    userId: string;
-    peerId: string;
-}
-type StageEvents = {
-    ['stageAccessRequestUpdate']: (requests?: StageRequestPayload[]) => void;
-    ['stageStatusUpdate']: (status: StageStatus) => void;
-    ['newStageRequest']: (payload: {
-        count: number;
-    }) => void;
-    ['stageRequestApproved']: () => void;
-    ['stageRequestRejected']: () => void;
-    ['*']: (eventName: string, ...args: any[]) => void;
-};
-declare class RTKStage extends RTKTypedEventEmitter<StageEvents> {
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, participants: RTKParticipants, stageSocketHandler: StageSocketHandler, roomSocketHandler: RoomSocketHandler);
-    readonly status: StageStatus;
-    getAccessRequests(): {
-        stageRequests: StageRequestPayload[];
+        type?: 'send' | 'recv';
+        status?: RTCPeerConnectionState | 'reconnecting';
+        lastDisconnectedTime?: string;
+        lastDisconnectedTimeOffset?: number;
+        durationPassed?: number;
+        remoteOfferAnswer?: RTCSessionDescriptionInit;
+        serverId?: string;
+    };
+    iceCandidate?: RTCIceCandidate;
+    iceRestart?: {
+        status?: RTCPeerConnectionState | 'reconnecting';
+        isSendTransport?: boolean;
+        isRecvTransport?: boolean;
+        currentAttempt?: number;
+    };
+    producer?: {
+        id: string;
+        peerId?: string;
+        kind: 'audio' | 'video' | PRODUCERS_TYPE;
+        status?: 'initializing' | 'producing' | 'paused' | 'failed' | 'closing' | 'closed' | 'UNKNOWN';
+        appData: {
+            screenShare?: boolean;
+            supportsRemoteControl?: boolean;
+        };
+        error?: string;
+        closureReason?: string;
+        remoteAnswer?: SessionDescription;
+        trackId?: string;
+    };
+    consumer?: {
+        id: string;
+        peerId?: string;
+        kind?: string;
+        appData?: {
+            screenShare?: boolean;
+            supportsRemoteControl?: boolean;
+        };
+        remotelyPaused?: boolean;
+        producerId?: string;
+        closureReason?: string;
+        sessionDescription?: RTCSessionDescriptionInit;
+    };
+    consumerIds?: string[];
+    consumerState?: ConsumerState;
+    consumerStateMap?: {
+        [key: string]: ConsumerState;
+    };
+    rtcChannel?: {
+        label?: string;
+        message?: DCMessage;
+        messageStringified?: string;
+    };
+    localStorage?: {
+        key?: string;
+        value?: string;
+    };
+    spotlight?: {
+        spotlighter?: {
+            id?: string;
+        };
+        currentTab?: {
+            id?: string;
+            type?: ActiveTabType;
+        };
+    };
+    networkCall?: {
+        status?: number;
+        statusText?: string;
+        baseURL?: string;
+        url?: string;
+        retries?: number;
+        method?: string;
+        isOnline?: string;
+        ip?: any;
+        timezone?: string;
+    };
+    ipInfo?: {
+        city: string;
+        country: string;
+        region: string;
+        loc: string;
+        timezone: string;
+        ip: string;
+        postal: string;
+    };
+    dytePolls?: {
+        hasQuestion?: boolean;
+        optionsLength?: number;
+    };
+    dyteChat?: {
+        imageType?: string;
+        messageType?: string;
+    };
+    dyteParticipant?: {
+        id: string;
+    };
+    actions?: {
+        disableAllAudio?: {
+            allowUnmute?: boolean;
+        };
+        trackRobustness?: {
+            reacquireTrack?: boolean;
+            eventType?: string;
+        };
+    };
+    recording?: {
+        id?: string;
+        state?: RecordingState;
+    };
+    selectedPeer?: {
+        oldIndex?: number;
+        newIndex?: number;
+        peerId?: string;
     };
-    requestAccess(): Promise<void>;
-    cancelRequestAccess(): Promise<void>;
-    grantAccess(userIds: string[]): Promise<void>;
-    denyAccess(userIds: string[]): Promise<void>;
-    join(): Promise<void>;
-    leave(): Promise<void>;
-    kick(userIds: string[]): Promise<{
+    pageNavigation?: {
+        viewMode: ViewMode;
+        currentPage: number;
+        pageCount: number;
+        maxActiveParticipantsCount: number;
+        settingPage?: number;
+    };
+    connectedMeetings?: {
+        movement?: {
+            sourceMeetingId?: string;
+            destinationMeetingId?: string;
+            totalParticipantsToMove?: number;
+        };
+    };
+    webinar?: {
+        stageStatus?: StageStatus;
+    };
+    livestream?: {
+        stageStatus?: StageStatus;
+        latency?: number;
+    };
+    moduleExists?: {
+        self?: boolean;
+    };
+    performanceObserver?: {
+        api: PerformanceEntry;
+    };
+    dyteLocker?: {
+        methodName: string;
+        lockName: string;
+    };
+    socket?: {
+        retryAttempt: number;
+    };
+    connectionState?: {
+        joinAttempted: boolean;
+    };
+    source?: string;
+    eventListener?: {
+        eventName: string;
+        listenerCount: number;
+    };
+    dataChannelMessageChunk?: {
         id: string;
-        payload: Uint8Array;
-    }>;
-}
-interface UserDetailsResponse {
-    id: string;
-    name: string;
-    email: string;
-    picture?: string;
-    loggedIn?: boolean;
-    scope?: string[];
-    clientSpecificId?: string;
-    customParticipantId?: string;
+        count: number;
+        chunkIndex: number;
+        chunk: string;
+        transprtId: string;
+    };
+    peerIds?: string[];
+    producers?: ProducerState[];
+    sdp?: RTCSessionDescription['sdp'];
+    awaitQueueTask?: {
+        id?: string | number;
+        metadata?: Record<string, unknown>;
+        queueSizeAtStart?: number;
+        taskStartTime?: number;
+        execTime?: number;
+    };
+};
+type EventSeverities = SupportedEventSeverities;
+type LogData$1 = LogData$2;
+interface MeetingMetadata {
+    peerId?: string;
+    roomName?: string;
     organizationId?: string;
+    sdkVersion?: string;
+    deviceInfo?: object;
+    visitedUrl?: string;
+    userId?: string;
 }
-declare class RTKSelf$1 extends RTKSelfMedia {
-    name: string;
-    picture: string;
-    customParticipantId: string;
-    waitlistStatus: 'accepted' | 'waiting' | 'rejected' | 'none';
-    role: any;
-    userId: string;
-    organizationId: string;
-    supportsRemoteControl: boolean;
-    device: DeviceConfig;
-    hidden: boolean;
-    readonly stageStatus: StageStatus;
-    readonly id: string;
-    presetName: string;
-    roomState: 'init' | 'joined' | 'waitlisted' | LeaveRoomState;
-    private constructor();
-    static __init__(context: Context<RTKContextState>, details: UserDetailsResponse, permissions: RTKPermissionsPreset$1, theme: RTKThemePreset$1, presetName: string, skipAwaits?: boolean): Promise<RTKSelf$1>;
-    cleanupEvents(): void;
-    readonly permissions: RTKPermissionsPreset$1;
-    readonly config: RTKThemePreset$1;
-    readonly roomJoined: boolean;
-    setName(name: string): void;
-    setupTracks(options?: {
-        video?: boolean;
-        audio?: boolean;
-        forceReset?: boolean;
-    }): Promise<void>;
-    destructMediaHandler(): Promise<void>;
-    removeDocumentEventListeners(): Promise<void>;
-    enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
-    enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
-    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
-    enableScreenShare(): Promise<void>;
-    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
-    disableAudio(): Promise<void>;
-    disableVideo(): Promise<void>;
-    disableScreenShare(): Promise<void>;
-    getAllDevices(): Promise<InputDeviceInfo[]>;
-    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
-    readonly isPinned: boolean;
-    pin(): Promise<void>;
-    unpin(): Promise<void>;
-    hide(): Promise<void>;
-    show(): void;
-    setDevice(device: MediaDeviceInfo): Promise<void>;
-    cleanUpTracks(): void;
-    playAudio(): Promise<void>;
-    registerVideoElement(videoElem: HTMLVideoElement, isPreview?: boolean): void;
-    deregisterVideoElement(videoElem?: HTMLVideoElement, isPreview?: boolean): void;
-}
-interface RTKPluginResponse {
-    baseURL: string;
-    createdAt: string;
-    description: string;
-    id: string;
-    name: string;
-    organizationId: string;
-    picture: string;
-    private: boolean;
-    published: boolean;
-    staggered: boolean;
-    tags: string[];
-    type: string;
-    updatedAt: string;
-}
-interface PluginViews {
-    [viewId: string]: {
-        url: string;
-        suggestedPosition: string;
-    };
-}
-interface PluginConfig {
-    name: string;
-    pluginId: string;
-    version: string;
-    description: string;
-    author?: string;
-    repository?: string;
-    tags?: string[];
-    picture?: string;
-    url?: string;
-    files: {
-        include: string[];
-        exclude?: string[];
-    };
-    views?: PluginViews;
-    contentScript?: string;
-    permissions?: {
-        [key: string]: {
-            default: boolean;
-            description: string;
-        };
-    };
-    config?: {
-        [key: string]: string;
-    };
-}
-interface PluginIframeMessage {
-    type: number;
-    uuid: string;
-    payload?: any;
-}
-interface SendDataOptions {
-    eventName: string;
-    data: any;
-}
-interface ReactNativeWebViewEvent {
-    nativeEvent: {
-        data: string;
-    };
-}
-interface ReactNativeWebView {
-    src: string;
-    allow: string;
-    title: string;
-    props: {
-        onMessage: (event: ReactNativeWebViewEvent) => void;
-    };
-    postMessage: (message: string) => void;
+declare class RTKTelemetry {
+    logsCache: {
+        [key: string]: any;
+    }[];
+    logsProcessorTimer: NodeJS.Timer;
+    static location: {
+        country: string;
+    };
+    readonly logsEndpoint: string;
+    tracingEnabled: boolean;
+    initialized: boolean;
+    readonly logsProcessingInterval = 7000;
+    logExclusionList: string[];
+    meetingMetadata: MeetingMetadata;
+    resetPeerId(peerId: string): void;
+    init(context: Context<RTKContextState>, options: MeetingMetadata, enableTracing: boolean): void;
+    static trace(spanName: string, metadata?: LogData$1 | undefined): (_target: Object, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    injectContext(injectionReceiver: any): void;
+    addLogInCurrentSpan(eventSeverity: EventSeverities, eventName: string, metadata?: LogData$1, noCache?: boolean): void;
+    sendOtelLogsToNewRelic(logs: object[]): void;
+    processCachedLogs(): void;
+    destruct(): void;
 }
-declare const PluginEventKeys: {
-    stateUpdate: string;
-    ready: string;
-    closed: string;
-    toggleViewMode: string;
-    enabled: string;
-    '* ': string;
-};
-type _string = string & {
-    _?: any;
-};
-type PluginEvents = keyof typeof PluginEventKeys | _string;
-declare class RTKPlugin$1 extends RTKEventEmitter<PluginEvents> {
-    readonly baseURL: string;
-    readonly createdAt: Date;
-    readonly description: string;
-    readonly id: string;
-    readonly name: string;
-    readonly organizationId: string;
-    readonly picture: string;
-    readonly private: boolean;
-    readonly published: boolean;
-    readonly staggered: boolean;
-    readonly tags: string[];
-    readonly type: string;
-    readonly updatedAt: Date;
-    config?: PluginConfig;
-    active: boolean;
-    iframes: Map<string, {
-        iframe: HTMLIFrameElement | ReactNativeWebView;
-        listener?: (message: MessageEvent) => void;
-    }>;
-    enabledBy: string;
-    constructor(context: Context<RTKContextState>, { baseURL, createdAt, description, id, name, organizationId, picture, private: isPrivate, published, staggered, tags, type, updatedAt, }: RTKPluginResponse, pluginSocketHandler: PluginSocketHandler, self: RTKSelf$1, participants: RTKParticipants$1, chat: Readonly<RTKChat$1>, meetingTitle: string);
-    sendIframeEvent(message: PluginIframeMessage): void;
-    sendData(payload: SendDataOptions): void;
-    removePluginView(viewId?: string): void;
-    addPluginView(iframe: HTMLIFrameElement | ReactNativeWebView, viewId?: string): void;
-    activateForSelf(): Promise<void>;
-    deactivateForSelf(): void;
-    enable(): Promise<void>;
-    disable(): void;
-    activate(): Promise<void>;
-    deactivate(): Promise<void>;
+type LogData = LogData$1;
+declare class RTKLogger$1 {
+    readonly telemetry: RTKTelemetry;
+    init(context: Context<RTKContextState>): void;
+    info(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
+    error(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
+    debug(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
+    log(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
+    warn(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
 }
 interface IceServerInformation {
     url: string;
@@ -5688,6 +5724,7 @@ declare class API {
     ipInfo: any;
     readonly peerId: string;
     context: Context<RTKContextState>;
+    readonly logger: RTKLogger$1;
     constructor(context: Context<RTKContextState>, options?: APIOptions);
     setAuthToken(token: string, options?: {
         bearer?: boolean;
@@ -5713,6 +5750,12 @@ interface RealtimeKitClientOptions {
 }
 declare class RealtimeKitClient {
     private constructor();
+    readonly peerId: string;
+    static initMedia(options?: {
+            video?: boolean;
+            audio?: boolean;
+            constraints?: MediaConstraints;
+        }, skipAwaits?: boolean, cachedUserDetails?: CachedUserDetails): RTKSelfMedia$1;
     static init(options: RealtimeKitClientOptions): Promise<RealtimeKitClient>;
     join(): Promise<void>;
     leave(state?: LeaveRoomState): Promise<void>;
@@ -5744,6 +5787,7 @@ 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>;
@@ -5752,6 +5796,7 @@ type RTKStore = RTKStore$1;
 type RTKConnectedMeetings = Readonly<RTKConnectedMeetings$1>;
 type RTKPermissionsPreset = Readonly<RTKPermissionsPreset$1>;
 type RTKThemePreset = Readonly<RTKThemePreset$1>;
+type RTKLogger = RTKLogger$1;
 type RTKType = {
     callStats?: unknown;
     RTKTelemetry?: typeof RTKTelemetry;
@@ -5769,4 +5814,4 @@ declare global {
         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, RTKStore, RTKThemePreset, FileMessage, ImageMessage, JoinedPeer, LeaveRoomState, LivestreamIngestionCredentials, LivestreamState, LogData, MediaConnectionState, MediaConnectionUpdate, MediaKind$1 as MediaKind, MediaPermission, Message, ProducerScoreStats, RTKSelfMedia as RTKSelfMedia, RecordingState, RequestToJoinType, SocketConnectionState, StageStatus, StartLivestreamConfig, TextMessage, VideoConsumerScoreStats, VideoMiddleware, VideoProducerScoreStats, VideoQualityConstraints, RealtimeKitClient as default, LeaveRoomState as leaveRoomState };
+export { ActiveTab, ActiveTabType, AudioConsumerScoreStats, AudioMiddleware, AudioProducerScoreStats, BroadcastMessagePayload, ChatChannel, ChatUpdateParams, CustomMessage, DeviceConfig, RTKBasicParticipant, RTKChat, RealtimeKitClientOptions, RTKConnectedMeetings, RTKLivestream, RTKMeta, RTKParticipant, RTKParticipantMap, RTKParticipants, RTKPermissionsPreset, RTKPlugin, RTKPluginMap, RTKPlugins, RTKPolls, RTKRecording, RTKSelf, RTKSelfMedia, RTKStore, RTKThemePreset, FileMessage, ImageMessage, JoinedPeer, LeaveRoomState, LivestreamIngestionCredentials, LivestreamState, LogData, MediaConnectionState, MediaConnectionUpdate, MediaKind$1 as MediaKind, MediaPermission, Message, ProducerScoreStats, RecordingState, RequestToJoinType, SocketConnectionState, StageStatus, StartLivestreamConfig, TextMessage, VideoConsumerScoreStats, VideoMiddleware, VideoProducerScoreStats, VideoQualityConstraints, RealtimeKitClient as default, LeaveRoomState as leaveRoomState };