@cloudflare/realtimekit 0.5.0-staging.49 → 0.5.0-staging.50

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 import { EventEmitter } from 'events';
 import { MessageType as MessageType$1 } from '@protobuf-ts/runtime';
+import * as _dyteinternals_utils from '@dyteinternals/utils';
+import { ViewType, PresetTypeV2, MediaVideoQualityType, MediaProductionPermissionType, WaitingRoomTypes, MediaScreenShareQualityType, LivestreamViewerMediaQualityType, PluginAccessControls, RecorderType as RecorderType$1, BorderRadius, BorderWidth, Theme } from '@dyteinternals/utils';
 import * as WorkerTimers from 'worker-timers';
 
 // TypeScript Version: 3.0
@@ -278,6 +280,54 @@ declare enum ProducerKind {
      */
     VIDEO = 1
 }
+declare class Codec$Type extends MessageType$1<Codec> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.Codec
+ */
+interface Codec {
+    /**
+     * @generated from protobuf field: optional int32 channels = 1;
+     */
+    channels?: number;
+    /**
+     * @generated from protobuf field: int32 clock_rate = 2;
+     */
+    clockRate: number;
+    /**
+     * @generated from protobuf field: string mime_type = 3;
+     */
+    mimeType: string;
+    /**
+     * @generated from protobuf field: optional string sdp_fmtp_line = 4;
+     */
+    sdpFmtpLine?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.Codec
+ */
+declare const Codec: Codec$Type;
+declare class HeaderExtension$Type extends MessageType$1<HeaderExtension> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.HeaderExtension
+ */
+interface HeaderExtension {
+    /**
+     * @generated from protobuf field: optional string direction = 1;
+     */
+    direction?: string;
+    /**
+     * @generated from protobuf field: string uri = 2;
+     */
+    uri: string;
+}
+/**
+ * @generated MessageType for protobuf message media.HeaderExtension
+ */
+declare const HeaderExtension: HeaderExtension$Type;
 declare class SessionDescription$Type extends MessageType$1<SessionDescription> {
     constructor();
 }
@@ -361,6 +411,10 @@ interface ProducerState$1 {
      * @generated from protobuf field: optional string producing_transport_id = 6;
      */
     producingTransportId?: string;
+    /**
+     * @generated from protobuf field: optional string mime_type = 7;
+     */
+    mimeType?: string;
 }
 /**
  * @generated MessageType for protobuf message media.ProducerState
@@ -390,6 +444,66 @@ interface ConsumerState {
  * @generated MessageType for protobuf message media.ConsumerState
  */
 declare const ConsumerState: ConsumerState$Type;
+declare class PeerRtpCapabilitites$Type extends MessageType$1<PeerRtpCapabilitites> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.PeerRtpCapabilitites
+ */
+interface PeerRtpCapabilitites {
+    /**
+     * @generated from protobuf field: media.RtpCapabilitites sender = 1;
+     */
+    sender?: RtpCapabilitites;
+    /**
+     * @generated from protobuf field: media.RtpCapabilitites receiver = 2;
+     */
+    receiver?: RtpCapabilitites;
+}
+/**
+ * @generated MessageType for protobuf message media.PeerRtpCapabilitites
+ */
+declare const PeerRtpCapabilitites: PeerRtpCapabilitites$Type;
+declare class RtpCapability$Type extends MessageType$1<RtpCapability> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.RtpCapability
+ */
+interface RtpCapability {
+    /**
+     * @generated from protobuf field: repeated media.Codec codecs = 1;
+     */
+    codecs: Codec[];
+    /**
+     * @generated from protobuf field: repeated media.HeaderExtension header_extensions = 2;
+     */
+    headerExtensions: HeaderExtension[];
+}
+/**
+ * @generated MessageType for protobuf message media.RtpCapability
+ */
+declare const RtpCapability: RtpCapability$Type;
+declare class RtpCapabilitites$Type extends MessageType$1<RtpCapabilitites> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.RtpCapabilitites
+ */
+interface RtpCapabilitites {
+    /**
+     * @generated from protobuf field: media.RtpCapability audio = 1;
+     */
+    audio?: RtpCapability;
+    /**
+     * @generated from protobuf field: media.RtpCapability video = 2;
+     */
+    video?: RtpCapability;
+}
+/**
+ * @generated MessageType for protobuf message media.RtpCapabilitites
+ */
+declare const RtpCapabilitites: RtpCapabilitites$Type;
 
 declare class GeoLocation$Type extends MessageType$1<GeoLocation> {
     constructor();
@@ -484,6 +598,10 @@ interface RoomParticipants {
      * @generated from protobuf field: optional string user_id = 4;
      */
     userId?: string;
+    /**
+     * @generated from protobuf field: optional media.PeerRtpCapabilitites capabilities = 5;
+     */
+    capabilities?: PeerRtpCapabilitites;
 }
 /**
  * @generated MessageType for protobuf message media.edge.RoomParticipants
@@ -627,7 +745,7 @@ declare const GlobalPeerPinningBroadcastResponse: GlobalPeerPinningBroadcastResp
  *
  * @generated from protobuf enum common.RecordingType
  */
-declare enum RecordingType {
+declare enum RecordingType$1 {
     /**
      * @generated from protobuf enum value: BROWSER = 0;
      */
@@ -670,7 +788,7 @@ declare enum StageType {
 /**
  * @generated from protobuf enum socket.room.RecorderType
  */
-declare enum RecorderType$1 {
+declare enum RecorderType {
     /**
      * @generated from protobuf enum value: RECORDER_TYPE_NONE = 0;
      */
@@ -875,7 +993,7 @@ interface ActiveRecording {
     /**
      * @generated from protobuf field: common.RecordingType recording_type = 2;
      */
-    recordingType: RecordingType;
+    recordingType: RecordingType$1;
     /**
      * @generated from protobuf field: string recording_status = 3;
      */
@@ -920,6 +1038,18 @@ interface WaitingRoomRequest {
      * @generated from protobuf field: string display_name = 3;
      */
     displayName: string;
+    /**
+     * @generated from protobuf field: optional string picture = 4;
+     */
+    picture?: string;
+    /**
+     * @generated from protobuf field: optional string custom_participant_id = 5;
+     */
+    customParticipantId?: string;
+    /**
+     * @generated from protobuf field: optional string preset_name = 6;
+     */
+    presetName?: string;
 }
 /**
  * @generated MessageType for protobuf message socket.room.WaitingRoomRequest
@@ -1272,7 +1402,7 @@ interface PresetUpdates {
     /**
      * @generated from protobuf field: optional socket.room.RecorderType recorder_type = 18;
      */
-    recorderType?: RecorderType$1;
+    recorderType?: RecorderType;
     /**
      * @generated from protobuf field: optional bool hidden_participant = 19;
      */
@@ -1929,207 +2059,121 @@ interface RecordingEvent {
     /**
      * @generated from protobuf field: common.RecordingType recording_type = 3;
      */
-    recordingType: RecordingType;
+    recordingType: RecordingType$1;
 }
 /**
  * @generated MessageType for protobuf message socket.recording.RecordingEvent
  */
 declare const RecordingEvent: RecordingEvent$Type;
 
-declare type BorderWidth = 'none' | 'thin' | 'fat';
-declare type BorderRadius = 'sharp' | 'rounded' | 'extra-rounded' | 'circular';
-declare type Theme = 'darkest' | 'dark' | 'light';
-/**
- * UI Colors
- *
- * Accepts hex color codes.
- */
-interface UIColors {
-    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;
-    text_on_brand: string;
-    text: string;
-    video_bg: string;
-    warning: string;
-}
-interface DesignTokens {
-    border_radius: BorderRadius;
-    border_width: BorderWidth;
-    colors: UIColors;
-    font_family?: string;
-    google_font?: string;
-    logo?: string;
-    spacing_base: number;
-    theme: Theme;
-}
-
-declare enum ViewType {
-    GroupCall = "GROUP_CALL",
-    Webinar = "WEBINAR",
-    AudioRoom = "AUDIO_ROOM",
-    Livestream = "LIVESTREAM",
-    Chat = "CHAT"
-}
-declare enum WaitingRoomTypes {
-    Skip = "SKIP",
-    OnPrivilegedUserEntry = "ON_PRIVILEGED_USER_ENTRY",
-    SkipOnAccept = "SKIP_ON_ACCEPT"
-}
-declare enum MediaProductionPermissionType {
-    Allowed = "ALLOWED",
-    NotAllowed = "NOT_ALLOWED",
-    CanRequest = "CAN_REQUEST"
-}
-declare type MediaVideoQualityType = 'qvga' | 'vga' | 'hd' | 'hd_cropped' | 'fhd';
-declare type MediaScreenShareQualityType = 'vga' | 'hd' | 'full_hd';
-declare type Config = {
-    view_type: ViewType;
-    media: {
-        audio: {
-            enable_stereo: boolean;
-            enable_high_bitrate: boolean;
-        };
-        video: {
-            quality: MediaVideoQualityType;
-            frame_rate: number;
-        };
-        screenshare: {
-            quality: MediaScreenShareQualityType;
-            frame_rate: number;
-        };
-    };
-    max_video_streams: {
-        mobile: number;
-        desktop: number;
-    };
-    max_screenshare_count: number;
-};
-declare enum PluginAccessControls {
-    FULL_ACCESS = "FULL_ACCESS",
-    VIEW_ONLY = "VIEW_ONLY"
-}
-declare type PluginConfig$1 = {
-    access_control: PluginAccessControls.FULL_ACCESS | PluginAccessControls.VIEW_ONLY;
-    disabled: boolean;
-    handles_view_only: boolean;
-};
-declare type PluginPermissionsType = {
-    can_close: boolean;
-    can_start: boolean;
-    can_edit_config?: boolean;
-    config: {
-        [pluginId: string]: Partial<PluginConfig$1>;
-    };
-};
+type ClientEnvTypeAll = 'devel' | 'preprod' | 'prod';
 
-declare type Permissions = {
-    accept_waiting_requests: boolean;
-    can_accept_production_requests: boolean;
-    can_edit_display_name: boolean;
-    can_record: boolean;
-    can_livestream: boolean;
-    can_spotlight?: boolean;
-    disable_participant_audio: boolean;
-    disable_participant_screensharing: boolean;
-    disable_participant_video: boolean;
-    kick_participant: boolean;
-    pin_participant: boolean;
-    plugins: PluginPermissionsType;
-    waiting_room_type: WaitingRoomTypes;
-    polls: {
-        can_create: boolean;
-        can_vote: boolean;
-        can_view: boolean;
-    };
-    media: {
-        video: {
-            can_produce: MediaProductionPermissionType;
-        };
-        audio: {
-            can_produce: MediaProductionPermissionType;
-        };
-        screenshare: {
-            can_produce: MediaProductionPermissionType;
-        };
-    };
-    chat: ChatPermissionTypes;
-    is_recorder?: boolean;
-    recorder_type: RecorderType;
-    hidden_participant: boolean;
-    show_participant_list: boolean;
-    can_change_participant_permissions: boolean;
-    connected_meetings: {
-        can_alter_connected_meetings: boolean;
-        can_switch_connected_meetings: boolean;
-        can_switch_to_parent_meeting: boolean;
-    };
-    stage_enabled?: boolean;
-    stage_access?: MediaProductionPermissionType;
-    accept_stage_requests?: boolean;
-    transcription_enabled?: boolean;
-};
-declare type PresetTypeV2 = {
-    ui: {
-        design_tokens: DesignTokens;
-        config_diff: ConfigDiff;
-    };
-    permissions: Permissions;
-    config: Config;
-    version?: string;
-    name?: string;
-};
+declare class RTKSelectedPeers {
+    private readonly _activeSpeakerPeers;
+    private readonly _compulsoryPeers;
+    constructor();
+    add(peerId: string, priority: number): number;
+    delete(peerId: string): void;
+    index(peerId: string): number;
+    get peers(): string[];
+    get compulsoryPeers(): string[];
+    get activeSpeakerPeers(): string[];
+    private _removeFromCompulsoryPeer;
+}
 
-declare type ChatPermissionTypes = {
-    public: PublicChatPermissionTypes;
-    private?: PrivateChatPermissionTypes;
-    channel?: ChannelPermissionTypes;
-    message?: MessagePermissionTypes;
-};
-declare type PublicChatPermissionTypes = {
-    can_send: boolean;
-    text: boolean;
-    files: boolean;
-};
-declare type PrivateChatPermissionTypes = {
-    can_send: boolean;
-    can_receive: boolean;
-    text: boolean;
-    files: boolean;
-};
-declare type ChannelPermissionTypes = {
-    can_create: 'NONE' | 'PRIVATE' | 'PUBLIC' | 'ALL';
-    can_delete: 'NONE' | 'PRIVATE' | 'PUBLIC' | 'ALL';
-    can_update: 'NONE' | 'PRIVATE' | 'PUBLIC' | 'ALL';
-    can_read_all: boolean;
-};
-declare type MessagePermissionTypes = {
-    can_delete: 'NONE' | 'SELF' | 'ALL';
-    can_edit: 'NONE' | 'SELF' | 'ALL';
-    delete_cutoff_time_seconds: number;
-    edit_cutoff_time_seconds: number;
+type PipEvents = {
+    ['cameraToggled']: () => void;
+    ['micToggled']: () => void;
+    ['hangup']: () => void;
+    ['pipStarted']: () => void;
+    ['pipEnded']: () => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
 };
-declare enum RecorderType {
-    none = "NONE",
-    recorder = "RECORDER",
-    livestreamer = "LIVESTREAMER"
+declare class RTKPip extends RTKTypedEventEmitter<PipEvents> {
+    #private;
+    private constructor();
+    static _init(context: Context<RTKContextState>, self: RTKSelf$1): Promise<RTKPip>;
+    private setupIcon;
+    overrideIcon(icon: 'handRaise' | 'pin', value: string): Promise<void>;
+    private constructImage;
+    private createVideoContainer;
+    private setupEventListeners;
+    private cleanupEventListeners;
+    private enablePipMediaControls;
+    private onSelfVideoUpdateListener;
+    private onSelfAudioUpdateListener;
+    private handlePipMediaControls;
+    private createCanvas;
+    private eventCallback;
+    private setupMediaSessionEvents;
+    private mountAudioEvents;
+    private mountVideoEvents;
+    private unmountEvents;
+    private getSources;
+    private drawEmptyTile;
+    private drawIcons;
+    private drawTile;
+    private calcGridElemSize;
+    private paintCanvas;
+    private animate;
+    isSupported(): boolean;
+    get isActive(): boolean;
+    private cleanup;
+    init({ height, width }?: {
+        height?: number;
+        width?: number;
+    }): void;
+    private updateMediaSession;
+    enableSource(source: string): void;
+    disableSource(source: string): void;
+    private generateAvatar;
+    addSource(id: string, element: HTMLVideoElement, enabled: boolean, pinned?: boolean, displayText?: string, imageUrl?: string, handRaised?: boolean): void;
+    updateSource(id: string, source: any): void;
+    removeSource(id: string): void;
+    removePinnedSource(): void;
+    removeAllSources(): void;
+    enable(): void;
+    disable: (partial?: boolean) => void;
 }
-declare type ConfigDiff = Record<string, any>;
 
-declare type ClientEnvTypeAll = 'devel' | 'preprod' | 'prod';
+interface AudioProducerScoreStats {
+    score: number;
+    packetsLostPercentage: number;
+    jitter: number;
+    isScreenShare: boolean;
+    bitrate: number;
+}
+interface VideoProducerScoreStats {
+    score: number;
+    frameWidth: number;
+    frameHeight: number;
+    framesPerSecond: number;
+    packetsLostPercentage: number;
+    jitter: number;
+    isScreenShare: boolean;
+    bitrate: number;
+    cpuLimitations: boolean;
+    bandwidthLimitations: boolean;
+}
+interface AudioConsumerScoreStats {
+    score: number;
+    packetsLostPercentage: number;
+    jitter: number;
+    isScreenShare: boolean;
+    bitrate: number;
+}
+interface VideoConsumerScoreStats {
+    score: number;
+    frameWidth: number;
+    frameHeight: number;
+    framesPerSecond: number;
+    packetsLostPercentage: number;
+    jitter: number;
+    isScreenShare: boolean;
+    bitrate: number;
+}
+type ProducerScoreStats = AudioProducerScoreStats | VideoProducerScoreStats;
+type ConsumerScoreStats = AudioConsumerScoreStats | VideoConsumerScoreStats;
 
 type TranscriptionData = {
     id: string;
@@ -2169,11 +2213,11 @@ declare enum MediaNodeType {
     CF = 3
 }
 type MediaConnectionState = {
-    consuming: {
+    recv: {
         state: `${TransportState}`;
         reconnected: boolean;
     };
-    producing: {
+    send: {
         state: `${TransportState}`;
         reconnected: boolean;
     };
@@ -2282,6 +2326,8 @@ declare class RTKMap<T extends (EventMap & WildCardEvent<T>), U extends {
     toArray(): U[];
 }
 
+type MediaKind$1 = 'audio' | 'video';
+
 type DCMessage = {
     type: string;
     payload: Record<string, unknown>;
@@ -2319,11 +2365,15 @@ type ParticipantEvents = {
         isScreenshare: boolean;
         score: number;
         participantId: string;
+        scoreStats: ConsumerScoreStats;
     }) => void;
     ['kicked']: () => void;
     ['*']: (event: string, ...args: any[]) => void;
 };
 type SelfEvents = {
+    ['toggleTile']: (payload: {
+        hidden: boolean;
+    }) => void;
     ['videoUpdate']: (payload: {
         videoEnabled: boolean;
         videoTrack: MediaStreamTrack;
@@ -2363,6 +2413,7 @@ type SelfEvents = {
         isScreenshare: boolean;
         score: number;
         participantId: string;
+        scoreStats: ProducerScoreStats;
     }) => void;
     ['waitlisted']: () => void;
     ['roomLeft']: (payload: {
@@ -2405,183 +2456,451 @@ declare class RTKBasicParticipantsMap extends RTKEventEmitter<'participantsUpdat
     toArray(): RTKBasicParticipant[];
 }
 
-type PipEvents = {
-    ['cameraToggled']: () => void;
-    ['micToggled']: () => void;
-    ['hangup']: () => void;
-    ['pipStarted']: () => void;
-    ['pipEnded']: () => void;
-    ['*']: (eventName: string, ...args: any[]) => void;
-};
-declare class RTKPip extends RTKTypedEventEmitter<PipEvents> {
-    #private;
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1);
-    private createVideoContainer;
-    private setupEventListeners;
-    private cleanupEventListeners;
-    private enablePipMediaControls;
-    private onSelfVideoUpdateListener;
-    private onSelfAudioUpdateListener;
-    private handlePipMediaControls;
-    private createCanvas;
-    private eventCallback;
-    private setupMediaSessionEvents;
-    private mountAudioEvents;
-    private mountVideoEvents;
-    private unmountEvents;
-    private getSources;
-    private drawEmptyTile;
-    private drawGrid;
-    private calcGridElemSize;
-    private paintCanvas;
-    private animate;
-    isSupported(): boolean;
-    get isActive(): boolean;
-    private cleanup;
-    init({ height, width }?: {
-        height?: number;
-        width?: number;
-    }): void;
-    private updateMediaSession;
-    enableSource(source: string): void;
-    disableSource(source: string): void;
-    addSource(id: string, element: HTMLVideoElement, enabled: boolean, pinned?: boolean, displayText?: string): void;
-    removeSource(id: string): void;
-    removePinnedSource(): void;
-    removeAllSources(): void;
-    enable(): void;
-    disable: () => void;
-}
-
-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 {
-    #private;
-    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 enum ChatMessageType {
-    TEXT = 0,
-    IMAGE = 1,
-    FILE = 2,
-    CUSTOM = 3
+declare const modes: readonly ["ACTIVE_GRID", "PAGINATED", "MANUAL"];
+type ViewMode = (typeof modes)[number];
+interface BroadcastMessagePayload {
+    [key: string]: boolean | number | string | Date | ActiveTab;
 }
-type ChatSocketMessage = SendChatMessageToRoomResponse | SendChatMessageToPeersResponse | EditChatMessageResponse | DeleteChatMessageResponse;
-interface SearchFilters {
-    channelId?: string;
-    timestamp?: number;
-    size?: number;
-    reversed?: boolean;
+interface PeerProducerConfig {
+    audio: boolean;
+    video: boolean;
+    screenshareAudio: boolean;
+    screenshareVideo: boolean;
 }
-declare class ChatSocketHandler {
+type BroadcastMessageTarget = {
+    participantIds: string[];
+} | {
+    presetNames: string[];
+} | {
+    meetingIds: string[];
+};
+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> {
     #private;
-    constructor(socketService: SocketService);
-    getChatMessages(): Promise<{
+    readonly waitlisted: Readonly<RTKParticipantMap$1<Omit<RTKParticipant$1, 'audioTrack' | 'videoTrack' | 'screenShareTracks'>>>;
+    readonly joined: Readonly<RTKParticipantMap$1>;
+    readonly active: Readonly<RTKParticipantMap$1>;
+    readonly videoSubscribed: Readonly<RTKParticipantMap$1>;
+    readonly audioSubscribed: Readonly<RTKParticipantMap$1>;
+    readonly pinned: Readonly<RTKParticipantMap$1>;
+    readonly all: Readonly<RTKBasicParticipantsMap>;
+    get pip(): RTKPip;
+    private get socketJoined();
+    private get mediaJoined();
+    rateLimitConfig: {
+        maxInvocations: number;
+        period: number;
+    };
+    get 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;
+    get count(): number;
+    get maxActiveParticipantsCount(): number;
+    setMaxActiveParticipantsCount(limit: number): void;
+    get pageCount(): number;
+    acceptWaitingRoomRequest(id: string): void;
+    acceptAllWaitingRoomRequest(userIds: string[]): Promise<void>;
+    rejectWaitingRoomRequest(id: string): Promise<void>;
+    setViewMode(viewMode: ViewMode): Promise<void>;
+    subscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
+    unsubscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
+    getPeerIdsForCurrentPage(): string[];
+    setPage(page: number): Promise<void>;
+    disableAllAudio(allowUnmute: boolean): Promise<void>;
+    disableAllVideo(): Promise<void>;
+    disableAudio(participantId: string): Promise<void>;
+    disableVideo(participantId: string): Promise<void>;
+    kick(participantId: string): Promise<void>;
+    kickAll(): Promise<void>;
+    broadcastMessage(type: Exclude<string, 'spotlight'>, payload: BroadcastMessagePayload, target?: BroadcastMessageTarget): Promise<void>;
+    getAllJoinedPeers(searchQuery: string, limit: number, offset: number): Promise<{
+        id: string;
+        userId: string;
+        name: string;
+        displayName: string;
+        stageType: StageStatus;
+        customParticipantId: string;
+        presetId: string;
+        picture: string;
+        waitlisted: boolean;
+        stageStatus: StageStatus;
+        metadata: {
+            preset_name: string;
+        };
+        recorderType: string;
+        flags: {
+            hiddenParticipant: boolean;
+            hidden_participant: boolean;
+            recorder: boolean;
+        };
+    }[]>;
+    updatePermissions(participantIds: string[], permissions: PresetUpdates): Promise<void>;
+    getParticipantsInMeetingPreJoin(): Promise<RoomPeersInfoResponse>;
+}
+
+type EventHandlerTypes = PeerInfoResponse | GetWaitingRoomRequests | RecordingEvent | UpdatePeersPresetResponse | PeerJoinBroadcastResponse | PeerJoinCompleteResponse | GlobalPeerPinningBroadcastResponse | PeerLeaveResponse | SelectedPeersResponse | SelectedPeersDiffResponse;
+declare class RoomSocketHandler {
+    #private;
+    socket: SocketService;
+    static create(socket: SocketService, context: Context<RTKContextState>): RoomSocketHandler;
+    static cleanup(): void;
+    constructor(socketService: SocketService, context: Context<RTKContextState>);
+    joinRoom(opts: {
+        name: string;
+        id: string;
+        userId: string;
+        customParticipantId: string;
+        picture?: string;
+    }, viewType: ViewType): 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;
     }>;
-    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;
+    broadcastToMeetings(type: string, meetingIds: string[], payload: BroadcastMessagePayload): 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;
+    broadcastToPeers(type: string, peerIds: string[], payload: BroadcastMessagePayload): Promise<boolean>;
+    leaveRoom(): Promise<void>;
+    kick(peerId: string): Promise<void>;
+    kickAll(propagateKickAll?: boolean): Promise<void>;
+    getWaitingRoomRequests(): void;
+    acceptWaitingRoomRequest(userIds: string[]): void;
+    rejectWaitingRoomRequest(userIds: string[]): void;
+    updatePermissions(userIds: string[], patch: PresetUpdates): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    private handleSocketEvents;
+    on(event: number, handler: (message: EventHandlerTypes) => void): void;
+    getUserPermissions(userId: string): Promise<Pick<PresetTypeV2['permissions'], 'chat' | 'polls' | 'plugins'>>;
 }
 
-interface ResponseStatus {
-    success: boolean;
-    message: string;
+interface DeviceConfig {
+    browserName: string;
+    browserVersion: string;
+    isMobile: boolean;
+    engineName: string;
+    osName: string;
 }
-
-type MediaPermission$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE' | 'CANCELED';
-
-declare class LocalMediaHandler extends RTKEventEmitter<LocalMediaEvents> {
-    #private;
-    audioUpdateInProgress: boolean;
-    videoUpdateInProgress: boolean;
-    constructor(context: Context<RTKContextState>, mediaConstraints: MediaConstraints, isNonPreferredDevice?: (media: MediaDeviceInfo) => boolean, autoSwitchDevice?: boolean);
-    private onVisibilityChange;
-    repopulateAvailableDevices(): Promise<boolean>;
-    setupStreams({ audio, video, }: {
-        audio: boolean;
-        video: boolean;
-    }): Promise<void>;
-    getCurrentDevices(): {
-        audio: MediaDeviceInfo;
-        video: MediaDeviceInfo;
-        speaker: MediaDeviceInfo;
+interface ProducerState {
+    producerId: string;
+    kind: 'audio' | 'video';
+    pause: boolean;
+    screenShare: boolean;
+    producingTransportId: string;
+    producingPeerId: string;
+}
+interface Participant {
+    id: string;
+    userId: string;
+    displayName: string;
+    device?: DeviceConfig;
+    picture?: string;
+    isHost: boolean;
+    flags: {
+        [key: string]: string | boolean;
     };
-    get permissions(): {
-        audio?: MediaPermission$1;
-        video?: MediaPermission$1;
-        screenshare?: MediaPermission$1;
+    clientSpecificId?: string;
+    customParticipantId?: string;
+    stageStatus?: StageStatus;
+    audioMuted: boolean;
+    audioTrack: MediaStreamTrack;
+    videoTrack: MediaStreamTrack;
+    videoEnabled: boolean;
+    producers?: ProducerState[];
+    metadata?: {
+        preset_name?: string;
     };
-    getAllDevices(): Promise<InputDeviceInfo[]>;
-    getDeviceById(deviceId: string, kind?: 'audioinput' | 'audiooutput' | 'videoinput'): Promise<MediaDeviceInfo>;
-    private onAudioTrackMuted;
-    private onAudioTrackChanged;
-    get rawAudioTrack(): MediaStreamTrack;
-    get audioTrack(): MediaStreamTrack;
-    get audioEnabled(): boolean;
-    enableAudio(): Promise<void>;
-    disableAudio(): void;
-    getAudioDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
-    setAudioDevice(device: MediaDeviceInfo): Promise<void>;
-    setupSpeaker(): Promise<void>;
-    setSpeakerDevice(device: MediaDeviceInfo): Promise<void>;
-    private onVideoTrackChanged;
-    private onVideoTrackEnded;
-    get rawVideoTrack(): MediaStreamTrack;
-    get videoTrack(): MediaStreamTrack;
-    get videoEnabled(): boolean;
-    enableVideo(): Promise<void>;
-    disableVideo(): void;
-    getVideoDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
-    setVideoDevice(device: MediaDeviceInfo): Promise<void>;
-    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
-    private onScreenShareEnded;
-    get screenShareTracks(): {
+    recorderType?: string;
+}
+declare class RTKParticipant$1 extends RTKTypedEventEmitter<ParticipantEvents> {
+    #private;
+    id: string;
+    userId: string;
+    name: string;
+    picture: string;
+    isHost: boolean;
+    customParticipantId?: string;
+    get clientSpecificId(): string;
+    flags: {
+        [key: string]: string | boolean;
+    };
+    device: DeviceConfig;
+    videoTrack: MediaStreamTrack;
+    audioTrack: MediaStreamTrack;
+    screenShareTracks: {
         audio: MediaStreamTrack;
         video: MediaStreamTrack;
     };
-    get screenShareEnabled(): boolean;
-    enableScreenShare(): Promise<void>;
-    disableScreenShare(): Promise<void>;
-    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    videoEnabled: boolean;
+    audioEnabled: boolean;
+    screenShareEnabled: boolean;
+    producers: ProducerState[];
+    manualProducerConfig: PeerProducerConfig;
+    supportsRemoteControl: boolean;
+    presetName?: string;
+    get stageStatus(): StageStatus;
+    private get mediaJoined();
+    private get socketJoined();
+    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;
+    private setupEvents;
+    pin(): Promise<unknown>;
+    unpin(): Promise<unknown>;
+    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;
+    get isPinned(): boolean;
+    registerVideoElement(videoElem: HTMLVideoElement): void;
+    deregisterVideoElement(videoElem?: HTMLVideoElement): void;
+    private updateVideo;
+}
+
+declare abstract class RoomNodeClient {
+    #private;
+    meetingTitle: string;
+    roomName: string;
+    roomUUID: string;
+    context: Context<RTKContextState>;
+    get peerId(): string;
+    authToken: string;
+    maxPreferredStreams: number;
+    get mediaJoined(): boolean;
+    set mediaJoined(_joined: boolean);
+    get sfuHandler(): any;
+    get mediaState(): MediaConnectionState;
+    reconnect(): void;
+    partialJoinRoom(displayName: string, roomUuid: string, rejoining?: boolean, loc?: GeoLocation): Promise<void>;
+    joinRoom(displayName: string, roomUUID: string, currentUserSharedMediaStates?: {
+        audio?: boolean;
+        video?: boolean;
+        screen?: boolean;
+    }, forceFullReset?: boolean, rejoining?: boolean): Promise<{
+        roomJoined: boolean;
+    }>;
+    leaveRoom(): Promise<void>;
+    reset(full?: boolean): void;
+    handleSocketCallbacks(message: any): Promise<void>;
+    handleSockets(message: any, callBack: (arg?: string) => void): Promise<void>;
+    shareMic(audioTrack: MediaStreamTrack): Promise<void>;
+    shareWebcam(videoTrack: MediaStreamTrack): Promise<MediaStreamTrack | null>;
+    shareScreen(screenShareTracks: {
+        audio?: MediaStreamTrack;
+        video?: MediaStreamTrack;
+    }): Promise<void>;
+    unmuteSelf(): Promise<void>;
+    muteSelf(): Promise<void>;
+    pauseWebcam(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    acceptWaitingRequest(id: string): Promise<void>;
+    rejectWaitingRequest(id: string): Promise<void>;
+    muteAll(allowUnMute: boolean): Promise<void>;
+    muteAllVideo(): Promise<void>;
+    disableAudio(peerId: string): Promise<void>;
+    disableVideo(peerId: string): Promise<void>;
+    kickAll(): Promise<void>;
+    kick(peerId: string): Promise<void>;
+    pinPeer(id: string): Promise<unknown>;
+    getConsumers(): any;
+    stopAllProducers(): void;
+    activatePeers(producers: ProducerState[]): Promise<void>;
+    deactivatePeers(producers: ProducerState[], mode?: 'manual' | 'default'): Promise<void>;
+    createConsumers(producers: ProducerState[]): Promise<void>;
+    closeConsumers(producers: ProducerState[]): Promise<void>;
+    switchConsumersToLayer(consumerIds: string[], layer: number): Promise<void>;
+}
+
+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 {
+    #private;
+    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 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 {
+    #private;
+    constructor(socketService: SocketService);
+    getChatMessages(): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    getChatMessagesPaginated(timeStamp: number, size: number, reversed: boolean, offset?: number, channelId?: string): Promise<GetPaginatedChatMessageRoomResponse>;
+    sendMessageToRoom(message: string, messageType: ChatMessageType): void;
+    sendMessageToPeers(message: string, messageType: ChatMessageType, peerIds: string[]): void;
+    sendMessageToChannel(message: string, messageType: ChatMessageType, channelId: string): void;
+    sendMessage(message: string, messageType: ChatMessageType, peerIds?: string[], channelId?: string): void;
+    editMessage(chatId: string, message: string, payloadType: ChatMessageType, channelId?: string, pinned?: boolean): Promise<ChatMessage>;
+    deleteMessage(chatId: string, channelId?: string): Promise<{
+        channelId?: string;
+        id: string;
+    }>;
+    searchMessages(query: string, filters: SearchFilters): Promise<ChatMessage[]>;
+    getAllChannels(): Promise<ChatChannel[]>;
+    markLastReadMessage(channelId: string, message: Message): Promise<string>;
+    setPinState(message: Message, pin: boolean): Promise<PinChatMessageResponse>;
+    on(event: number, handler: (socketMessage: ChatSocketMessage) => void): void;
+}
+
+interface ResponseStatus {
+    success: boolean;
+    message: string;
+}
+
+type MediaPermission$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE' | 'CANCELED';
+
+declare class LocalMediaHandler extends RTKEventEmitter<LocalMediaEvents> {
+    #private;
+    audioUpdateInProgress: boolean;
+    videoUpdateInProgress: boolean;
+    constructor(context: Context<RTKContextState>, mediaConstraints: MediaConstraints, isNonPreferredDevice?: (media: MediaDeviceInfo) => boolean, autoSwitchDevice?: boolean);
+    private onVisibilityChange;
+    repopulateAvailableDevices(): Promise<boolean>;
+    setupStreams({ audio, video, }: {
+        audio: boolean;
+        video: boolean;
+    }): Promise<void>;
+    getCurrentDevices(): {
+        audio: MediaDeviceInfo;
+        video: MediaDeviceInfo;
+        speaker: MediaDeviceInfo;
+    };
+    get permissions(): {
+        audio?: MediaPermission$1;
+        video?: MediaPermission$1;
+        screenshare?: MediaPermission$1;
+    };
+    getAllDevices(): Promise<InputDeviceInfo[]>;
+    getDeviceById(deviceId: string, kind?: 'audioinput' | 'audiooutput' | 'videoinput'): Promise<MediaDeviceInfo>;
+    private onAudioTrackMuted;
+    private onAudioTrackChanged;
+    get rawAudioTrack(): MediaStreamTrack;
+    get audioTrack(): MediaStreamTrack;
+    get audioEnabled(): boolean;
+    enableAudio(): Promise<void>;
+    disableAudio(): void;
+    getAudioDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    setAudioDevice(device: MediaDeviceInfo): Promise<void>;
+    setupSpeaker(): Promise<void>;
+    setSpeakerDevice(device: MediaDeviceInfo): Promise<void>;
+    private onVideoTrackChanged;
+    private onVideoTrackEnded;
+    get rawVideoTrack(): MediaStreamTrack;
+    get videoTrack(): MediaStreamTrack;
+    get videoEnabled(): boolean;
+    enableVideo(): Promise<void>;
+    disableVideo(): void;
+    getVideoDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    setVideoDevice(device: MediaDeviceInfo): Promise<void>;
+    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    private onScreenShareEnded;
+    get screenShareTracks(): {
+        audio: MediaStreamTrack;
+        video: MediaStreamTrack;
+    };
+    get screenShareEnabled(): boolean;
+    enableScreenShare(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
     getSpeakerDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
     addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
     removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
+    removeAllAudioMiddlewares(): Promise<ResponseStatus>;
     addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
     removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
+    removeAllVideoMiddlewares(): Promise<ResponseStatus>;
     setVideoMiddlewareGlobalConfig(config: VideoMiddlewareGlobalConfig): Promise<void>;
     destruct(): void;
     onDeviceChange(changedDevices: {
@@ -2590,6 +2909,8 @@ declare class LocalMediaHandler extends RTKEventEmitter<LocalMediaEvents> {
         devices: MediaDeviceInfo[];
     }, skipDeviceChange: boolean): Promise<void>;
     removeAllTracks(): void;
+    removeAudioTrack(): void;
+    removeVideoTrack(): void;
     removeDocumentEventListeners(): Promise<void>;
 }
 
@@ -2675,6 +2996,7 @@ type PresetV2CamelCased = {
                 frameRate: number;
             };
         };
+        livestreamViewerQualities: LivestreamViewerMediaQualityType[];
         maxVideoStreams: {
             mobile: number;
             desktop: number;
@@ -2748,7 +3070,7 @@ type PresetV2CamelCased = {
             };
         };
         isRecorder?: boolean;
-        recorderType: RecorderType;
+        recorderType: RecorderType$1;
         hiddenParticipant: boolean;
         showParticipantList: boolean;
         canChangeParticipantPermissions: boolean;
@@ -2839,6 +3161,7 @@ declare class RTKThemePreset$1 {
     }>;
     get pipMode(): Readonly<boolean>;
     get viewType(): Readonly<ViewType>;
+    get livestreamViewerQualities(): Readonly<LivestreamViewerMediaQualityType[]>;
     get maxVideoStreams(): Readonly<MaxVideoStreams>;
     get maxScreenShareCount(): Readonly<number>;
     get plugins(): Readonly<string[]>;
@@ -2855,7 +3178,7 @@ type PermissionEvents = {
     ['chatUpdate']: () => void;
     ['pollsUpdate']: () => void;
     ['pluginsUpdate']: () => void;
-    ['permissionsUpdate']: () => void;
+    ['permissionsUpdate']: (patch: PresetUpdates) => void;
     ['*']: () => void;
 };
 declare class RTKPermissionsPreset$1 extends RTKTypedEventEmitter<PermissionEvents> {
@@ -2918,6 +3241,38 @@ interface UserDetailsResponseV2 {
 }
 type leaveRoomState = 'kicked' | 'ended' | 'left' | 'rejected' | 'connected-meeting' | 'disconnected' | 'failed';
 
+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;
+};
+type StartLivestreamConfig = {
+    manualIngestion: boolean;
+};
+interface LivestreamIngestionCredentials {
+    ingestionServer: string;
+    streamKey: string;
+}
+type LivestreamResponse = {
+    status: string;
+    playbackUrl: string;
+    manualIngest: boolean;
+    ingestionCredentials?: LivestreamIngestionCredentials;
+};
+declare class RTKLivestream$1 extends RTKTypedEventEmitter<LivestreamEvents> {
+    #private;
+    state: LivestreamState;
+    playbackUrl: string | undefined;
+    ingestionCredentials: LivestreamIngestionCredentials;
+    viewerCount: number;
+    constructor(self: RTKSelf);
+    setLivestreamState(livestreamState: LivestreamState): void;
+    private emitCurrentLivestreamState;
+    start(livestreamConfig?: StartLivestreamConfig): Promise<void>;
+    stop(): Promise<void>;
+}
+
 interface RecordingConfig {
     fileNamePrefix?: string;
     videoConfig?: {
@@ -2949,15 +3304,12 @@ declare abstract class BaseAPIClient extends API {
     abstract getActiveTranscript(): Promise<{
         transcript: string;
     }>;
-    abstract startLivestreaming(): Promise<string>;
+    abstract startLivestreaming(startLivestreamConfig: StartLivestreamConfig): Promise<LivestreamResponse>;
     abstract stopLivestreaming(): Promise<void>;
-    abstract getActiveLivestream(): Promise<{
-        status: string;
-        playbackUrl: string;
-    }>;
+    abstract getActiveLivestream(): Promise<LivestreamResponse>;
     getIPDetails(): Promise<any>;
     getICEServers(): Promise<any>;
-    getPlugins(): Promise<RTKPluginResponse[]>;
+    getPlugins(): Promise<any[]>;
     getPluginDetails(pluginId: string): Promise<RTKPluginResponse>;
     getPluginConfig(pluginBaseUrl: string): Promise<PluginConfig>;
     authorizePlugin(pluginId: string): Promise<string>;
@@ -3070,7 +3422,7 @@ declare class RTKChat$1 extends RTKTypedEventEmitter<ChatEvents> {
     channels: ChatChannel[];
     maxTextLimit: number;
     setMaxTextLimit(limit: number): void;
-    private get roomJoined();
+    private get socketJoined();
     constructor(context: Context<RTKContextState>, chatSocketHandler: ChatSocketHandler, chatChannelSocketHandler: ChatChannelSocketHandler, self: RTKSelf$1, participants: RTKParticipants$1);
     private sendMessageInternal;
     private sendTextMessageInternal;
@@ -3124,6 +3476,7 @@ declare class PollSocketHandler {
     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 {
@@ -3154,7 +3507,7 @@ type PollsEvents = {
 declare class RTKPolls$1 extends RTKTypedEventEmitter<PollsEvents> {
     #private;
     items: Poll[];
-    private get roomJoined();
+    private get socketJoined();
     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>;
@@ -3246,6 +3599,10 @@ declare class RTKSelfMedia extends RTKTypedEventEmitter<SelfEvents> {
         success: boolean;
         message: string;
     }>;
+    removeAllAudioMiddlewares(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
     get videoTrack(): MediaStreamTrack;
     get rawVideoTrack(): MediaStreamTrack;
     addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
@@ -3257,6 +3614,10 @@ declare class RTKSelfMedia extends RTKTypedEventEmitter<SelfEvents> {
         success: boolean;
         message: string;
     }>;
+    removeAllVideoMiddlewares(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
     get screenShareTracks(): {
         audio: MediaStreamTrack;
         video: MediaStreamTrack;
@@ -3283,9 +3644,11 @@ declare class RTKSelfMedia extends RTKTypedEventEmitter<SelfEvents> {
 }
 
 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;
@@ -3391,6 +3754,7 @@ declare const enum PRODUCERS_TYPE {
 type SupportedEventSeverities = 'info' | 'error' | 'debug' | 'log' | 'warn';
 type LogData$2 = {
     error?: ReturnType<typeof createSafeToLogError>;
+    peers?: string;
     flags?: string | {
         [key: string]: {
             enabled: boolean;
@@ -3402,6 +3766,7 @@ type LogData$2 = {
     constraints?: string | RTKMediaStreamConstraints;
     timeout?: number;
     execTime?: number;
+    country?: string;
     media?: {
         audio?: {
             enabled: boolean;
@@ -3452,6 +3817,11 @@ type LogData$2 = {
         message: string;
         deviceId?: string;
     };
+    pip?: {
+        id: string;
+        handRaised?: boolean;
+        source?: any;
+    };
     memoize?: {
         doubleInvoked?: {
             property: string;
@@ -3622,476 +3992,281 @@ type LogData$2 = {
     };
     source?: string;
     eventListener?: {
-        eventName: string;
-        listenerCount: number;
-    };
-    dataChannelMessageChunk?: {
-        id: string;
-        count: number;
-        chunkIndex: number;
-        chunk: string;
-        transprtId: string;
-    };
-};
-
-type EventSeverities = SupportedEventSeverities;
-type LogData$1 = LogData$2;
-declare class RTKTelemetry {
-    static logsCache: {
-        [key: string]: any;
-    }[];
-    static logsProcessorTimer: NodeJS.Timer;
-    static get 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;
-    };
-    static resetPeerId(peerId: string): void;
-    static init(context: Context<RTKContextState>, enableTracing: boolean): void;
-    static trace(spanName: string): (_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;
-}
-
-type LogData = LogData$1;
-declare class RTKLogger {
-    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 RTKInternals {
-    logger: typeof RTKLogger;
-    features: typeof RTKFeatures;
-    browserSpecs: BrowserCapabilities;
-    callStats: any;
-    constructor(logger: typeof RTKLogger, features: typeof RTKFeatures, callStats: any);
-    static init(callstats: any): RTKInternals;
-}
-
-type LivestreamState = 'IDLE' | 'STARTING' | 'LIVESTREAMING' | 'STOPPING';
-type LivestreamEvents = {
-    ['livestreamUpdate']: (state: LivestreamState) => void;
-    ['viewerCountUpdate']: (count: number) => void;
-    ['*']: (eventName: string, ...args: any[]) => void;
-};
-declare class RTKLivestream$1 extends RTKTypedEventEmitter<LivestreamEvents> {
-    #private;
-    state: LivestreamState;
-    playbackUrl: string | undefined;
-    viewerCount: number;
-    constructor(self: RTKSelf);
-    setLivestreamState(livestreamState: LivestreamState): void;
-    private emitCurrentLivestreamState;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-}
-
-type StoreData = {
-    [type: string]: any;
-};
-declare class RTKStore {
-    #private;
-    name: string;
-    volatile: boolean;
-    private listeners;
-    constructor({ name, socketHandler, meetingId }: {
-        name: string;
-        socketHandler: PluginSocketHandler;
-        meetingId: string;
-    });
-    set(key: string, value: any, sync?: boolean, emit?: boolean): Promise<void>;
-    bulkSet(data: {
-        key: string;
-        payload: any;
-    }[]): Promise<void>;
-    update(key: string, value: any, sync?: boolean): Promise<void>;
-    delete(key: string, sync?: boolean, emit?: boolean): Promise<void>;
-    bulkDelete(data: {
-        key: string;
-    }[]): Promise<void>;
-    get(key: string): any;
-    getAll(): StoreData;
-    subscribe(key: string | '*', cb: (value: any) => any): void;
-    unsubscribe(key: string | '*'): void;
-    populate(data: StoreData): void;
-}
-
-declare class RTKStoreManager {
-    #private;
-    stores: Map<String, RTKStore>;
-    constructor(context: Context<RTKContextState>, handler: PluginSocketHandler);
-    create(name: string): Promise<RTKStore>;
-}
-
-declare class RTKSelectedPeers {
-    private readonly _activeSpeakerPeers;
-    private readonly _compulsoryPeers;
-    constructor();
-    add(peerId: string, priority: number): number;
-    delete(peerId: string): void;
-    index(peerId: string): number;
-    get peers(): string[];
-    get compulsoryPeers(): string[];
-    get peerPriorities(): number[];
-    get activeSpeakerPeers(): string[];
-    private _removeFromCompulsoryPeer;
-}
-
-interface Modules {
-    pip?: boolean;
-    chat?: boolean;
-    poll?: boolean;
-    theme?: boolean;
-    stage?: boolean;
-    plugin?: boolean;
-    tracing?: boolean;
-    internals?: boolean;
-    recording?: boolean;
-    livestream?: boolean;
-    participant?: boolean;
-    connectedMeetings?: boolean;
-    e2ee?: {
-        manager: any;
-        enabled: boolean;
-    };
-    devTools?: {
-        logs: boolean;
-        plugins?: {
-            id: string;
-            name: string;
-            port: number;
-            picture?: string;
-            description?: string;
-            staggered?: boolean;
-        }[];
-    };
-}
-interface DefaultOptions {
-    video?: boolean;
-    audio?: boolean;
-    recording?: RecordingConfig;
-    mediaHandler?: RTKSelfMedia;
-    autoSwitchAudioDevice?: boolean;
-    mediaConfiguration?: {
-        video?: VideoQualityConstraints;
-        audio?: AudioQualityConstraints;
-        screenshare?: ScreenshareQualityConstraints;
-    };
-    isNonPreferredDevice?: (device: MediaDeviceInfo) => boolean;
-}
-interface RoomDetails {
-    sfu: MediaNodeType;
-    roomNodeUrl: string;
-    meetingTitle: string;
-    useHiveMedia: boolean;
-}
-
-declare const modes: readonly ["ACTIVE_GRID", "PAGINATED", "MANUAL"];
-type ViewMode = (typeof modes)[number];
-interface BroadcastMessagePayload {
-    [key: string]: boolean | number | string | Date | ActiveTab;
-}
-interface PeerProducerConfig {
-    audio: boolean;
-    video: boolean;
-    screenshareAudio: boolean;
-    screenshareVideo: boolean;
-}
-interface SubscriptionProducerConfig {
-    id: string;
-    producers: PeerProducerConfig;
-}
-type BroadcastMessageTarget = {
-    participantIds: string[];
-} | {
-    presetNames: string[];
-};
-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;
-    }) => void;
-    ['media_decode_error']: (payload: {
-        reason: string;
-        code: '1702' | '1703';
-    }) => void;
-    ['*']: (event: string, ...args: any[]) => void;
-};
-declare class RTKParticipants$1 extends RTKTypedEventEmitter<ParticipantsEvents> {
-    #private;
-    readonly waitlisted: Readonly<RTKParticipantMap$1<Omit<RTKParticipant$1, 'audioTrack' | 'videoTrack' | 'screenShareTracks'>>>;
-    readonly joined: Readonly<RTKParticipantMap$1>;
-    readonly active: Readonly<RTKParticipantMap$1>;
-    readonly pinned: Readonly<RTKParticipantMap$1>;
-    readonly all: Readonly<RTKBasicParticipantsMap>;
-    readonly pip: Readonly<RTKPip>;
-    private get roomJoined();
-    viewMode: ViewMode;
-    currentPage: number;
-    lastActiveSpeaker: string;
-    selectedPeers: RTKSelectedPeers;
-    constructor(context: Context<RTKContextState>, self: RTKSelf$1, roomSocketHandler: RoomSocketHandler, modules?: Modules);
-    setupEvents(): void;
-    get count(): number;
-    get maxActiveParticipantsCount(): number;
-    setMaxActiveParticipantsCount(limit: number): void;
-    get pageCount(): number;
-    acceptWaitingRoomRequest(id: string): void;
-    acceptAllWaitingRoomRequest(userIds: string[]): Promise<void>;
-    rejectWaitingRoomRequest(id: string): Promise<void>;
-    setViewMode(viewMode: ViewMode): Promise<void>;
-    subscribe(peers: SubscriptionProducerConfig[]): Promise<void>;
-    unsubscribe(peers: string[]): 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;
-            recorder: boolean;
-        };
-    }[]>;
-    updatePermissions(participantIds: string[], permissions: PresetUpdates): Promise<void>;
-    getParticipantsInMeetingPreJoin(): Promise<RoomPeersInfoResponse>;
-}
-
-type EventHandlerTypes = PeerInfoResponse | GetWaitingRoomRequests | RecordingEvent | UpdatePeersPresetResponse | PeerJoinBroadcastResponse | PeerJoinCompleteResponse | GlobalPeerPinningBroadcastResponse | PeerLeaveResponse | SelectedPeersResponse | SelectedPeersDiffResponse;
-declare class RoomSocketHandler {
-    socket: SocketService;
-    static create(socket: SocketService): RoomSocketHandler;
-    static cleanup(): void;
-    constructor(socketService: SocketService);
-    joinRoom(displayName: string, peerId: string, userId: string, viewType: ViewType): 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;
-    }>;
-    broadcastToPeers(type: string, peerIds: string[], payload: BroadcastMessagePayload): Promise<boolean>;
-    leaveRoom(): Promise<void>;
-    kick(peerId: string): Promise<void>;
-    kickAll(): Promise<void>;
-    getWaitingRoomRequests(): void;
-    acceptWaitingRoomRequest(userIds: string[]): void;
-    rejectWaitingRoomRequest(userIds: string[]): void;
-    updatePermissions(userIds: string[], patch: PresetUpdates): Promise<{
-        id: string;
-        payload: Uint8Array;
-    }>;
-    private handleSocketEvents;
-    on(event: number, handler: (message: EventHandlerTypes) => void): void;
-    getUserPermissions(userId: string): Promise<Pick<PresetTypeV2['permissions'], 'chat' | 'polls' | 'plugins'>>;
-}
-
-interface DeviceConfig {
-    browserName: string;
-    browserVersion: string;
-    isMobile: boolean;
-    engineName: string;
-    osName: string;
-}
-interface ProducerState {
-    producerId: string;
-    kind: 'audio' | 'video';
-    pause: boolean;
-    screenShare: boolean;
-    producingTransportId: string;
-}
-interface Participant {
-    id: string;
-    userId: string;
-    displayName: string;
-    device?: DeviceConfig;
-    picture?: string;
-    isHost: boolean;
-    flags: {
-        [key: string]: string | boolean;
+        eventName: string;
+        listenerCount: number;
     };
-    clientSpecificId?: string;
-    customParticipantId?: string;
-    stageStatus?: StageStatus;
-    audioMuted: boolean;
-    audioTrack: MediaStreamTrack;
-    videoTrack: MediaStreamTrack;
-    videoEnabled: boolean;
+    dataChannelMessageChunk?: {
+        id: string;
+        count: number;
+        chunkIndex: number;
+        chunk: string;
+        transprtId: string;
+    };
+    peerIds?: string[];
     producers?: ProducerState[];
-    metadata?: {
-        preset_name?: string;
+};
+
+type EventSeverities = SupportedEventSeverities;
+type LogData$1 = LogData$2;
+declare class RTKTelemetry {
+    static logsCache: {
+        [key: string]: any;
+    }[];
+    static logsProcessorTimer: NodeJS.Timer;
+    static location: {
+        country: string;
     };
-    recorderType?: string;
+    static get 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;
+    };
+    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;
 }
-declare class RTKParticipant$1 extends RTKTypedEventEmitter<ParticipantEvents> {
+
+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 RTKInternals {
+    logger: typeof RTKLogger$1;
+    features: typeof RTKFeatures;
+    browserSpecs: BrowserCapabilities;
+    callStats: any;
+    constructor(logger: typeof RTKLogger$1, features: typeof RTKFeatures, callStats: any);
+    static init(callstats: any): RTKInternals;
+}
+
+type StoreData = {
+    [type: string]: any;
+};
+declare class RTKStore$1 {
     #private;
-    id: string;
-    userId: string;
     name: string;
-    picture: string;
-    isHost: boolean;
-    customParticipantId?: string;
-    get clientSpecificId(): string;
-    flags: {
-        [key: string]: string | boolean;
+    rateLimitConfig: {
+        maxInvocations: number;
+        period: number;
     };
-    device: DeviceConfig;
-    videoTrack: MediaStreamTrack;
-    audioTrack: MediaStreamTrack;
-    screenShareTracks: {
-        audio: MediaStreamTrack;
-        video: MediaStreamTrack;
+    bulkRateLimitConfig: {
+        maxInvocations: number;
+        period: number;
     };
-    videoEnabled: boolean;
-    audioEnabled: boolean;
-    screenShareEnabled: boolean;
-    producers: ProducerState[];
-    manualProducerConfig: PeerProducerConfig;
-    supportsRemoteControl: boolean;
-    presetName?: string;
-    get stageStatus(): StageStatus;
-    private get roomJoined();
-    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;
-    private setupEvents;
-    pin(): Promise<unknown>;
-    unpin(): Promise<unknown>;
-    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
-    disableAudio(): Promise<void>;
-    kick(): Promise<void>;
-    disableVideo(): Promise<void>;
-    getPermissions(): Promise<Pick<Permissions, "polls" | "plugins" | "chat">>;
-    setStageStatus(stageStatus: StageStatus): void;
-    get isPinned(): boolean;
-    registerVideoElement(videoElem: HTMLVideoElement): void;
-    deregisterVideoElement(videoElem: HTMLVideoElement): void;
+    private listeners;
+    constructor({ name, socketHandler, meetingId }: {
+        name: string;
+        socketHandler: PluginSocketHandler;
+        meetingId: string;
+    });
+    set(key: string, value: any, sync?: boolean, emit?: boolean): Promise<void>;
+    private remoteSet;
+    bulkSet(data: {
+        key: string;
+        payload: any;
+    }[]): Promise<void>;
+    update(key: string, value: any, sync?: boolean): Promise<void>;
+    delete(key: string, sync?: boolean, emit?: boolean): Promise<void>;
+    bulkDelete(data: {
+        key: string;
+    }[]): Promise<void>;
+    get(key: string): any;
+    getAll(): StoreData;
+    get rateLimits(): {
+        maxInvocations: number;
+        period: number;
+    };
+    updateRateLimits(num: number, period: number): void;
+    get bulkRateLimits(): {
+        maxInvocations: number;
+        period: number;
+    };
+    updateBulkRateLimits(num: number, period: number): void;
+    subscribe(key: string | '*', cb: (value: any) => any): void;
+    unsubscribe(key: string | '*', cb?: (value: any) => any): void;
+    populate(data: StoreData): void;
 }
 
-declare abstract class RoomNodeClient {
+declare class RTKStoreManager {
     #private;
+    stores: Map<String, RTKStore$1>;
+    constructor(context: Context<RTKContextState>, handler: PluginSocketHandler);
+    create(name: string): Promise<RTKStore$1>;
+}
+
+interface Modules {
+    pip?: boolean;
+    chat?: boolean;
+    poll?: boolean;
+    theme?: boolean;
+    stage?: boolean;
+    plugin?: boolean;
+    tracing?: boolean;
+    internals?: boolean;
+    recording?: boolean;
+    livestream?: boolean;
+    participant?: boolean;
+    connectedMeetings?: boolean;
+    e2ee?: {
+        manager: any;
+        enabled: boolean;
+    };
+    devTools?: {
+        logs: boolean;
+        plugins?: {
+            id: string;
+            name: string;
+            port: number;
+            picture?: string;
+            description?: string;
+            staggered?: boolean;
+        }[];
+    };
+}
+interface DefaultOptions {
+    video?: boolean;
+    audio?: boolean;
+    recording?: RecordingConfig;
+    mediaHandler?: RTKSelfMedia;
+    autoSwitchAudioDevice?: boolean;
+    mediaConfiguration?: {
+        video?: VideoQualityConstraints;
+        audio?: AudioQualityConstraints;
+        screenshare?: ScreenshareQualityConstraints;
+    };
+    isNonPreferredDevice?: (device: MediaDeviceInfo) => boolean;
+}
+interface RoomDetails {
+    sfu: MediaNodeType;
+    roomNodeUrl: string;
     meetingTitle: string;
-    roomName: string;
-    roomUUID: string;
-    context: Context<RTKContextState>;
-    get peerId(): string;
-    authToken: string;
-    maxPreferredStreams: number;
-    roomJoined: boolean;
-    get sfuHandler(): any;
-    get socketState(): SocketConnectionState;
-    get mediaState(): MediaConnectionState;
-    reconnect(): void;
-    partialJoinRoom(displayName: string, roomUuid: string, rejoining?: boolean, loc?: GeoLocation): Promise<void>;
-    joinRoom(displayName: string, roomUUID: string, currentUserSharedMediaStates?: {
-        audio?: boolean;
-        video?: boolean;
-        screen?: boolean;
-    }, forceFullReset?: boolean, rejoining?: boolean): Promise<{
-        roomJoined: boolean;
-    }>;
-    leaveRoom(): Promise<void>;
-    reset(full?: boolean): void;
-    handleSocketCallbacks(message: any): Promise<void>;
-    handleSockets(message: any, callBack: (arg?: string) => void): Promise<void>;
-    shareMic(audioTrack: MediaStreamTrack): Promise<void>;
-    shareWebcam(videoTrack: MediaStreamTrack): Promise<MediaStreamTrack | null>;
-    shareScreen(screenShareTracks: {
-        audio?: MediaStreamTrack;
-        video?: MediaStreamTrack;
-    }): Promise<void>;
-    unmuteSelf(): Promise<void>;
-    muteSelf(): Promise<void>;
-    pauseWebcam(): Promise<void>;
-    disableScreenShare(): Promise<void>;
-    acceptWaitingRequest(id: string): Promise<void>;
-    rejectWaitingRequest(id: string): Promise<void>;
-    muteAll(allowUnMute: boolean): Promise<void>;
-    muteAllVideo(): Promise<void>;
-    disableAudio(peerId: string): Promise<void>;
-    disableVideo(peerId: string): Promise<void>;
-    kickAll(): Promise<void>;
-    kick(peerId: string): Promise<void>;
-    pinPeer(id: string): Promise<unknown>;
-    getConsumers(): any;
-    stopAllProducers(): void;
-    activatePeers(producerInfos: {
-        peerId: string;
-        producers: ProducerState[];
-        force?: boolean;
-    }[]): Promise<void>;
-    deactivatePeers(producerInfo: {
-        peerId: string;
-        producers: ProducerState[];
-    }): Promise<void>;
-    switchConsumersToLayer(consumerIds: string[], layer: number): Promise<void>;
+    useHiveMedia: boolean;
+}
+
+declare class ConnectionHandler {
+    mediaJoined: boolean;
+    socketJoined: boolean;
+    socketJoinAttempted: boolean;
+    mediaJoinAttempted: boolean;
+    socketState: SocketConnectionState;
+    mediaState: MediaConnectionState;
+    get joinAttempted(): boolean;
+    get roomJoined(): boolean;
+    constructor();
+    updateSocketConnectionState(state: SocketStateEvent, attempt?: number): void;
+}
+
+declare const ERROR_CODES: {
+    '0000': string;
+    '0001': string;
+    '0002': string;
+    '0003': string;
+    '0004': string;
+    '0010': string;
+    '0011': string;
+    '0012': string;
+    '0013': string;
+    '0100': string;
+    '0101': string;
+    '0102': string;
+    '0200': string;
+    '0300': string;
+    '0400': string;
+    '0404': string;
+    '0500': string;
+    '0501': string;
+    '0502': string;
+    '0503': string;
+    '0504': string;
+    '0505': string;
+    '0506': string;
+    '0510': string;
+    '0600': string;
+    '0601': string;
+    '0602': string;
+    '0603': string;
+    '0700': string;
+    '0705': string;
+    '0800': string;
+    '0801': string;
+    '0900': string;
+    '0904': string;
+    '1000': string;
+    '1001': string;
+    '1004': string;
+    '1005': string;
+    '1100': string;
+    '1101': string;
+    '1102': string;
+    '1103': string;
+    '1104': string;
+    '1105': string;
+    '1106': string;
+    '1200': string;
+    '1201': string;
+    '1202': string;
+    '1203': string;
+    '1204': string;
+    '1205': string;
+    '1206': string;
+    '1207': string;
+    '1208': string;
+    '1209': string;
+    '1300': string;
+    '1400': string;
+    '1402': string;
+    '1403': string;
+    '1500': string;
+    '1600': string;
+    '1601': string;
+    '1602': string;
+    '1603': string;
+    '1604': string;
+    '1605': string;
+    '1606': string;
+    '1607': string;
+    '1608': string;
+    '1609': string;
+    '1610': string;
+    '1611': string;
+    '1612': string;
+    '1701': string;
+    '1800': string;
+    '1801': string;
+    '1900': string;
+    '1901': string;
+    '1902': string;
+    '2000': string;
+    '2001': string;
+    '2002': string;
+    '2003': string;
+    '2004': string;
+    '2005': string;
+    '2006': string;
+    '9900': string;
+};
+declare class RTKError extends Error {
+    code: keyof typeof ERROR_CODES;
+    constructor(message: string, code?: keyof typeof ERROR_CODES, log?: boolean);
 }
 
 type RTKContextState = {
@@ -4099,18 +4274,19 @@ type RTKContextState = {
     peerId?: string;
     apiBase?: string;
     baseURI?: string;
+    onError?: (error: RTKError) => void;
     stageStatus?: StageStatus;
     organizationId?: string;
+    maxPreferredStreams?: number;
     defaults?: DefaultOptions;
     modules?: Modules;
-    overrides?: {
-        [key: string]: boolean | string;
-    };
+    overrides?: Overrides;
     apiClient?: BaseAPIClient;
     userId?: string;
     meetingId?: string;
     roomName?: string;
     socketService?: SocketService;
+    pip?: RTKPip;
     roomNodeOptions?: {
         meetingTitle: string;
         roomNodeUrl: string;
@@ -4121,6 +4297,7 @@ type RTKContextState = {
     env?: ClientEnvTypeAll;
     sdkVersion?: string;
     sdkName?: 'web-core';
+    connectionHandler?: ConnectionHandler;
     cachedUserDetails?: CachedUserDetails;
 };
 interface Context<T extends Record<string, any>> {
@@ -4145,7 +4322,8 @@ declare class SocketService {
     readonly roomName: string;
     readonly authToken: string;
     readonly capabilities: SocketServiceCapabilities;
-    connectionState: SocketConnectionState;
+    get joinAttempted(): boolean;
+    set joinAttempted(value: boolean);
     get peerId(): string;
     constructor(context: Context<RTKContextState>, { peerId, meetingId, authToken, capabilities, }: {
         peerId: string;
@@ -4157,7 +4335,7 @@ declare class SocketService {
     private static getSocketEdgeDomain;
     get url(): string;
     connect(): Promise<void>;
-    disconnect(): void;
+    disconnect(): Promise<void>;
     get isConnected(): boolean;
     sendMessage(event: number, protobuf?: Uint8Array, messageId?: string): boolean;
     sendMessagePromise(event: number, protobuf?: Uint8Array, messageId?: string, resp?: number): Promise<{
@@ -4179,7 +4357,13 @@ declare class SocketService {
         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 StageSocketMessage = GetStageRequestsResponse | GetStagePeersResponse | DenyStageAccessRequest | PeerStatusUpdate;
@@ -4265,12 +4449,14 @@ declare class RTKSelf$1 extends RTKSelfMedia {
     organizationId: string;
     supportsRemoteControl: boolean;
     device: DeviceConfig;
+    hidden: boolean;
     get stageStatus(): StageStatus;
     get 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;
     private setupEvents;
     get permissions(): RTKPermissionsPreset$1;
     get config(): RTKThemePreset$1;
@@ -4296,11 +4482,13 @@ declare class RTKSelf$1 extends RTKSelfMedia {
     get isPinned(): boolean;
     pin(): Promise<unknown>;
     unpin(): Promise<unknown>;
+    hide(): Promise<void>;
+    show(): void;
     setDevice(device: MediaDeviceInfo): Promise<void>;
     cleanUpTracks(): void;
-    registerVideoElement(videoElem: HTMLVideoElement): void;
-    deregisterVideoElement(videoElem: HTMLVideoElement): void;
-    updateVideo(e: HTMLVideoElement): void;
+    registerVideoElement(videoElem: HTMLVideoElement, isPreview?: boolean): void;
+    deregisterVideoElement(videoElem?: HTMLVideoElement, isPreview?: boolean): void;
+    private updateVideo;
 }
 
 interface RTKPluginResponse {
@@ -4534,14 +4722,17 @@ declare class RTKConnectedMeetings$1 extends RTKTypedEventEmitter<ConnectedMeeti
     private moveSuccessHandler;
 }
 
+interface Overrides {
+    disableSimulcast?: boolean;
+    [key: string]: boolean | string | number;
+}
 interface RealtimeKitClientOptions {
     authToken: string;
     defaults?: DefaultOptions;
     modules?: Modules;
-    overrides?: {
-        [key: string]: boolean | string;
-    };
+    overrides?: Overrides;
     baseURI?: string;
+    onError?: (error: RTKError) => void;
     cachedUserDetails?: CachedUserDetails;
 }
 declare class RealtimeKitClient {
@@ -4572,8 +4763,14 @@ type RTKParticipant = Readonly<RTKParticipant$1>;
 
 type RTKParticipants = Readonly<RTKParticipants$1>;
 type RTKParticipantMap = Readonly<RTKParticipantMap$1>;
+
+type RTKPlugin = Readonly<RTKPlugin$1>;
 type RTKSelf = Readonly<RTKSelf$1>;
 
+type RTKConnectedMeetings = Readonly<RTKConnectedMeetings$1>;
+
+type RTKPermissionsPreset = Readonly<RTKPermissionsPreset$1>;
+
 type RTKType = {
     callStats?: unknown;
     RTKTelemetry?: typeof RTKTelemetry;
@@ -4592,4 +4789,4 @@ declare global {
     }
 }
 
-export { RealtimeKitClientOptions, RTKParticipant, RTKParticipantMap, RTKSelf, RTKSelfMedia, RealtimeKitClient as default };
+export { ActiveTabType, CustomMessage, DeviceConfig, RTKBasicParticipant, RealtimeKitClientOptions, RTKConnectedMeetings, RTKParticipant, RTKParticipantMap, RTKParticipants, RTKPermissionsPreset, RTKPlugin, RTKSelf, RTKSelfMedia, FileMessage, ImageMessage, LivestreamState, MediaConnectionState, MediaKind$1 as MediaKind, Message, ProducerScoreStats, SocketConnectionState, StageStatus, TextMessage, VideoProducerScoreStats, RealtimeKitClient as default, leaveRoomState };