@cloudflare/realtimekit 1.1.6-staging.2 → 1.1.7-agent.1

package/dist/react.d.ts

@@ -0,0 +1,4695 @@
+import { EventEmitter } from 'events';
+import { MessageType as MessageType$1 } from '@protobuf-ts/runtime';
+import * as _dyteinternals_utils from '@dyteinternals/utils';
+import { ViewType, PresetTypeV2, MediaVideoQualityType, MediaScreenShareQualityType, LivestreamViewerMediaQualityType, PluginAccessControls, WaitingRoomTypes, MediaProductionPermissionType, RecorderType as RecorderType$1, BorderRadius, BorderWidth, Theme } from '@dyteinternals/utils';
+import * as WorkerTimers from 'worker-timers';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+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> = `${Extract<keyof BaseType, string | number>}`;
+
+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 = {
+    [key: string]: (...args: any[]) => void;
+};
+type WildCardEvent<T> = {
+    ['*']: (event: StringKeyOf<T>, ...args: any) => void;
+};
+declare class RTKTypedEventEmitter<Events extends EventMap & 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
+ *
+ * @generated from protobuf enum media.Target
+ */
+declare enum Target {
+    /**
+     * @generated from protobuf enum value: PUBLISHER = 0;
+     */
+    PUBLISHER = 0,
+    /**
+     * @generated from protobuf enum value: SUBSCRIBER = 1;
+     */
+    SUBSCRIBER = 1
+}
+/**
+ * protolint:disable ENUM_FIELD_NAMES_PREFIX
+ *
+ * @generated from protobuf enum media.ProducerKind
+ */
+declare enum ProducerKind {
+    /**
+     * @generated from protobuf enum value: AUDIO = 0;
+     */
+    AUDIO = 0,
+    /**
+     * @generated from protobuf enum value: VIDEO = 1;
+     */
+    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 from protobuf field: optional uint32 payload_type = 5;
+     */
+    payloadType?: number;
+}
+/**
+ * @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();
+}
+/**
+ * @generated from protobuf message media.SessionDescription
+ */
+interface SessionDescription {
+    /**
+     * @generated from protobuf field: media.Target target = 1;
+     */
+    target: Target;
+    /**
+     * 'offer' | 'answer'
+     *
+     * @generated from protobuf field: string type = 2;
+     */
+    type: string;
+    /**
+     * sdp contents
+     *
+     * @generated from protobuf field: string sdp = 3;
+     */
+    sdp: string;
+}
+/**
+ * @generated MessageType for protobuf message media.SessionDescription
+ */
+declare const SessionDescription: SessionDescription$Type;
+declare class ProducerTrack$Type extends MessageType$1<ProducerTrack> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.ProducerTrack
+ */
+interface ProducerTrack {
+    /**
+     * @generated from protobuf field: string track_id = 1;
+     */
+    trackId: string;
+    /**
+     * @generated from protobuf field: string producer_id = 2;
+     */
+    producerId: string;
+    /**
+     * @generated from protobuf field: string stream_id = 3;
+     */
+    streamId: string;
+}
+/**
+ * @generated MessageType for protobuf message media.ProducerTrack
+ */
+declare const ProducerTrack: ProducerTrack$Type;
+declare class ProducerState$Type extends MessageType$1<ProducerState$1> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.ProducerState
+ */
+interface ProducerState$1 {
+    /**
+     * @generated from protobuf field: string producer_id = 1;
+     */
+    producerId: string;
+    /**
+     * @generated from protobuf field: media.ProducerKind kind = 2;
+     */
+    kind: ProducerKind;
+    /**
+     * @generated from protobuf field: bool pause = 3;
+     */
+    pause: boolean;
+    /**
+     * @generated from protobuf field: bool screen_share = 4;
+     */
+    screenShare: boolean;
+    /**
+     * @generated from protobuf field: optional string app_data = 5;
+     */
+    appData?: string;
+    /**
+     * @generated from protobuf field: optional string producing_transport_id = 6;
+     */
+    producingTransportId?: string;
+    /**
+     * @generated from protobuf field: optional string mime_type = 7;
+     */
+    mimeType?: string;
+    /**
+     * @generated from protobuf field: optional media.Codec codec = 8;
+     */
+    codec?: Codec;
+}
+/**
+ * @generated MessageType for protobuf message media.ProducerState
+ */
+declare const ProducerState$1: ProducerState$Type;
+declare class ConsumerState$Type extends MessageType$1<ConsumerState> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.ConsumerState
+ */
+interface ConsumerState {
+    /**
+     * @generated from protobuf field: string consumer_id = 1;
+     */
+    consumerId: string;
+    /**
+     * @generated from protobuf field: media.ProducerState producer_state = 2;
+     */
+    producerState?: ProducerState$1;
+    /**
+     * @generated from protobuf field: media.ProducerTrack producer_track = 3;
+     */
+    producerTrack?: ProducerTrack;
+    /**
+     * @generated from protobuf field: optional string error_code = 4;
+     */
+    errorCode?: string;
+}
+/**
+ * @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();
+}
+/**
+ * @generated from protobuf message media.edge.GeoLocation
+ */
+interface GeoLocation {
+    /**
+     * @generated from protobuf field: float latitude = 1;
+     */
+    latitude: number;
+    /**
+     * @generated from protobuf field: float longitude = 2;
+     */
+    longitude: number;
+    /**
+     * @generated from protobuf field: optional string region = 3;
+     */
+    region?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.GeoLocation
+ */
+declare const GeoLocation: GeoLocation$Type;
+declare class GetRoomStateResponse$Type extends MessageType$1<GetRoomStateResponse> {
+    constructor();
+}
+/**
+ * GetRoomStateResponse contains the room state sent by the hub
+ *
+ * @generated from protobuf message media.edge.GetRoomStateResponse
+ */
+interface GetRoomStateResponse {
+    /**
+     * @generated from protobuf field: string display_title = 1;
+     */
+    displayTitle: string;
+    /**
+     * @generated from protobuf field: bool locked_mode = 2;
+     */
+    lockedMode: boolean;
+    /**
+     * @generated from protobuf field: string room_uuid = 3;
+     */
+    roomUuid: string;
+    /**
+     * @generated from protobuf field: string room_name = 4;
+     */
+    roomName: string;
+    /**
+     * @generated from protobuf field: string current_peer_id = 5;
+     */
+    currentPeerId: string;
+    /**
+     * @generated from protobuf field: optional bool is_recording = 6;
+     */
+    isRecording?: boolean;
+    /**
+     * @generated from protobuf field: optional string recorder_participant_id = 7;
+     */
+    recorderParticipantId?: string;
+    /**
+     * @generated from protobuf field: repeated string pinned_peer_ids = 8;
+     */
+    pinnedPeerIds: string[];
+}
+/**
+ * @generated MessageType for protobuf message media.edge.GetRoomStateResponse
+ */
+declare const GetRoomStateResponse: GetRoomStateResponse$Type;
+declare class RoomParticipants$Type extends MessageType$1<RoomParticipants> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.RoomParticipants
+ */
+interface RoomParticipants {
+    /**
+     * @generated from protobuf field: string peer_id = 1;
+     */
+    peerId: string;
+    /**
+     * @generated from protobuf field: repeated media.ProducerState producer_states = 2;
+     */
+    producerStates: ProducerState$1[];
+    /**
+     * @generated from protobuf field: string display_name = 3;
+     */
+    displayName: string;
+    /**
+     * @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
+ */
+declare const RoomParticipants: RoomParticipants$Type;
+declare class SelectedPeersResponse$Type extends MessageType$1<SelectedPeersResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.SelectedPeersResponse
+ */
+interface SelectedPeersResponse {
+    /**
+     * @generated from protobuf field: repeated string audio_peers = 1;
+     */
+    audioPeers: string[];
+    /**
+     * @generated from protobuf field: repeated string compulsory_peers = 2;
+     */
+    compulsoryPeers: string[];
+}
+/**
+ * @generated MessageType for protobuf message media.edge.SelectedPeersResponse
+ */
+declare const SelectedPeersResponse: SelectedPeersResponse$Type;
+declare class SelectedPeersDiffEntry$Type extends MessageType$1<SelectedPeersDiffEntry> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.SelectedPeersDiffEntry
+ */
+interface SelectedPeersDiffEntry {
+    /**
+     * @generated from protobuf field: string peer_id = 1;
+     */
+    peerId: string;
+    /**
+     * @generated from protobuf field: int32 priority = 2;
+     */
+    priority: number;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.SelectedPeersDiffEntry
+ */
+declare const SelectedPeersDiffEntry: SelectedPeersDiffEntry$Type;
+declare class SelectedPeersDiffResponse$Type extends MessageType$1<SelectedPeersDiffResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.SelectedPeersDiffResponse
+ */
+interface SelectedPeersDiffResponse {
+    /**
+     * @generated from protobuf field: repeated media.edge.SelectedPeersDiffEntry entries = 1;
+     */
+    entries: SelectedPeersDiffEntry[];
+}
+/**
+ * @generated MessageType for protobuf message media.edge.SelectedPeersDiffResponse
+ */
+declare const SelectedPeersDiffResponse: SelectedPeersDiffResponse$Type;
+declare class PeerJoinCompleteResponse$Type extends MessageType$1<PeerJoinCompleteResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.PeerJoinCompleteResponse
+ */
+interface PeerJoinCompleteResponse {
+    /**
+     * @generated from protobuf field: optional media.edge.GetRoomStateResponse room_state = 1;
+     */
+    roomState?: GetRoomStateResponse;
+    /**
+     * @generated from protobuf field: repeated media.edge.RoomParticipants participants = 2;
+     */
+    participants: RoomParticipants[];
+    /**
+     * @generated from protobuf field: media.edge.SelectedPeersResponse selected_peers = 3;
+     */
+    selectedPeers?: SelectedPeersResponse;
+    /**
+     * @generated from protobuf field: int32 max_preferred_streams = 4;
+     */
+    maxPreferredStreams: number;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.PeerJoinCompleteResponse
+ */
+declare const PeerJoinCompleteResponse: PeerJoinCompleteResponse$Type;
+declare class PeerLeaveResponse$Type extends MessageType$1<PeerLeaveResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.PeerLeaveResponse
+ */
+interface PeerLeaveResponse {
+    /**
+     * @generated from protobuf field: bool closed = 1;
+     */
+    closed: boolean;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.PeerLeaveResponse
+ */
+declare const PeerLeaveResponse: PeerLeaveResponse$Type;
+declare class PeerJoinBroadcastResponse$Type extends MessageType$1<PeerJoinBroadcastResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.PeerJoinBroadcastResponse
+ */
+interface PeerJoinBroadcastResponse {
+    /**
+     * @generated from protobuf field: media.edge.RoomParticipants participant = 1;
+     */
+    participant?: RoomParticipants;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.PeerJoinBroadcastResponse
+ */
+declare const PeerJoinBroadcastResponse: PeerJoinBroadcastResponse$Type;
+declare class GlobalPeerPinningBroadcastResponse$Type extends MessageType$1<GlobalPeerPinningBroadcastResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.GlobalPeerPinningBroadcastResponse
+ */
+interface GlobalPeerPinningBroadcastResponse {
+    /**
+     * @generated from protobuf field: string participant_id = 1;
+     */
+    participantId: string;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.GlobalPeerPinningBroadcastResponse
+ */
+declare const GlobalPeerPinningBroadcastResponse: GlobalPeerPinningBroadcastResponse$Type;
+
+/**
+ * protolint:disable ENUM_FIELD_NAMES_PREFIX
+ *
+ * @generated from protobuf enum common.RecordingType
+ */
+declare enum RecordingType$1 {
+    /**
+     * @generated from protobuf enum value: BROWSER = 0;
+     */
+    BROWSER = 0,
+    /**
+     * @generated from protobuf enum value: TRACK = 1;
+     */
+    TRACK = 1,
+    /**
+     * @generated from protobuf enum value: COMPOSITE = 2;
+     */
+    COMPOSITE = 2
+}
+
+/**
+ * @generated from protobuf enum socket.room.StageType
+ */
+declare enum StageType {
+    /**
+     * @generated from protobuf enum value: STAGE_TYPE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from protobuf enum value: STAGE_TYPE_ON_STAGE = 1;
+     */
+    ON_STAGE = 1,
+    /**
+     * @generated from protobuf enum value: STAGE_TYPE_APPROVED_STAGE = 2;
+     */
+    APPROVED_STAGE = 2,
+    /**
+     * @generated from protobuf enum value: STAGE_TYPE_REQUESTED_STAGE = 3;
+     */
+    REQUESTED_STAGE = 3,
+    /**
+     * @generated from protobuf enum value: STAGE_TYPE_OFF_STAGE = 4;
+     */
+    OFF_STAGE = 4
+}
+/**
+ * @generated from protobuf enum socket.room.RecorderType
+ */
+declare enum RecorderType {
+    /**
+     * @generated from protobuf enum value: RECORDER_TYPE_NONE = 0;
+     */
+    NONE = 0,
+    /**
+     * @generated from protobuf enum value: RECORDER_TYPE_RECORDER = 1;
+     */
+    RECORDER = 1,
+    /**
+     * @generated from protobuf enum value: RECORDER_TYPE_LIVESTREAMER = 2;
+     */
+    LIVESTREAMER = 2
+}
+/**
+ * @generated from protobuf enum socket.room.Capabilities
+ */
+declare enum Capabilities {
+    /**
+     * @generated from protobuf enum value: CAPABILITIES_HIVE = 0;
+     */
+    HIVE = 0,
+    /**
+     * @generated from protobuf enum value: CAPABILITIES_CHAT = 1;
+     */
+    CHAT = 1,
+    /**
+     * @generated from protobuf enum value: CAPABILITIES_PING = 2;
+     */
+    PING = 2
+}
+declare class PeerFlags$Type extends MessageType$1<PeerFlags> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.PeerFlags
+ */
+interface PeerFlags {
+    /**
+     * @generated from protobuf field: string preset_name = 1;
+     */
+    presetName: string;
+    /**
+     * @generated from protobuf field: string recorder_type = 2;
+     */
+    recorderType: string;
+    /**
+     * @generated from protobuf field: bool hidden_participant = 3;
+     */
+    hiddenParticipant: boolean;
+}
+/**
+ * @generated MessageType for protobuf message socket.room.PeerFlags
+ */
+declare const PeerFlags: PeerFlags$Type;
+declare class Peer$Type extends MessageType$1<Peer> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.Peer
+ */
+interface Peer {
+    /**
+     * @generated from protobuf field: string peer_id = 1;
+     */
+    peerId: string;
+    /**
+     * @generated from protobuf field: string user_id = 2;
+     */
+    userId: string;
+    /**
+     * @generated from protobuf field: string display_name = 3;
+     */
+    displayName: string;
+    /**
+     * @generated from protobuf field: optional socket.room.StageType stage_type = 4;
+     */
+    stageType?: StageType;
+    /**
+     * @generated from protobuf field: optional string custom_participant_id = 5;
+     */
+    customParticipantId?: string;
+    /**
+     * @generated from protobuf field: optional string preset_id = 6;
+     */
+    presetId?: string;
+    /**
+     * @generated from protobuf field: optional string display_picture_url = 7;
+     */
+    displayPictureUrl?: string;
+    /**
+     * @generated from protobuf field: bool waitlisted = 8;
+     */
+    waitlisted: boolean;
+    /**
+     * @generated from protobuf field: socket.room.PeerFlags flags = 9;
+     */
+    flags?: PeerFlags;
+}
+/**
+ * @generated MessageType for protobuf message socket.room.Peer
+ */
+declare const Peer: Peer$Type;
+declare class PeerInfoResponse$Type extends MessageType$1<PeerInfoResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.PeerInfoResponse
+ */
+interface PeerInfoResponse {
+    /**
+     * @generated from protobuf field: socket.room.Peer peer = 1;
+     */
+    peer?: Peer;
+}
+/**
+ * @generated MessageType for protobuf message socket.room.PeerInfoResponse
+ */
+declare const PeerInfoResponse: PeerInfoResponse$Type;
+declare class PeerStatusUpdate$Type extends MessageType$1<PeerStatusUpdate> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.PeerStatusUpdate
+ */
+interface PeerStatusUpdate {
+    /**
+     * @generated from protobuf field: string peer_id = 1;
+     */
+    peerId: string;
+    /**
+     * @generated from protobuf field: string user_id = 2;
+     */
+    userId: string;
+    /**
+     * @generated from protobuf field: optional socket.room.StageType stage_type = 3;
+     */
+    stageType?: StageType;
+}
+/**
+ * @generated MessageType for protobuf message socket.room.PeerStatusUpdate
+ */
+declare const PeerStatusUpdate: PeerStatusUpdate$Type;
+declare class RoomPeersInfoResponse$Type extends MessageType$1<RoomPeersInfoResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.RoomPeersInfoResponse
+ */
+interface RoomPeersInfoResponse {
+    /**
+     * @generated from protobuf field: repeated socket.room.Peer peers = 1;
+     */
+    peers: Peer[];
+}
+/**
+ * @generated MessageType for protobuf message socket.room.RoomPeersInfoResponse
+ */
+declare const RoomPeersInfoResponse: RoomPeersInfoResponse$Type;
+declare class Room$Type extends MessageType$1<Room> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.Room
+ */
+interface Room {
+    /**
+     * @generated from protobuf field: string room_id = 1;
+     */
+    roomId: string;
+    /**
+     * @generated from protobuf field: string title = 2;
+     */
+    title: string;
+    /**
+     * @generated from protobuf field: uint64 created_at = 4 [jstype = JS_NUMBER];
+     */
+    createdAt: number;
+    /**
+     * @generated from protobuf field: repeated socket.room.ActiveRecording active_recordings = 5;
+     */
+    activeRecordings: ActiveRecording[];
+    /**
+     * @generated from protobuf field: optional string room_uuid = 6;
+     */
+    roomUuid?: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.room.Room
+ */
+declare const Room: Room$Type;
+declare class ActiveRecording$Type extends MessageType$1<ActiveRecording> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.ActiveRecording
+ */
+interface ActiveRecording {
+    /**
+     * @generated from protobuf field: string recording_id = 1;
+     */
+    recordingId: string;
+    /**
+     * @generated from protobuf field: common.RecordingType recording_type = 2;
+     */
+    recordingType: RecordingType$1;
+    /**
+     * @generated from protobuf field: string recording_status = 3;
+     */
+    recordingStatus: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.room.ActiveRecording
+ */
+declare const ActiveRecording: ActiveRecording$Type;
+declare class RoomInfoResponse$Type extends MessageType$1<RoomInfoResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.RoomInfoResponse
+ */
+interface RoomInfoResponse {
+    /**
+     * @generated from protobuf field: socket.room.Room room = 1;
+     */
+    room?: Room;
+}
+/**
+ * @generated MessageType for protobuf message socket.room.RoomInfoResponse
+ */
+declare const RoomInfoResponse: RoomInfoResponse$Type;
+declare class WaitingRoomRequest$Type extends MessageType$1<WaitingRoomRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.WaitingRoomRequest
+ */
+interface WaitingRoomRequest {
+    /**
+     * @generated from protobuf field: string peer_id = 1;
+     */
+    peerId: string;
+    /**
+     * @generated from protobuf field: string user_id = 2;
+     */
+    userId: string;
+    /**
+     * @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
+ */
+declare const WaitingRoomRequest: WaitingRoomRequest$Type;
+declare class GetWaitingRoomRequests$Type extends MessageType$1<GetWaitingRoomRequests> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.GetWaitingRoomRequests
+ */
+interface GetWaitingRoomRequests {
+    /**
+     * @generated from protobuf field: repeated socket.room.WaitingRoomRequest requests = 1;
+     */
+    requests: WaitingRoomRequest[];
+}
+/**
+ * @generated MessageType for protobuf message socket.room.GetWaitingRoomRequests
+ */
+declare const GetWaitingRoomRequests: GetWaitingRoomRequests$Type;
+declare class GetRoomStageStateResponse$Type extends MessageType$1<GetRoomStageStateResponse> {
+    constructor();
+}
+/**
+ * not adding off stage array, as remaining will be off stage
+ *
+ * @generated from protobuf message socket.room.GetRoomStageStateResponse
+ */
+interface GetRoomStageStateResponse {
+    /**
+     * @generated from protobuf field: repeated string on_stage_peers = 1;
+     */
+    onStagePeers: string[];
+    /**
+     * @generated from protobuf field: repeated string approved_stage_peers = 2;
+     */
+    approvedStagePeers: string[];
+    /**
+     * @generated from protobuf field: repeated string requested_stage_peers = 3;
+     */
+    requestedStagePeers: string[];
+}
+/**
+ * @generated MessageType for protobuf message socket.room.GetRoomStageStateResponse
+ */
+declare const GetRoomStageStateResponse: GetRoomStageStateResponse$Type;
+
+/**
+ * @generated from protobuf enum socket.preset.WaitingRoomType
+ */
+declare enum WaitingRoomType {
+    /**
+     * @generated from protobuf enum value: WAITING_ROOM_TYPE_NONE = 0;
+     */
+    NONE = 0,
+    /**
+     * @generated from protobuf enum value: WAITING_ROOM_TYPE_SKIP = 1;
+     */
+    SKIP = 1,
+    /**
+     * @generated from protobuf enum value: WAITING_ROOM_TYPE_ON_PRIVILEGED_USER_ENTRY = 2;
+     */
+    ON_PRIVILEGED_USER_ENTRY = 2,
+    /**
+     * @generated from protobuf enum value: WAITING_ROOM_TYPE_SKIP_ON_ACCEPT = 3;
+     */
+    SKIP_ON_ACCEPT = 3
+}
+/**
+ * @generated from protobuf enum socket.preset.StreamPermissionType
+ */
+declare enum StreamPermissionType {
+    /**
+     * @generated from protobuf enum value: STREAM_PERMISSION_TYPE_NONE = 0;
+     */
+    NONE = 0,
+    /**
+     * @generated from protobuf enum value: STREAM_PERMISSION_TYPE_ALLOWED = 1;
+     */
+    ALLOWED = 1,
+    /**
+     * @generated from protobuf enum value: STREAM_PERMISSION_TYPE_NOT_ALLOWED = 2;
+     */
+    NOT_ALLOWED = 2,
+    /**
+     * @generated from protobuf enum value: STREAM_PERMISSION_TYPE_CAN_REQUEST = 3;
+     */
+    CAN_REQUEST = 3
+}
+declare class PollsPermissionUpdate$Type extends MessageType$1<PollsPermissionUpdate> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.PollsPermissionUpdate
+ */
+interface PollsPermissionUpdate {
+    /**
+     * @generated from protobuf field: optional bool can_create = 1;
+     */
+    canCreate?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_vote = 2;
+     */
+    canVote?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_view = 3;
+     */
+    canView?: boolean;
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.PollsPermissionUpdate
+ */
+declare const PollsPermissionUpdate: PollsPermissionUpdate$Type;
+declare class PluginsPermissionsUpdate$Type extends MessageType$1<PluginsPermissionsUpdate> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.PluginsPermissionsUpdate
+ */
+interface PluginsPermissionsUpdate {
+    /**
+     * @generated from protobuf field: optional bool can_close = 1;
+     */
+    canClose?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_start = 2;
+     */
+    canStart?: boolean;
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.PluginsPermissionsUpdate
+ */
+declare const PluginsPermissionsUpdate: PluginsPermissionsUpdate$Type;
+declare class PublicChatPermission$Type extends MessageType$1<PublicChatPermission> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.PublicChatPermission
+ */
+interface PublicChatPermission {
+    /**
+     * @generated from protobuf field: optional bool can_send = 1;
+     */
+    canSend?: boolean;
+    /**
+     * @generated from protobuf field: optional bool text = 2;
+     */
+    text?: boolean;
+    /**
+     * @generated from protobuf field: optional bool files = 3;
+     */
+    files?: boolean;
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.PublicChatPermission
+ */
+declare const PublicChatPermission: PublicChatPermission$Type;
+declare class PrivateChatPermission$Type extends MessageType$1<PrivateChatPermission> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.PrivateChatPermission
+ */
+interface PrivateChatPermission {
+    /**
+     * @generated from protobuf field: optional bool can_send = 1;
+     */
+    canSend?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_receive = 2;
+     */
+    canReceive?: boolean;
+    /**
+     * @generated from protobuf field: optional bool text = 3;
+     */
+    text?: boolean;
+    /**
+     * @generated from protobuf field: optional bool files = 4;
+     */
+    files?: boolean;
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.PrivateChatPermission
+ */
+declare const PrivateChatPermission: PrivateChatPermission$Type;
+declare class ChatPermissionUpdate$Type extends MessageType$1<ChatPermissionUpdate> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.ChatPermissionUpdate
+ */
+interface ChatPermissionUpdate {
+    /**
+     * @generated from protobuf field: optional socket.preset.PublicChatPermission public = 1;
+     */
+    public?: PublicChatPermission;
+    /**
+     * @generated from protobuf field: optional socket.preset.PrivateChatPermission private = 2;
+     */
+    private?: PrivateChatPermission;
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.ChatPermissionUpdate
+ */
+declare const ChatPermissionUpdate: ChatPermissionUpdate$Type;
+declare class ConnectedMeetingPermissionUpdate$Type extends MessageType$1<ConnectedMeetingPermissionUpdate> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.ConnectedMeetingPermissionUpdate
+ */
+interface ConnectedMeetingPermissionUpdate {
+    /**
+     * @generated from protobuf field: optional bool can_alter_connected_meetings = 1;
+     */
+    canAlterConnectedMeetings?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_switch_to_parent_meeting = 2;
+     */
+    canSwitchToParentMeeting?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_switch_connected_meetings = 3;
+     */
+    canSwitchConnectedMeetings?: boolean;
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.ConnectedMeetingPermissionUpdate
+ */
+declare const ConnectedMeetingPermissionUpdate: ConnectedMeetingPermissionUpdate$Type;
+declare class StreamPermission$Type extends MessageType$1<StreamPermission> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.StreamPermission
+ */
+interface StreamPermission {
+    /**
+     * @generated from protobuf field: optional socket.preset.StreamPermissionType can_produce = 1;
+     */
+    canProduce?: StreamPermissionType;
+    /**
+     * @generated from protobuf field: optional socket.preset.StreamPermissionType can_consume = 2;
+     */
+    canConsume?: StreamPermissionType;
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.StreamPermission
+ */
+declare const StreamPermission: StreamPermission$Type;
+declare class MediaPermissionUpdate$Type extends MessageType$1<MediaPermissionUpdate> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.MediaPermissionUpdate
+ */
+interface MediaPermissionUpdate {
+    /**
+     * @generated from protobuf field: optional socket.preset.StreamPermission video = 1;
+     */
+    video?: StreamPermission;
+    /**
+     * @generated from protobuf field: optional socket.preset.StreamPermission audio = 2;
+     */
+    audio?: StreamPermission;
+    /**
+     * @generated from protobuf field: optional socket.preset.StreamPermission screenshare = 3;
+     */
+    screenshare?: StreamPermission;
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.MediaPermissionUpdate
+ */
+declare const MediaPermissionUpdate: MediaPermissionUpdate$Type;
+declare class PresetUpdates$Type extends MessageType$1<PresetUpdates> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.PresetUpdates
+ */
+interface PresetUpdates {
+    /**
+     * @generated from protobuf field: optional socket.preset.PollsPermissionUpdate polls = 1;
+     */
+    polls?: PollsPermissionUpdate;
+    /**
+     * @generated from protobuf field: optional socket.preset.PluginsPermissionsUpdate plugins = 2;
+     */
+    plugins?: PluginsPermissionsUpdate;
+    /**
+     * @generated from protobuf field: optional socket.preset.ChatPermissionUpdate chat = 3;
+     */
+    chat?: ChatPermissionUpdate;
+    /**
+     * @generated from protobuf field: optional bool accept_waiting_requests = 4;
+     */
+    acceptWaitingRequests?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_accept_production_requests = 5;
+     */
+    canAcceptProductionRequests?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_edit_display_name = 6;
+     */
+    canEditDisplayName?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_record = 7;
+     */
+    canRecord?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_livestream = 8;
+     */
+    canLivestream?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_spotlight = 9;
+     */
+    canSpotlight?: boolean;
+    /**
+     * @generated from protobuf field: optional bool disable_participant_audio = 10;
+     */
+    disableParticipantAudio?: boolean;
+    /**
+     * @generated from protobuf field: optional bool disable_participant_screensharing = 11;
+     */
+    disableParticipantScreensharing?: boolean;
+    /**
+     * @generated from protobuf field: optional bool disable_participant_video = 12;
+     */
+    disableParticipantVideo?: boolean;
+    /**
+     * @generated from protobuf field: optional bool kick_participant = 13;
+     */
+    kickParticipant?: boolean;
+    /**
+     * @generated from protobuf field: optional bool pin_participant = 14;
+     */
+    pinParticipant?: boolean;
+    /**
+     * @generated from protobuf field: optional bool transcription_enabled = 15;
+     */
+    transcriptionEnabled?: boolean;
+    /**
+     * @generated from protobuf field: optional socket.preset.WaitingRoomType waiting_room_type = 16;
+     */
+    waitingRoomType?: WaitingRoomType;
+    /**
+     * @generated from protobuf field: optional bool is_recorder = 17;
+     */
+    isRecorder?: boolean;
+    /**
+     * @generated from protobuf field: optional socket.room.RecorderType recorder_type = 18;
+     */
+    recorderType?: RecorderType;
+    /**
+     * @generated from protobuf field: optional bool hidden_participant = 19;
+     */
+    hiddenParticipant?: boolean;
+    /**
+     * @generated from protobuf field: optional bool show_participant_list = 20;
+     */
+    showParticipantList?: boolean;
+    /**
+     * @generated from protobuf field: optional bool can_change_participant_permissions = 21;
+     */
+    canChangeParticipantPermissions?: boolean;
+    /**
+     * @generated from protobuf field: optional socket.preset.ConnectedMeetingPermissionUpdate connected_meetings = 22;
+     */
+    connectedMeetings?: ConnectedMeetingPermissionUpdate;
+    /**
+     * @generated from protobuf field: optional socket.preset.MediaPermissionUpdate media = 23;
+     */
+    media?: MediaPermissionUpdate;
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.PresetUpdates
+ */
+declare const PresetUpdates: PresetUpdates$Type;
+declare class UpdatePeerPreset$Type extends MessageType$1<UpdatePeerPreset> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.UpdatePeerPreset
+ */
+interface UpdatePeerPreset {
+    /**
+     * @generated from protobuf field: string user_ids = 1;
+     */
+    userIds: string;
+    /**
+     * @generated from protobuf field: socket.preset.PresetUpdates patch = 2;
+     */
+    patch?: PresetUpdates;
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.UpdatePeerPreset
+ */
+declare const UpdatePeerPreset: UpdatePeerPreset$Type;
+declare class UpdatePeersPresetResponse$Type extends MessageType$1<UpdatePeersPresetResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.preset.UpdatePeersPresetResponse
+ */
+interface UpdatePeersPresetResponse {
+    /**
+     * @generated from protobuf field: repeated socket.preset.UpdatePeerPreset update_peers_presets = 1;
+     */
+    updatePeersPresets: UpdatePeerPreset[];
+}
+/**
+ * @generated MessageType for protobuf message socket.preset.UpdatePeersPresetResponse
+ */
+declare const UpdatePeersPresetResponse: UpdatePeersPresetResponse$Type;
+
+declare class ChatMessage$Type extends MessageType$1<ChatMessage> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.chat.ChatMessage
+ */
+interface ChatMessage {
+    /**
+     * @generated from protobuf field: string chat_id = 1;
+     */
+    chatId: string;
+    /**
+     * @generated from protobuf field: string peer_id = 2;
+     */
+    peerId: string;
+    /**
+     * @generated from protobuf field: string user_id = 3;
+     */
+    userId: string;
+    /**
+     * @generated from protobuf field: string display_name = 4;
+     */
+    displayName: string;
+    /**
+     * @generated from protobuf field: bool pinned = 5;
+     */
+    pinned: boolean;
+    /**
+     * @generated from protobuf field: bool is_edited = 6;
+     */
+    isEdited: boolean;
+    /**
+     * @generated from protobuf field: int32 payload_type = 7;
+     */
+    payloadType: number;
+    /**
+     * @generated from protobuf field: string payload = 8;
+     */
+    payload: string;
+    /**
+     * @generated from protobuf field: repeated string target_user_ids = 10;
+     */
+    targetUserIds: string[];
+    /**
+     * @generated from protobuf field: uint64 created_at = 11 [jstype = JS_NUMBER];
+     */
+    createdAt: number;
+    /**
+     * @generated from protobuf field: optional uint64 created_at_ms = 12 [jstype = JS_NUMBER];
+     */
+    createdAtMs?: number;
+    /**
+     * @generated from protobuf field: optional string channel_id = 13;
+     */
+    channelId?: string;
+    /**
+     * The index of this message within it's channel
+     *
+     * @generated from protobuf field: optional string channel_index = 14;
+     */
+    channelIndex?: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.chat.ChatMessage
+ */
+declare const ChatMessage: ChatMessage$Type;
+declare class GetPaginatedChatMessageRoomResponse$Type extends MessageType$1<GetPaginatedChatMessageRoomResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.chat.GetPaginatedChatMessageRoomResponse
+ */
+interface GetPaginatedChatMessageRoomResponse {
+    /**
+     * @generated from protobuf field: repeated socket.chat.ChatMessage messages = 1;
+     */
+    messages: ChatMessage[];
+    /**
+     * @generated from protobuf field: bool next = 2;
+     */
+    next: boolean;
+}
+/**
+ * @generated MessageType for protobuf message socket.chat.GetPaginatedChatMessageRoomResponse
+ */
+declare const GetPaginatedChatMessageRoomResponse: GetPaginatedChatMessageRoomResponse$Type;
+declare class SendChatMessageToRoomResponse$Type extends MessageType$1<SendChatMessageToRoomResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.chat.SendChatMessageToRoomResponse
+ */
+interface SendChatMessageToRoomResponse {
+    /**
+     * @generated from protobuf field: socket.chat.ChatMessage message = 1;
+     */
+    message?: ChatMessage;
+}
+/**
+ * @generated MessageType for protobuf message socket.chat.SendChatMessageToRoomResponse
+ */
+declare const SendChatMessageToRoomResponse: SendChatMessageToRoomResponse$Type;
+declare class SendChatMessageToPeersResponse$Type extends MessageType$1<SendChatMessageToPeersResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.chat.SendChatMessageToPeersResponse
+ */
+interface SendChatMessageToPeersResponse {
+    /**
+     * @generated from protobuf field: socket.chat.ChatMessage message = 1;
+     */
+    message?: ChatMessage;
+}
+/**
+ * @generated MessageType for protobuf message socket.chat.SendChatMessageToPeersResponse
+ */
+declare const SendChatMessageToPeersResponse: SendChatMessageToPeersResponse$Type;
+declare class PinChatMessageResponse$Type extends MessageType$1<PinChatMessageResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.chat.PinChatMessageResponse
+ */
+interface PinChatMessageResponse {
+    /**
+     * @generated from protobuf field: string chat_id = 1;
+     */
+    chatId: string;
+    /**
+     * @generated from protobuf field: bool pinned = 2;
+     */
+    pinned: boolean;
+    /**
+     * @generated from protobuf field: optional string channel_id = 3;
+     */
+    channelId?: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.chat.PinChatMessageResponse
+ */
+declare const PinChatMessageResponse: PinChatMessageResponse$Type;
+declare class EditChatMessageResponse$Type extends MessageType$1<EditChatMessageResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.chat.EditChatMessageResponse
+ */
+interface EditChatMessageResponse {
+    /**
+     * @generated from protobuf field: socket.chat.ChatMessage message = 1;
+     */
+    message?: ChatMessage;
+}
+/**
+ * @generated MessageType for protobuf message socket.chat.EditChatMessageResponse
+ */
+declare const EditChatMessageResponse: EditChatMessageResponse$Type;
+declare class DeleteChatMessageResponse$Type extends MessageType$1<DeleteChatMessageResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.chat.DeleteChatMessageResponse
+ */
+interface DeleteChatMessageResponse {
+    /**
+     * @generated from protobuf field: string chat_id = 1;
+     */
+    chatId: string;
+    /**
+     * @generated from protobuf field: optional string channel_id = 2;
+     */
+    channelId?: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.chat.DeleteChatMessageResponse
+ */
+declare const DeleteChatMessageResponse: DeleteChatMessageResponse$Type;
+
+declare class LatestMessageAndUnreadCount$Type extends MessageType$1<LatestMessageAndUnreadCount> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.chat.LatestMessageAndUnreadCount
+ */
+interface LatestMessageAndUnreadCount {
+    /**
+     * @generated from protobuf field: optional socket.chat.ChatMessage message = 1;
+     */
+    message?: ChatMessage;
+    /**
+     * @generated from protobuf field: uint64 unread_count = 2 [jstype = JS_NUMBER];
+     */
+    unreadCount: number;
+}
+/**
+ * @generated MessageType for protobuf message socket.chat.LatestMessageAndUnreadCount
+ */
+declare const LatestMessageAndUnreadCount: LatestMessageAndUnreadCount$Type;
+declare class ChatChannel$Type extends MessageType$1<ChatChannel$1> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.chat.ChatChannel
+ */
+interface ChatChannel$1 {
+    /**
+     * @generated from protobuf field: string chat_channel_id = 1;
+     */
+    chatChannelId: string;
+    /**
+     * @generated from protobuf field: string display_name = 2;
+     */
+    displayName: string;
+    /**
+     * @generated from protobuf field: optional string display_picture_url = 3;
+     */
+    displayPictureUrl?: string;
+    /**
+     * @generated from protobuf field: string visibility = 4;
+     */
+    visibility: string;
+    /**
+     * @generated from protobuf field: bool is_direct_message = 5;
+     */
+    isDirectMessage: boolean;
+    /**
+     * @generated from protobuf field: socket.chat.LatestMessageAndUnreadCount latest_message_and_unread_count = 6;
+     */
+    latestMessageAndUnreadCount?: LatestMessageAndUnreadCount;
+    /**
+     * @generated from protobuf field: repeated string target_user_ids = 7;
+     */
+    targetUserIds: string[];
+}
+/**
+ * @generated MessageType for protobuf message socket.chat.ChatChannel
+ */
+declare const ChatChannel$1: ChatChannel$Type;
+declare class GetChatChannelResponse$Type extends MessageType$1<GetChatChannelResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.chat.GetChatChannelResponse
+ */
+interface GetChatChannelResponse {
+    /**
+     * @generated from protobuf field: repeated socket.chat.ChatChannel chat_channels = 1;
+     */
+    chatChannels: ChatChannel$1[];
+}
+/**
+ * @generated MessageType for protobuf message socket.chat.GetChatChannelResponse
+ */
+declare const GetChatChannelResponse: GetChatChannelResponse$Type;
+
+declare class EnablePluginResponse$Type extends MessageType$1<EnablePluginResponse> {
+    constructor();
+}
+/**
+ * Response sent whenever a plugin is enabled.
+ * Applicable for all requests that enable a plugin.
+ *
+ * @generated from protobuf message socket.plugin.EnablePluginResponse
+ */
+interface EnablePluginResponse {
+    /**
+     * @generated from protobuf field: string plugin_id = 1;
+     */
+    pluginId: string;
+    /**
+     * @generated from protobuf field: string enabled_by = 2;
+     */
+    enabledBy: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.plugin.EnablePluginResponse
+ */
+declare const EnablePluginResponse: EnablePluginResponse$Type;
+declare class EnablePluginsResponse$Type extends MessageType$1<EnablePluginsResponse> {
+    constructor();
+}
+/**
+ * Response sent when all enabled plugins are requested.
+ *
+ * @generated from protobuf message socket.plugin.EnablePluginsResponse
+ */
+interface EnablePluginsResponse {
+    /**
+     * @generated from protobuf field: repeated socket.plugin.EnablePluginResponse plugins = 1;
+     */
+    plugins: EnablePluginResponse[];
+}
+/**
+ * @generated MessageType for protobuf message socket.plugin.EnablePluginsResponse
+ */
+declare const EnablePluginsResponse: EnablePluginsResponse$Type;
+declare class DisablePluginResponse$Type extends MessageType$1<DisablePluginResponse> {
+    constructor();
+}
+/**
+ * Response sent whenever a plugin is disabled.
+ * Applicable for all requests that disable a plugin.
+ *
+ * @generated from protobuf message socket.plugin.DisablePluginResponse
+ */
+interface DisablePluginResponse {
+    /**
+     * @generated from protobuf field: string plugin_id = 1;
+     */
+    pluginId: string;
+    /**
+     * @generated from protobuf field: string disabled_by = 2;
+     */
+    disabledBy: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.plugin.DisablePluginResponse
+ */
+declare const DisablePluginResponse: DisablePluginResponse$Type;
+declare class PluginStoreItem$Type extends MessageType$1<PluginStoreItem> {
+    constructor();
+}
+/**
+ * Response sent whenever a plugin store is updated.
+ * Applicable for all requests that access a store.
+ *
+ * @generated from protobuf message socket.plugin.PluginStoreItem
+ */
+interface PluginStoreItem {
+    /**
+     * @generated from protobuf field: string timestamp = 1;
+     */
+    timestamp: string;
+    /**
+     * @generated from protobuf field: string peer_id = 2;
+     */
+    peerId: string;
+    /**
+     * @generated from protobuf field: string store_key = 3;
+     */
+    storeKey: string;
+    /**
+     * @generated from protobuf field: bytes payload = 4;
+     */
+    payload: Uint8Array;
+}
+/**
+ * @generated MessageType for protobuf message socket.plugin.PluginStoreItem
+ */
+declare const PluginStoreItem: PluginStoreItem$Type;
+declare class PluginStoreResponse$Type extends MessageType$1<PluginStoreResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.plugin.PluginStoreResponse
+ */
+interface PluginStoreResponse {
+    /**
+     * @generated from protobuf field: string plugin_id = 1;
+     */
+    pluginId: string;
+    /**
+     * @generated from protobuf field: string store_name = 2;
+     */
+    storeName: string;
+    /**
+     * @generated from protobuf field: repeated socket.plugin.PluginStoreItem store_items = 3;
+     */
+    storeItems: PluginStoreItem[];
+}
+/**
+ * @generated MessageType for protobuf message socket.plugin.PluginStoreResponse
+ */
+declare const PluginStoreResponse: PluginStoreResponse$Type;
+declare class PluginEventResponse$Type extends MessageType$1<PluginEventResponse> {
+    constructor();
+}
+/**
+ * Response sent for custom plugin event.
+ *
+ * @generated from protobuf message socket.plugin.PluginEventResponse
+ */
+interface PluginEventResponse {
+    /**
+     * @generated from protobuf field: string plugin_id = 1;
+     */
+    pluginId: string;
+    /**
+     * @generated from protobuf field: bytes plugin_data = 2;
+     */
+    pluginData: Uint8Array;
+}
+/**
+ * @generated MessageType for protobuf message socket.plugin.PluginEventResponse
+ */
+declare const PluginEventResponse: PluginEventResponse$Type;
+
+declare class GetStagePeersResponse$Type extends MessageType$1<GetStagePeersResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.livestreaming.GetStagePeersResponse
+ */
+interface GetStagePeersResponse {
+    /**
+     * @generated from protobuf field: repeated string stage_peers = 1;
+     */
+    stagePeers: string[];
+}
+/**
+ * @generated MessageType for protobuf message socket.livestreaming.GetStagePeersResponse
+ */
+declare const GetStagePeersResponse: GetStagePeersResponse$Type;
+declare class StageRequest$Type extends MessageType$1<StageRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.livestreaming.StageRequest
+ */
+interface StageRequest {
+    /**
+     * @generated from protobuf field: string display_name = 1;
+     */
+    displayName: string;
+    /**
+     * @generated from protobuf field: string user_id = 2;
+     */
+    userId: string;
+    /**
+     * @generated from protobuf field: string peer_id = 3;
+     */
+    peerId: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.livestreaming.StageRequest
+ */
+declare const StageRequest: StageRequest$Type;
+declare class GetStageRequestsResponse$Type extends MessageType$1<GetStageRequestsResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.livestreaming.GetStageRequestsResponse
+ */
+interface GetStageRequestsResponse {
+    /**
+     * @generated from protobuf field: repeated socket.livestreaming.StageRequest stage_requests = 1;
+     */
+    stageRequests: StageRequest[];
+}
+/**
+ * @generated MessageType for protobuf message socket.livestreaming.GetStageRequestsResponse
+ */
+declare const GetStageRequestsResponse: GetStageRequestsResponse$Type;
+declare class DenyStageAccessRequest$Type extends MessageType$1<DenyStageAccessRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.livestreaming.DenyStageAccessRequest
+ */
+interface DenyStageAccessRequest {
+    /**
+     * @generated from protobuf field: repeated string user_ids = 1;
+     */
+    userIds: string[];
+}
+/**
+ * @generated MessageType for protobuf message socket.livestreaming.DenyStageAccessRequest
+ */
+declare const DenyStageAccessRequest: DenyStageAccessRequest$Type;
+
+declare class Poll$Type extends MessageType$1<Poll$1> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.polls.Poll
+ */
+interface Poll$1 {
+    /**
+     * @generated from protobuf field: string poll_id = 1;
+     */
+    pollId: string;
+    /**
+     * @generated from protobuf field: string created_by = 2;
+     */
+    createdBy: string;
+    /**
+     * @generated from protobuf field: string created_by_user_id = 3;
+     */
+    createdByUserId: string;
+    /**
+     * @generated from protobuf field: string question = 4;
+     */
+    question: string;
+    /**
+     * @generated from protobuf field: repeated socket.polls.PollOption options = 5;
+     */
+    options: PollOption$1[];
+    /**
+     * @generated from protobuf field: bool hide_votes = 6;
+     */
+    hideVotes: boolean;
+    /**
+     * @generated from protobuf field: bool anonymous = 7;
+     */
+    anonymous: boolean;
+    /**
+     * @generated from protobuf field: repeated string votes = 8;
+     */
+    votes: string[];
+}
+/**
+ * @generated MessageType for protobuf message socket.polls.Poll
+ */
+declare const Poll$1: Poll$Type;
+declare class PollOption$Type extends MessageType$1<PollOption$1> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.polls.PollOption
+ */
+interface PollOption$1 {
+    /**
+     * @generated from protobuf field: string text = 1;
+     */
+    text: string;
+    /**
+     * @generated from protobuf field: optional uint64 count = 2 [jstype = JS_NUMBER];
+     */
+    count?: number;
+    /**
+     * @generated from protobuf field: repeated socket.polls.PollVote votes = 3;
+     */
+    votes: PollVote[];
+}
+/**
+ * @generated MessageType for protobuf message socket.polls.PollOption
+ */
+declare const PollOption$1: PollOption$Type;
+declare class PollVote$Type extends MessageType$1<PollVote> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.polls.PollVote
+ */
+interface PollVote {
+    /**
+     * @generated from protobuf field: string user_id = 1;
+     */
+    userId: string;
+    /**
+     * @generated from protobuf field: string name = 2;
+     */
+    name: string;
+}
+/**
+ * @generated MessageType for protobuf message socket.polls.PollVote
+ */
+declare const PollVote: PollVote$Type;
+declare class UpdatePollResponse$Type extends MessageType$1<UpdatePollResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.polls.UpdatePollResponse
+ */
+interface UpdatePollResponse {
+    /**
+     * @generated from protobuf field: socket.polls.Poll poll = 1;
+     */
+    poll?: Poll$1;
+}
+/**
+ * @generated MessageType for protobuf message socket.polls.UpdatePollResponse
+ */
+declare const UpdatePollResponse: UpdatePollResponse$Type;
+
+declare class RecordingEvent$Type extends MessageType$1<RecordingEvent> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.recording.RecordingEvent
+ */
+interface RecordingEvent {
+    /**
+     * @generated from protobuf field: string recording_id = 1;
+     */
+    recordingId: string;
+    /**
+     * @generated from protobuf field: string err_message = 2;
+     */
+    errMessage: string;
+    /**
+     * @generated from protobuf field: common.RecordingType recording_type = 3;
+     */
+    recordingType: RecordingType$1;
+}
+/**
+ * @generated MessageType for protobuf message socket.recording.RecordingEvent
+ */
+declare const RecordingEvent: RecordingEvent$Type;
+
+type ClientEnvTypeAll = 'devel' | 'preprod' | 'prod';
+
+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 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 {
+    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;
+}
+
+declare class RTKSelectedPeers {
+    constructor();
+    add(peerId: string, priority: number): number;
+    delete(peerId: string): void;
+    index(peerId: string): number;
+    get peers(): string[];
+    get compulsoryPeers(): string[];
+    get activeSpeakerPeers(): string[];
+}
+
+type PipEvents = {
+    ['cameraToggled']: () => void;
+    ['micToggled']: () => void;
+    ['hangup']: () => void;
+    ['pipStarted']: () => void;
+    ['pipEnded']: () => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
+};
+declare class RTKPip extends RTKTypedEventEmitter<PipEvents> {
+    private constructor();
+    static _init(context: Context<RTKContextState>, self: RTKSelf$1): Promise<RTKPip>;
+    overrideIcon(icon: 'handRaise' | 'pin', value: string): Promise<void>;
+    isSupported(): boolean;
+    get isActive(): boolean;
+    init({ height, width }?: {
+        height?: number;
+        width?: number;
+    }): void;
+    enableSource(source: string): void;
+    disableSource(source: string): void;
+    addSource(id: string, element: HTMLVideoElement, enabled: boolean, pinned?: boolean, displayText?: string, imageUrl?: string, handRaised?: boolean): void;
+    updateSource(id: string, source: any): void;
+    removeSource(id: string): void;
+    removePinnedSource(): void;
+    removeAllSources(): void;
+    enable(): void;
+    disable: (partial?: boolean) => void;
+}
+
+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 EventHandlerTypes = PeerInfoResponse | GetWaitingRoomRequests | RecordingEvent | UpdatePeersPresetResponse | PeerJoinBroadcastResponse | PeerJoinCompleteResponse | GlobalPeerPinningBroadcastResponse | PeerLeaveResponse | SelectedPeersResponse | SelectedPeersDiffResponse;
+declare class RoomSocketHandler {
+    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;
+    }): 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'>>;
+}
+
+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 GenericHandlerResult {
+    offerSdp: RTCSessionDescriptionInit;
+    callback: (answer: RTCSessionDescriptionInit) => Promise<any>;
+    sender?: RTCRtpSender;
+}
+type HandlerRunOptions = {
+    direction: 'send' | 'recv';
+    iceServers?: RTCIceServer[];
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    additionalSettings?: any;
+    proprietaryConstraints?: any;
+    onTrackHandler?: (event: RTCTrackEvent) => void;
+};
+type CodecOption = {
+    name: string;
+    parameters?: string[];
+};
+type HandlerSendOptions = {
+    track: MediaStreamTrack | 'audio' | 'video';
+    screenShare?: boolean;
+    encodings?: RTCRtpEncodingParameters[];
+    codecs?: RTCRtpCodecCapability[];
+    codecOptions?: CodecOption[];
+};
+interface HandlerSendResult extends GenericHandlerResult {
+    mid: string;
+}
+declare abstract class HandlerInterface<TransportPromiseEvents> extends EnhancedEventEmitter<TransportPromiseEvents> {
+    pc: RTCPeerConnection;
+    enableHighBitrate: boolean;
+    enableStereo: boolean;
+    enableDtx: boolean;
+    get midTransceiverMap(): Map<string, RTCRtpTransceiver>;
+    abstract get name(): string;
+    close(): void;
+    restartIce(): Promise<GenericHandlerResult>;
+    init({ direction, iceServers, iceTransportPolicy, additionalSettings, proprietaryConstraints, onTrackHandler, }: HandlerRunOptions): void;
+    connect(): Promise<GenericHandlerResult>;
+    getTransportStats(): Promise<RTCStatsReport>;
+    getReceiverStats(localId: string): Promise<RTCStatsReport>;
+    stopSending(localId: string): Promise<GenericHandlerResult>;
+    abstract send(options: HandlerSendOptions): Promise<HandlerSendResult>;
+    replaceTrack(localId: string, track: MediaStreamTrack | null): Promise<void>;
+    setMaxSpatialLayer(localId: string, spatialLayer: number): Promise<void>;
+    setRtpEncodingParameters(localId: string, params: any): Promise<void>;
+    getSenderStats(localId: string): Promise<RTCStatsReport>;
+    _addEventListeners(): void;
+    addCustomEventListeners(): void;
+}
+
+type DCMessage = {
+    type: string;
+    payload: Record<string, unknown>;
+};
+
+declare enum TransportState {
+    NEW = "new",
+    CONNECTING = "connecting",
+    RECONNECTING = "reconnecting",
+    DISCONNECTED = "disconnected",
+    CONNECTED = "connected",
+    FAILED = "failed",
+    CLOSED = "closed"
+}
+declare enum MediaNodeType {
+    HIVE = 1,
+    ROOM_NODE = 2,
+    CF = 3
+}
+type MediaConnectionState = {
+    recv: {
+        state: `${TransportState}`;
+        reconnected: boolean;
+    };
+    send: {
+        state: `${TransportState}`;
+        reconnected: boolean;
+    };
+};
+
+type TransportPromiseEvents = {
+    'connect': {
+        answer: RTCSessionDescriptionInit;
+    };
+    'close': {
+        answer: RTCSessionDescriptionInit;
+    };
+    'negotiate': {
+        description: RTCSessionDescriptionInit;
+    };
+};
+
+type ConsumerOptions = {
+    id?: string;
+    producerId: string;
+    producingPeerId: string;
+    producingTransportId: string;
+    kind?: 'audio' | 'video';
+    paused?: boolean;
+    appData?: Record<string, unknown>;
+    mimeType?: string;
+    localId: string;
+    handler: HandlerInterface<TransportPromiseEvents>;
+    track?: MediaStreamTrack;
+    rtpReceiver?: RTCRtpReceiver;
+    transceiver: RTCRtpTransceiver;
+    closeTranscieverOnClose?: boolean;
+};
+type MediaKind = '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);
+    get closed(): boolean;
+    get kind(): MediaKind;
+    get paused(): boolean;
+    close(reason?: string, closeTranscieverOnClose?: boolean): void;
+    getStats(): Promise<RTCStatsReport>;
+    pause(): void;
+    resume(): void;
+}
+
+declare const localMediaEvents: readonly ["AUDIO_TRACK_CHANGE", "VIDEO_TRACK_CHANGE", "SCREENSHARE_TRACK_CHANGE", "SCREENSHARE_ENDED", "AUDIO_TRACK_SILENT", "FORCE_MUTE_AUDIO", "FORCE_MUTE_VIDEO", "DEVICE_CHANGE", "DEVICE_LIST_UPDATED"];
+type LocalMediaEvents = (typeof localMediaEvents)[number];
+type ParticipantEvents = {
+    ['videoUpdate']: (payload: {
+        videoEnabled: boolean;
+        videoTrack: MediaStreamTrack;
+    }) => void;
+    ['audioUpdate']: (payload: {
+        audioEnabled: boolean;
+        audioTrack: MediaStreamTrack;
+    }) => void;
+    ['screenShareUpdate']: (payload: {
+        screenShareEnabled: boolean;
+        screenShareTracks: {
+            audio: MediaStreamTrack;
+            video: MediaStreamTrack;
+        };
+    }) => void;
+    ['pinned']: (payload: RTKParticipant) => void;
+    ['unpinned']: (payload: RTKParticipant) => void;
+    ['poorConnection']: (payload: {
+        score: number;
+        kind: string;
+    }) => void;
+    ['stageStatusUpdate']: (payload: RTKParticipant) => void;
+    ['mediaScoreUpdate']: (payload: {
+        kind: MediaKind;
+        isScreenshare: boolean;
+        score: number;
+        participantId: string;
+        scoreStats: ConsumerScoreStats;
+    }) => void;
+    ['kicked']: () => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+type SelfEvents = {
+    ['toggleTile']: (payload: {
+        hidden: boolean;
+    }) => void;
+    ['videoUpdate']: (payload: {
+        videoEnabled: boolean;
+        videoTrack: MediaStreamTrack;
+    }) => void;
+    ['audioUpdate']: (payload: {
+        audioEnabled: boolean;
+        audioTrack: MediaStreamTrack;
+    }) => void;
+    ['screenShareUpdate']: (payload: {
+        screenShareEnabled: boolean;
+        screenShareTracks: {
+            audio?: MediaStreamTrack;
+            video?: MediaStreamTrack;
+        };
+    }) => void;
+    ['deviceUpdate']: ({ device }: {
+        device: MediaDeviceInfo;
+    }) => void;
+    ['deviceListUpdate']: (changedDevices: {
+        added: MediaDeviceInfo[];
+        removed: MediaDeviceInfo[];
+        devices: MediaDeviceInfo[];
+    }) => void;
+    ['pinned']: (payload: RTKSelf) => void;
+    ['unpinned']: (payload: RTKSelf) => void;
+    ['mediaPermissionUpdate']: (payload: {
+        message: keyof typeof MediaPermission;
+        kind: 'audio' | 'video' | 'screenshare';
+    }) => void;
+    ['mediaPermissionError']: (payload: {
+        message: keyof typeof MediaPermission;
+        constraints: any;
+        kind: 'audio' | 'video' | 'screenshare';
+    }) => void;
+    ['mediaScoreUpdate']: (payload: {
+        kind: MediaKind;
+        isScreenshare: boolean;
+        score: number;
+        participantId: string;
+        scoreStats: ProducerScoreStats;
+    }) => void;
+    ['waitlisted']: () => void;
+    ['roomLeft']: (payload: {
+        state: LeaveRoomState;
+    }) => void;
+    ['roomJoined']: (payload: {
+        reconnected: boolean;
+    }) => void;
+    ['*']: (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;
+    get 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;
+    get 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;
+    get isPinned(): boolean;
+    registerVideoElement(videoElem: HTMLVideoElement): void;
+    deregisterVideoElement(videoElem: HTMLVideoElement): void;
+}
+
+type TranscriptionData = {
+    id: string;
+    name: string;
+    peerId: string;
+    userId: string;
+    customParticipantId: string;
+    transcript: string;
+    isPartialTranscript: boolean;
+    date: Date;
+};
+type AiEvents = {
+    ['transcript']: (t: TranscriptionData) => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+declare class RTKAi extends RTKTypedEventEmitter<AiEvents> {
+    transcripts: TranscriptionData[];
+    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;
+}
+declare enum TabChangeSource {
+    User = 0,
+    Meeting = 1
+}
+interface MediaConnectionUpdate {
+    transport: 'consuming' | 'producing';
+    state: `${TransportState}`;
+    reconnected: boolean;
+}
+type MetaEvents = {
+    ['mediaConnectionUpdate']: (payload: MediaConnectionUpdate) => void;
+    ['socketConnectionUpdate']: (state: SocketConnectionState) => void;
+    ['poorConnection']: (payload: {
+        score: number;
+    }) => void;
+    ['meetingStartTimeUpdate']: (payload: {
+        meetingStartedTimestamp: Date;
+    }) => void;
+    ['transcript']: (t: TranscriptionData) => void;
+    ['activeTabUpdate']: (tab: ActiveTab) => void;
+    ['selfTabUpdate']: (tab: ActiveTab) => void;
+    ['broadcastTabChangesUpdate']: (broadcastTabChanges: boolean) => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+declare class RTKMeta$1 extends RTKTypedEventEmitter<MetaEvents> {
+    selfActiveTab: ActiveTab | undefined;
+    get socketState(): SocketConnectionState;
+    get mediaState(): MediaConnectionState;
+    broadcastTabChanges: boolean;
+    viewType: string;
+    meetingStartedTimestamp: Date;
+    meetingTitle: string;
+    sessionId: string;
+    constructor(context: Context<RTKContextState>, self: RTKSelf, viewType: string, roomSocketHandler: RoomSocketHandler, meetingTitle: string);
+    get meetingId(): string;
+    setBroadcastTabChanges(broadcastTabChanges: boolean): void;
+    setSelfActiveTab(spotlightTab: ActiveTab, tabChangeSource: TabChangeSource): void;
+}
+
+interface RTKMapEvents<T extends EventMap> {
+    onAddEvent?: keyof T;
+    onDeleteEvent?: keyof T;
+    onClearEvent?: keyof T;
+}
+type ModifyPrependObject<T extends EventMap, 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 & WildCardEvent<T>), U extends {
+        id: string;
+    } & RTKTypedEventEmitter<T>, V extends EventMap> 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 const modes: readonly ["ACTIVE_GRID", "PAGINATED", "MANUAL"];
+type ViewMode = (typeof modes)[number];
+interface BroadcastMessagePayload {
+    [key: string]: boolean | number | string | Date | ActiveTab;
+}
+interface PeerProducerConfig {
+    audio: boolean;
+    video: boolean;
+    screenshareAudio: boolean;
+    screenshareVideo: boolean;
+}
+type BroadcastMessageTarget = {
+    participantIds: string[];
+} | {
+    presetNames: string[];
+} | {
+    meetingIds: string[];
+};
+type ParticipantsEvents = {
+    ['viewModeChanged']: (payload: {
+        viewMode: string;
+        currentPage: number;
+        pageCount: number;
+    }) => void;
+    ['activeSpeaker']: (payload: {
+        peerId: string;
+        volume: number;
+    }) => void;
+    ['broadcastedMessage']: (payload: {
+        type: string;
+        payload: BroadcastMessagePayload;
+        timestamp: number;
+    }) => void;
+    ['poorConnection']: (payload: {
+        participantId: string;
+        score: number;
+        kind: string;
+    }) => void;
+    ['pageChanged']: (payload: {
+        viewMode: string;
+        currentPage: number;
+        pageCount: number;
+    }) => void;
+    ['mediaScoreUpdate']: (payload: {
+        kind: string;
+        isScreenshare: boolean;
+        score: number;
+        participantId: string;
+        scoreStats: ConsumerScoreStats;
+    }) => void;
+    ['media_decode_error']: (payload: {
+        reason: string;
+        code: '1702' | '1703';
+    }) => void;
+    ['*']: (event: string, ...args: any[]) => void;
+};
+declare class RTKParticipants$1 extends RTKTypedEventEmitter<ParticipantsEvents> {
+    readonly waitlisted: Readonly<RTKParticipantMap$1<Omit<RTKParticipant$1, 'audioTrack' | 'videoTrack' | 'screenShareTracks'>>>;
+    readonly joined: Readonly<RTKParticipantMap$1>;
+    readonly active: Readonly<RTKParticipantMap$1>;
+    readonly videoSubscribed: Readonly<RTKParticipantMap$1>;
+    readonly audioSubscribed: Readonly<RTKParticipantMap$1>;
+    readonly pinned: Readonly<RTKParticipantMap$1>;
+    readonly all: Readonly<RTKBasicParticipantsMap>;
+    get pip(): RTKPip;
+    rateLimitConfig: {
+        maxInvocations: number;
+        period: number;
+    };
+    get rateLimits(): {
+        maxInvocations: number;
+        period: number;
+    };
+    updateRateLimits(num: number, period: number): void;
+    viewMode: ViewMode;
+    currentPage: number;
+    lastActiveSpeaker: string;
+    selectedPeers: RTKSelectedPeers;
+    constructor(context: Context<RTKContextState>, self: RTKSelf$1, roomSocketHandler: RoomSocketHandler);
+    setupEvents(): void;
+    get count(): number;
+    get maxActiveParticipantsCount(): number;
+    setMaxActiveParticipantsCount(limit: number): void;
+    get pageCount(): number;
+    acceptWaitingRoomRequest(id: string): void;
+    acceptAllWaitingRoomRequest(userIds: string[]): Promise<void>;
+    rejectWaitingRoomRequest(id: string): Promise<void>;
+    setViewMode(viewMode: ViewMode): Promise<void>;
+    subscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
+    unsubscribe(peerIds: string[], kinds?: ('audio' | 'video' | 'screenshareAudio' | 'screenshareVideo')[]): Promise<void>;
+    getPeerIdsForCurrentPage(): string[];
+    setPage(page: number): Promise<void>;
+    disableAllAudio(allowUnmute: boolean): Promise<void>;
+    disableAllVideo(): Promise<void>;
+    disableAudio(participantId: string): Promise<void>;
+    disableVideo(participantId: string): Promise<void>;
+    kick(participantId: string): Promise<void>;
+    kickAll(): Promise<void>;
+    broadcastMessage(type: Exclude<string, 'spotlight'>, payload: BroadcastMessagePayload, target?: BroadcastMessageTarget): Promise<void>;
+    getAllJoinedPeers(searchQuery: string, limit: number, offset: number): Promise<{
+        id: string;
+        userId: string;
+        name: string;
+        displayName: string;
+        stageType: StageStatus;
+        customParticipantId: string;
+        presetId: string;
+        picture: string;
+        waitlisted: boolean;
+        stageStatus: StageStatus;
+        metadata: {
+            preset_name: string;
+        };
+        recorderType: string;
+        flags: {
+            hiddenParticipant: boolean;
+            hidden_participant: boolean;
+            recorder: boolean;
+        };
+    }[]>;
+    updatePermissions(participantIds: string[], permissions: PresetUpdates): Promise<void>;
+    getParticipantsInMeetingPreJoin(): Promise<RoomPeersInfoResponse>;
+}
+
+interface FetchRequestConfig {
+    baseURL?: string;
+    url?: string;
+    method?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retry?: number;
+    retryDelay?: number;
+    responseType?: string;
+    data?: any;
+    params?: Record<string, string>;
+}
+interface FetchResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    config: FetchRequestConfig;
+}
+declare class FetchClient {
+    defaults: {
+        baseURL: string;
+        headers: {
+            common: Record<string, string>;
+        };
+        timeout: number;
+        retry: number;
+        retryDelay: number;
+    };
+    constructor(options: {
+        baseURL: string;
+        timeout: number;
+        retry: number;
+        retryDelay: number;
+        responseType?: string;
+    });
+    request<T = any>(config: FetchRequestConfig): Promise<FetchResponse<T>>;
+    get<T = any>(url: string, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
+    post<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
+    put<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
+}
+
+interface 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> {
+    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;
+    }): Promise<void>;
+    getCurrentDevices(): {
+        audio: MediaDeviceInfo;
+        video: MediaDeviceInfo;
+        speaker: MediaDeviceInfo;
+    };
+    get permissions(): {
+        audio?: MediaPermission$1;
+        video?: MediaPermission$1;
+        screenshare?: MediaPermission$1;
+    };
+    getAllDevices(): Promise<InputDeviceInfo[]>;
+    getDeviceById(deviceId: string, kind?: 'audioinput' | 'audiooutput' | 'videoinput'): Promise<MediaDeviceInfo>;
+    get rawAudioTrack(): MediaStreamTrack;
+    get audioTrack(): MediaStreamTrack;
+    get audioEnabled(): boolean;
+    enableAudio(): Promise<void>;
+    disableAudio(): void;
+    getAudioDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    setAudioDevice(device: MediaDeviceInfo): Promise<void>;
+    setupSpeaker(): Promise<void>;
+    setSpeakerDevice(device: MediaDeviceInfo): Promise<void>;
+    get rawVideoTrack(): MediaStreamTrack;
+    get videoTrack(): MediaStreamTrack;
+    get videoEnabled(): boolean;
+    enableVideo(): Promise<void>;
+    disableVideo(): void;
+    getVideoDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    setVideoDevice(device: MediaDeviceInfo): Promise<void>;
+    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    get screenShareTracks(): {
+        audio: MediaStreamTrack;
+        video: MediaStreamTrack;
+    };
+    get screenShareEnabled(): boolean;
+    enableScreenShare(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    getSpeakerDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
+    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
+    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
+    removeAllAudioMiddlewares(): Promise<ResponseStatus>;
+    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
+    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
+    removeAllVideoMiddlewares(): Promise<ResponseStatus>;
+    setVideoMiddlewareGlobalConfig(config: VideoMiddlewareGlobalConfig): Promise<void>;
+    destruct(): void;
+    onDeviceChange(changedDevices: {
+        added: MediaDeviceInfo[];
+        removed: MediaDeviceInfo[];
+        devices: MediaDeviceInfo[];
+    }, skipDeviceChange: boolean): Promise<void>;
+    removeAllTracks(): void;
+    removeAudioTrack(): void;
+    removeVideoTrack(): void;
+    removeDocumentEventListeners(): Promise<void>;
+}
+
+declare enum MediaPermission {
+    NOT_REQUESTED = 0,
+    ACCEPTED = 1,
+    DENIED = 2,
+    CANCELED = 3,
+    SYSTEM_DENIED = 4,
+    COULD_NOT_START = 5,
+    NO_DEVICES_AVAILABLE = 6
+}
+
+type AudioMiddleware = (audioContext: AudioContext) => Promise<ScriptProcessorNode | AudioWorkletNode>;
+
+type VideoMiddleware = (() => Promise<(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D) => Promise<void>>) | ((helpers: {
+    canvas: HTMLCanvasElement;
+    WorkerTimers: typeof WorkerTimers;
+}) => Promise<void>);
+type VideoMiddlewareGlobalConfig = {
+    disablePerFrameCanvasRendering: boolean;
+};
+
+type PresetMediaConstraints = PresetV2CamelCased['config']['media'];
+type AudioQualityConstraints = {
+    echoCancellation?: boolean;
+    noiseSupression?: boolean;
+    autoGainControl?: boolean;
+    enableStereo?: boolean;
+    enableHighBitrate?: boolean;
+};
+type VideoQualityConstraints = {
+    width: {
+        ideal: number;
+    };
+    height: {
+        ideal: number;
+    };
+    frameRate?: {
+        ideal: number;
+    };
+};
+type ScreenshareQualityConstraints = {
+    width?: {
+        max: number;
+    };
+    height?: {
+        max: number;
+    };
+    frameRate?: {
+        ideal: number;
+        max: number;
+    };
+    displaySurface?: 'window' | 'monitor' | 'browser';
+    selfBrowserSurface?: 'include' | 'exclude';
+};
+interface RTKMediaTrackConstraints extends MediaTrackConstraints {
+    optional?: Array<object>;
+}
+interface RTKMediaStreamConstraints extends MediaStreamConstraints {
+    audio?: boolean | RTKMediaTrackConstraints;
+}
+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;
+    get setupScreen(): Readonly<{
+        isEnabled: boolean;
+    }>;
+    get waitingRoom(): Readonly<{
+        isEnabled: boolean;
+    }>;
+    get controlBar(): Readonly<{
+        isEnabled: boolean;
+        elements?: {
+            chat?: boolean;
+            fullscreen?: boolean;
+            invite?: boolean;
+            layout?: boolean;
+            participants?: boolean;
+            plugins?: boolean;
+            polls?: boolean;
+            reactions?: boolean;
+            screenshare?: boolean;
+        };
+    }>;
+    get header(): Readonly<{
+        isEnabled: boolean;
+        elements: {
+            logo: string;
+            timer: boolean;
+            title: boolean;
+            participantCount: boolean;
+            changeLayout: boolean;
+        };
+    }>;
+    get pipMode(): Readonly<boolean>;
+    get viewType(): Readonly<ViewType>;
+    get livestreamViewerQualities(): Readonly<LivestreamViewerMediaQualityType[]>;
+    get maxVideoStreams(): Readonly<MaxVideoStreams>;
+    get maxScreenShareCount(): Readonly<number>;
+    get plugins(): Readonly<string[]>;
+    get disabledPlugins(): Readonly<string[]>;
+    get designTokens(): Readonly<PresetV2CamelCased['ui']['designTokens']>;
+    get configDiff(): Readonly<PresetV2CamelCased['ui']['configDiff']>;
+    get mediaConstraints(): Readonly<PresetMediaConstraints>;
+    get name(): string;
+}
+
+type PresetPermissions = PresetV2CamelCased['permissions'];
+type 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;
+    get mediaRoomType(): Readonly<MediaRoomType>;
+    get stageEnabled(): Readonly<boolean>;
+    get acceptStageRequests(): Readonly<boolean>;
+    get stageAccess(): Readonly<MediaProductionPermissionType>;
+    get acceptWaitingRequests(): Readonly<boolean>;
+    get requestProduceVideo(): Readonly<boolean>;
+    get requestProduceAudio(): Readonly<boolean>;
+    get requestProduceScreenshare(): Readonly<boolean>;
+    get canAllowParticipantAudio(): Readonly<boolean>;
+    get canAllowParticipantScreensharing(): Readonly<boolean>;
+    get canAllowParticipantVideo(): Readonly<boolean>;
+    get canDisableParticipantAudio(): Readonly<boolean>;
+    get canDisableParticipantVideo(): Readonly<boolean>;
+    get kickParticipant(): Readonly<boolean>;
+    get pinParticipant(): Readonly<boolean>;
+    get canRecord(): Readonly<boolean>;
+    get waitingRoomType(): Readonly<WaitingRoomTypes>;
+    get waitingRoomBehaviour(): Readonly<WaitingRoomTypes>;
+    get plugins(): Readonly<PresetPermissions['plugins']>;
+    get polls(): Readonly<PresetPermissions['polls']>;
+    get produceVideo(): Readonly<MediaProductionPermissionType>;
+    get requestProduce(): Readonly<boolean>;
+    get canProduceVideo(): Readonly<MediaProductionPermissionType>;
+    get produceScreenshare(): Readonly<MediaProductionPermissionType>;
+    get canProduceScreenshare(): Readonly<MediaProductionPermissionType>;
+    get produceAudio(): Readonly<MediaProductionPermissionType>;
+    get canProduceAudio(): Readonly<MediaProductionPermissionType>;
+    get chatPublic(): Readonly<PresetPermissions['chat']['public']>;
+    get chatPrivate(): Readonly<PresetPermissions['chat']['private']>;
+    get chatChannel(): Readonly<PresetPermissions['chat']['channel']>;
+    get chatMessage(): Readonly<PresetPermissions['chat']['message']>;
+    get connectedMeetings(): Readonly<PresetPermissions['connectedMeetings']>;
+    get hiddenParticipant(): Readonly<boolean>;
+    get showParticipantList(): Readonly<boolean>;
+    get canChangeParticipantRole(): Readonly<boolean>;
+    get canChangeParticipantPermissions(): Readonly<boolean>;
+    get canChangeTheme(): Readonly<boolean>;
+    get canPresent(): Readonly<boolean>;
+    get acceptPresentRequests(): Readonly<boolean>;
+    get canEditDisplayName(): Readonly<boolean>;
+    get maxScreenShareCount(): Readonly<number>;
+    get isRecorder(): Readonly<boolean>;
+    get canSpotlight(): Readonly<boolean>;
+    get canLivestream(): Readonly<boolean>;
+    get transcriptionEnabled(): Readonly<boolean>;
+}
+
+interface UserDetailsResponseV2 {
+    participant: UserDetailsResponse;
+    preset: PresetV2CamelCased;
+}
+type LeaveRoomState = 'kicked' | 'ended' | 'left' | 'rejected' | 'connected-meeting' | 'disconnected' | 'failed' | 'stageLeft';
+
+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> {
+    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;
+    };
+}
+interface ReactNativeFile {
+    uri: string;
+    name: string;
+    type: 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 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: Omit<ChatUpdateParams, 'action'>) => void;
+    ['unpinMessage']: (payload: Omit<ChatUpdateParams, 'action'>) => void;
+    ['channelCreate']: (channel: ChatChannel) => void;
+    ['channelMessageUpdate']: (channel: ChatChannel) => void;
+    ['channelUpdate']: (channel?: ChatChannel) => 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);
+    get 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>;
+    get 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;
+}
+
+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$1 = {
+    ['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$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>;
+    get audioTrack(): MediaStreamTrack;
+    get rawAudioTrack(): MediaStreamTrack;
+    get mediaPermissions(): {
+        audio?: MediaPermission$1;
+        video?: MediaPermission$1;
+        screenshare?: MediaPermission$1;
+    };
+    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    removeAllAudioMiddlewares(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    get videoTrack(): MediaStreamTrack;
+    get rawVideoTrack(): MediaStreamTrack;
+    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    setVideoMiddlewareGlobalConfig(config?: VideoMiddlewareGlobalConfig): Promise<void>;
+    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    removeAllVideoMiddlewares(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    get screenShareTracks(): {
+        audio: MediaStreamTrack;
+        video: MediaStreamTrack;
+    };
+    get audioEnabled(): boolean;
+    get videoEnabled(): boolean;
+    get screenShareEnabled(): boolean;
+    enableAudio(): Promise<void>;
+    enableVideo(): Promise<void>;
+    disableAudio(): Promise<void>;
+    enableScreenShare(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    disableVideo(): Promise<void>;
+    getCurrentDevices(): {
+        audio: MediaDeviceInfo;
+        video: MediaDeviceInfo;
+        speaker: MediaDeviceInfo;
+    };
+    getAudioDevices(): Promise<MediaDeviceInfo[]>;
+    getVideoDevices(): Promise<MediaDeviceInfo[]>;
+    getSpeakerDevices(): Promise<MediaDeviceInfo[]>;
+    getDeviceById(deviceId: string, kind: 'audio' | 'video' | 'speaker'): Promise<MediaDeviceInfo>;
+    setDevice(device: MediaDeviceInfo): Promise<void>;
+}
+
+type RecordingState = 'IDLE' | 'STARTING' | 'RECORDING' | 'PAUSED' | 'STOPPING';
+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[];
+    get recordingState(): RecordingState;
+    recordings: RecordingInfo[];
+    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>;
+}
+
+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 {
+    static hasFeature(featureName: string): boolean;
+    static getFeatureValue(featureName: string): _dyteinternals_utils.RTKFlagValues;
+    static getAllFeatures(): {
+            [x: string]: _dyteinternals_utils.RTKFlagsEntry;
+        };
+}
+
+declare function createSafeToLogError(ex: any): {
+    stack?: string;
+    message?: string;
+    name?: string;
+    reason?: string;
+    code?: number | string;
+};
+
+declare const enum PRODUCERS_TYPE {
+    WEBCAM = "webcam",
+    WEBCAM_BACKUP = "webcam_backup",
+    MIC = "mic",
+    SCREENSHARE_VIDEO = "screenshare_video",
+    SCREENSHARE_AUDIO = "screenshare_audio"
+}
+
+type SupportedEventSeverities = 'info' | 'error' | 'debug' | 'log' | 'warn';
+type LogData$2 = {
+    error?: ReturnType<typeof createSafeToLogError>;
+    peers?: string;
+    flags?: string | {
+        [key: string]: {
+            enabled: boolean;
+            value: string | number | boolean;
+        };
+    };
+    devices?: string | MediaDeviceInfo[];
+    debuggingHint?: string;
+    constraints?: string | RTKMediaStreamConstraints;
+    timeout?: number;
+    execTime?: number;
+    country?: string;
+    media?: {
+        audio?: {
+            enabled: boolean;
+            deviceName?: string;
+            deviceId?: string;
+            trackId?: string;
+            permission?: keyof typeof MediaPermission;
+            canProduce?: MediaProductionPermissionType;
+        };
+        video?: {
+            enabled?: boolean;
+            deviceName?: string;
+            deviceId?: string;
+            trackId?: string;
+            permission?: keyof typeof MediaPermission;
+            canProduce?: MediaProductionPermissionType;
+            layer?: number;
+        };
+        screenshare?: {
+            enabled: boolean;
+            count?: number;
+            maxAllowedCount?: number;
+            permission?: keyof typeof MediaPermission;
+            deviceName?: string;
+            deviceId?: string;
+            audio?: {
+                enabled: boolean;
+                trackId?: string;
+            };
+            video?: {
+                enabled: boolean;
+                trackId?: string;
+            };
+            canProduce?: MediaProductionPermissionType;
+        };
+    };
+    producerInfo?: {
+        peerId: string;
+        producers: ProducerState[];
+    };
+    preferredDevice?: {
+        kind: 'audio' | 'video';
+        preferredDeviceId?: string;
+        lastUsedPreferredDeviceId?: string;
+    };
+    mediaPermissionsErrors?: {
+        kind: 'audio' | 'video' | 'screenshare';
+        message: string;
+        deviceId?: string;
+    };
+    pip?: {
+        id: string;
+        handRaised?: boolean;
+        source?: any;
+    };
+    memoize?: {
+        doubleInvoked?: {
+            property: string;
+        };
+    };
+    dyteClientInitOptions?: RealtimeKitClientOptions;
+    plugin?: {
+        id?: string;
+        name?: string;
+        enabledBy?: string;
+        duration?: number;
+        storeName?: string;
+        data?: any;
+    };
+    roomJoined?: boolean;
+    transport?: {
+        id?: string;
+        type?: 'send' | 'recv';
+        status?: RTCPeerConnectionState | 'reconnecting';
+        lastDisconnectedTime?: string;
+        lastDisconnectedTimeOffset?: number;
+        durationPassed?: number;
+        remoteOfferAnswer?: RTCSessionDescriptionInit;
+        serverId?: string;
+    };
+    iceCandidate?: RTCIceCandidate;
+    iceRestart?: {
+        status?: RTCPeerConnectionState | 'reconnecting';
+        isSendTransport?: boolean;
+        isRecvTransport?: boolean;
+        currentAttempt?: number;
+    };
+    producer?: {
+        id: string;
+        peerId?: string;
+        kind: 'audio' | 'video' | PRODUCERS_TYPE;
+        status?: 'initializing' | 'producing' | 'paused' | 'failed' | 'closing' | 'closed' | 'UNKNOWN';
+        appData: {
+            screenShare?: boolean;
+            supportsRemoteControl?: boolean;
+        };
+        error?: string;
+        closureReason?: string;
+        remoteAnswer?: SessionDescription;
+        trackId?: string;
+    };
+    consumer?: {
+        id: string;
+        peerId?: string;
+        kind?: string;
+        appData?: {
+            screenShare?: boolean;
+            supportsRemoteControl?: boolean;
+        };
+        remotelyPaused?: boolean;
+        producerId?: string;
+        closureReason?: string;
+        sessionDescription?: RTCSessionDescriptionInit;
+    };
+    consumerIds?: string[];
+    consumerState?: ConsumerState;
+    consumerStateMap?: {
+        [key: string]: ConsumerState;
+    };
+    rtcChannel?: {
+        label?: string;
+        message?: DCMessage;
+        messageStringified?: string;
+    };
+    localStorage?: {
+        key?: string;
+        value?: string;
+    };
+    spotlight?: {
+        spotlighter?: {
+            id?: string;
+        };
+        currentTab?: {
+            id?: string;
+            type?: ActiveTabType;
+        };
+    };
+    networkCall?: {
+        status?: number;
+        statusText?: string;
+        baseURL?: string;
+        url?: string;
+        retries?: number;
+        method?: string;
+        isOnline?: string;
+        ip?: any;
+        timezone?: string;
+    };
+    ipInfo?: {
+        city: string;
+        country: string;
+        region: string;
+        loc: string;
+        timezone: string;
+        ip: string;
+        postal: string;
+    };
+    dytePolls?: {
+        hasQuestion?: boolean;
+        optionsLength?: number;
+    };
+    dyteChat?: {
+        imageType?: string;
+        messageType?: string;
+    };
+    dyteParticipant?: {
+        id: string;
+    };
+    actions?: {
+        disableAllAudio?: {
+            allowUnmute?: boolean;
+        };
+        trackRobustness?: {
+            reacquireTrack?: boolean;
+            eventType?: string;
+        };
+    };
+    recording?: {
+        id?: string;
+        state?: RecordingState;
+    };
+    selectedPeer?: {
+        oldIndex?: number;
+        newIndex?: number;
+        peerId?: string;
+    };
+    pageNavigation?: {
+        viewMode: ViewMode;
+        currentPage: number;
+        pageCount: number;
+        maxActiveParticipantsCount: number;
+        settingPage?: number;
+    };
+    connectedMeetings?: {
+        movement?: {
+            sourceMeetingId?: string;
+            destinationMeetingId?: string;
+            totalParticipantsToMove?: number;
+        };
+    };
+    webinar?: {
+        stageStatus?: StageStatus;
+    };
+    livestream?: {
+        stageStatus?: StageStatus;
+        latency?: number;
+    };
+    moduleExists?: {
+        self?: boolean;
+    };
+    performanceObserver?: {
+        api: PerformanceEntry;
+    };
+    dyteLocker?: {
+        methodName: string;
+        lockName: string;
+    };
+    socket?: {
+        retryAttempt: number;
+    };
+    connectionState?: {
+        joinAttempted: boolean;
+    };
+    source?: string;
+    eventListener?: {
+        eventName: string;
+        listenerCount: number;
+    };
+    dataChannelMessageChunk?: {
+        id: string;
+        count: number;
+        chunkIndex: number;
+        chunk: string;
+        transprtId: string;
+    };
+    peerIds?: string[];
+    producers?: ProducerState[];
+};
+
+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 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;
+}
+
+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 {
+    name: string;
+    rateLimitConfig: {
+        maxInvocations: number;
+        period: number;
+    };
+    bulkRateLimitConfig: {
+        maxInvocations: number;
+        period: number;
+    };
+    constructor({ name, socketHandler, meetingId }: {
+        name: string;
+        socketHandler: PluginSocketHandler;
+        meetingId: string;
+    });
+    set(key: string, value: any, sync?: boolean, emit?: boolean): Promise<void>;
+    bulkSet(data: {
+        key: string;
+        payload: any;
+    }[]): Promise<void>;
+    update(key: string, value: any, sync?: boolean): Promise<void>;
+    delete(key: string, sync?: boolean, emit?: boolean): Promise<void>;
+    bulkDelete(data: {
+        key: string;
+    }[]): Promise<void>;
+    get(key: string): any;
+    getAll(): StoreData;
+    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 class RTKStoreManager {
+    stores: Map<String, RTKStore$1>;
+    constructor(context: Context<RTKContextState>, handler: PluginSocketHandler);
+    create(name: string): Promise<RTKStore$1>;
+}
+
+declare const videoCodecPriority: readonly ["video/VP9", "video/VP8"];
+type VideoCodec = (typeof videoCodecPriority)[number];
+interface MediaNodeClientOptions {
+    peerId: string;
+    socket: SocketService;
+}
+declare class MediaNodeClient {
+    readonly context: Context<RTKContextState>;
+    readonly authToken: string;
+    readonly e2ee: boolean;
+    get peerId(): string;
+    constructor(context: Context<RTKContextState>, nodeType: MediaNodeType, options: MediaNodeClientOptions);
+    get mediaJoined(): boolean;
+    set mediaJoined(joined: boolean);
+    reset(full?: boolean): void;
+    joinRoom(displayName: string, roomUuid: string, currentUserSharedMediaStates?: {
+        audio?: boolean;
+        video?: boolean;
+        screen?: boolean;
+    }, forceFullReset?: boolean, rejoining?: boolean): Promise<{
+        roomJoined: boolean;
+    }>;
+    _partialJoinRoom(displayName: string, roomUuid: string, rejoining?: boolean, loc?: GeoLocation): Promise<void>;
+    partialJoinRoom(displayName: string, roomUuid: string, rejoining?: boolean, loc?: GeoLocation): Promise<any>;
+    leaveRoom(): Promise<void>;
+    getConsumers(): Map<string, Consumer>;
+    activatePeers(producers: ProducerState[]): Promise<void>;
+    deactivatePeers(producers: ProducerState[], mode?: 'manual' | 'default'): Promise<void>;
+    createConsumers(producers: ProducerState[]): Promise<void>;
+    closeConsumers(producers: ProducerState[]): Promise<void>;
+    _shareWebcam(videoTrack: MediaStreamTrack & {
+        originalSettings?: {
+            width: number;
+        };
+    }, codec: VideoCodec): Promise<MediaStreamTrack>;
+    shareWebcam(videoTrack: MediaStreamTrack): Promise<MediaStreamTrack | null>;
+    shareScreen(tracks: {
+        video?: MediaStreamTrack;
+        audio?: MediaStreamTrack;
+    }): Promise<void>;
+    shareMic(audioTrack: MediaStreamTrack): Promise<void>;
+    pauseMic(): Promise<void>;
+    pauseWebcam(): Promise<void>;
+    resumeMic(): Promise<void>;
+    resumeWebcam(producerType?: PRODUCERS_TYPE): Promise<void>;
+    disableWebcam(codec: VideoCodec): Promise<void>;
+    disableMic(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    muteSelf(): Promise<void>;
+    unmuteSelf(): Promise<void>;
+    resetVideoProducers(videoTrack: MediaStreamTrack, screenShareTrack?: MediaStreamTrack): Promise<void>;
+    changeDisplayName(displayName: string, peerId?: string): Promise<void>;
+    kick(peerId: string): Promise<void>;
+    kickAll(): Promise<void>;
+    muteAll(_allowUnMute: boolean): Promise<void>;
+    muteAllVideo(): Promise<void>;
+    disableAudio(peerId: string): Promise<void>;
+    disableVideo(peerId: string): Promise<void>;
+    pinPeer(peerId: string | null): Promise<void>;
+    validateScreenShare(payload: {
+        peerId: string;
+        consumerId: string;
+        screenShare: boolean;
+        producerId: string;
+        consumerPeerId: string;
+    }): number;
+    switchConsumersToLayer(consumerIds: string[], layer: number): Promise<void>;
+    handleSocketEvents(): Promise<void>;
+    handleCallstatsEvents(): void;
+    handlePeerCapabilities(peerId: string, capabilities: PeerRtpCapabilitites): void;
+    handlePeerLeaving(peerId: string): void;
+}
+
+interface 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 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 = {
+    authToken: string;
+    peerId?: string;
+    apiBase?: string;
+    baseURI?: string;
+    onError?: (error: RTKError) => void;
+    stageStatus?: StageStatus;
+    organizationId?: string;
+    presetName?: string;
+    maxPreferredStreams?: number;
+    defaults?: DefaultOptions;
+    modules?: Modules;
+    overrides?: Overrides;
+    apiClient?: APIClient;
+    userId?: string;
+    meetingId?: string;
+    roomName?: string;
+    socketService?: SocketService;
+    pip?: RTKPip;
+    roomNodeOptions?: {
+        sfu: MediaNodeType;
+    };
+    roomNodeClient?: MediaNodeClient;
+    viewType?: ViewType;
+    env?: ClientEnvTypeAll;
+    sdkVersion?: string;
+    sdkName?: 'web-core';
+    connectionHandler?: ConnectionHandler;
+    cachedUserDetails?: CachedUserDetails;
+};
+interface Context<T extends Record<string, any>> {
+    subscribe: (key: keyof T, listener: (value: any) => void) => () => void;
+    unsubscribe: (key: keyof T, listener: (value: any) => void) => void;
+    notify: <K extends keyof T>(key: K) => void;
+    setValue: <K extends keyof T>(key: K, newValue: T[K], notify?: boolean) => void;
+    getValue: <K extends keyof T>(key: K) => T[K];
+    getAllValues: () => T;
+}
+
+type SocketServiceCapability = keyof typeof Capabilities;
+type SocketStateEvent = 'connected' | 'disconnected' | 'reconnected' | 'errored' | 'reconnecting' | 'reconnectAttempt' | 'reconnectFailure' | 'failed';
+type SocketServiceCapabilities = SocketServiceCapability[];
+interface SocketConnectionState {
+    state: Extract<SocketStateEvent, 'connected' | 'disconnected' | 'reconnecting' | 'failed'>;
+    reconnected: boolean;
+    reconnectionAttempt: number;
+}
+declare class SocketService {
+    readonly roomName: string;
+    readonly authToken: string;
+    readonly capabilities: SocketServiceCapabilities;
+    get joinAttempted(): boolean;
+    set joinAttempted(value: boolean);
+    get peerId(): string;
+    constructor(context: Context<RTKContextState>, { peerId, meetingId, authToken, capabilities, }: {
+        peerId: string;
+        meetingId: string;
+        authToken: string;
+        capabilities: SocketServiceCapabilities;
+    });
+    updateURL(peerID: string): void;
+    get url(): string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    get isConnected(): boolean;
+    sendMessage(event: number, protobuf?: Uint8Array, messageId?: string): boolean;
+    sendMessagePromise(event: number, protobuf?: Uint8Array, messageId?: string, resp?: number): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    sendMessagePromiseWithTimeout({ event, timeout, protobuf, messageId, resp, }: {
+        timeout: number;
+        event: number;
+        protobuf?: Uint8Array;
+        messageId?: string;
+        resp?: number;
+    }): Promise<{
+        id: string;
+        payload: Uint8Array;
+    }>;
+    on(event: number, listener: (message: {
+        id?: string;
+        payload?: Uint8Array;
+    }) => void): void;
+    onStateEvent(event: SocketStateEvent, listener: (...args: any) => void): void;
+    removeListener(event: number, listener: (message: {
+        id?: string;
+        payload?: Uint8Array;
+    }) => void): void;
+    removeListeners(event: number): void;
+    flush(): any;
+    handleSocketConnectionEvents(): void;
+}
+
+type 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);
+    get 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;
+        payload: Uint8Array;
+    }>;
+}
+
+interface UserDetailsResponse {
+    id: string;
+    name: string;
+    email: string;
+    picture?: string;
+    loggedIn?: boolean;
+    scope?: string[];
+    clientSpecificId?: string;
+    customParticipantId?: string;
+    organizationId?: string;
+}
+declare class RTKSelf$1 extends RTKSelfMedia {
+    name: string;
+    picture: string;
+    customParticipantId: string;
+    waitlistStatus: 'accepted' | 'waiting' | 'rejected' | 'none';
+    role: any;
+    userId: string;
+    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;
+    get permissions(): RTKPermissionsPreset$1;
+    get config(): RTKThemePreset$1;
+    get roomJoined(): boolean;
+    setName(name: string): void;
+    setupTracks(options?: {
+        video?: boolean;
+        audio?: boolean;
+        forceReset?: boolean;
+    }): Promise<void>;
+    destructMediaHandler(): Promise<void>;
+    removeDocumentEventListeners(): Promise<void>;
+    enableAudio(): Promise<void>;
+    enableVideo(): Promise<void>;
+    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    enableScreenShare(): Promise<void>;
+    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
+    disableAudio(): Promise<void>;
+    disableVideo(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    getAllDevices(): Promise<InputDeviceInfo[]>;
+    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
+    get isPinned(): boolean;
+    pin(): Promise<void>;
+    unpin(): Promise<void>;
+    hide(): Promise<void>;
+    show(): void;
+    setDevice(device: MediaDeviceInfo): Promise<void>;
+    cleanUpTracks(): void;
+    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 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>;
+}
+
+interface IceServerInformation {
+    url: string;
+    username?: string;
+    urls: string;
+    credential?: string;
+}
+interface CachedUserDetails {
+    peerId?: string;
+    pluginInformation: RTKPluginResponse[];
+    userDetails: UserDetailsResponseV2;
+    roomDetails: RoomDetails;
+    iceServers: IceServerInformation[];
+}
+interface APIOptions {
+    baseURL?: string;
+    authToken?: string;
+    timeout?: number;
+    retry?: number;
+    retryDelay?: number;
+    cachedUserDetails?: CachedUserDetails;
+}
+declare class API {
+    ipInfo: any;
+    get peerId(): string;
+    context: Context<RTKContextState>;
+    constructor(context: Context<RTKContextState>, options?: APIOptions);
+    setAuthToken(token: string, options?: {
+        bearer?: boolean;
+    }): void;
+    setHeader(key: string, value: string): void;
+    setRoomName(name: string): void;
+    setRoomUUID(id: string): void;
+    setOrganizationId(id: string): void;
+}
+
+interface ConnectedMeetingParticipant {
+    id?: string;
+    customParticipantId?: string;
+    presetId?: string;
+    displayName?: string;
+    displayPictureUrl?: string;
+}
+interface ConnectedMeeting {
+    id?: string;
+    title?: string;
+    participants: ConnectedMeetingParticipant[];
+}
+
+type ConnectedMeetingsEvents = {
+    ['meetingChanged']: (meeting: RealtimeKitClient) => void;
+    ['stateUpdate']: (payload: {
+        meetings: ConnectedMeeting[];
+        parentMeeting: ConnectedMeeting;
+    }) => void;
+    ['changingMeeting']: (meetingId: string) => void;
+    ['*']: (eventName: string, ...args: any[]) => void;
+};
+declare class RTKConnectedMeetings$1 extends RTKTypedEventEmitter<ConnectedMeetingsEvents> {
+    constructor(context: Context<RTKContextState>, meeting: RealtimeKitClient);
+    meetings: ConnectedMeeting[];
+    parentMeeting: ConnectedMeeting;
+    get supportsConnectedMeetings(): boolean;
+    get isActive(): boolean;
+    get currentMeetingId(): string;
+    getConnectedMeetings(): Promise<{
+        parentMeeting: ConnectedMeeting;
+        meetings: ConnectedMeeting[];
+    }>;
+    createMeetings(request: {
+        title: string;
+    }[]): Promise<{
+        id: string;
+        title: string;
+    }[]>;
+    updateMeetings(request: {
+        id: string;
+        title: string;
+    }[]): Promise<void>;
+    deleteMeetings(meetingIds: string[]): Promise<{
+        id: string;
+    }[]>;
+    moveParticipants(sourceMeetingId: string, destinationMeetingId: string, participantIds: string[]): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+    moveParticipantsWithCustomPreset(sourceMeetingId: string, destinationMeetingId: string, participants: {
+        id: string;
+        presetId: string;
+    }[]): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+}
+
+interface Overrides {
+    disableSimulcast?: boolean;
+    forceRelay?: boolean;
+    [key: string]: boolean | string | number;
+}
+interface RealtimeKitClientOptions {
+    authToken: string;
+    defaults?: DefaultOptions;
+    modules?: Modules;
+    overrides?: Overrides;
+    baseURI?: string;
+    onError?: (error: RTKError) => void;
+    cachedUserDetails?: CachedUserDetails;
+}
+declare class RealtimeKitClient {
+    private constructor();
+    static init(options: RealtimeKitClientOptions): Promise<RealtimeKitClient>;
+    join(): Promise<void>;
+    leave(state?: LeaveRoomState): Promise<void>;
+    get participants(): Readonly<RTKParticipants$1>;
+    get self(): Readonly<RTKSelf$1>;
+    get meta(): Readonly<RTKMeta$1>;
+    get ai(): Readonly<RTKAi>;
+    get plugins(): Readonly<RTKPlugins$1>;
+    get chat(): Readonly<RTKChat$1>;
+    get polls(): Readonly<RTKPolls$1>;
+    get connectedMeetings(): Readonly<RTKConnectedMeetings$1>;
+    get recording(): Readonly<RTKRecording$1>;
+    get livestream(): Readonly<RTKLivestream$1>;
+    get stage(): Readonly<RTKStage>;
+    get stores(): Readonly<RTKStoreManager>;
+    get __internals__(): Readonly<RTKInternals>;
+    joinRoom(): Promise<void>;
+    leaveRoom(state?: LeaveRoomState): Promise<void>;
+}
+
+type RTKParticipant = Readonly<RTKParticipant$1>;
+
+type RTKParticipants = Readonly<RTKParticipants$1>;
+type RTKSelf = Readonly<RTKSelf$1>;
+
+type RTKType = {
+    callStats?: unknown;
+    RTKTelemetry?: typeof RTKTelemetry;
+};
+declare global {
+    interface Navigator {
+        RNLocalMediaHandlerImpl?: any;
+        isReactNative?: boolean;
+    }
+    interface Window {
+        RTK?: RTKType;
+        FAST_DYTE?: boolean;
+        MediaStreamTrackProcessor?: any;
+        MediaStreamTrackGenerator?: any;
+        TransformStream?: any;
+    }
+}
+
+declare function RTKProvider({ value, children, fallback, }: {
+    value: RealtimeKitClient | undefined;
+    children: ReactNode;
+    fallback?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+interface RealtimeKitClientParams {
+    resetOnLeave?: boolean;
+}
+declare const useRealtimeKitClient: (e?: RealtimeKitClientParams) => readonly [RealtimeKitClient | undefined, (options: RealtimeKitClientOptions) => Promise<RealtimeKitClient | undefined>];
+declare const RealtimeKitProvider: typeof RTKProvider;
+declare const useRealtimeKitMeeting: () => () => {
+    meeting: RealtimeKitClient;
+};
+type StateSelector<T extends object, U> = (state: T) => U;
+declare const useRTKSelector: <StateSlice>(selector: StateSelector<RealtimeKitClient, StateSlice>) => StateSlice;
+
+export { RealtimeKitProvider, useRTKSelector, useRealtimeKitClient, useRealtimeKitMeeting };