/// <reference types="node" />
import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
import * as _dyteinternals_utils from '@dyteinternals/utils';
import { PresetTypeV2, MediaVideoQualityType, ViewType, MediaScreenShareQualityType, LivestreamViewerMediaQualityType, PluginAccessControls, WaitingRoomTypes, MediaProductionPermissionType, RecorderType as RecorderType$1, BorderRadius, BorderWidth, Theme, createNewFlagsmithInstance } from '@dyteinternals/utils';
import { MessageType as MessageType$1 } from '@protobuf-ts/runtime';
import * as WorkerTimers from 'worker-timers';

declare global {
	interface SymbolConstructor {
		readonly observable: symbol;
	}
}

/**
Get keys of the given type as strings.

Number keys are converted to strings.

Use-cases:
- Get string keys from a type which may have number keys.
- Makes it possible to index using strings retrieved from template types.

@example
```
import type {StringKeyOf} from 'type-fest';

type Foo = {
	1: number,
	stringKey: string,
};

type StringKeysOfFoo = StringKeyOf<Foo>;
//=> '1' | 'stringKey'
```

@category Object
*/
type StringKeyOf<BaseType> = `${Extract<keyof BaseType, string | 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 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 CreateRoomRequestPayload$Type extends MessageType$1<CreateRoomRequestPayload> {
    constructor();
}
/**
 * @generated from protobuf message socket.room.CreateRoomRequestPayload
 */
interface CreateRoomRequestPayload {
    /**
     * @generated from protobuf field: optional string title = 1;
     */
    title?: string;
}
/**
 * @generated MessageType for protobuf message socket.room.CreateRoomRequestPayload
 */
declare const CreateRoomRequestPayload: CreateRoomRequestPayload$Type;
declare class UpdateRoomRequestPayload$Type extends MessageType$1<UpdateRoomRequestPayload> {
    constructor();
}
/**
 * @generated from protobuf message socket.room.UpdateRoomRequestPayload
 */
interface UpdateRoomRequestPayload {
    /**
     * @generated from protobuf field: optional string meeting_id = 1;
     */
    meetingId?: string;
    /**
     * @generated from protobuf field: optional string title = 2;
     */
    title?: string;
}
/**
 * @generated MessageType for protobuf message socket.room.UpdateRoomRequestPayload
 */
declare const UpdateRoomRequestPayload: UpdateRoomRequestPayload$Type;
declare class MovePeerPayload$Type extends MessageType$1<MovePeerPayload> {
    constructor();
}
/**
 * @generated from protobuf message socket.room.MovePeerPayload
 */
interface MovePeerPayload {
    /**
     * @generated from protobuf field: optional string id = 1;
     */
    id?: string;
    /**
     * @generated from protobuf field: optional string preset_id = 2;
     */
    presetId?: string;
}
/**
 * @generated MessageType for protobuf message socket.room.MovePeerPayload
 */
declare const MovePeerPayload: MovePeerPayload$Type;
declare class MovePeersBetweenRoomsRequest$Type extends MessageType$1<MovePeersBetweenRoomsRequest> {
    constructor();
}
/**
 * @generated from protobuf message socket.room.MovePeersBetweenRoomsRequest
 */
interface MovePeersBetweenRoomsRequest {
    /**
     * @generated from protobuf field: optional string source_meeting_id = 1;
     */
    sourceMeetingId?: string;
    /**
     * @generated from protobuf field: optional string destination_meeting_id = 2;
     */
    destinationMeetingId?: string;
    /**
     * @generated from protobuf field: repeated socket.room.MovePeerPayload participants = 3;
     */
    participants: MovePeerPayload[];
}
/**
 * @generated MessageType for protobuf message socket.room.MovePeersBetweenRoomsRequest
 */
declare const MovePeersBetweenRoomsRequest: MovePeersBetweenRoomsRequest$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;

interface DeviceInfo$1 {
    isMobile: boolean;
    browserName: string;
    browserVersion: string;
    osName: string;
    osVersionName: string;
    engineName: string;
    userAgent: string;
    cpus: number;
    memory?: number;
    webglSupport?: number;
}
interface GeoLocation {
    coords: {
        latitude: number;
        longitude: number;
    };
}
interface IPDetails {
    ip: string;
    city: string;
    region: string;
    country: string;
    loc: string | GeoLocation;
    org: string;
    portal: string;
    timezone: string;
}
interface ThroughputInformation {
    throughput: number;
    fractionalLoss: number;
    RTT: number;
    jitter: number;
    backendRTT: number;
}
interface IceConnectivity {
    host: boolean;
    relay: boolean;
    reflexive: boolean;
}
interface NetworkQualityInformation extends ThroughputInformation {
    connectivity: IceConnectivity;
}
interface NetworkInformation extends NetworkQualityInformation {
    ipDetails: IPDetails;
    location: GeoLocation;
    turnConnectivity: boolean;
    effectiveNetworkType: string;
}
interface NetworkInformationWithoutConnectivityData {
    ipDetails: IPDetails;
    location: GeoLocation;
    effectiveNetworkType: string;
}
type RTCDtlsTransportState = 'closed' | 'connected' | 'connecting' | 'failed' | 'new';
type RTCIceRole = 'controlled' | 'controlling' | 'unknown';
interface VideoStreamStats {
    frameHeight: number;
    frameWidth: number;
    droppedFrames?: number;
    framerateMean?: number;
    framesDropped: number;
    framesPerSecond: number;
    firCount: number;
}
interface AudioStreamStats {
}
interface InboundStreamStats {
    codecId: string;
    bytesReceived: number;
    headerBytesReceived: number;
    packetsReceived: number;
    packetsLost: number;
    packetsDiscarded: number;
    jitter: number;
    nackCount: number;
    jitterBufferDelay: number;
    jitterBufferEmittedCount: number;
    jitterBufferMinimumDelay: number;
    jitterBufferTargetDelay: number;
    lastPacketReceivedTimestamp: number;
    ssrc: number;
    mid: string;
    score?: number;
}
interface RemoteInboundStreamStats {
    jitter: number;
    fractionLost: number;
    roundTripTime: number;
    roundTripTimeMeasurements: number;
    totalRoundTripTime: number;
    packetsLost: number;
    localId?: string;
}
interface OutboundStreamStats {
    active: boolean;
    codecId: string;
    headerBytesSent: number;
    totalPacketSendDelay: number;
    bytesSent: number;
    packetsSent: number;
    retransmittedBytesSent?: number;
    retransmittedPacketsSent?: number;
    remoteData?: RemoteInboundStreamStats;
    nackCount: number;
    ssrc: number;
    mid: string;
    score?: number;
}
interface InboundVideoStreamStats extends VideoStreamStats, InboundStreamStats {
    qpSum: number;
    totalAssemblyTime: number;
    totalDecodeTime: number;
    totalFreezesDuration: number;
    totalInterFrameDelay: number;
    totalPausesDuration: number;
    totalSquaredInterFrameDelay: number;
    framesDecoded: number;
    framesDropped: number;
    keyFramesDecoded: number;
    freezeCount: number;
    framesReceived: number;
    pauseCount: number;
    pliCount: number;
    totalProcessingDelay: number;
    decoderImplementation: string;
    powerEfficientDecoder: boolean;
}
interface QualityLimitationDurations {
    bandwidth: number;
    cpu: number;
    none: number;
    other: number;
}
interface OutboundVideoStreamStats extends VideoStreamStats, OutboundStreamStats {
    hugeFramesSent: number;
    pliCount: number;
    qpSum: number;
    framesEncoded: number;
    framesSent: number;
    keyFramesEncoded: number;
    encoderImplementation: string;
    qualityLimitationReason: string;
    qualityLimitationResolutionChanges: number;
    qualityLimitationDurations: QualityLimitationDurations;
    totalEncodeTime: number;
    targetBitrate?: number;
    scalabilityMode: string;
    powerEfficientEncoder: boolean;
}
interface InboundAudioStreamStats extends AudioStreamStats, InboundStreamStats {
    audioLevel: number;
    concealedSamples: number;
    concealmentEvents: number;
    totalAudioEnergy: number;
    totalSamplesDuration: number;
    totalSamplesReceived: number;
    fecPacketsDiscarded: number;
    fecPacketsReceived: number;
    insertedSamplesForDeceleration: number;
    removedSamplesForAcceleration: number;
    silentConcealedSamples: number;
    playoutId: string;
}
interface OutboundAudioStreamStats extends AudioStreamStats, OutboundStreamStats {
}
interface IceCandidateStats {
    id: string;
    type?: string;
    address?: string;
    port?: number;
    relatedAddress?: string;
    relatedPort?: number;
    url?: string;
    protocol?: string;
    networkType?: string;
}
interface IceCandidatePairStats {
    nominated: boolean;
    currentRoundTripTime?: number;
    totalRoundTripTime?: number;
    bytesSent?: number;
    bytesReceived?: number;
    bytesDiscardedOnSend?: number;
    packetsSent?: number;
    packetsReceived?: number;
    packetsDiscardedOnSend?: number;
    availableOutgoingBitrate?: number;
    availableIncomingBitrate?: number;
    lastPacketReceivedTimestamp?: number;
    lastPacketSentTimestamp?: number;
    localCandidateId?: string;
    localCandidateType?: string;
    localCandidateAddress?: string;
    localCandidatePort?: number;
    localCandidateRelatedAddress?: string;
    localCandidateRelatedPort?: number;
    localCandidateUrl?: string;
    localCandidateProtocol?: string;
    localCandidateNetworkType?: string;
    remoteCandidateId?: string;
    remoteCandidateType?: string;
    remoteCandidateAddress?: string;
    remoteCandidatePort?: number;
    remoteCandidateUrl?: string;
    remoteCandidateProtocol?: string;
}
interface WebRtcTransportStat {
    bytesReceived?: number;
    bytesSent?: number;
    roundTripTime?: number;
    totalRoundTripTime?: number;
    availableOutgoingBitrate?: number;
    availableIncomingBitrate?: number;
    dtlsCipher?: string;
    dtlsState?: RTCDtlsTransportState;
    iceRole?: RTCIceRole;
    packetsReceived?: number;
    packetsSent?: number;
    candidatePairs?: IceCandidatePairStats[];
}
interface TransportStatistics extends Object {
    transportId: string;
    consuming: boolean;
    producing: boolean;
    stats: WebRtcTransportStat;
}
interface ProducerStatistics extends Object {
    producerId: string;
    videoStats: OutboundVideoStreamStats[];
    audioStats: OutboundAudioStreamStats[];
    appData?: {
        screenShare?: boolean;
        supportsRemoteControl?: boolean;
    };
}
interface ConsumerStatistics extends Object {
    consumerId: string;
    peerId: string;
    producerId: string;
    videoStats: InboundVideoStreamStats[];
    audioStats: InboundAudioStreamStats[];
    appData: Record<string, unknown>;
}
interface ProcessedStatsReport {
    transportReport: TransportStatistics;
    producerReport: ProducerStatistics[];
    consumerReport: ConsumerStatistics[];
}
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;

interface IceServerInfo {
    urls: string;
    username: string;
    credential?: string;
    /**
     * Note(ravindra-dyte):
     * credentialType is deprecated.
     * https://developer.mozilla.org/en-US/docs/Web/API/RTCIceServer/credentialType
     */
    credentialType?: 'password';
}
interface RegionalIceInformation {
    regionId: string;
    iceServers: IceServerInfo[];
}
interface ApiHostnames {
    location: string;
    locationLegacy: string;
    daCollector: string;
}
type ClientEnvTypeAll = 'devel' | 'preprod' | 'prod';
declare enum MediaDeviceType {
    AUDIO = "AUDIO",
    VIDEO = "VIDEO",
    SPEAKER = "SPEAKER",
    SCREENSHARE = "SCREENSHARE"
}
type MediaDeviceTypeAll = keyof typeof MediaDeviceType;
interface DeviceInfo {
    isMobile: boolean;
    browserName: string;
    browserVersion: string;
    osName: string;
    osVersionName: string;
    engineName: string;
    userAgent: string;
    cpus: number;
    memory: number;
    webglSupport?: number;
}
interface PeerMetaData$1 {
    metaData: Object;
    deviceInfo: DeviceInfo;
    meetingEnv?: string;
    peerId: string;
    userId: string;
    roomUUID: string;
    permissions: Object;
    participantRole?: string;
    roomViewType: string;
}
/** Similar to what web-core has for media permissions */
type MediaPermissions$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'CANCELED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE';
interface InhouseCallStatsInitializeParams {
    peerId: string;
    engineName: string;
    env?: ClientEnvTypeAll;
    iceServers: any[];
    apiBase?: string;
    flags: Record<string, Record<'enabled' | 'value', any>>;
    logger?: DyteLogger$2;
    apiHostnames: ApiHostnames;
    skipConnectivityChecks: boolean;
}
/**
 * Note(ravindra-dyte):
 * This is redundantly added here to avoid circular dependency on web-core build
 *   */
declare type LogData$3 = {
    [key: string]: string | number | boolean | null | undefined | LogData$3;
};
declare interface DyteLogger$2 {
    info(humanReadableLogIdentifier: string, logData?: LogData$3, isCrucial?: boolean): void;
    error(humanReadableLogIdentifier: string, logData?: LogData$3, isCrucial?: boolean): void;
    debug(humanReadableLogIdentifier: string, logData?: LogData$3, isCrucial?: boolean): void;
    log(humanReadableLogIdentifier: string, logData?: LogData$3, isCrucial?: boolean): void;
    warn(humanReadableLogIdentifier: string, logData?: LogData$3, isCrucial?: boolean): void;
}

declare enum Event {
    PRECALL_TEST_BEGIN = "precall_begin",
    PRECALL_TEST_COMPLETE = "precall_end",
    CALL_JOIN_BEGIN = "call_join",
    NET_QUALITY_TEST_BEGIN = "net_quality_test_begin",
    NET_QUALITY_TEST_END = "net_quality_test_end",
    WEBSOCKET_CONNECTED = "websocket_connected",
    TRANSPORT_CONNECTED = "transport_connected",
    AUDIO_ON = "audio_on",
    AUDIO_OFF = "audio_off",
    VIDEO_ON = "video_on",
    VIDEO_OFF = "video_off",
    PARTICIPANT_ROLE = "participant_role",
    PING_STAT = "ping_stat",
    DISCONNECT = "disconnect",
    RECONNECT_ATTEMPT = "reconnect_attempt",
    SCREENSHARE_START_REQUESTED = "screenshare_start_requested",
    SCREENSHARE_STARTED = "screenshare_started",
    SCREENSHARE_STOPPED = "screenshare_stopped",
    TAB_CHANGE = "tab_change",
    BROWSER_BACKGROUNDED = "browser_backgrounded",
    BROWSER_FOREGROUNDED = "browser_foregrounded",
    DOMINANT_SPEAKER = "dominant_speaker",
    AUDIO_DEVICES_UPDATES = "audio_devices_updates",
    VIDEO_DEVICES_UPDATES = "video_devices_updates",
    SPEAKER_DEVICES_UPDATES = "speaker_devices_updates",
    SELECTED_MICROHPONE_UPDATE = "selected_microphone_update",
    SELECTED_CAMERA_UPDATE = "selected_camera_update",
    SELECTED_SPEAKER_UPDATE = "selected_speaker_update",
    EXPECTED_VIDEO_RESOLUTION = "expected_video_resolution",
    EXPECTED_SCREENSHARE_RESOLUTION = "expected_screenshare_resolution",
    MEDIA_PERMISSION = "media_permission",
    LEGACY_SWITCH = "legacy_switch",
    AUDIO_PLAY_FAILED = "audio_play_failed",
    VIDEO_PLAY_FAILED = "video_play_failed",
    AUDIO_TRACK_MUTED = "audio_track_muted",
    VIDEO_TRACK_MUTED = "video_track_muted",
    IVS_PLAYER_REBUFFERING = "ivs_player_rebuffering",
    IVS_PLAYER_AUDIO_BLOCKED = "ivs_player_audio_blocked",
    IVS_PLAYER_PLAYBACK_BLOCKED = "ivs_player_playback_blocked",
    IVS_PLAYER_ERROR = "ivs_player_error",
    IVS_PLAYER_RECOVERABLE_ERROR = "ivs_player_recoverable_error",
    IVS_PLAYER_WORKER_ERROR = "ivs_player_worker_error",
    IVS_PLAYER_NETWORK_UNAVAILABLE = "ivs_player_network_unavailable",
    LIVESTREAM_LATENCY = "livestream_latency",
    IVS_PLAYER_ANALYTICS_EVENT = "ivs_player_analytics_event",
    IVS_PLAYER_PLAYBACK_RATE_CHANGED = "ivs_player_playback_rate_changed",
    IVS_PLAYER_QUALITY_CHANGED = "ivs_player_quality_changed",
    IVS_PLAYER_INITIALIZED = "ivs_player_initialized"
}
interface PeerMetaData {
    metaData: Object;
    deviceInfo: DeviceInfo$1;
    meetingEnv?: string;
    peerId: string;
    userId: string;
    roomUUID: string;
    permissions: Object;
    participantRole?: string;
    roomViewType: string;
}
interface EventDataBase extends Object {
}
interface CallJoinData extends EventDataBase {
    peerMetaData: PeerMetaData;
}
interface PingStatsData extends EventDataBase {
    producingTransportStats?: TransportStatistics;
    consumingTransportStats?: TransportStatistics;
    producerStats?: ProducerStatistics[];
    consumerStats?: ConsumerStatistics[];
}
interface PreCallTestData extends EventDataBase {
    connectionInfo?: NetworkInformation;
}
interface PreCallTestDataWithoutConnectivityData extends EventDataBase {
    connectionInfo?: NetworkInformationWithoutConnectivityData;
}
interface RegionalNetworkQualityTestData extends RegionalIceInformation {
    networkResults: NetworkQualityInformation;
}
interface NetworkQualityTestData extends EventDataBase {
    regionData: RegionalNetworkQualityTestData[];
}
interface ParticipantRoleData extends EventDataBase {
    participantRole: string;
}
interface ExpectedVideoResolutionEntry extends EventEntryBase {
    event: Event.EXPECTED_VIDEO_RESOLUTION;
    metaData: {
        frameWidth: number;
        frameHeight: number;
    };
}
interface ExpectedScreenshareResolutionEntry extends EventEntryBase {
    event: Event.EXPECTED_SCREENSHARE_RESOLUTION;
    metaData: {
        frameWidth: number;
        frameHeight: number;
    };
}
interface EmptyData extends EventDataBase {
}
interface MediaDevicesData extends EventDataBase {
    deviceList: MediaDeviceInfo[];
}
interface IVSPlayerQualityChangedData extends EventDataBase {
    name: string;
    group: string;
    codecs: string;
    bitrate: number;
    width: number;
    height: number;
    framerate: number;
    isDefault: boolean;
}
interface IVSPlayerAnalyticsEventData extends EventDataBase {
    name: string;
    properties: Object;
}
interface IVSPlayerErrorData extends EventDataBase {
    type: string;
    code: number;
    source: string;
    message: string;
}
interface IVSPlayerRecoverableErrorData extends EventDataBase {
    type: string;
    code: number;
    source: string;
    message: string;
}
interface IVSPlayerPlaybackRateChangedData extends EventDataBase {
    updatedPlaybackRate: number;
}
interface IVSPlayerLiveLatencyData extends EventDataBase {
    latency: number;
}
type EventData = CallJoinData | PingStatsData | NetworkQualityTestData | EmptyData | ParticipantRoleData | ParticipantRoleData | MediaDevicesData | IVSPlayerQualityChangedData | IVSPlayerAnalyticsEventData | IVSPlayerErrorData | IVSPlayerRecoverableErrorData | IVSPlayerPlaybackRateChangedData | IVSPlayerLiveLatencyData;
interface EventEntryBase {
    event: Event;
    timestamp: Date;
    metaData?: EventData;
}
interface PreCallTestBeginEntry extends EventEntryBase {
    event: Event.PRECALL_TEST_BEGIN;
}
interface PreCallTestCompletedEntry extends EventEntryBase {
    event: Event.PRECALL_TEST_COMPLETE;
    metaData: PreCallTestData | PreCallTestDataWithoutConnectivityData;
}
interface CallJoinBeginEntry extends EventEntryBase {
    event: Event.CALL_JOIN_BEGIN;
    metaData: CallJoinData;
}
interface NetworkQualityTestBeginEntry extends EventEntryBase {
    event: Event.NET_QUALITY_TEST_BEGIN;
}
interface NetworkQualityTestEndEntry extends EventEntryBase {
    event: Event.NET_QUALITY_TEST_END;
    metaData: NetworkQualityTestData;
}
interface WebSocketConnectedEntry extends EventEntryBase {
    event: Event.WEBSOCKET_CONNECTED;
}
interface TransportConnectedEntry extends EventEntryBase {
    event: Event.TRANSPORT_CONNECTED;
}
interface AudioToggleEntry extends EventEntryBase {
    event: Event.AUDIO_OFF | Event.AUDIO_ON;
}
interface VideoToggleEntry extends EventEntryBase {
    event: Event.VIDEO_OFF | Event.VIDEO_ON;
}
interface ScreenShareToggleEntry extends EventEntryBase {
    event: Event.SCREENSHARE_STARTED | Event.SCREENSHARE_STOPPED;
    metaData: {
        ssrc: number;
    };
}
interface ScreenShareRequestedEntry extends EventEntryBase {
    event: Event.SCREENSHARE_START_REQUESTED;
}
interface DominantSpeakerEntry extends EventEntryBase {
    event: Event.DOMINANT_SPEAKER;
    metaData: {
        peerId: string;
    };
}
interface DevicesEntry extends EventEntryBase {
    event: Event.AUDIO_DEVICES_UPDATES | Event.VIDEO_DEVICES_UPDATES | Event.SPEAKER_DEVICES_UPDATES;
    metaData: MediaDevicesData;
}
interface SelectedDeviceEntry extends EventEntryBase {
    event: Event.SELECTED_CAMERA_UPDATE | Event.SELECTED_MICROHPONE_UPDATE | Event.SELECTED_SPEAKER_UPDATE;
    metaData: {
        device: MediaDeviceInfo;
    };
}
interface MediaPermissionEntry extends EventEntryBase {
    event: Event.MEDIA_PERMISSION;
    metaData: {
        deviceType: MediaDeviceTypeAll;
        permission: MediaPermissions$1;
    };
}
interface MediaPlaybackFailureEntry extends EventEntryBase {
    event: Event.AUDIO_PLAY_FAILED | Event.VIDEO_PLAY_FAILED;
    metaData: {
        deviceType: MediaDeviceTypeAll;
    };
}
interface MediaTrackFailureEntry extends EventEntryBase {
    event: Event.AUDIO_TRACK_MUTED | Event.VIDEO_TRACK_MUTED;
    metaData: {
        deviceType: MediaDeviceTypeAll;
    };
}
interface TabChangeEntry extends EventEntryBase {
    event: Event.TAB_CHANGE;
    metaData: {
        isMeetingsTabActive: boolean;
    };
}
interface BrowserBackgroundedEntry extends EventEntryBase {
    event: Event.BROWSER_BACKGROUNDED;
}
interface BrowserForegroundedEntry extends EventEntryBase {
    event: Event.BROWSER_FOREGROUNDED;
}
interface LegacySwitchEntry extends EventEntryBase {
    event: Event.LEGACY_SWITCH;
    metadata: {
        on: boolean;
    };
}
interface ParticipantRoleToggleEntry extends EventEntryBase {
    event: Event.PARTICIPANT_ROLE;
    metaData: ParticipantRoleData;
}
interface PingStatsEntry extends EventEntryBase {
    event: Event.PING_STAT;
    metaData: PingStatsData;
}
interface DisconnectEntry extends EventEntryBase {
    event: Event.DISCONNECT;
}
interface ReconnectEntry extends EventEntryBase {
    event: Event.RECONNECT_ATTEMPT;
}
interface IVSPlayerRebufferingEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_REBUFFERING;
}
interface IVSPlayerAudioBlockedEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_AUDIO_BLOCKED;
}
interface IVSPlayerPlaybackBlockedEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_PLAYBACK_BLOCKED;
}
interface IVSPlayerNetworkUnavailableEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_NETWORK_UNAVAILABLE;
}
interface IVSPlayerInitializedEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_INITIALIZED;
}
interface IVSPlayerWorkerErrorEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_WORKER_ERROR;
}
interface IVSPlayerErrorEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_ERROR;
    metaData: IVSPlayerErrorData;
}
interface IVSPlayerRecoverableErrorEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_RECOVERABLE_ERROR;
    metaData: IVSPlayerRecoverableErrorData;
}
interface IVSPlayerAnalyticsEventEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_ANALYTICS_EVENT;
    metaData: IVSPlayerAnalyticsEventData;
}
interface IVSPlayerPlaybackRateChangedEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_PLAYBACK_RATE_CHANGED;
    metaData: IVSPlayerPlaybackRateChangedData;
}
interface IVSPlayerQualityChangedEntry extends EventEntryBase {
    event: Event.IVS_PLAYER_QUALITY_CHANGED;
    metaData: IVSPlayerQualityChangedData;
}
interface IVSPlayerLiveLatencyEntry extends EventEntryBase {
    event: Event.LIVESTREAM_LATENCY;
    metaData: IVSPlayerLiveLatencyData;
}
type EventEntry = CallJoinBeginEntry | NetworkQualityTestBeginEntry | NetworkQualityTestEndEntry | BrowserForegroundedEntry | PingStatsEntry | PreCallTestBeginEntry | PreCallTestCompletedEntry | WebSocketConnectedEntry | TransportConnectedEntry | AudioToggleEntry | VideoToggleEntry | ScreenShareToggleEntry | DisconnectEntry | ReconnectEntry | ParticipantRoleToggleEntry | DominantSpeakerEntry | DevicesEntry | SelectedDeviceEntry | MediaPermissionEntry | MediaPlaybackFailureEntry | MediaTrackFailureEntry | ScreenShareRequestedEntry | ExpectedVideoResolutionEntry | ExpectedScreenshareResolutionEntry | TabChangeEntry | BrowserBackgroundedEntry | LegacySwitchEntry | IVSPlayerRebufferingEntry | IVSPlayerAudioBlockedEntry | IVSPlayerPlaybackBlockedEntry | IVSPlayerNetworkUnavailableEntry | IVSPlayerInitializedEntry | IVSPlayerErrorEntry | IVSPlayerRecoverableErrorEntry | IVSPlayerAnalyticsEventEntry | IVSPlayerLiveLatencyEntry | IVSPlayerPlaybackRateChangedEntry | IVSPlayerQualityChangedEntry | IVSPlayerWorkerErrorEntry;

declare class EventHandler extends EventEmitter {
    private logger;
    private peerId;
    private eventStore;
    private apiEndpoint;
    constructor({ logger, peerId, apiHostnames, }: {
        logger: DyteLogger$2;
        peerId: string;
        apiHostnames: ApiHostnames;
    });
    private sendEventsChunkToServer;
    callEvent(entry: EventEntry): void;
    flush(): Promise<boolean>;
}

interface ParsedProducerStats {
    outboundVideoRtpId: string[];
    outboundAudioRtpId: string[];
}
interface ParsedConsumerStats {
    inboundVideoRtpId: string[];
    inboundAudioRtpId: string[];
}
declare class ParsedRTCStats {
    transport: WebRtcTransportStat;
    candidatePair: IceCandidatePairStats;
    outboundVideoRtp: Map<string, OutboundVideoStreamStats>;
    inboundVideoRtp: Map<string, InboundVideoStreamStats>;
    outboundAudioRtp: Map<string, OutboundAudioStreamStats>;
    inboundAudioRtp: Map<string, InboundAudioStreamStats>;
    remoteInboundRtp: Map<string, RemoteInboundStreamStats>;
    producerStreamMap: Map<string, ParsedProducerStats>;
    consumerStreamMap: Map<string, ParsedConsumerStats>;
    staleProducerStreamMap: boolean;
    staleConsumerStreamMap: boolean;
}
declare abstract class Measurements extends EventEmitter {
    observer: EventEmitter;
    outboundProducerMap: Map<string, string>;
    inboundConsumerMap: Map<string, string>;
    consumerPeerIdMap: Map<string, {
        producerId: string;
        peerId: string;
        appData: Record<string, unknown>;
    }>;
    pausedConsumerMap: Map<string, {
        lastReportCalculated: boolean;
    }>;
    pausedProducerMap: Map<string, {
        lastReportCalculated: boolean;
    }>;
    overallProducingTransportsStatsMap: Record<string, {
        totalPacketsSent: number;
    }>;
    overallConsumingTransportsStatsMap: Record<string, {
        totalPacketsReceived: number;
    }>;
    overallConsumersStatsMap: Record<string, {
        totalVideoPacketsReceived: number;
        totalAudioPacketsReceived: number;
    }>;
    overallProducersStatsMap: Record<string, {
        totalVideoPacketsSent: number;
        totalAudioPacketsSent: number;
    }>;
    videoProducerToStatsMap: Map<string, OutboundVideoStreamStats>;
    audioProducerToStatsMap: Map<string, OutboundAudioStreamStats>;
    videoConsumerToStatsMap: Map<string, InboundVideoStreamStats>;
    audioConsumerToStatsMap: Map<string, InboundAudioStreamStats>;
    consumerIdsWithFreezedVideo: Set<string>;
    consumerIdsWithFreezedAudio: Set<string>;
    producerIdsWithFreezedVideo: Set<string>;
    producerIdsWithFreezedAudio: Set<string>;
    freezedProducingTransportIds: Set<string>;
    freezedConsumingTransportIds: Set<string>;
    screenShareProducers: Set<string>;
    screenShareConsumers: Set<string>;
    ipDetails: IPDetails;
    callStatsInstance: CallStats;
    constructor();
    registerProducer(producer: any): Promise<void>;
    pauseProducer(producerId: string): void;
    resumeProducer(producerId: string): void;
    processInboundConsumerVideoStats(consumerId: string, overallStatsForConsumer: {
        totalVideoPacketsReceived: number;
        totalAudioPacketsReceived: number;
    }, streamStatsData: InboundVideoStreamStats): void;
    processInboundConsumerAudioStats(consumerId: string, overallStatsForConsumer: {
        totalVideoPacketsReceived: number;
        totalAudioPacketsReceived: number;
    }, streamStatsData: InboundAudioStreamStats): void;
    processOutboundProducerVideoStats(producerId: string, overallStatsForProducer: {
        totalVideoPacketsSent: number;
        totalAudioPacketsSent: number;
    }, streamStatsData: OutboundVideoStreamStats): void;
    processOutboundProducerAudioStats(producerId: string, overallStatsForProducer: {
        totalVideoPacketsSent: number;
        totalAudioPacketsSent: number;
    }, streamStatsData: OutboundAudioStreamStats): void;
    processProducingTransportStats(transportId: string, overallStatsForTransport: {
        totalPacketsSent: number;
    }, transportStatsData: WebRtcTransportStat): void;
    processConsumingTransportStats(transportId: string, overallStatsForTransport: {
        totalPacketsReceived: number;
    }, streamStatsData: WebRtcTransportStat): void;
    registerConsumer(consumer: any): Promise<void>;
    pauseConsumer(consumerId: string): void;
    resumeConsumer(consumerId: string): void;
    generateProducerStreamMap(producer: any, parse?: boolean): Promise<ProducerStatistics>;
    generateConsumerStreamMap(consumer: any, parse?: boolean): Promise<ConsumerStatistics>;
    deregisterProducer(producer: any): void;
    deregisterConsumer(consumer: any): void;
    protected getIceCandidateStats(stats: any): IceCandidateStats;
    getWorkingSimulcastVideoStats(videoStatsList: OutboundVideoStreamStats[]): OutboundVideoStreamStats;
    protected parseRTCReport(report: RTCStatsReport, filters?: string[], onceOnly?: boolean, ownerId?: string, transportInfo?: {
        id: string;
        producing: boolean;
        consuming: boolean;
    }): ParsedRTCStats;
    getProducersReport(producers: any[]): Promise<ProducerStatistics[]>;
    getConsumersReport(consumers: any[]): Promise<ConsumerStatistics[]>;
    getTransportReport(transport: any): Promise<any>;
    getProcessedStats(transport: any, consuming: boolean, producing: boolean): Promise<ProcessedStatsReport>;
    protected getProducerStatsFromReport(report: ParsedRTCStats): ProducerStatistics[];
    protected getConsumerStatsFromReport(report: ParsedRTCStats): ConsumerStatistics[];
    getUserLocation(): Promise<GeoLocation>;
    getConnectivity(iceServers: IceServerInfo[]): Promise<{
        host: boolean;
        relay: boolean;
        reflexive: boolean;
    }>;
    getThroughput(iceServers: IceServerInfo[]): Promise<ThroughputInformation>;
    getIPDetails(): Promise<IPDetails>;
    getNetworkQuality(iceServers: IceServerInfo[]): Promise<NetworkQualityInformation>;
    getNetworkInfo(iceServers: IceServerInfo[], skipConnectivityChecks?: boolean): Promise<NetworkInformation | NetworkInformationWithoutConnectivityData>;
}

declare class CallStats extends EventEmitter {
    observer: EventEmitter;
    eventHandler: EventHandler;
    protected measurements: Measurements;
    protected producingTransport: any;
    protected consumingTransport: any;
    producers: Map<string, any>;
    protected consumers: Map<string, any>;
    protected iceServers: IceServerInfo[];
    protected connectionInfoPromise: Promise<NetworkInformation | NetworkInformationWithoutConnectivityData>;
    protected pingStatsTimeout: NodeJS.Timeout;
    logger: DyteLogger$2;
    env: ClientEnvTypeAll;
    apiHostnames: ApiHostnames;
    peerId: string;
    consumerSharedMediaStatesMap: Map<string, {
        audio?: boolean;
        video?: boolean;
        screen?: boolean;
    }>;
    currentUserMediaStates: {
        audio?: boolean;
        video?: boolean;
        screen?: boolean;
    };
    constructor(backendUrl: string, engineName: string, env: ClientEnvTypeAll, flags: InhouseCallStatsInitializeParams['flags'], logger: DyteLogger$2, peerId: string, apiHostnames: ApiHostnames);
    registerIceServers(servers: IceServerInfo[]): void;
    protected registerConsumer(consumer: any): void;
    protected registerProducer(producer: any): void;
    sendConsumerSharedMediaStateEvent(consumerId: string, statusObj: {
        audio?: boolean;
        video?: boolean;
        screen?: boolean;
    }): void;
    registerProducingTransport(transport: any): void;
    registerConsumingTransport(transport: any): void;
    protected deRegisterConsumer(consumer: any): void;
    protected deRegisterProducer(producer: any): void;
    disconnectConsumingTransport(): void;
    disconnectProducingTransport(): void;
    protected callEvent(entry: EventEntry): void;
    sendPreCallTestBeginEvent(skipConnectivityChecks: boolean, timestamp: Date): void;
    sendScreenShareToggleEvent(on: boolean, ssrc: number, timestamp: Date): void;
    sendScreenShareRequestedEvent(timestamp: Date): void;
    sendActiveSpeakerEvent(peerId: string, timestamp: Date): void;
    devices(deviceType: MediaDeviceTypeAll, deviceList: MediaDeviceInfo[], timestamp: Date): void;
    selectedDevice(deviceType: MediaDeviceTypeAll, device: MediaDeviceInfo, timestamp: Date): void;
    mediaPermission(deviceType: MediaDeviceTypeAll, permission: MediaPermissions$1, timestamp: Date): void;
    mediaPlaybackFailed(deviceType: MediaDeviceTypeAll, timestamp: Date): void;
    mediaTrackMuted(deviceType: MediaDeviceTypeAll, timestamp: Date): void;
    tabChanged(isMeetingsTabActive: boolean, timestamp: Date): void;
    browserBackgrounded(timestamp: Date): void;
    browserForegrounded(timestamp: Date): void;
    legacySwitch(on: boolean, timestamp: Date): void;
    getPreCallTestResults(): Promise<NetworkInformation | NetworkInformationWithoutConnectivityData>;
    sendCallJoinBeginEvent(peerMetaData: PeerMetaData, timestamp: Date): void;
    sendNetworkQualityTestBeginEvent(regionalInformations: RegionalIceInformation[], timestamp: Date): void;
    sendWebSocketConnectedEvent(timestamp: Date): void;
    sendTransportConnectedEvent(timestamp: Date): void;
    sendAudioToggleEvent(on: boolean, timestamp: Date): void;
    sendVideoToggleEvent(on: boolean, timestamp: Date): void;
    sendParticipantRoleToggleEvent(role: ParticipantRoleData, timestamp: Date): void;
    startPingStats(interval?: number): void;
    stopPingStats(): void;
    sendPingStatsEvent(optimize: boolean, timestamp: Date): Promise<void>;
    sendIVSPlayerRebufferEvent(timestamp: Date): void;
    sendIVSPlayerAudioBlockEvent(timestamp: Date): void;
    sendIVSPlayerPlaybackBlockedEvent(timestamp: Date): void;
    sendIVSPlayerNetworkUnavailableEvent(timestamp: Date): void;
    sendIVSPlayerInitializedEvent(timestamp: Date): void;
    sendIVSPlayerWorkerErrorEvent(timestamp: Date): void;
    sendIVSPlayerErrorEvent(payload: IVSPlayerErrorData, timestamp: Date): void;
    sendIVSPlayerRecoverableErrorEvent(payload: IVSPlayerRecoverableErrorData, timestamp: Date): void;
    sendIVSPlayerAnalyticsEvent(payload: IVSPlayerAnalyticsEventData, timestamp: Date): void;
    sendIVSPlayerPlaybackRateChangedEvent(updatedPlaybackRate: number, timestamp: Date): void;
    sendIVSPlayerQualityChanged(payload: IVSPlayerQualityChangedData, timestamp: Date): void;
    sendPlayerLiveLatency(latency: number, timestamp: Date): void;
    sendDisconnectEvent(timestamp: Date): void;
    sendReconnectEvent(timestamp: Date): void;
    expectedVideoResolution(frameWidth: number, frameHeight: number, timestamp: Date): void;
    expectedScreenshareResolution(frameWidth: number, frameHeight: number, timestamp: Date): void;
}

declare class InhouseCallStats extends EventEmitter {
    stats: any;
    peerId: string;
    backend: CallStats;
    iceServers: IceServerInfo[];
    initialized: boolean;
    stalled: boolean;
    ipInformation: Object;
    logger: DyteLogger$2;
    initialize({ peerId, engineName, env, iceServers, apiBase, flags, logger, apiHostnames, skipConnectivityChecks, }: InhouseCallStatsInitializeParams): Promise<void>;
    configureSendTransport(sendTransport: any): void;
    configureRecvTransport(recvTransport: any): void;
    candidateRegionalNetworkQualityTest(regionalIceServersInfo: RegionalIceInformation[]): Promise<void>;
    roomJoined(peerData: PeerMetaData$1): Promise<void>;
    audioOff(): void;
    audioOn(): void;
    videoOff(): void;
    videoOn(): void;
    callEnded(): void;
    screenShareStart(ssrc?: number): void;
    consumerSharedMediaState(consumerId: string, statusObj: {
        audio?: boolean;
        video?: boolean;
        screen?: boolean;
    }): void;
    screenShareStop(ssrc?: number): void;
    screenShareRequested(): void;
    activeSpeaker(peerId: string): void;
    devices(deviceType: MediaDeviceTypeAll, deviceList: MediaDeviceInfo[]): void;
    selectedDevice(deviceType: MediaDeviceTypeAll, device: MediaDeviceInfo): void;
    mediaPermission(deviceType: MediaDeviceTypeAll, permission: MediaPermissions$1): void;
    mediaPlaybackFailed(deviceType: MediaDeviceTypeAll): void;
    mediaTrackMuted(deviceType: MediaDeviceTypeAll): void;
    tabChanged(isMeetingsTabActive?: boolean): void;
    browserBackgrounded(): void;
    browserForegrounded(): void;
    legacySwitch(on: boolean): void;
    startPreCallTest(skipConnectivityChecks?: boolean): Promise<void>;
    onPreCallTestResults(fx: any): any;
    onReceivingConsumerAudioStatus(fx: any): void;
    onReceivingConsumerVideoStatus(fx: any): void;
    onReceivingProducerAudioStatus(fx: any): void;
    onReceivingProducerVideoStatus(fx: any): void;
    onReceivingProducingTransportStatus(fx: any): void;
    onReceivingConsumingTransportStatus(fx: any): void;
    onProducerScore(fx: any): void;
    onConsumerScore(fx: any): void;
    private onSafeInitialization;
    removeInitializationListener(fx: Function): void;
    stallCallStats(): void;
    ivsPlayerEvent(type: String, payload: any): void;
    livestreamLatency(latency: number): void;
    expectedVideoResolution(frameWidth: number, frameHeight: number): void;
    expectedScreenshareResolution(frameWidth: number, frameHeight: number): void;
}

interface DyteBasicParticipant {
    userId: string;
    name?: string;
    picture?: string;
    customParticipantId: string;
}
declare class DyteBasicParticipantsMap extends DyteEventEmitter<'participantsUpdate'> {
    constructor(logger: DyteLogger);
    __set(objId: string, obj: DyteBasicParticipant): Map<string, DyteBasicParticipant>;
    __clear(): void;
    get(objId: string): DyteBasicParticipant;
    toArray(): DyteBasicParticipant[];
}

type ChatChannelSocketMessage = GetChatChannelResponse;
interface ChatChannel {
    id: string;
    displayName: string;
    memberIds: string[];
    displayPictureUrl?: string;
    visibility?: string;
    isDirectMessage?: boolean;
    latestMessage?: Message;
    unreadCount: number;
}
interface UpdateChannelRequestPayload {
    memberIds?: string[];
    displayName?: string;
    displayPictureUrl?: string;
    visibility?: string;
}
declare class ChatChannelSocketHandler {
    get telemetry(): DyteTelemetry;
    get logger(): DyteLogger;
    constructor(context: Context<DyteContextState>, 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<DyteBasicParticipant[]>;
    on(event: number, handler: (socketMessage: ChatChannelSocketMessage) => void): void;
}

declare enum ChatMessageType {
    TEXT = 0,
    IMAGE = 1,
    FILE = 2,
    CUSTOM = 3
}
type ChatSocketMessage = SendChatMessageToRoomResponse | SendChatMessageToPeersResponse | EditChatMessageResponse | DeleteChatMessageResponse;
interface SearchFilters {
    channelId?: string;
    timestamp?: number;
    size?: number;
    reversed?: boolean;
}
declare class ChatSocketHandler {
    get telemetry(): DyteTelemetry;
    get logger(): DyteLogger;
    constructor(context: Context<DyteContextState>, 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 DyteSelectedPeers {
    private readonly _activeSpeakerPeers;
    private readonly _compulsoryPeers;
    constructor();
    add(peerId: string, priority: number, context: Context<DyteContextState>): number;
    delete(peerId: string, context: Context<DyteContextState>): void;
    index(peerId: string): number;
    get peers(): string[];
    get compulsoryPeers(): string[];
    get activeSpeakerPeers(): string[];
    private _removeFromCompulsoryPeer;
}

type PipEvents = {
    ['cameraToggled']: () => void;
    ['micToggled']: () => void;
    ['hangup']: () => void;
    ['pipStarted']: () => void;
    ['pipEnded']: () => void;
    ['*']: (eventName: string, ...args: any[]) => void;
};
declare class DytePip extends DyteTypedEventEmitter<PipEvents> {
    private constructor();
    static _init(context: Context<DyteContextState>, self: DyteSelf$1): Promise<DytePip>;
    private setupIcon;
    overrideIcon(icon: 'handRaise' | 'pin', value: string): Promise<void>;
    private constructImage;
    private createVideoContainer;
    private setupEventListeners;
    private cleanupEventListeners;
    private enablePipMediaControls;
    private onSelfVideoUpdateListener;
    private onSelfAudioUpdateListener;
    private handlePipMediaControls;
    private createCanvas;
    private eventCallback;
    private setupMediaSessionEvents;
    private mountAudioEvents;
    private mountVideoEvents;
    private unmountEvents;
    private getSources;
    private drawEmptyTile;
    private drawIcons;
    private drawTile;
    private calcGridElemSize;
    private paintCanvas;
    private animate;
    isSupported(): boolean;
    get isActive(): boolean;
    private cleanup;
    init({ height, width }?: {
        height?: number;
        width?: number;
    }): void;
    private updateMediaSession;
    enableSource(source: string): void;
    disableSource(source: string): void;
    private generateAvatar;
    addSource(id: string, element: HTMLVideoElement, enabled: boolean, pinned?: boolean, displayText?: string, imageUrl?: string, handRaised?: boolean): void;
    updateSource(id: string, source: any): void;
    removeSource(id: string): void;
    removePinnedSource(): void;
    removeAllSources(): void;
    enable(): void;
    disable: (partial?: boolean) => void;
}

type EventHandlerTypes = PeerInfoResponse | GetWaitingRoomRequests | RecordingEvent | UpdatePeersPresetResponse | PeerJoinBroadcastResponse | PeerJoinCompleteResponse | GlobalPeerPinningBroadcastResponse | PeerLeaveResponse | SelectedPeersResponse | SelectedPeersDiffResponse;
declare class RoomSocketHandler {
    socket: SocketService;
    get telemetry(): DyteTelemetry;
    get logger(): DyteLogger;
    cleanup(): void;
    constructor(context: Context<DyteContextState>, socketService: SocketService);
    joinRoom(opts: {
        name: string;
        id: string;
        userId: string;
        customParticipantId: string;
        picture?: string;
    }): Promise<{
        peer: Peer;
    }>;
    getAllAddedParticipants(): Promise<DyteBasicParticipant[]>;
    getRoomPeers(searchQuery: string, limit: number, offset: number): Promise<RoomPeersInfoResponse>;
    getRoomPeersNonPaginated(): Promise<RoomPeersInfoResponse>;
    getStagePeers(): Promise<RoomPeersInfoResponse>;
    getPeerInfo(peerId: string): Promise<PeerInfoResponse>;
    getRoomState(): Promise<RoomInfoResponse>;
    getRoomStageState(): Promise<GetRoomStageStateResponse>;
    broadcastMessage(type: string, payload: BroadcastMessagePayload): Promise<{
        id: string;
        payload: Uint8Array;
    }>;
    broadcastToMeetings(type: string, meetingIds: string[], payload: BroadcastMessagePayload): Promise<{
        id: string;
        payload: Uint8Array;
    }>;
    broadcastToPeers(type: string, peerIds: string[], payload: BroadcastMessagePayload): Promise<boolean>;
    leaveRoom(): Promise<void>;
    kick(peerId: string): Promise<void>;
    kickAll(propagateKickAll?: boolean): Promise<void>;
    getWaitingRoomRequests(): void;
    acceptWaitingRoomRequest(userIds: string[]): void;
    rejectWaitingRoomRequest(userIds: string[]): void;
    updatePermissions(userIds: string[], patch: PresetUpdates): Promise<{
        id: string;
        payload: Uint8Array;
    }>;
    private handleSocketEvents;
    on(event: number, handler: (message: EventHandlerTypes) => void): void;
    getUserPermissions(userId: string): Promise<Pick<PresetTypeV2['permissions'], 'chat' | 'polls' | 'plugins'>>;
}

type 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 DyteAi extends DyteTypedEventEmitter<AiEvents> {
    transcripts: TranscriptionData[];
    get telemetry(): DyteTelemetry;
    constructor(context: Context<DyteContextState>);
    static init(context: Context<DyteContextState>, transcriptionEnabled: boolean): Promise<DyteAi>;
    static parseTranscript(transcriptData: string, isPartialTranscript?: boolean): TranscriptionData | undefined;
    static parseTranscripts(transcriptData: string): TranscriptionData[];
    getActiveTranscript(): Promise<void>;
    onTranscript(transcript: TranscriptionData): Promise<void>;
}

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}`;
    };
    send: {
        state: `${TransportState}`;
    };
};

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 DyteMeta extends DyteTypedEventEmitter<MetaEvents> {
    selfActiveTab: ActiveTab | undefined;
    get socketState(): SocketConnectionState;
    get mediaState(): MediaConnectionState;
    broadcastTabChanges: boolean;
    viewType: string;
    meetingStartedTimestamp: Date;
    meetingTitle: string;
    sessionId: string;
    constructor(context: Context<DyteContextState>, self: DyteSelf, viewType: string, roomSocketHandler: RoomSocketHandler, meetingTitle: string);
    get meetingId(): string;
    setBroadcastTabChanges(broadcastTabChanges: boolean): void;
    setSelfActiveTab(spotlightTab: ActiveTab, tabChangeSource: TabChangeSource): void;
    private assertActiveTabToRoom;
}

interface DyteMapEvents<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 DyteMap<T extends (EventMap & WildCardEvent<T>), U extends {
    id: string;
} & DyteTypedEventEmitter<T>, V extends EventMap> extends Map<string, U> {
    readonly onAddEvent: keyof V;
    readonly onDeleteEvent: keyof V;
    readonly onClearEvent: keyof V;
    constructor(options: DyteMapEvents<V>, logger?: DyteLogger);
    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]): DyteTypedEventEmitter<{ [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]): DyteTypedEventEmitter<{ [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]): DyteTypedEventEmitter<{ [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]): DyteTypedEventEmitter<{ [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]): DyteTypedEventEmitter<{ [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]): DyteTypedEventEmitter<{ [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]): DyteTypedEventEmitter<{ [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): DyteTypedEventEmitter<{ [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): DyteTypedEventEmitter<{ [K in keyof T]: (obj: U, ...args: Parameters<T[K]>) => ReturnType<T[K]>; } & {
        "*": (event: String, ...args: any[]) => void;
    } & V>;
    eventNames(): (string | symbol)[];
    add(obj: U, emitEvent?: boolean): this;
    set(objId: string, obj: U, emitEvent?: boolean): this;
    delete(objId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
    clear(emitEvent?: boolean, removeListeners?: boolean): void;
    toArray(): U[];
}

declare class EnhancedEventEmitter<TransportPromiseEvents> extends EventEmitter$1 {
    get logger(): DyteLogger;
    constructor(context: Context<DyteContextState>);
    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> {
    protected _sendWebStream: MediaStream;
    protected _sendScreenShareStream: MediaStream;
    protected _direction?: 'send' | 'recv';
    pc: RTCPeerConnection;
    protected _transportReady: boolean;
    private readonly _mapMidTransceiver;
    enableHighBitrate: boolean;
    enableStereo: boolean;
    enableDtx: boolean;
    sfu: MediaNodeType;
    get midTransceiverMap(): Map<string, RTCRtpTransceiver>;
    abstract get name(): string;
    close(): void;
    restartIce(): Promise<GenericHandlerResult>;
    init({ direction, iceServers, iceTransportPolicy, additionalSettings, proprietaryConstraints, onTrackHandler, }: HandlerRunOptions): void;
    connect(): Promise<GenericHandlerResult>;
    getTransportStats(): Promise<RTCStatsReport>;
    protected _assertSendDirection(): void;
    protected _assertRecvDirection(): void;
    getReceiverStats(localId: string): Promise<RTCStatsReport>;
    stopSending(localId: string): Promise<GenericHandlerResult>;
    abstract send(options: HandlerSendOptions): Promise<HandlerSendResult>;
    replaceTrack(localId: string, track: MediaStreamTrack | null): Promise<void>;
    setMaxSpatialLayer(localId: string, spatialLayer: number): Promise<void>;
    setRtpEncodingParameters(localId: string, params: any): Promise<void>;
    getSenderStats(localId: string): Promise<RTCStatsReport>;
    _addEventListeners(): void;
    addCustomEventListeners(): void;
}

type DCMessage = {
    type: string;
    payload: Record<string, unknown>;
};

type TransportPromiseEvents = {
    '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(context: Context<DyteContextState>, 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"];
declare const e2eeEvents: readonly ["participantEncryptionStatusChanged", "encryptionError"];
declare const e2eeKeyEvents: readonly ["setKey", "ratchetRequest", "keyRatcheted"];
type LocalMediaEvents = (typeof localMediaEvents)[number];
type EncryptionEvents = (typeof e2eeEvents)[number];
type KeyProviderEvents = (typeof e2eeKeyEvents)[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: DyteParticipant$1) => void;
    ['unpinned']: (payload: DyteParticipant$1) => void;
    ['poorConnection']: (payload: {
        score: number;
        kind: string;
    }) => void;
    ['stageStatusUpdate']: (payload: DyteParticipant$1) => 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: DyteSelf) => void;
    ['unpinned']: (payload: DyteSelf) => 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;
    ['autoplayError']: (error: Error) => void;
    ['*']: (event: string, ...args: any[]) => void;
};

type ParticipantMapEvents = {
    ['participantJoined']: (payload: DyteParticipant) => void;
    ['participantLeft']: (payload: DyteParticipant) => void;
    ['participantsCleared']: () => void;
    ['participantsUpdate']: () => void;
    ['kicked']: (payload: {
        id: string;
    }) => void;
};
declare class DyteParticipantMap<T extends Pick<DyteParticipant, 'id' | keyof DyteTypedEventEmitter<ParticipantEvents>> = DyteParticipant> extends DyteMap<ParticipantEvents, T, ParticipantMapEvents> {
    constructor(logger: DyteLogger$1, options?: DyteMapEvents<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 DyteParticipants$1 extends DyteTypedEventEmitter<ParticipantsEvents> {
    readonly waitlisted: Readonly<DyteParticipantMap<Omit<DyteParticipant, 'audioTrack' | 'videoTrack' | 'screenShareTracks'>>>;
    readonly joined: Readonly<DyteParticipantMap>;
    readonly active: Readonly<DyteParticipantMap>;
    readonly videoSubscribed: Readonly<DyteParticipantMap>;
    readonly audioSubscribed: Readonly<DyteParticipantMap>;
    readonly pinned: Readonly<DyteParticipantMap>;
    readonly all: Readonly<DyteBasicParticipantsMap>;
    get pip(): DytePip;
    rateLimitConfig: {
        maxInvocations: number;
        period: number;
    };
    get rateLimits(): {
        maxInvocations: number;
        period: number;
    };
    updateRateLimits(num: number, period: number): void;
    get telemetry(): DyteTelemetry;
    viewMode: ViewMode;
    currentPage: number;
    lastActiveSpeaker: string;
    selectedPeers: DyteSelectedPeers;
    constructor(context: Context<DyteContextState>, self: DyteSelf$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;
    });
    private buildURL;
    request<T = any>(config: FetchRequestConfig): Promise<FetchResponse<T>>;
    get<T = any>(url: string, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
    post<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
    put<T = any>(url: string, data?: any, config?: FetchRequestConfig): Promise<FetchResponse<T>>;
}

interface ResponseStatus {
    success: boolean;
    message: string;
}

type MediaPermission$1 = 'NOT_REQUESTED' | 'ACCEPTED' | 'DENIED' | 'SYSTEM_DENIED' | 'COULD_NOT_START' | 'NO_DEVICES_AVAILABLE' | 'CANCELED';

declare class LocalMediaHandler extends DyteEventEmitter<LocalMediaEvents> {
    get telemetry(): DyteTelemetry;
    audioUpdateInProgress: boolean;
    videoUpdateInProgress: boolean;
    constructor(context: Context<DyteContextState>, mediaConstraints: MediaConstraints, isNonPreferredDevice?: (media: MediaDeviceInfo) => boolean, autoSwitchDevice?: boolean);
    set context(context: Context<DyteContextState>);
    private onVisibilityChange;
    repopulateAvailableDevices(): Promise<boolean>;
    setupStreams({ audio, video, }: {
        audio: boolean;
        video: boolean;
    }): Promise<void>;
    getCurrentDevices(): {
        audio: MediaDeviceInfo;
        video: MediaDeviceInfo;
        speaker: MediaDeviceInfo;
    };
    get permissions(): {
        audio?: MediaPermission$1;
        video?: MediaPermission$1;
        screenshare?: MediaPermission$1;
    };
    getAllDevices(): Promise<InputDeviceInfo[]>;
    getDeviceById(deviceId: string, kind?: 'audioinput' | 'audiooutput' | 'videoinput'): Promise<MediaDeviceInfo>;
    private onAudioTrackMuted;
    private onAudioTrackChanged;
    get rawAudioTrack(): MediaStreamTrack;
    get audioTrack(): MediaStreamTrack;
    get audioEnabled(): boolean;
    enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
    disableAudio(): void;
    getAudioDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
    setAudioDevice(device: MediaDeviceInfo): Promise<void>;
    setupSpeaker(): Promise<void>;
    setSpeakerDevice(device: MediaDeviceInfo): Promise<void>;
    private onVideoTrackChanged;
    private onVideoTrackEnded;
    get rawVideoTrack(): MediaStreamTrack;
    get videoTrack(): MediaStreamTrack;
    get videoEnabled(): boolean;
    enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
    disableVideo(): void;
    getVideoDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
    setVideoDevice(device: MediaDeviceInfo): Promise<void>;
    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
    private onScreenShareEnded;
    get screenShareTracks(): {
        audio: MediaStreamTrack;
        video: MediaStreamTrack;
    };
    get screenShareEnabled(): boolean;
    enableScreenShare(): Promise<void>;
    disableScreenShare(): Promise<void>;
    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
    getSpeakerDevices(devices?: MediaDeviceInfo[]): Promise<MediaDeviceInfo[]>;
    addAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
    removeAudioMiddleware(audioMiddleware: AudioMiddleware): Promise<ResponseStatus>;
    removeAllAudioMiddlewares(): Promise<ResponseStatus>;
    addVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
    removeVideoMiddleware(videoMiddleware: VideoMiddleware): Promise<ResponseStatus>;
    removeAllVideoMiddlewares(): Promise<ResponseStatus>;
    setVideoMiddlewareGlobalConfig(config: VideoMiddlewareGlobalConfig): Promise<void>;
    destruct(): void;
    onDeviceChange(changedDevices: {
        added: MediaDeviceInfo[];
        removed: MediaDeviceInfo[];
        devices: MediaDeviceInfo[];
    }, skipDeviceChange: boolean): Promise<void>;
    removeAllTracks(): void;
    removeAudioTrack(): void;
    removeVideoTrack(): void;
    removeDocumentEventListeners(): Promise<void>;
}

declare enum MediaPermission {
    NOT_REQUESTED = 0,
    ACCEPTED = 1,
    DENIED = 2,
    CANCELED = 3,
    SYSTEM_DENIED = 4,
    COULD_NOT_START = 5,
    NO_DEVICES_AVAILABLE = 6
}

type AudioMiddleware = (audioContext: AudioContext) => Promise<ScriptProcessorNode | AudioWorkletNode>;

type VideoMiddleware = (() => Promise<(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D) => Promise<void>>) | ((helpers: {
    canvas: HTMLCanvasElement;
    WorkerTimers: typeof WorkerTimers;
}) => Promise<void>);
type VideoMiddlewareGlobalConfig = {
    disablePerFrameCanvasRendering: boolean;
};

type PresetMediaConstraints = PresetV2CamelCased['config']['media'];
type AudioQualityConstraints = {
    echoCancellation?: boolean;
    noiseSupression?: boolean;
    autoGainControl?: boolean;
    enableStereo?: boolean;
    enableHighBitrate?: boolean;
};
type VideoQualityConstraints = {
    width: {
        ideal: number;
    };
    height: {
        ideal: number;
    };
    frameRate?: {
        ideal: number;
    };
};
type ScreenshareQualityConstraints = {
    width?: {
        max: number;
    };
    height?: {
        max: number;
    };
    frameRate?: {
        ideal: number;
        max: number;
    };
    displaySurface?: 'window' | 'monitor' | 'browser';
    selfBrowserSurface?: 'include' | 'exclude';
};
interface DyteMediaTrackConstraints extends MediaTrackConstraints {
    optional?: Array<object>;
}
interface DyteMediaStreamConstraints extends MediaStreamConstraints {
    audio?: boolean | DyteMediaTrackConstraints;
}
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 DyteThemePreset {
    private constructor();
    static fromResponse(preset: PresetV2CamelCased): DyteThemePreset;
    static default(): DyteThemePreset;
    static init(preset?: PresetV2CamelCased, useDefault?: boolean): DyteThemePreset;
    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 DytePermissionsPreset extends DyteTypedEventEmitter<PermissionEvents> {
    private constructor();
    private setupEvents;
    static fromResponse(response: PresetPermissions, viewType: ViewType, context: Context<DyteContextState>): DytePermissionsPreset;
    static default(context: Context<DyteContextState>, viewType: ViewType): DytePermissionsPreset;
    static init(context: Context<DyteContextState>, viewType: ViewType, response?: PresetPermissions): DytePermissionsPreset;
    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';
declare class SelfController {
    readonly self: DyteSelf$1;
    readonly authToken: string;
    get peerId(): string;
    viewType: ViewType;
    get telemetry(): DyteTelemetry;
    get logger(): DyteLogger;
    get mediaJoined(): boolean;
    private constructor();
    static init(context: Context<DyteContextState>, roomSocketHandler: RoomSocketHandler, participant: UserDetailsResponseV2['participant'], permissions: DytePermissionsPreset, theme: DyteThemePreset): Promise<SelfController>;
    shareMediaTracks(): Promise<void>;
    private kickHandler;
    private waitlistedHandler;
    private waitlistAcceptHandler;
    private waitlistRejectedHandler;
    resetSelf(shouldAutoJoin: boolean): Promise<void>;
    private setupEvents;
    joinRoom(reconnected?: boolean): Promise<void>;
    leaveRoom(state?: LeaveRoomState): Promise<void>;
    private joinMediaRoom;
    private leaveMediaRoom;
    private cleanupSelf;
}

type LivestreamState = 'IDLE' | 'STARTING' | 'WAITING_ON_MANUAL_INGESTION' | 'LIVESTREAMING' | 'STOPPING';
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 DyteLivestream extends DyteTypedEventEmitter<LivestreamEvents> {
    state: LivestreamState;
    playbackUrl: string | undefined;
    ingestionCredentials: LivestreamIngestionCredentials;
    viewerCount: number;
    get telemetry(): DyteTelemetry;
    constructor(context: Context<DyteContextState>, self: DyteSelf);
    setLivestreamState(livestreamState: LivestreamState): void;
    private emitCurrentLivestreamState;
    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 {
    telemetry: DyteTelemetry;
    constructor(context: Context<DyteContextState>, options?: APIOptions);
    getIPDetails(): Promise<any>;
    getICEServers(): Promise<any>;
    getPlugins(): Promise<any[]>;
    getPluginDetails(pluginId: string): Promise<DytePluginResponse>;
    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 DyteChat extends DyteTypedEventEmitter<ChatEvents> {
    messages: Message[];
    channels: ChatChannel[];
    maxTextLimit: number;
    get telemetry(): DyteTelemetry;
    setMaxTextLimit(limit: number): void;
    constructor(context: Context<DyteContextState>, chatSocketHandler: ChatSocketHandler, chatChannelSocketHandler: ChatChannelSocketHandler, self: DyteSelf$1, participants: DyteParticipants$1);
    private sendMessageInternal;
    private sendTextMessageInternal;
    private sendImageMessageInternal;
    private sendFileMessageInternal;
    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<DyteBasicParticipant[]>;
    searchMessages(query: string, filters?: SearchFilters): Promise<Message[]>;
    markLastReadMessage(channelId: string, message: Message): Promise<void>;
    get pinned(): Message[];
}

declare class PollSocketHandler {
    get logger(): DyteLogger;
    get telemetry(): DyteTelemetry;
    constructor(context: Context<DyteContextState>, 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 DytePolls extends DyteTypedEventEmitter<PollsEvents> {
    items: Poll[];
    constructor(context: Context<DyteContextState>, self: DyteSelf$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: DytePlugin) => void;
    ['pluginDeleted']: (plugin: DytePlugin) => 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 DytePluginMap<T extends DytePlugin = DytePlugin> extends DyteMap<PluginEvents$1, T, PluginMapEvents> {
    constructor(logger: DyteLogger);
    add(plugin: T, emitEvent?: boolean): this;
    delete(pluginId: string, emitEvent?: boolean, removeListeners?: boolean): boolean;
}

declare class DytePlugins {
    readonly all: DytePluginMap;
    readonly active: DytePluginMap;
    constructor(logger: DyteLogger$1);
}

type PluginSocketMessage = DisablePluginResponse | EnablePluginResponse | PluginEventResponse | PluginStoreResponse | SendChatMessageToPeersResponse | SendChatMessageToRoomResponse;
declare class PluginSocketHandler {
    constructor(context: Context<DyteContextState>, socketService: SocketService);
    get logger(): DyteLogger;
    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 DyteSelfMedia extends DyteTypedEventEmitter<SelfEvents> {
    protected localMediaHandler: LocalMediaHandler;
    protected updatePermission(): Promise<void>;
    protected populateMediaPermissionsInCallstats({ message, kind, }: {
        message: keyof typeof MediaPermission;
        kind: 'audio' | 'video' | 'screenshare';
    }): Promise<void>;
    get peerId(): string;
    init(options?: {
        video?: boolean;
        audio?: boolean;
        constraints?: MediaConstraints;
    }, skipAwaits?: boolean, context?: Context<DyteContextState>): Promise<void>;
    set context(context: Context<DyteContextState>);
    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 DyteRecording extends DyteTypedEventEmitter<RecordingEvents> {
    recordingPeerIds: string[];
    get recordingState(): RecordingState;
    recordings: RecordingInfo[];
    constructor(context: Context<DyteContextState>, self: DyteSelf);
    get telemetry(): DyteTelemetry;
    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 DyteFeatures {
    constructor(context: Context<DyteContextState>);
    hasFeature(featureName: string): boolean;
    getFeatureValue(featureName: string): _dyteinternals_utils.DyteFlagValues;
    getAllFeatures(): {
        [x: string]: _dyteinternals_utils.DyteFlagsEntry;
    };
}

declare class DyteInternals {
    logger: DyteLogger;
    features: DyteFeatures;
    browserSpecs: BrowserCapabilities;
    callStats: InhouseCallStats;
    constructor(logger: DyteLogger, features: DyteFeatures, callStats: InhouseCallStats);
    static init(context: Context<DyteContextState>): DyteInternals;
}

type StoreData = {
    [type: string]: any;
};
declare class DyteStore {
    name: string;
    rateLimitConfig: {
        maxInvocations: number;
        period: number;
    };
    bulkRateLimitConfig: {
        maxInvocations: number;
        period: number;
    };
    private listeners;
    constructor({ name, socketHandler, meetingId }: {
        name: string;
        socketHandler: PluginSocketHandler;
        meetingId: string;
    });
    set(key: string, value: any, sync?: boolean, emit?: boolean): Promise<void>;
    private remoteSet;
    bulkSet(data: {
        key: string;
        payload: any;
    }[]): 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 DyteStoreManager {
    stores: Map<String, DyteStore>;
    constructor(context: Context<DyteContextState>, handler: PluginSocketHandler);
    create(name: string): Promise<DyteStore>;
}

declare const enum PRODUCERS_TYPE {
    WEBCAM = "webcam",
    WEBCAM_BACKUP = "webcam_backup",
    MIC = "mic",
    SCREENSHARE_VIDEO = "screenshare_video",
    SCREENSHARE_AUDIO = "screenshare_audio"
}

interface MediaPermissions {
    canProduceAudio?: MediaProductionPermissionType;
    canProduceVideo?: MediaProductionPermissionType;
    canProduceScreenshare?: MediaProductionPermissionType;
}
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<DyteContextState>;
    readonly authToken: string;
    readonly e2ee: boolean;
    get peerId(): string;
    get telemetry(): DyteTelemetry;
    get logger(): DyteLogger;
    constructor(context: Context<DyteContextState>, nodeType: MediaNodeType, options: MediaNodeClientOptions);
    get mediaJoined(): boolean;
    set mediaJoined(joined: boolean);
    reset(): void;
    joinRoom(displayName: string, roomUuid: string, forceFullReset?: boolean, rejoining?: boolean, permissions?: MediaPermissions): Promise<{
        roomJoined: boolean;
    }>;
    initializeConnection(displayName: string, roomUuid: string, rejoining?: boolean, permissions?: MediaPermissions): Promise<void>;
    getConsumers(): Map<string, Consumer>;
    leaveRoom(): Promise<void>;
    activatePeers(producers: ProducerState[]): 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): void;
    kickAll(): 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 SocketServicePayload {
    payload: any;
}
interface ConnectedMeetingParticipant {
    id?: string;
    customParticipantId?: string;
    presetId?: string;
    displayName?: string;
    displayPictureUrl?: string;
}
interface ConnectedMeeting {
    id?: string;
    title?: string;
    participants: ConnectedMeetingParticipant[];
}
declare class ConnectedMeetingsSocketHandler {
    socketService: SocketService;
    constructor(socketService: SocketService);
    handleConnectedRoomsDumpRaw({ payload }: SocketServicePayload): {
        parentMeeting: ConnectedMeeting;
        meetings: ConnectedMeeting[];
    };
    handleTransferPeerRaw({ payload }: SocketServicePayload): {
        authToken: string;
        meetingId: string;
    };
    handleMovedPeerRaw({ payload }: SocketServicePayload): {
        meetingId: string;
        customParticipantId: string;
    };
    handleConnectedRoomsUpdatedRaw({ payload }: SocketServicePayload): {
        id: string;
        title: string;
    }[];
    handleConnectedRoomsDeletedRaw({ payload }: SocketServicePayload): {
        id: string;
    }[];
    getConnectedRoomsDump(): Promise<{
        parentMeeting: ConnectedMeeting;
        meetings: ConnectedMeeting[];
    }>;
    createConnectedRooms(request: CreateRoomRequestPayload[]): Promise<{
        id: string;
        title: string;
    }[]>;
    updateConnectedRooms(request: UpdateRoomRequestPayload[]): Promise<void>;
    disableConnectedRooms(meetingIds: string[]): Promise<{
        id: string;
    }[]>;
    movePeersBetweenRooms(request: MovePeersBetweenRoomsRequest): Promise<{
        success: boolean;
        error?: undefined;
    } | {
        success: boolean;
        error: any;
    }>;
}

type ConnectedMeetingsEvents = {
    ['meetingChanged']: (meeting: DyteClient) => void;
    ['stateUpdate']: (payload: {
        meetings: ConnectedMeeting[];
        parentMeeting: ConnectedMeeting;
    }) => void;
    ['changingMeeting']: (meetingId: string) => void;
    ['*']: (eventName: string, ...args: any[]) => void;
};
declare class DyteConnectedMeetings extends DyteTypedEventEmitter<ConnectedMeetingsEvents> {
    constructor(context: Context<DyteContextState>);
    meetings: ConnectedMeeting[];
    parentMeeting: ConnectedMeeting;
    get supportsConnectedMeetings(): boolean;
    get isActive(): boolean;
    private validateConnectedMeetingsAction;
    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;
    }>;
    private moveSuccessHandler;
}

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;
        }[];
    };
    experimentalAudioPlayback?: boolean;
}
interface DefaultOptions {
    video?: boolean;
    audio?: boolean;
    recording?: RecordingConfig;
    mediaHandler?: DyteSelfMedia;
    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(context: Context<DyteContextState>);
    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 DyteError extends Error {
    code: keyof typeof ERROR_CODES;
    constructor(message: string, code?: keyof typeof ERROR_CODES, logger?: DyteLogger | undefined, log?: boolean);
}

type EventMap$1 = {
    [key: string]: (...args: any[]) => void;
};
interface TypedEventEmitter<Events extends EventMap$1> {
    addListener<E extends keyof Events>(event: E, listener: Events[E]): this;
    on<E extends keyof Events>(event: E, listener: Events[E]): this;
    onAsync<E extends keyof Events>(event: E, listener: Events[E]): this;
    once<E extends keyof Events>(event: E, listener: Events[E]): this;
    prependListener<E extends keyof Events>(event: E, listener: Events[E]): this;
    prependOnceListener<E extends keyof Events>(event: E, listener: Events[E]): this;
    off<E extends keyof Events>(event: E, listener: Events[E]): this;
    removeAllListeners<E extends keyof Events>(event?: E): this;
    removeListener<E extends keyof Events>(event: E, listener: Events[E]): this;
    emit<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): void;
    emitAsync<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): Promise<void>;
    eventNames(): (keyof Events | string | symbol)[];
    rawListeners<E extends keyof Events>(event: E): Events[E][];
    listeners<E extends keyof Events>(event: E): Events[E][];
    listenerCount<E extends keyof Events>(event: E): number;
    getMaxListeners(): number;
    setMaxListeners(maxListeners: number): this;
    reset(): void;
}

declare enum SessionEvents {
    NEW_PRODUCER = "NEW_PRODUCER",
    PRODUCER_TRACK_ENDED = "PRODUCER_TRACK_ENDED",
    ROOM_NODE_CONNECTION_ERROR = "ROOM_NODE_CONNECTION_ERROR",
    SOCKET_SERVICE_ROOM_JOINED = "SOCKET_SERVICE_ROOM_JOINED",
    SOCKET_SERVICE_RECONNECTED = "SOCKET_SERVICE_RECONNECTED",
    SOCKET_SERVICE_DISCONNECTED = "SOCKET_SERVICE_DISCONNECTED",
    SOCKET_SERVICE_FAILED = "SOCKET_SERVICE_FAILED",
    SOCKET_STATE_UPDATE = "SOCKET_STATE_UPDATE",
    ROOM_NODE_RECONNECTED = "ROOM_NODE_RECONNECTED",
    ROOM_NODE_DISCONNECTED = "ROOM_NODE_DISCONNECTED",
    ROOM_NODE_FAILED = "ROOM_NODE_FAILED",
    TRANSPORT_STATE_UPDATE = "TRANSPORT_STATE_UPDATE",
    PRODUCER_SCORE_UPDATE = "PRODUCER_SCORE_UPDATE",
    CONSUMER_SCORE_UPDATE = "CONSUMER_SCORE_UPDATE",
    PRODUCER_STATUS_UPDATE = "PRODUCER_STATUS_UPDATE",
    CONSUMER_STATUS_UPDATE = "CONSUMER_STATUS_UPDATE",
    LOW_PRODUCER_SCORE = "LOW_PRODUCER_SCORE",
    LOW_CONSUMER_SCORE = "LOW_CONSUMER_SCORE",
    MEDIA_PERMISSION_ERROR = "MEDIA_PERMISSION_ERROR",
    MEDIA_PERMISSION_UPDATE = "MEDIA_PERMISSION_UPDATE",
    WAITLISTED = "WAIT_LISTED",
    MESSAGE = "websocket/message",
    ROOM_MESSAGE = "websocket/room-message",
    PEER_JOINED_INTERNAL = "peer/joined-internal",
    PEER_CLOSED = "websocket/peer-closed",
    CONSUMER_CLOSED = "websocket/consumer-closed",
    CONSUMER_PAUSED = "websocket/consumer-paused",
    CONSUMER_RESUMED = "websocket/consumer-resumed",
    PRODUCER_CLOSED = "websocket/producer-closed",
    NEW_CONSUMER = "websocket/new-consumer",
    PRODUCER_SCORE = "websocket/producer-score",
    CONSUMER_SCORE = "websocket/consumer-score",
    PRODUCER_TOGGLE = "hive/producer-toggle",
    CONSUMER_TOGGLE = "hive/consumer-toggle",
    SELECTED_PEERS_DIFF = "hive/selected-peers-diff",
    UPDATE_ACTIVE = "media/update-active",
    RESET_PRODUCER_STATE = "hive/reset-producer-state",
    CF_TRANSPORT_STATE_CHANGED = "cf/transport-state-changed",
    CF_ROOM_REJOINING = "cf/room-rejoining",
    CF_ROOM_REJOIN_FAILED = "cf/room-rejoining-failed",
    CF_ROOM_REJOINED = "cf/room-rejoined",
    CF_TRANPSORT_RECONNECTING = "cf/transport-reconnecting",
    ROOM_STATE = "sockethub/room-state",
    PEER_DISPLAY_NAME_CHANGED = "hive/display-name-changed",
    GET_STAGE_REQUESTS = "GET_STAGE_REQUESTS",
    UPDATE_STAGE_REQUESTS = "UPDATE_STAGE_REQUESTS",
    KICK_PEER = "KICK_PEER",
    UPDATE_PEER_STAGE_STATUS = "UPDATE_PEER_STAGE_STATUS",
    JOIN_MEDIA_ROOM = "JOIN_MEDIA_ROOM",
    LEAVE_MEDIA_ROOM = "LEAVE_MEDIA_ROOM",
    PIP_HANGUP = "PIP_HANGUP",
    E2EE_ACTIVE_PRODUCER = "E2EE_ACTIVE_PRODUCER",
    E2EE_INACTIVE_PRODUCER = "E2EE_INACTIVE_PRODUCER",
    E2EE_ACTIVE_CONSUMER = "E2EE_ACTIVE_CONSUMER",
    E2EE_INACTIVE_CONSUMER = "E2EE_INACTIVE_CONSUMER",
    SOCKET_PEERS = "SOCKET_PEERS",
    UPDATE_PERMISSIONS = "UPDATE_PERMISSIONS",
    MAX_SPATIAL_LAYER_CHANGE = "MAX_SPATIAL_LAYER_CHANGE",
    MUTE_SELF = "MUTE_SELF",
    MUTE_SELF_VIDEO = "MUTE_SELF_VIDEO"
}
type AllEvents = {
    [key in SessionEvents]: (payload?: any) => void;
};
type TypedEvents = {
    [SessionEvents.UPDATE_PERMISSIONS]: (p: PresetUpdates) => void;
    [SessionEvents.MAX_SPATIAL_LAYER_CHANGE]: (p: {
        peerId: string;
        maxSpatialLayer: number;
    }) => void;
    [SessionEvents.UPDATE_ACTIVE]: (p?: {
        page?: number;
        createAllConsumers?: boolean;
    }) => void;
    [SessionEvents.PEER_JOINED_INTERNAL]: (p: DyteParticipant) => void;
    [SessionEvents.UPDATE_PEER_STAGE_STATUS]: (p: {
        id: string;
        status: string;
    }) => void;
    [SessionEvents.GET_STAGE_REQUESTS]: (stageRequests: StageRequest[]) => void;
    [SessionEvents.UPDATE_STAGE_REQUESTS]: (payload: {
        request: StageRequestPayload;
        add: boolean;
    }) => void;
    [SessionEvents.KICK_PEER]: (payload: {
        peerId: string;
    }) => void;
    [SessionEvents.JOIN_MEDIA_ROOM]: () => void;
    [SessionEvents.LEAVE_MEDIA_ROOM]: (state: LeaveRoomState) => void;
};
type UntypedEvents = Omit<AllEvents, keyof TypedEvents>;
type SessionEventsType = TypedEvents & UntypedEvents;

type ErrorCallback = (error: Error) => void;
declare class AudioPlayback {
    constructor();
    playTracks(tracks: MediaStreamTrack[]): Promise<void>;
    setSpeakerDevice(deviceId: string): void;
    removeTrack(trackId: string): void;
    play(): Promise<void>;
    onError(callback: ErrorCallback): void;
}

declare class AudioPlaybackManager extends AudioPlayback {
    constructor();
    addParticipantTrack(participantId: string, track: MediaStreamTrack): void;
    removeParticipantTrack(participantId: string): void;
}

type DyteContextState = {
    authToken?: string;
    peerId?: string;
    apiBase?: string;
    baseURI?: string;
    onError?: (error: DyteError) => 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?: DytePip;
    roomNodeOptions?: {
        sfu: MediaNodeType;
    };
    roomNodeClient?: MediaNodeClient;
    viewType?: ViewType;
    env?: ClientEnvTypeAll;
    sdkVersion?: string;
    sdkName?: 'web-core';
    callstats?: InhouseCallStats;
    connectionHandler?: ConnectionHandler;
    cachedUserDetails?: CachedUserDetails;
    peerSessionStore?: TypedEventEmitter<SessionEventsType>;
    flagsmith?: ReturnType<typeof createNewFlagsmithInstance>;
    roomSocketHandler?: RoomSocketHandler;
    connectedMeetingsSocketHandler?: ConnectedMeetingsSocketHandler;
    audioPlayback?: AudioPlaybackManager;
    options?: DyteClientOptions;
    self?: DyteSelf;
    telemetry?: DyteTelemetry;
    logger?: DyteLogger;
    meeting?: DyteClient;
    selfController?: SelfController;
};
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 telemetry(): DyteTelemetry;
    get logger(): DyteLogger;
    get peerId(): string;
    constructor(context: Context<DyteContextState>, { peerId, meetingId, authToken, capabilities, }: {
        peerId: string;
        meetingId: string;
        authToken: string;
        capabilities: SocketServiceCapabilities;
    });
    updateURL(peerID: string): void;
    private static getSocketEdgeDomain;
    get url(): string;
    connect(): Promise<void>;
    disconnect(): void;
    get isConnected(): boolean;
    sendMessage(event: number, protobuf?: Uint8Array, messageId?: string): boolean;
    sendMessagePromise(event: number, protobuf?: Uint8Array, messageId?: string, resp?: number): Promise<{
        id: string;
        payload: Uint8Array;
    }>;
    sendMessagePromiseWithTimeout({ event, timeout, protobuf, messageId, resp, }: {
        timeout: number;
        event: number;
        protobuf?: Uint8Array;
        messageId?: string;
        resp?: number;
    }): Promise<{
        id: string;
        payload: Uint8Array;
    }>;
    on(event: number, listener: (message: {
        id?: string;
        payload?: Uint8Array;
    }) => void): void;
    onStateEvent(event: SocketStateEvent, listener: (...args: any) => void): void;
    removeListener(event: number, listener: (message: {
        id?: string;
        payload?: Uint8Array;
    }) => void): void;
    removeListeners(event: number): void;
    flush(): any;
    handleSocketConnectionEvents(): void;
}

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 DyteStage extends DyteTypedEventEmitter<StageEvents> {
    get telemetry(): DyteTelemetry;
    constructor(context: Context<DyteContextState>, self: DyteSelf$1, participants: DyteParticipants, stageSocketHandler: StageSocketHandler, roomSocketHandler: RoomSocketHandler);
    get status(): StageStatus;
    private setupEvents;
    getAccessRequests(): {
        stageRequests: StageRequestPayload[];
    };
    requestAccess(): Promise<void>;
    cancelRequestAccess(): Promise<void>;
    grantAccess(userIds: string[]): Promise<void>;
    denyAccess(userIds: string[]): Promise<void>;
    get peerId(): string;
    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 DyteSelf$1 extends DyteSelfMedia {
    name: string;
    picture: string;
    customParticipantId: string;
    waitlistStatus: 'accepted' | 'waiting' | 'rejected' | 'none';
    role: any;
    userId: string;
    organizationId: string;
    supportsRemoteControl: boolean;
    device: DeviceConfig;
    get telemetry(): DyteTelemetry;
    hidden: boolean;
    get stageStatus(): StageStatus;
    get id(): string;
    get peerId(): string;
    presetName: string;
    roomState: 'init' | 'joined' | 'waitlisted' | LeaveRoomState;
    private constructor();
    static __init__(context: Context<DyteContextState>, details: UserDetailsResponse, permissions: DytePermissionsPreset, theme: DyteThemePreset, presetName: string, skipAwaits?: boolean): Promise<DyteSelf$1>;
    cleanupEvents(): void;
    private setupEvents;
    get permissions(): DytePermissionsPreset;
    get config(): DyteThemePreset;
    get roomJoined(): boolean;
    setName(name: string): void;
    setupTracks(options?: {
        video?: boolean;
        audio?: boolean;
        forceReset?: boolean;
    }): Promise<void>;
    destructMediaHandler(): Promise<void>;
    removeDocumentEventListeners(): Promise<void>;
    enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
    enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
    updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
    enableScreenShare(): Promise<void>;
    updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
    disableAudio(): Promise<void>;
    disableVideo(): Promise<void>;
    disableScreenShare(): Promise<void>;
    getAllDevices(): Promise<InputDeviceInfo[]>;
    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
    get isPinned(): boolean;
    pin(): Promise<void>;
    unpin(): Promise<void>;
    hide(): Promise<void>;
    show(): void;
    setDevice(device: MediaDeviceInfo): Promise<void>;
    cleanUpTracks(): void;
    playAudio(): Promise<void>;
    registerVideoElement(videoElem: HTMLVideoElement, isPreview?: boolean): void;
    deregisterVideoElement(videoElem?: HTMLVideoElement, isPreview?: boolean): void;
    private updateVideo;
}

interface DytePluginResponse {
    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 DytePlugin extends DyteEventEmitter<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;
    get telemetry(): DyteTelemetry;
    constructor(context: Context<DyteContextState>, { baseURL, createdAt, description, id, name, organizationId, picture, private: isPrivate, published, staggered, tags, type, updatedAt, }: DytePluginResponse, pluginSocketHandler: PluginSocketHandler, self: DyteSelf$1, participants: DyteParticipants$1, chat: Readonly<DyteChat>, meetingTitle: string);
    sendIframeEvent(message: PluginIframeMessage): void;
    private handleIframeMessage;
    sendData(payload: SendDataOptions): void;
    removePluginView(viewId?: string): void;
    addPluginView(iframe: HTMLIFrameElement | ReactNativeWebView, viewId?: string): void;
    private setActive;
    activateForSelf(): Promise<void>;
    deactivateForSelf(): void;
    enable(): Promise<void>;
    disable(): void;
    activate(): Promise<void>;
    deactivate(): Promise<void>;
}

interface IceServerInformation {
    url: string;
    username?: string;
    urls: string;
    credential?: string;
}
interface CachedUserDetails {
    peerId?: string;
    pluginInformation: DytePluginResponse[];
    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;
    protected fetchClient: FetchClient;
    protected requests: FetchClient;
    protected roomName: string;
    protected roomUUID: string;
    protected authToken: string;
    protected organizationId: string;
    protected iceServers: IceServerInformation[];
    protected pluginInformation: DytePluginResponse[];
    protected userDetails: UserDetailsResponseV2;
    protected roomDetails: RoomDetails;
    get peerId(): string;
    context: Context<DyteContextState>;
    get logger(): DyteLogger;
    constructor(context: Context<DyteContextState>, 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 Overrides {
    disableSimulcast?: boolean;
    forceRelay?: boolean;
    [key: string]: boolean | string | number;
}
interface DyteClientOptions {
    authToken: string;
    defaults?: DefaultOptions;
    modules?: Modules;
    overrides?: Overrides;
    baseURI?: string;
    onError?: (error: DyteError) => void;
    cachedUserDetails?: CachedUserDetails;
}
declare class DyteClient {
    private constructor();
    get peerId(): string;
    static initMedia(options?: {
        video?: boolean;
        audio?: boolean;
        constraints?: MediaConstraints;
    }, skipAwaits?: boolean, cachedUserDetails?: CachedUserDetails): DyteSelfMedia;
    static init(options: DyteClientOptions): Promise<DyteClient>;
    private static setupContext;
    join(): Promise<void>;
    leave(state?: LeaveRoomState): Promise<void>;
    get participants(): Readonly<DyteParticipants$1>;
    get self(): Readonly<DyteSelf$1>;
    get meta(): Readonly<DyteMeta>;
    get ai(): Readonly<DyteAi>;
    get plugins(): Readonly<DytePlugins>;
    get chat(): Readonly<DyteChat>;
    get polls(): Readonly<DytePolls>;
    get connectedMeetings(): Readonly<DyteConnectedMeetings>;
    get recording(): Readonly<DyteRecording>;
    get livestream(): Readonly<DyteLivestream>;
    get stage(): Readonly<DyteStage>;
    get stores(): Readonly<DyteStoreManager>;
    get audio(): AudioPlaybackManager;
    get __internals__(): Readonly<DyteInternals>;
    joinRoom(): Promise<void>;
    leaveRoom(state?: LeaveRoomState): Promise<void>;
}

type DyteParticipant$1 = Readonly<DyteParticipant>;

type DyteParticipants = Readonly<DyteParticipants$1>;
type DyteSelf = Readonly<DyteSelf$1>;
type DyteLogger$1 = DyteLogger;

type DyteType = {
    callStats?: unknown;
    DyteTelemetry?: typeof DyteTelemetry;
};
declare global {
    interface Navigator {
        RNLocalMediaHandlerImpl?: any;
        RNAudioSampleHandlerImpl?: any;
        RNBackgroundTimerImpl?: any;
        RNDeviceInfoImpl?: any;
        isReactNative?: boolean;
    }
    interface Window {
        Dyte?: DyteType;
        FAST_DYTE?: boolean;
        MediaStreamTrackProcessor?: any;
        MediaStreamTrackGenerator?: any;
        TransformStream?: any;
    }
}

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;
    consumer?: Partial<Consumer>;
}
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 DyteParticipant extends DyteTypedEventEmitter<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;
    get telemetry(): DyteTelemetry;
    constructor(context: Context<DyteContextState>, participant: Participant, self: DyteSelf, roomSocket: RoomSocketHandler);
    setVideoEnabled(videoEnabled: boolean, emitEvent?: boolean): void;
    setAudioEnabled(audioEnabled: boolean, emitEvent?: boolean): void;
    setScreenShareEnabled(screenShareEnabled: boolean, emitEvent?: boolean): void;
    private setupEvents;
    pin(): Promise<void>;
    unpin(): Promise<void>;
    setIsPinned(isPinned: boolean, emitEvent?: boolean): void;
    disableAudio(): Promise<void>;
    kick(): Promise<void>;
    disableVideo(): Promise<void>;
    getPermissions(): Promise<Pick<_dyteinternals_utils.Permissions, "plugins" | "polls" | "chat">>;
    setStageStatus(stageStatus: StageStatus): void;
    get isPinned(): boolean;
    registerVideoElement(videoElem: HTMLVideoElement): void;
    deregisterVideoElement(videoElem?: HTMLVideoElement): void;
    private updateVideo;
}

declare function createSafeToLogError(ex: any): {
    stack?: string;
    message?: string;
    name?: string;
    reason?: string;
    code?: number | string;
};

type SupportedEventSeverities = 'info' | 'error' | 'debug' | 'log' | 'warn';
type LogData$2 = {
    error?: ReturnType<typeof createSafeToLogError>;
    peers?: string;
    flags?: string | {
        [key: string]: {
            enabled: boolean;
            value: string | number | boolean;
        };
    };
    devices?: string | MediaDeviceInfo[];
    debuggingHint?: string;
    constraints?: string | DyteMediaStreamConstraints;
    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?: DyteClientOptions;
    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[];
    sdp?: RTCSessionDescription['sdp'];
    awaitQueueTask?: {
        id?: string | number;
        metadata?: Record<string, unknown>;
        queueSizeAtStart?: number;
        taskStartTime?: number;
        execTime?: number;
    };
};

type EventSeverities = SupportedEventSeverities;
type LogData$1 = LogData$2;
interface MeetingMetadata {
    peerId?: string;
    roomName?: string;
    organizationId?: string;
    sdkVersion?: string;
    deviceInfo?: object;
    visitedUrl?: string;
    userId?: string;
}
declare class DyteTelemetry {
    logsCache: {
        [key: string]: any;
    }[];
    logsProcessorTimer: NodeJS.Timer;
    static location: {
        country: string;
    };
    get logsEndpoint(): string;
    tracingEnabled: boolean;
    initialized: boolean;
    readonly logsProcessingInterval = 7000;
    logExclusionList: string[];
    meetingMetadata: MeetingMetadata;
    resetPeerId(peerId: string): void;
    init(context: Context<DyteContextState>, options: MeetingMetadata, enableTracing: boolean): void;
    static trace(spanName: string, metadata?: LogData$1 | undefined): (_target: Object, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
    injectContext(injectionReceiver: any): void;
    addLogInCurrentSpan(eventSeverity: EventSeverities, eventName: string, metadata?: LogData$1, noCache?: boolean): void;
    sendOtelLogsToNewRelic(logs: object[]): void;
    processCachedLogs(): void;
    destruct(): void;
}

type LogData = LogData$1;
declare class DyteLogger {
    get telemetry(): DyteTelemetry;
    init(context: Context<DyteContextState>): void;
    info(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
    error(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
    debug(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
    log(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
    warn(humanReadableLogIdentifier: string, logData?: LogData, isCrucial?: boolean): void;
}

declare class DyteEventEmitter<T extends string | symbol> extends EventEmitter$1 {
    logger: DyteLogger | undefined;
    constructor(logger: DyteLogger);
    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 DyteTypedEventEmitter<Events extends EventMap & WildCardEvent<Events>> extends EventEmitter$1 {
    logger: DyteLogger | undefined;
    constructor(logger: DyteLogger);
    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;
}

type KeyProviderOptions = {
    sharedKey: boolean;
    ratchetSalt: string;
    ratchetWindowSize: number;
};
type KeyInfo = {
    key: CryptoKey;
    participantId?: string;
    keyIndex?: number;
};
type E2EEOptions = {
    keyProvider: BaseKeyProvider;
};

declare class BaseKeyProvider extends DyteEventEmitter<KeyProviderEvents> {
    private keyInfoMap;
    private options;
    constructor(options?: Partial<KeyProviderOptions>);
    protected onSetEncryptionKey(key: CryptoKey, participantId?: string, keyIndex?: number): void;
    protected onKeyRatcheted: (material: CryptoKey, keyIndex?: number) => void;
    getKeys(): KeyInfo[];
    getOptions(): KeyProviderOptions;
    ratchetKey(participantId?: string, keyIndex?: number): void;
}
declare class SharedKeyProvider extends BaseKeyProvider {
    ratchetInterval: number | undefined;
    constructor(options?: Partial<Omit<KeyProviderOptions, 'sharedKey'>>);
    setKey(key: string): Promise<void>;
}

declare class DyteE2EEManager extends DyteEventEmitter<EncryptionEvents> {
    protected worker: Worker;
    private encryptionEnabled;
    private keyProvider;
    private peerSessionStore;
    get isEnabled(): boolean;
    static SharedKeyProvider: typeof SharedKeyProvider;
    constructor(options: E2EEOptions);
    init(logger: DyteLogger$1, peerSessionStore: any): void;
    setup(): void;
    private onWorkerMessage;
}

export { DyteE2EEManager as default };