import { Container, Module, ModuleDeclaration } from 'ditox';
import { JitsiLocalTrackEffect, JitsiVideoResolution } from 'lib-jitsi-meet';
import { Atom, Scope as Scope$0, Signal } from 'nrgy';
import { Controller, Query, Query as RxEffectsQuery } from 'rx-effects';
import { Observable } from 'rxjs';

type LogMetadata = Readonly<Record<string, string>>;
type LogFunction = (...data: unknown[]) => void;
type Logger = {
  /**
   * Returns a nested logger
   */
  getLogger: typeof getLogger;
  withMeta: (meta: LogMetadata) => Logger;
  debug: LogFunction;
  log: LogFunction;
  info: LogFunction;
  warn: LogFunction;
  error: LogFunction;
};
declare function getLogger(tag: string, meta?: LogMetadata): Logger;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
type AnyObject = Record<string, any>;
type Timestamp = number;
/** Autocomplete for string union with ability use any string
 * e.g. 'apple' | 'banana' | string
 *
 * WARNING: doesn't work as object key with empty default value
 * following code will throw type error:
 * const obj1: Record<Autocomplete<'foo' | 'bar'>, any> = {}
 */
type StringEnum<Enum extends string> = Enum | (string & Record<never, never>);
type EventLike = {
  type: string;
};
/**
 * This is a subset of  Web Storage API
 */
type KeyValueStorage = Readonly<{
  /**
   * Returns the current value associated with the given key, or null if the
   * given key does not exist in the list associated with the object.
   */
  getItem: (key: string) => string | undefined;
  /**
   * Sets the value of the pair identified by key to value, creating a new
   * key/value pair if none existed for key previously.
   *
   * Throws a "QuotaExceededError" DOMException exception if the new value
   * couldn't be set. (Setting could fail if, e.g., the user has disabled
   * storage for the site, or if the quota has been exceeded.)
   */
  setItem: (key: string, value: string) => void;
  /**
   * Removes the key/value pair with the given key from the list associated
   * with the object, if a key/value pair with the given key exists.
   */
  removeItem: (key: string) => void;
  /**
   * Empties the list associated with the object of all key/value pairs, if
   * there are any.
   */
  clear: () => void;
  getKeys: () => ReadonlyArray<string>;
}>;
type UserRole = StringEnum<'owner' | 'member' | 'viewer'>;
type ConferenceId = string;
// type AudioLevelsStore = Record<ParticipantId, number>;
// #create EndpointMessage
// Actually `AllRemoteVideoMuted`
// type AllParticipantsMuted = boolean;
// #create? AllParticipantsMutedStore
// type ViewMode = 'speaker' | 'tile';
// #create? ViewModeStore
// type ThumbnailsActive = boolean;
// #create? ThumbnailsActiveStore
type ReactionType = 'applause' | 'surprise' | 'smile' | 'like' | 'dislike';
declare const JazzRoomTokens: typeof JazzMeetingTokens;
declare const JazzMeetingTokens: typeof JazzRoomTokens;
type RoomManagerService = MeetingManagerService;
type MeetingManagerService = RoomManagerService;
type ClientManagerEvent = ClientsManagerEvent;
type ClientsManagerEvent = ClientManagerEvent;
type ClientManagerService = ClientsManagerService;
type ClientsManagerService = ClientManagerService;
/**
 * @example b2b_13ne6i_2tm8gv
 */
type RoomId = string;
type RoomSettings = Readonly<{
  title?: string;
  watermarkEnabled?: boolean;
  lobbyEnabled?: boolean;
  guestEnabled?: boolean;
  sipEnabled?: boolean;
  /*
   * @deprecated
   * в новых версиях бэкенда будет отправляться в featureFlags
   */
  jsonChatEnabled?: boolean;
  serverVideoRecordAutoStartEnabled?: boolean;
  room3dEnabled?: boolean;
  room3dScene?: string;
  summarizationEnabled?: boolean;
  // HACK: Not returned by server
  isNext?: boolean;
}>;
type EditableRoomSettings = Readonly<
  Partial<
    Pick<
      RoomSettings,
      | 'title'
      | 'watermarkEnabled'
      | 'lobbyEnabled'
      | 'sipEnabled'
      | 'serverVideoRecordAutoStartEnabled'
      | 'room3dEnabled'
      | 'room3dScene'
      | 'summarizationEnabled'
    >
  >
>;
type RoomRestrictions = Readonly<{
  asrAllowed?: boolean;
  chatAllowed?: boolean;
  denoiserAllowed?: boolean;
  editOwnNameAllowed?: boolean;
  editTitleAllowed?: boolean;
  guestAllowed?: boolean;
  inviteAllowed?: boolean;
  lobbyAllowed?: boolean;
  maxConferenceCapacity?: number;
  maxConferenceDurationSec?: number;
  maxPremiumConferences?: number;
  maxUsersForInfiniteConference?: number;
  recordScreenAllowed?: boolean;
  sipAllowed?: boolean;
  watermarkAllowed?: boolean;
  webinarAllowed?: boolean;
  maxConferenceViewersCapacity?: number;
}>;
declare const USER_PERMISSION: readonly [
  'canEditOwnName',
  'canEditRoomPolicy',
  'canEditRoomTitle',
  'canFinishCall',
  'canGrantPermission',
  'canInvite',
  'canKickUser',
  'canMuteUser',
  'canRequestPermission',
  'canSendMessage',
  'canShareAudio',
  'canShareCamera',
  'canShareMedia',
  'canViewModerators',
  'canViewAsr',
  'canManageAsr',
  'canManageWatermark',
  'canManageLobby',
  'canToggleLobby',
  'canManageDenoiser',
  'canRecordScreen',
  'canStartServerVideoRecord',
  'canStartPoll',
  'canSendReaction',
  'canManagePoll',
  'canManageSessionGroups',
  'canLeaveSessionGroups',
  'canViewMessage',
];
type UserPermissionKey = (typeof USER_PERMISSION)[number];
type UserPermissions = Readonly<Record<UserPermissionKey, boolean>>;
type PartialUserPermissions = Partial<UserPermissions>;
type RolePermissions = Readonly<Record<UserRole, PartialUserPermissions>>;
type RoomMuteMediaType = 'audio' | 'video';
type ApiAuthErrorResolution = 'retry' | 'fail';
type AuditUser = Readonly<{
  id?: string;
  name?: string;
  email?: string;
  affiliation?: string;
}>;
type EventType = {
  type: string;
  localizedType?: string;
};
type Event = {
  id: string;
  timestamp: number;
  type: EventType;
  params?: string;
  room?: {
    id: string;
  };
  user?: AuditUser;
  client?: {
    id?: string;
    type?: string;
  };
};
type ConnectionInterruptedReason =
  | 'unknown'
  | 'iceConnection'
  | 'xmppConnection'
  | 'jvbConnection';
type AuthStatus = 'anonymous' | 'authorised';
type AuthMethod = StringEnum<'token'>;
type DisplayCaptureMode = 'highQuality' | 'maxFPS';
declare const LOCAL_MEDIA_DEVICE_KIND: {
  readonly AUDIO_INPUT: 'audioInput';
  readonly AUDIO_OUTPUT: 'audioOutput';
  readonly VIDEO_INPUT: 'videoInput';
};
declare const MEDIA_PERMISSION: {
  readonly GRANTED: 'granted';
  readonly DENIED: 'denied';
  readonly PROMPT: 'prompt';
};
declare const DISPLAY_MEDIA_TYPE: {
  readonly SCREEN: 'displayScreen';
};
declare const USER_MEDIA_TYPE: {
  readonly AUDIO: 'audio';
  readonly VIDEO: 'video';
};
type MediaPermission = 'granted' | 'denied' | 'prompt';
type UserMediaType = 'audio' | 'video';
type DisplayMediaType = 'displayScreen';
type MediaType$0 = UserMediaType | DisplayMediaType;
type UserMediaPermissionState = Readonly<
  Record<UserMediaType, MediaPermission>
>;
type DisplayMediaPermissionState = Readonly<
  Record<DisplayMediaType, MediaPermission>
>;
type GroupedDevices = {
  ['audioInput']: LocalAudioInputDevice[];
  ['audioOutput']: LocalAudioOutputDevice[];
  ['videoInput']: LocalVideoInputDevice[];
};
type LocalMediaDeviceKind = 'audioInput' | 'audioOutput' | 'videoInput';
type LocalMediaDeviceId = string;
type BaseMediaDeviceInfo = {
  deviceId: LocalMediaDeviceId;
  groupId?: string;
  label: string | '';
};
type LocalAudioInputDevice = Readonly<
  {
    kind: 'audioInput';
  } & BaseMediaDeviceInfo
>;
type LocalAudioOutputDevice = Readonly<
  {
    kind: 'audioOutput';
  } & BaseMediaDeviceInfo
>;
type LocalVideoInputDevice = Readonly<
  {
    kind: 'videoInput';
  } & BaseMediaDeviceInfo
>;
type LocalMediaDevice =
  | LocalAudioInputDevice
  | LocalAudioOutputDevice
  | LocalVideoInputDevice;
type MediaPermissionErrorType =
  | 'browser' // NotAllowedError - при запрете в окне разрешить / запретить
  | 'OS' // NotFoundError - при запрете на уровне операционной системы
  | 'unknown';
type MediaPermissionErrorKind = 'audio' | 'video';
type LocalTrackEffect = JitsiLocalTrackEffect;
type JazzVideoResolution = JitsiVideoResolution;
declare class OrderDisplayTrackError extends Error {
  constructor();
}
type MediaKind = 'audio' | 'video' | 'desktop';
declare class RequiredDeviceIdError extends Error {
  kind: MediaKind;
  constructor(kind: MediaKind);
}
declare class ScreenShareUserCanceledError extends Error {
  constructor();
}
declare class NotReadableError extends Error {
  constructor();
}
declare class DisplayPermissionDeniedError extends Error {
  constructor();
}
/**
 * Provider of a state value.
 */
type Query$0<T> = RxEffectsQuery<T>;
/**
 * Function which unsubscribes from something.
 */
type Unsubscriber = () => void;
/**
 * Subscribes a listener on a value of the query and its changes.
 * @example
 * ```ts
 import {
 handleQuery,
 } from '@salutejs/jazz-sdk-web';
 
 ...
 
 const unsubscribe = handleQuery(room.participants, (participants) => {
 console.log(participants);
 });
 
 unsubscribe()
 ```
 */
declare function handleQuery<T>(
  query: Query$0<T> | Atom<T>,
  observer: (value: T) => unknown,
): Unsubscriber;
/**
 * Subscribes a listener on changes of the query only.
 *
 * @example
 * ```ts
 import {
 handleQueryChanges,
 } from '@salutejs/jazz-sdk-web';
 
 ...
 
 const unsubscribe = handleQueryChanges(room.participants, (participants) => {
 console.log(participants);
 });
 
 unsubscribe()
 ```
 
 */
declare function handleQueryChanges<T>(
  query: Query$0<T> | Atom<T>,
  listener: (value: T) => unknown,
): Unsubscriber;
/**
 * Subscribes a listener on an event bus by type.
 *
 * @example
 * ```ts
 import {
 handleEvent,
 } from '@salutejs/jazz-sdk-web';
 
 ...
 
 const unsubscribe = handleEvent(
 client.event$,
 'addRoom',
 async ({ payload }) => {
 console.log(payload.room);
 },
 );
 
 unsubscribe();
 ```
 */
declare function handleEvent<
  Event extends EventLike,
  Type extends Event['type'],
  TypedEvent extends Event & {
    type: Type;
  },
>(
  eventBus: Observable<Event> | Signal<Event>,
  type: Type,
  listener: (event: TypedEvent) => unknown,
  isOnce?: boolean,
): Unsubscriber;
/**
 * Subscribes a listener on an event bus.
 *
 * @example
 * ```ts
 import {
 handleEvents,
 } from '@salutejs/jazz-sdk-web';
 
 ...
 
 const unsubscribe = handleEvents(client.event$, (event) => {
 if (event.type === 'addRoom') {
 console.log(payload.room);
 }
 });
 
 unsubscribe()
 ```
 */
declare function handleEvents<Event extends EventLike>(
  eventBus: Observable<Event> | Signal<Event>,
  listener: (event: Event) => unknown,
  isOnce?: boolean,
): Unsubscriber;
declare class JazzRoomError<
  T extends JazzRoomErrorReason = JazzRoomErrorReason,
> extends Error {
  readonly reason: T;
  constructor(message: string, reason: T);
}
declare class AuthorizationRequiredError extends Error {
  constructor();
}
declare class RoomConnectedError extends Error {
  constructor();
}
declare class PermissionDeniedError extends Error {
  constructor(permission: string);
}
type JazzRoomEventLocalParticipantId = Readonly<{
  type: 'localParticipantId';
  payload: {
    participantId: JazzRoomParticipantId;
  };
}>;
type JazzRoomEventParticipants = Readonly<{
  type: 'participants';
  payload: {
    participants: JazzRoomParticipant[];
  };
}>;
type JazzRoomEventParticipantUpdate = Readonly<{
  type: 'participantUpdate';
  payload: {
    participant: {
      id: JazzRoomParticipantId;
    } & Partial<Omit<JazzRoomParticipant, 'id'>>;
  };
}>;
type JazzRoomEventParticipantLeft = Readonly<{
  type: 'participantLeft';
  payload: {
    participant: JazzRoomParticipant;
  };
}>;
type JazzRoomEventParticipantJoined = Readonly<{
  type: 'participantJoined';
  payload: {
    participant: JazzRoomParticipant;
  };
}>;
type JazzRoomParticipantRole = StringEnum<'owner' | 'member'>;
type JazzRoomParticipantId = string;
type JazzRoomParticipantCommon = {
  id: JazzRoomParticipantId;
  name: string;
  isGuest: boolean;
  role: JazzRoomParticipantRole;
  joinedDate: number;
  email?: string;
};
type JazzRoomParticipantBotType = string;
type JazzRoomParticipantBotDetails = {
  type: JazzRoomParticipantBotType;
};
type JazzRoomParticipantBot = JazzRoomParticipantCommon & {
  bot: JazzRoomParticipantBotDetails;
};
type JazzRoomParticipantUser = JazzRoomParticipantCommon & {
  bot?: undefined;
};
type JazzRoomParticipant = JazzRoomParticipantBot | JazzRoomParticipantUser;
type JazzRoomStatus = JazzRoomStatusMap[keyof JazzRoomStatusMap];
type JazzRoomStatusMap = {
  readonly CONNECTED: 'connected';
  readonly CONNECTING: 'connecting';
  readonly DISCONNECTING: 'disconnecting';
  readonly DISCONNECTED: 'disconnected';
  readonly ERROR: 'error';
};
type JazzRoomConnectionStatus =
  JazzRoomConnectionStatusMap[keyof JazzRoomConnectionStatusMap];
type JazzRoomConnectionStatusMap = {
  readonly CONNECTED: 'connected';
  readonly CONNECTING: 'connecting';
  readonly DISCONNECTED: 'disconnected';
  readonly FAILED: 'failed';
};
type JazzRoomReconnectingReason =
  | ConnectionInterruptedReason
  | 'errorConferenceRestarted'
  | 'suspendDetected'
  | 'network';
type JazzRoomAudioSource = 'user' | 'display';
type JazzRoomVideoSource = 'user' | 'display';
/** @deprecated please use width and height */
type JazzRoomQuality = 'high' | 'medium' | 'low';
type JazzRoomVideoQuality = Readonly<{
  /** @deprecated please use width and height */
  quality?: JazzRoomQuality;
  height: number;
  width: number;
}>;
type JazzRoomMediaSourceState = Readonly<{
  isMuted: boolean;
  stream?: MediaStream;
}>;
type JazzRoomAudioSourceState = Readonly<
  Record<JazzRoomAudioSource, JazzRoomMediaSourceState | undefined>
>;
type JazzRoomVideoSourceState = Readonly<
  Record<JazzRoomVideoSource, JazzRoomMediaSourceState | undefined>
>;
type JazzRoomVideoRequest = Readonly<
  {
    source: JazzRoomVideoSource;
  } & JazzRoomVideoQuality
>;
type JazzRoomSettings = {
  title: string;
  isGuestEnabled: boolean;
};
type JazzRoomSettingsUpdate = Partial<JazzRoomSettings>;
type JazzRoomSettingsState = {
  [key in keyof JazzRoomSettings]: JazzRoomSettings[key] | undefined;
};
type JazzRoomSettingsQueries = {
  [key in keyof JazzRoomSettingsState]: Query$0<JazzRoomSettingsState[key]>;
};
type JazzRoomUserPermissionRequest = {
  permissionKey: JazzRoomUserPermissionKey;
  created: Timestamp;
  canRequestAgain: boolean;
};
type JazzRoomUserPermissionKey = UserPermissionKey;
type JazzRoomUserPermissions = UserPermissions;
type JazzRoomPartialUserPermissions = PartialUserPermissions;
type NotAllowedError = {
  type: 'notAllowed';
};
type AccessByPermissionError = {
  type: 'accessByPermission';
};
type ExceededMaxSdkMeetingsError = {
  type: 'exceededMaxSdkMeetings';
};
type NetworkError = {
  type: 'network';
};
type OpenConnectionError = {
  type: 'openConnection';
};
type RoomNotFoundError = {
  type: 'roomNotFound';
};
type RoomNotSupportedByClientError = {
  type: 'roomNotSupportedByClientError';
};
type UnauthorizedError = {
  type: 'unauthorized';
};
type ForbiddenError = {
  type: 'forbidden';
};
type RoomCapacityExceededError$0 = {
  type: 'roomCapacityExceeded';
  payload: {
    roomCapacity?: number;
  };
};
type UnknownError = {
  type: 'unknown';
};
type JazzRoomErrorReason =
  | NotAllowedError
  | AccessByPermissionError
  | ExceededMaxSdkMeetingsError
  | NetworkError
  | OpenConnectionError
  | RoomNotFoundError
  | RoomNotSupportedByClientError
  | UnauthorizedError
  | ForbiddenError
  | RoomCapacityExceededError$0
  | UnknownError;
type JazzRoomKickedReason = StringEnum<
  | 'callEnded'
  | 'kicked'
  | 'exceededMaxConferenceCapacity'
  | 'exceededMaxConferenceViewersCapacity'
  | 'exceededMaxConferenceDuration'
>;
type JazzRoomKickedPayload = {
  reason: JazzRoomKickedReason;
};
type JazzRoomEventKicked = {
  type: 'kicked';
  payload: JazzRoomKickedPayload;
};
type JazzRoomLeaveReason = 'localEnd' | 'callEnd';
type JazzRoomEventLeave = {
  type: 'leave';
  payload: {
    reason: JazzRoomLeaveReason;
  };
};
type JazzRoomEventAddTrack = Readonly<{
  type: 'addTrack';
  payload: {
    stream: MediaStream;
    mediaType: MediaType$0;
    participantId: JazzRoomParticipantId;
    isMuted: boolean;
    isLocal: boolean;
  };
}>;
type JazzRoomEventRemoveTrack = Readonly<{
  type: 'removeTrack';
  payload: {
    stream: MediaStream;
    mediaType: MediaType$0;
    participantId: JazzRoomParticipantId;
    isMuted: boolean;
    isLocal: boolean;
  };
}>;
type JazzRoomEventTrackMuteChanged = Readonly<{
  type: 'trackMuteChanged';
  payload: {
    isMuted: boolean;
    stream: MediaStream;
    mediaType: MediaType$0;
    participantId: JazzRoomParticipantId;
    changedByParticipantId: string;
    isLocal: boolean;
  };
}>;
type JazzRoomEventTrackMuteChangeRejected = Readonly<{
  type: 'trackMuteChangeRejected';
  payload: {
    stream: MediaStream;
    mediaType: MediaType$0;
  };
}>;
type JazzRoomEventTrackUpdated = Readonly<{
  type: 'trackUpdated';
  payload: {
    stream: MediaStream;
    mediaType: MediaType$0;
    participantId: JazzRoomParticipantId;
    isMuted: boolean;
    isLocal: boolean;
  };
}>;
type JazzRoomEventRemoteTrackInfo = Readonly<{
  type: 'remoteTrackInfo';
  payload: {
    participantId: JazzRoomParticipantId;
    mediaType: MediaType$0;
    isMuted: boolean;
  };
}>;
type JazzRoomEventSettingsChanged = Readonly<{
  type: 'settingsChanged';
  payload: Partial<{
    title: string;
    isGuestEnabled: boolean;
  }>;
}>;
type JazzRoomParamsUpdate = Readonly<{
  conferenceId: JazzRoomConferenceId;
  conferencePassword: string;
  roomId: JazzRoomId;
  roomPassword: string;
  roomType: JazzRoomType;
  nodeUrl: string;
  nodeToken: string;
  domainUrl: string | undefined;
  sessionSecret: string;
}>;
type JazzRoomEventParamsChanged = Readonly<{
  type: 'paramsChanged';
  payload: JazzRoomParamsUpdate;
}>;
type JazzRoomEventLocalParticipantChanged = Readonly<{
  type: 'localParticipantChanged';
  payload: {
    participant: JazzRoomParticipant;
  };
}>;
type JazzRoomEventDominantSpeakerChanged = Readonly<{
  type: 'dominantSpeakerChanged';
  payload: {
    id: JazzRoomParticipantId;
    prevId: JazzRoomParticipantId | undefined;
  };
}>;
type JazzRoomEventDestroy = Readonly<{
  type: 'destroy';
}>;
type JazzRoomEventAccessByPermission = Readonly<{
  type: 'accessByPermission';
}>;
type JazzRoomEventStatusChanged = Readonly<{
  type: 'statusChanged';
  payload:
    | {
        status: JazzRoomStatusMap['CONNECTING'];
      }
    | {
        status: JazzRoomStatusMap['CONNECTED'];
      }
    | {
        status: JazzRoomStatusMap['DISCONNECTING'];
      }
    | {
        status: JazzRoomStatusMap['DISCONNECTED'];
      }
    | {
        status: JazzRoomStatusMap['ERROR'];
        error: JazzRoomErrorReason;
      };
}>;
type JazzRoomEventConnecting = Readonly<{
  type: 'connecting';
}>;
type JazzRoomEventConnected = Readonly<{
  type: 'connected';
  payload: {
    localParticipantId: JazzRoomParticipantId;
    roomId: JazzRoomId;
    meetingId: JazzMeetingId;
  };
}>;
type JazzRoomEventDisconnecting = Readonly<{
  type: 'disconnecting';
}>;
type JazzRoomEventDisconnected = Readonly<{
  type: 'disconnected';
}>;
type JazzRoomEventError = Readonly<{
  type: 'error';
  payload: {
    error: JazzRoomErrorReason;
  };
}>;
type JazzRoomEventConnectionChanged = Readonly<{
  type: 'connectionChanged';
  payload:
    | {
        status: JazzRoomConnectionStatusMap['FAILED'];
        reason: string;
      }
    | {
        status: JazzRoomConnectionStatusMap['CONNECTING'];
      }
    | {
        status: JazzRoomConnectionStatusMap['CONNECTED'];
      }
    | {
        status: JazzRoomConnectionStatusMap['DISCONNECTED'];
      };
}>;
type JazzRoomEventConnectionFailed = Readonly<{
  type: 'connectionFailed';
  payload: {
    reason: string;
  };
}>;
type JazzRoomEventConnectionConnecting = Readonly<{
  type: 'connectionConnecting';
}>;
type JazzRoomEventConnectionOpen = Readonly<{
  type: 'connectionOpen';
}>;
type JazzRoomEventConnectionDisconnected = Readonly<{
  type: 'connectionDisconnected';
}>;
type JazzRoomEventReconnecting = Readonly<{
  type: 'reconnecting';
  payload: {
    reason: JazzRoomReconnectingReason;
  };
}>;
type JazzRoomEventConnectionInterrupted = Readonly<{
  type: 'connectionInterrupted';
  payload: {
    reason: ConnectionInterruptedReason;
  };
}>;
type JazzRoomEventPermissionGranted = Readonly<{
  type: 'permissionGranted';
  payload: {
    permission: JazzRoomUserPermissionKey;
  };
}>;
type JazzRoomEventPermissionDenied = Readonly<{
  type: 'permissionDenied';
  payload: {
    permission: JazzRoomUserPermissionKey;
  };
}>;
type JazzRoomEventRolePermissionsChanged = Readonly<{
  type: 'rolePermissionsChanged';
  payload: {
    userRole: JazzRoomParticipantRole;
    permissions: PartialUserPermissions;
    prevPermissions: PartialUserPermissions;
  };
}>;
type JazzRoomEventPermissionRequested = Readonly<{
  type: 'permissionRequested';
  payload: {
    participantId: JazzRoomParticipantId;
    permission: JazzRoomUserPermissionKey;
  };
}>;
type JazzRoomEvent =
  | JazzRoomEventAddTrack
  | JazzRoomEventRemoveTrack
  | JazzRoomEventTrackMuteChanged
  | JazzRoomEventTrackMuteChangeRejected
  | JazzRoomEventTrackUpdated
  | JazzRoomEventRemoteTrackInfo
  | JazzRoomEventSettingsChanged
  | JazzRoomEventLocalParticipantId
  | JazzRoomEventLocalParticipantChanged
  | JazzRoomEventParticipants
  | JazzRoomEventParticipantUpdate
  | JazzRoomEventParticipantLeft
  | JazzRoomEventParticipantJoined
  | JazzRoomEventDominantSpeakerChanged
  | JazzRoomEventDestroy
  | JazzRoomEventAccessByPermission
  | JazzRoomEventParamsChanged
  | JazzRoomEventKicked
  | JazzRoomEventLeave
  | JazzRoomEventPermissionGranted
  | JazzRoomEventPermissionDenied
  | JazzRoomEventRolePermissionsChanged
  | JazzRoomEventPermissionRequested
  | JazzRoomEventStatusChanged
  | JazzRoomEventConnecting
  | JazzRoomEventConnected
  | JazzRoomEventDisconnecting
  | JazzRoomEventDisconnected
  | JazzRoomEventError
  | JazzRoomEventConnectionChanged
  | JazzRoomEventConnectionFailed
  | JazzRoomEventConnectionConnecting
  | JazzRoomEventConnectionOpen
  | JazzRoomEventConnectionDisconnected
  | JazzRoomEventReconnecting
  | JazzRoomEventConnectionInterrupted;
type JazzRoomSources = ReadonlyMap<MediaType$0, JazzRoomMediaSourceState>;
type JazzRoomConferenceId = ConferenceId;
type JazzRoomId = RoomId;
type JazzMeetingId = RoomId;
type JazzRoomType = StringEnum<'ANONYMOUS' | 'MEETING'>;
type JazzRoomParams = Readonly<{
  conferenceId: JazzRoomConferenceId;
  conferencePassword: string;
  roomId: Query$0<JazzRoomId | undefined>;
  roomPassword: Query$0<string | undefined>;
  roomType: Query$0<JazzRoomType | undefined>;
  nodeUrl: Query$0<string | undefined>;
  nodeToken: Query$0<string | undefined>;
  domainUrl: Query$0<string | undefined>;
  sessionSecret: Query$0<string | undefined>;
}>;
type JazzRoomUserPermissionRequests = ReadonlyMap<
  JazzRoomUserPermissionKey,
  JazzRoomUserPermissionRequest
>;
type JazzRoomRolePermissions = RolePermissions;
type JazzRoomPermissionRequests = ReadonlyArray<JazzRoomPermissionRequest>;
type JazzRoomPermissionRequestResolutions = ReadonlyMap<
  JazzRoomParticipantId,
  ReadonlyMap<JazzRoomUserPermissionKey, JazzRoomPermissionRequestResolution>
>;
type JazzRoomGrantedPermissions = ReadonlyMap<
  JazzRoomParticipantId,
  ReadonlySet<JazzRoomUserPermissionKey>
>;
type JazzRoom = Readonly<{
  container: Container;
  //
  // Room lifecycle
  //
  event$: Observable<JazzRoomEvent>;
  status: Query$0<JazzRoomStatus>;
  error: Query$0<JazzRoomErrorReason | undefined>;
  connectionStatus: Query$0<JazzRoomConnectionStatus>;
  params: JazzRoomParams;
  settings: JazzRoomSettingsQueries;
  ready: (
    status?: 'connected' | 'disconnecting' | 'disconnected',
  ) => Promise<void>;
  leave: (options?: { endConference: boolean }) => Promise<void>;
  //
  // Participants
  //
  localParticipant: Query$0<JazzRoomParticipant | undefined>;
  remoteParticipants: Query$0<Readonly<JazzRoomParticipant>[]>;
  participants: Query$0<Readonly<JazzRoomParticipant>[]>;
  dominantParticipantId: Query$0<JazzRoomParticipantId | undefined>;
  sources: Query$0<ReadonlyMap<JazzRoomParticipantId, JazzRoomSources>>;
  userPermissions: Query$0<JazzRoomUserPermissions>;
  userPermissionRequests: Query$0<JazzRoomUserPermissionRequests>;
  requestPermission: (permission: JazzRoomUserPermissionKey) => void;
  getParticipantSource: (
    participantId: JazzRoomParticipantId,
    mediaType: MediaType$0,
  ) => JazzRoomMediaSourceState | undefined;
  //
  // Local media streams
  //
  userAudioStream: Query$0<MediaStream | undefined>;
  userVideoStream: Query$0<MediaStream | undefined>;
  displayStream: Query$0<MediaStream | undefined>;
  setUserAudioInput: (stream: MediaStream | undefined) => void;
  setUserVideoInput: (stream: MediaStream | undefined) => void;
  setDisplayVideoInput: (stream: MediaStream | undefined) => void;
  isAudioInputMuted: Query$0<boolean>;
  muteAudioInput: (isMuted: boolean) => Promise<void>;
  isVideoInputMuted: Query$0<boolean>;
  muteVideoInput: (isMuted: boolean) => Promise<void>;
  isDisplayVideoInputMuted: Query$0<boolean>;
  muteDisplayVideoInput: (isMuted: boolean) => Promise<void>;
  displayCaptureMode: Atom<DisplayCaptureMode>;
  setDisplayCaptureMode: (mode: DisplayCaptureMode) => void;
  //
  // Remote media streams
  //
  getAudioStream: (
    participantId: JazzRoomParticipantId,
  ) => MediaStream | undefined;
  getVideoStream: (
    participantId: JazzRoomParticipantId,
    request: {
      source: JazzRoomVideoSource;
    },
  ) => MediaStream | undefined;
  getVideoStreamSourceName: (
    participantId: JazzRoomParticipantId,
    source: JazzRoomVideoSource,
  ) => string | undefined;
  // TODO: Нужно доделать
  // releaseMediaStream: (stream: MediaStream) => void;
  // releaseMediaStreams: (
  //   participant: JazzRoomParticipant,
  //   filter?: { source?: 'user' | 'display'; type?: 'audio' | 'video' },
  // ) => void;
  // releaseAllMediaStreams: () => void;
  moderator: {
    permissionRequests: Query$0<JazzRoomPermissionRequests>;
    rolePermissions: Query$0<JazzRoomRolePermissions>;
    permissionRequestResolutions: Query$0<JazzRoomPermissionRequestResolutions>;
    grantedPermissions: Query$0<JazzRoomGrantedPermissions>;
    muteUsers: (
      participantIds:
        | ReadonlyArray<JazzRoomParticipantId>
        | JazzRoomParticipantId,
      type: RoomMuteMediaType,
    ) => void;
    muteUsersAll: (type: RoomMuteMediaType) => void;
    kickUsers: (
      participantIds:
        | ReadonlyArray<JazzRoomParticipantId>
        | JazzRoomParticipantId,
    ) => void;
    kickUsersAll: () => void;
    setRolePermissions: (props: {
      role: JazzRoomParticipantRole;
      permissions: JazzRoomPartialUserPermissions;
    }) => Promise<void>;
    grantPermission: (
      participantId: JazzRoomParticipantId,
      permission: JazzRoomUserPermissionKey,
      allowed: boolean,
    ) => void;
    removeGrantedPermission: (permission: JazzRoomUserPermissionKey) => void;
    setSettings: (settingsUpdate: JazzRoomSettingsUpdate) => Promise<void>;
  };
}>;
type JazzRoomPermissionRequest = {
  participantId: JazzRoomParticipantId;
  created: Timestamp;
  permissionKey: JazzRoomUserPermissionKey;
};
type JazzRoomPermissionRequestResolution = {
  participantId: JazzRoomParticipantId;
  created: Timestamp;
  permissionKey: JazzRoomUserPermissionKey;
  resolution: boolean;
};
type RoomConnectionEvent =
  | JazzRoomEventConnectionChanged
  | JazzRoomEventConnectionFailed
  | JazzRoomEventConnectionConnecting
  | JazzRoomEventConnectionOpen
  | JazzRoomEventConnectionDisconnected
  | JazzRoomEventConnectionInterrupted
  | JazzRoomEventReconnecting
  | JazzRoomEventConnecting
  | JazzRoomEventAddRoom
  | JazzRoomEventRemoveRoom
  | JazzRoomEventError;
type JazzRoomEventAddRoom = {
  type: 'addRoom';
  payload: {
    roomConnection: JazzRoomConnection;
    room: JazzRoom;
  };
};
type JazzRoomEventRemoveRoom = {
  type: 'removeRoom';
  payload: {
    roomConnection: JazzRoomConnection;
    room: JazzRoom;
  };
};
type JazzRoomConnection = {
  roomId: JazzRoomId;
  roomPassword: string;
  connectionStatus: Query<JazzRoomConnectionStatus>;
  container: Container;
  event$: Observable<RoomConnectionEvent>;
};
type DisplayInputOptions = {
  /**
   * Create media stream from device
   */
  device?: LocalVideoInputDevice;
};
type AudioInputOptions = {
  device: LocalAudioInputDevice;
  isMuted?: boolean;
};
type VideoInputOptions = {
  device: LocalVideoInputDevice;
  isMuted?: boolean;
  resolution?: JazzVideoResolution;
  frameRate?: number;
};
type GetSelectedAudioInputOptions = {
  isMuted?: boolean;
};
type GetSelectedVideoInputOptions = {
  isMuted?: boolean;
  resolution?: JazzVideoResolution;
  frameRate?: number;
};
type MediaKind$0 = 'audio' | 'video';
declare class UserDeniedPermissionError extends Error {
  constructor(types: MediaKind$0[]);
}
declare class DevicesNotFoundError extends Error {
  kind: MediaKind$0;
  constructor(kind: MediaKind$0);
}
/**
 * Jazz SDK Plugin provides additional features.
 */
type JazzSdkPlugin<T extends Module<AnyObject> = Module<AnyObject>> = Promise<
  () => {
    key: string | undefined;
    module: JazzSdkModuleDeclaration<T>;
  }
>;
type JazzSdkModuleDeclaration<
  T extends JazzSdkModule<AnyObject> = JazzSdkModule<AnyObject>,
> = ModuleDeclaration<T>;
type JazzSdkModule<T extends AnyObject = AnyObject> = Module<T>;
type JazzSdkAdditionalPlugins = ReadonlyArray<JazzSdkPlugin>;
type EmptyObject$0 = {
  [K in string]: never;
};
type ValuesProps = AnyObject;
type JazzSdkModuleFactoryProps<
  Props extends ValuesProps | EmptyObject$0 | undefined,
  Name extends string | undefined = undefined,
> = (Props extends undefined | EmptyObject$0
  ? {
      container: Container;
      scope: Scope$0;
    }
  : {
      container: Container;
      deps: Props;
      scope: Scope$0;
    }) &
  (Name extends undefined
    ? // eslint-disable-next-line @typescript-eslint/ban-types
      {}
    : {
        name: Name;
      });
type JazzSdkModuleFactory<
  T extends Module<ValuesProps>,
  Deps extends ValuesProps | EmptyObject$0 | undefined,
  Name extends string | undefined,
> = (props: JazzSdkModuleFactoryProps<Deps, Name>) => T;
type JazzSdkEventAddClient = Readonly<{
  type: 'addClient';
  payload: {
    client: JazzClient;
  };
}>;
type JazzSdkEventRemoveClient = Readonly<{
  type: 'removeClient';
  payload: {
    client: JazzClient;
  };
}>;
type JazzSdkEventAddRoom = Readonly<{
  type: 'addRoom';
  payload: {
    client: JazzClient;
    room: JazzRoom;
  };
}>;
type JazzSdkEventRemoveRoom = Readonly<{
  type: 'removeRoom';
  payload: {
    client: JazzClient;
    room: JazzRoom;
  };
}>;
type JazzSdkEvent =
  | JazzSdkEventAddClient
  | JazzSdkEventRemoveClient
  | JazzSdkEventAddRoom
  | JazzSdkEventRemoveRoom;
/**
 * Jazz SDK provides a common runtime for Jazz Clients and Plugins
 */
type JazzSdk = Controller<{
  container: Container;
  event$: Observable<JazzSdkEvent>;
}>;
type JazzSdkOptions = Readonly<{
  /** Extensions for the SDK */
  plugins?: JazzSdkAdditionalPlugins;
  /** Custom ID to identify an application which uses the SDK. */
  userAgent?: string;
  /**
   * Custom storage for persisting data between sessions.
   * By default, a platform-specific storage is used.
   * Pass 'in-memory' value to force using an in-memory storage.
   */
  localStorage?: KeyValueStorage | 'in-memory';
  /**
   * Custom storage to persist data during a user session.
   * By default, a platform-specific storage is used.
   * Pass 'in-memory' value to force using an in-memory storage.
   */
  sessionStorage?: KeyValueStorage | 'in-memory';
  /**
   * Custom DI container for low-level SDK setup.
   */
  container?: Container;
  /**
   * Key-value flags to low-level SDK setup.
   */
  configFlags?: Readonly<Record<string, string>>;
  /**
   * Initial audio input deviceId
   */
  audioInputDeviceId?: string | undefined;
  /**
   * Initial audio output deviceId
   */
  audioOutputDeviceId?: string | undefined;
  /**
   * Initial video input deviceId
   */
  videoInputDeviceId?: string | undefined;
  /**
   * Mod of the audio input switching strategy.
   * - 'new-prefer' - automatic selection of the added device
   * - 'manual' - the device does not switch when adding a new device
   * @default 'new-prefer'
   */
  audioInputSwitchingMode?: SwitchingMode;
  /**
   * Mod of the audio output switching strategy.
   * - 'new-prefer' - automatic selection of the added device
   * - 'manual' - the device does not switch when adding a new device
   * @default 'new-prefer'
   */
  audioOutputSwitchingMode?: SwitchingMode;
  /**
   * Mod of the video input switching strategy.
   * - 'new-prefer' - automatic selection of the added device
   * - 'manual' - the device does not switch when adding a new device
   * @default 'new-prefer'
   */
  videoInputSwitchingMode?: SwitchingMode;
}>;
type SwitchingMode = 'new-prefer' | 'manual';
declare function createJazzClient(
  sdk: JazzSdk | JazzClient,
  options: JazzClientOptions,
): Promise<JazzClient>;
/**
 * Manager of conferences
 */
type JazzSdkConferenceManager = Readonly<{
  /**
   * Connects to a conference room
   */
  join: (params: { conferenceId: string; password: string }) => JazzRoom;
  /**
   * Gets details about a conference
   */
  getDetails: (
    params: JazzSdkRoomDetailsParams,
  ) => Promise<JazzSdkConferenceRoomDetails>;
  /**
   * Creates a conference for authorised users.
   *
   * Use the "guestEnabled" parameter to allow anonymous participants
   * to join the conference.
   */
  createConference: (
    params: JazzSdkCreateConferenceParams,
  ) => Promise<JazzSdkCreateConferenceResult>;
  /**
   * Updates the conference settings.
   */
  update: (params: {
    conferenceId: string;
    password: string;
    roomSettings: EditableRoomSettings;
  }) => Promise<void>;
  /**
   * Closes the conference to connect.
   */
  close: (params: { conferenceId: string; password: string }) => Promise<void>;
}>;
type JazzSdkRoomDetails = Readonly<{
  roomType: StringEnum<'MEETING'>;
  userRole: JazzRoomParticipantRole;
  roomTitle?: string;
  roomRestrictions?: JazzClientRoomRestrictions;
}>;
type JazzClientRoomRestrictions = RoomRestrictions;
type JazzSdkGetRoomDetailsError =
  | {
      type: 'notFound';
    }
  | {
      type: 'unauthorised';
    }
  | {
      type: 'unknown';
    }
  | {
      type: 'accessDenied';
    }
  | {
      type: 'httpClientError';
    }
  | {
      type: 'invalidState';
    };
type JazzSdkConferenceRoomDetails = JazzSdkRoomDetails;
type JazzSdkCreateAnonymousRoomParams = Readonly<{
  title: string;
}>;
// TODO: нужно разобраться с ошибками при создании комнаты
type JazzSdkCreateAnonymousRoomError = {
  type: 'unknown';
};
type JazzSdkCreateAnonymousRoomDetails = Readonly<{
  id: string;
  roomTitle: string;
  roomType: StringEnum<'ANONYMOUS'>;
  password: string;
  url: string;
}>;
type JazzSdkCreateAnonymousRoomResult = JazzSdkCreateAnonymousRoomDetails;
type JazzSdkCreateConferenceParams = Readonly<{
  title: string;
  isGuestEnabled?: boolean;
  isLobbyEnabled?: boolean;
  jazzNextOnly?: boolean;
  roomType?: JazzRoomType;
}>;
// TODO: нужно разобраться с ошибками при создании комнаты
type JazzSdkCreateConferenceError = {
  type: 'unknown';
};
type JazzSdkCreateConferenceDetails = Readonly<{
  id: string;
  roomTitle: string;
  roomType: StringEnum<'MEETING'>;
  password: string;
  url: string;
}>;
type JazzSdkCreateConferenceResult = JazzSdkCreateConferenceDetails;
type JazzSdkRoomDetailsParams = Readonly<{
  conferenceId: string;
  password: string;
}>;
type SdkTokenOptions = {
  /**
   * Уникальный идентификатор запроса от клиента к серверу
   * @example beaff5c1-644c-413f-ba76-a583d892b5a4
   */
  requestId?: string;
  /**
   * Время в секундах через которое истечет срок жизни токена
   * @default 120
   */
  expireIn?: number;
  /**
   * Название компании или проекта используется в логах
   * Есть ограничение в 100 символов
   */
  iss?: string;
  /**
   * Идентификатор пользователя
   */
  sub: string;
  /**
   * Имя пользователя
   */
  userName?: string;
  /**
   * Почта пользователя
   */
  userEmail?: string;
};
/**
 *
 * @param secret base64 строка
 * @param options настройки окружения
 *
 * @returns {Promise} токен доступа
 */
declare function createSdkToken(
  secret: string,
  options: SdkTokenOptions,
): Promise<{
  sdkToken: string;
}>;
type JazzSdkUserInfoAuthType = StringEnum<'SDK'>;
type JazzSdkAuthStatus = 'authorised' | 'anonymous' | 'pending';
type JazzSdkAuthMethod = AuthMethod;
type JazzSdkUserInfoAuthError =
  | 'OK'
  | 'AUTH_TYPE_MISMATCH'
  | 'TOKEN_EXPIRED'
  | 'TOKEN_INVALID'
  | 'TOKEN_MISSING';
type JazzSdkAuthEvent =
  | {
      type: 'authorised';
      payload: Readonly<{
        authMethod: AuthMethod;
        userInfo: JazzSdkUserInfo;
      }>;
    }
  | {
      type: 'loginStarted';
      payload: Readonly<{
        authMethod: AuthMethod;
      }>;
    }
  | {
      type: 'loginFailed';
      payload: Readonly<{
        authMethod: AuthMethod;
      }>;
    }
  | {
      type: 'loggedOut';
      payload: Readonly<{
        authMethod?: AuthMethod;
        authStatus: AuthStatus;
        userInfo?: JazzSdkUserInfo;
      }>;
    }
  | {
      type: 'invalidToken';
    }
  | {
      type: 'unauthorisedError';
    };
type JazzSdkUserInfoServerFeatures = Readonly<{
  maxConferenceDuration?: number;
  maxConferenceCapacity?: number;
  maxUsersForInfiniteConference?: number;
  lobbyAvailable?: boolean;
}>;
type JazzSdkUserInfo = Readonly<{
  authType?: JazzSdkUserInfoAuthType;
  authErr?: JazzSdkUserInfoAuthError;
  name?: string;
  email?: string;
  features?: JazzSdkUserInfoServerFeatures;
}>;
/**
 * Jazz SDK authorisation service
 */
type JazzSdkAuthService = Readonly<{
  /** Authorisation event bus */
  event$: Observable<JazzSdkAuthEvent>;
  /** Authorisation status */
  authStatus: Query$0<JazzSdkAuthStatus>;
  /** Authorisation method */
  authMethod: Query$0<JazzSdkAuthMethod | undefined>;
  /** Authorised user flag */
  isAuthorised: Query$0<boolean>;
  /**
   * Info about the current user.
   * Data can be retrieved for both authorised and anonymous users.
   */
  userInfo: Query$0<JazzSdkUserInfo | undefined>;
  /**
   * Authenticates by an SDK token
   *
   * @return JazzSdkUserInfo if a user is authorised
   */
  loginBySdkToken: (sdkToken: string) => Promise<JazzSdkUserInfo>;
  /**
   * Authenticates by a low-level auth-token
   *
   * @return `true` if a user is authorised
   */
  setAuthToken: (authToken: string) => Promise<boolean>;
  /** Discards a current user session */
  logout: () => Promise<void>;
}>;
declare function getJazzClient(jazzRoom: JazzRoom): JazzClient;
// TODO: experimental change from Query to Atom through an intermediate step QueryAtom
/**
 * type Query is deprecated, the name of the future reactive data is Atom
 */
type QueryAtom<T> = Atom<T> & Query<T>;
type JazzClientEventAddRoomConnection = {
  type: 'addRoomConnection';
  payload: {
    roomConnection: JazzRoomConnection;
  };
};
type JazzClientEventRemoveRoomConnection = {
  type: 'removeRoomConnection';
  payload: {
    roomConnection: JazzRoomConnection;
  };
};
type JazzClientEventAddRoom = {
  type: 'addRoom';
  payload: {
    room: JazzRoom;
  };
};
type JazzClientEventRemoveRoom = {
  type: 'removeRoom';
  payload: {
    room: JazzRoom;
  };
};
type JazzClientEventDestroy = {
  type: 'destroy';
};
type JazzClientEvent =
  | JazzClientEventAddRoom
  | JazzClientEventRemoveRoom
  | JazzClientEventDestroy
  | JazzClientEventAddRoomConnection
  | JazzClientEventRemoveRoomConnection;
/**
 * JazzClient is a client for the Jazz server
 */
type JazzClient = Readonly<{
  container: Container;
  /** Server URL which is used by the client */
  serverUrl: string;
  /** Authorization service to manage a user session */
  auth: JazzSdkAuthService;
  /** Manager of conferences */
  conferences: JazzSdkConferenceManager;
  event$: Observable<JazzClientEvent>;
  sdk: JazzSdk;
  /**
   * @deprecated
   */
  isNetworkOnline: QueryAtom<boolean>;
  destroy: () => void;
}>;
/** Options for `createJazzClient()` factory */
type JazzClientOptions = Readonly<{
  /**
   * Jazz server URL
   */
  serverUrl: string;
  /**
   * Provider for working with authorization
   */
  authProvider?: JazzSdkAuthProvider;
}>;
type JazzSdkAuthProvider = {
  /**
   * 401 error handler
   */
  handleUnauthorizedError?: (
    context: JazzSdkAuthService,
  ) => Promise<ApiAuthErrorResolution>;
  /**
   * 403 error handler
   */
  handleAuthorizationInvalidError?: (
    context: JazzSdkAuthService,
  ) => Promise<ApiAuthErrorResolution>;
};
type LocalDevicesEventAddTrack = Readonly<{
  type: 'addTrack';
  payload: {
    stream: MediaStream;
    mediaType: MediaType$0;
    isMuted: boolean;
  };
}>;
type LocalDevicesEventRemoveTrack = Readonly<{
  type: 'removeTrack';
  payload: {
    stream: MediaStream;
    mediaType: MediaType$0;
  };
}>;
type LocalDevicesEventDisposeTrack = Readonly<{
  type: 'disposeTrack';
  payload: {
    stream: MediaStream;
    mediaType: MediaType$0;
  };
}>;
type LocalDevicesEventMuteTrackChanged = Readonly<{
  type: 'muteTrackChanged';
  payload: {
    stream: MediaStream;
    mediaType: MediaType$0;
    isMuted: boolean;
  };
}>;
type LocalDevicesEventLocalTrackUpdated = Readonly<{
  type: 'localTrackUpdated';
  payload: {
    stream: MediaStream;
    mediaType: MediaType$0;
    isMuted: boolean;
  };
}>;
type LocalDevicesEventMixDisplayAudio = Readonly<{
  type: 'mixDisplayAudio';
  payload: {
    enabled: boolean;
    stream: MediaStream;
  };
}>;
type LocalDevicesEventAudioAGCChanged = Readonly<{
  type: 'audioAGCChanged';
  payload: {
    isEnabled: boolean;
  };
}>;
type LocalDevicesEventAudioInputChanged = Readonly<{
  type: 'audioInputChanged';
  payload: {
    device: LocalAudioInputDevice;
    prevDevice: LocalAudioInputDevice | undefined;
  };
}>;
type LocalDevicesEventVideoInputChanged = Readonly<{
  type: 'videoInputChanged';
  payload: {
    device: LocalVideoInputDevice;
    prevDevice: LocalVideoInputDevice | undefined;
  };
}>;
type LocalDevicesEventAudioOutputChanged = Readonly<{
  type: 'audioOutputChanged';
  payload: {
    device: LocalAudioOutputDevice;
    prevDevice: LocalAudioOutputDevice | undefined;
  };
}>;
type LocalDevicesEventMediaDevicesChanged = Readonly<{
  type: 'mediaDevicesChanged';
  payload: {
    devices: ReadonlyArray<LocalMediaDevice>;
    groupedDevices: GroupedDevices;
    added: ReadonlyArray<LocalMediaDevice>;
    removed: ReadonlyArray<LocalMediaDevice>;
    groupedAddedDevices: GroupedDevices;
    groupedRemovedDevices: GroupedDevices;
  };
}>;
type LocalDevicesEventPermissionsChanged = Readonly<{
  type: 'permissionsChanged';
  payload: UserMediaPermissionState;
}>;
type LocalDevicesEventErrorDevicePermissions = Readonly<{
  type: 'errorDevicePermissions';
  payload: {
    type: MediaPermissionErrorType;
    kind: MediaPermissionErrorKind[];
    message: string;
  };
}>;
type LocalDevicesEventRequestDevicePermissions = {
  type: 'requestDevicePermissions';
  payload: {
    mediaTypes: UserMediaType[];
  };
};
type LocalDevicesEventSuccessDevicePermissions = {
  type: 'successDevicePermissions';
  payload: {
    mediaTypes: UserMediaType[];
    state: UserMediaPermissionState;
  };
};
type LocalDevicesEvent =
  | LocalDevicesEventAddTrack
  | LocalDevicesEventRemoveTrack
  | LocalDevicesEventDisposeTrack
  | LocalDevicesEventMuteTrackChanged
  | LocalDevicesEventLocalTrackUpdated
  | LocalDevicesEventMixDisplayAudio
  | LocalDevicesEventAudioAGCChanged
  | LocalDevicesEventAudioAGCChanged
  | LocalDevicesEventAudioInputChanged
  | LocalDevicesEventVideoInputChanged
  | LocalDevicesEventAudioOutputChanged
  | LocalDevicesEventMediaDevicesChanged
  | LocalDevicesEventPermissionsChanged
  | LocalDevicesEventErrorDevicePermissions
  | LocalDevicesEventRequestDevicePermissions
  | LocalDevicesEventSuccessDevicePermissions;
type LocalDevicesMediaStreamState = {
  isMuted: Query<boolean>;
  mute: (isMuted: boolean) => Promise<void>;
  deviceId: string;
};
/**
 * Managed of local media devices.
 */
type LocalDevicesManager = {
  /** Local device event bus */
  event$: Observable<LocalDevicesEvent>;
  /** Checking support for display media */
  // supportsGetDisplayMedia: () => boolean;
  //
  // Permissions
  //
  /** Permissions for user media devices */
  userMediaPermissions: Query<UserMediaPermissionState>;
  /** Permissions for display media devices */
  // displayMediaPermissions: Query<DisplayMediaPermissionState>;
  /** Request a permission to use user media devices */
  requestUserMediaPermissions: (
    ...types: UserMediaType[]
  ) => Promise<UserMediaPermissionState>;
  /** Request a permission to use display media devices */
  // requestDisplayMediaPermissions: (
  //   ...types: DisplayMediaType[]
  // ) => Promise<DisplayMediaPermissionState>;
  //
  // Devices
  //
  // Queries
  /** Available audio inputs */
  audioInputDevices: Query<ReadonlyArray<LocalAudioInputDevice>>;
  /** Available audio outputs */
  audioOutputDevices: Query<ReadonlyArray<LocalAudioOutputDevice>>;
  /** Available video inputs */
  videoInputDevices: Query<ReadonlyArray<LocalVideoInputDevice>>;
  /** Current audio input for general use in conferences. */
  audioInput: Query<LocalAudioInputDevice | undefined>;
  /** Current audio output for general use in conferences. */
  audioOutput: Query<LocalAudioOutputDevice | undefined>;
  /** Current video input for general use in conferences. */
  videoInput: Query<LocalVideoInputDevice | undefined>;
  // Methods
  /** Selects the current audio input.
   *
   * @example
   * ```ts
   *  try {
   *   selectAudioInput(device)
   *  } catch(e) {
   *   if (e instanceof UserDeniedPermissionError) {
   *
   *   }
   *   if (e instanceof DevicesNotFoundError) {
   *
   *   }
   *  }
   * ```
   */
  selectAudioInput: (device: LocalAudioInputDevice) => Promise<void>;
  /** Selects the current audio output.
   *
   * @example
   * ```ts
   *  try {
   *   selectAudioOutput(device)
   *  } catch(e) {
   *   if (e instanceof DevicesNotFoundError) {
   *
   *   }
   *  }
   * ```
   */
  selectAudioOutput: (device: LocalAudioOutputDevice) => Promise<void>;
  /** Selects the current video input.
   *
   * @example
   * ```ts
   *  try {
   *   selectVideoInput(device)
   *  } catch(e) {
   *   if (e instanceof UserDeniedPermissionError) {
   *
   *   }
   *   if (e instanceof DevicesNotFoundError) {
   *
   *   }
   *  }
   * ```
   */
  selectVideoInput: (device: LocalVideoInputDevice) => Promise<void>;
  /** Mute and unmute the current audio input. */
  muteAllAudioInput: (isMuted: boolean) => Promise<void>;
  /** Mute and unmute the current video input. */
  muteAllVideoInput: (isMuted: boolean) => Promise<void>;
  /** Mute and unmute the current audio input. */
  muteAudioInput: (stream: MediaStream, isMuted: boolean) => Promise<void>;
  /** Mute and unmute the current video input. */
  muteVideoInput: (stream: MediaStream, isMuted: boolean) => Promise<void>;
  //
  // Media streams
  //
  /**
   * Returns MediaStream which represents a current audio input.
   *
   * If the current audio input is changed the MediaStream remains the same,
   * only its tracks are replaced.
   *
   * @default options.isMuted = true
   */
  getSelectedAudioInputStream: (
    options?: GetSelectedAudioInputOptions,
  ) => Promise<MediaStream>;
  /**
   * Returns MediaStream which represents a current video input.
   *
   * If the current video input is changed the MediaStream remains the same,
   * only its tracks are replaced.
   *
   * @default options.isMuted = true
   */
  getSelectedVideoInputStream: (
    options?: GetSelectedVideoInputOptions,
  ) => Promise<MediaStream>;
  /**
   * Returns MediaStream of a provided local audio input.
   */
  getAudioInputStream: (options: AudioInputOptions) => Promise<MediaStream>;
  /**
   * Returns MediaStream of a provided local video input.
   */
  getVideoInputStream: (options: VideoInputOptions) => Promise<MediaStream>;
  /**
   * Returns audio and video streams of a local display media if they are available.
   */
  getDisplayInputStream: (
    options?: DisplayInputOptions,
  ) => Promise<MediaStream>;
  /**
   * Releasing an unused media stream.
   */
  releaseMediaStream: (stream: MediaStream) => Promise<void>;
  getMediaStreamManager: (stream: MediaStream) => {
    $isMuted: Query<boolean>;
    mute: (isMuted: boolean) => Promise<void>;
  };
  getMediaStreamState: (stream: MediaStream) => LocalDevicesMediaStreamState;
  isEnableAudioAGC: Query<boolean>;
  setAudioAGC: (enabled: boolean) => void;
  audioInputSwitchingMode: Query<SwitchingMode>;
  setAudioInputSwitchingMode: (mode: SwitchingMode) => void;
  videoInputSwitchingMode: Query<SwitchingMode>;
  setVideoInputSwitchingMode: (mode: SwitchingMode) => void;
  audioOutputSwitchingMode: Query<SwitchingMode>;
  setAudioOutputSwitchingMode: (mode: SwitchingMode) => void;
  setEffect: (
    stream: MediaStream,
    effect: LocalTrackEffect | undefined,
  ) => Promise<void>;
};
type LocalDeviceManagerService = {
  localDevices: LocalDevicesManager;
};
type LocalDeviceManagerPlugin = {
  localDeviceManager: LocalDeviceManagerService;
};
declare function localDeviceManagerPlugin(): JazzSdkPlugin<LocalDeviceManagerPlugin>;
/**
 * Returns the instance of LocalDeviceManager.
 */
declare function getLocalDevices(
  sdk: JazzSdk | JazzRoom | JazzClient,
): LocalDevicesManager;
type DisplayEndpointsManager = {
  getDisplayEndpointsManager: (room: JazzRoom) => DisplayEndpointsService;
  releaseDisplayEndpoints: (room: JazzRoom) => void;
};
type RegisterId = symbol;
type Unsubscribe$0 = () => void;
type RegisterInfo = Readonly<{
  id: RegisterId;
  unregister: Unsubscribe$0;
}>;
type DisplayEndpointsService = Readonly<{
  registerUsage: (
    participantId: JazzRoomParticipantId,
    request: JazzRoomVideoRequest,
  ) => RegisterInfo;
  /** @deprecated please use setUsageSize */
  setUsageHeight: (
    participantId: JazzRoomParticipantId,
    source: JazzRoomVideoSource,
    id: RegisterId,
    height: number,
  ) => void;
  /** @deprecated please use setUsageSize */
  setUsageQuality: (
    participantId: JazzRoomParticipantId,
    source: JazzRoomVideoSource,
    id: RegisterId,
    quality: JazzRoomVideoQuality,
  ) => void;
  setUsageSize: (
    participantId: JazzRoomParticipantId,
    source: JazzRoomVideoSource,
    id: RegisterId,
    width: number,
    height: number,
  ) => void;
  clearUsage: (participantId: JazzRoomParticipantId) => void;
}>;
declare function getDisplayEndpoints(room: JazzRoom): DisplayEndpointsService;
type DisplayEndpointsPlugin = {
  displayEndpointsManager: DisplayEndpointsManager;
};
declare function displayEndpointsPlugin(): JazzSdkPlugin<DisplayEndpointsPlugin>;
type JazzLobbyStatus =
  (typeof JAZZ_LOBBY_STATUS)[keyof typeof JAZZ_LOBBY_STATUS];
type JazzLobbyStatusMap = typeof JAZZ_LOBBY_STATUS;
declare const JAZZ_LOBBY_STATUS: {
  readonly CONNECTED: 'connected';
  readonly CONNECTING: 'connecting';
  readonly DISCONNECTING: 'disconnecting';
  readonly DISCONNECTED: 'disconnected';
  readonly ERROR: 'error';
};
type AccessDeniedError = {
  type: 'accessDenied';
};
type JazzLobbyErrorReason = AccessDeniedError | UnknownError | NotAllowedError;
type JazzLobbyEventParticipantJoined = {
  type: 'participantJoined';
  payload: {
    participant: JazzLobbyParticipant;
  };
};
type JazzLobbyEventParticipantLeft = {
  type: 'participantLeft';
  payload: {
    participant: JazzLobbyParticipant;
  };
};
type JazzLobbyEventAccessDenied = {
  type: 'accessDenied';
};
type JazzLobbyEventAccessGranted = {
  type: 'accessGranted';
};
type JazzLobbyEventConnecting = {
  type: 'connecting';
};
type JazzLobbyEventConnected = {
  type: 'connected';
};
type JazzLobbyEventDisconnecting = {
  type: 'disconnecting';
};
type JazzLobbyEventDisconnected = {
  type: 'disconnected';
};
type JazzLobbyEventError = {
  type: 'error';
  payload: {
    error: JazzLobbyErrorReason;
  };
};
type JazzLobbyEventSettingsChanged = {
  type: 'settingsChanged';
  payload: JazzLobbySettingsUpdate;
};
type JazzLobbyEventStatusChanged = {
  type: 'statusChanged';
  payload:
    | {
        status: JazzLobbyStatusMap['CONNECTING'];
      }
    | {
        status: JazzLobbyStatusMap['CONNECTED'];
      }
    | {
        status: JazzLobbyStatusMap['DISCONNECTING'];
      }
    | {
        status: JazzLobbyStatusMap['DISCONNECTED'];
      }
    | {
        status: JazzLobbyStatusMap['ERROR'];
        error: JazzLobbyErrorReason;
      };
};
type JazzLobbyEvent =
  | JazzLobbyEventParticipantJoined
  | JazzLobbyEventParticipantLeft
  | JazzLobbyEventAccessDenied
  | JazzLobbyEventAccessGranted
  | JazzLobbyEventConnecting
  | JazzLobbyEventConnected
  | JazzLobbyEventDisconnecting
  | JazzLobbyEventDisconnected
  | JazzLobbyEventError
  | JazzLobbyEventStatusChanged
  | JazzLobbyEventSettingsChanged;
type JazzLobbyParticipantId = string;
type JazzLobbyParticipant = Readonly<{
  id: JazzLobbyParticipantId;
  userName: string;
}>;
type JazzLobbyModerator = Readonly<{
  denyAccess: (
    participantIds:
      | ReadonlyArray<JazzLobbyParticipantId>
      | JazzLobbyParticipantId,
  ) => void;
  denyAccessAll: () => void;
  approveAccess: (
    participantIds:
      | ReadonlyArray<JazzLobbyParticipantId>
      | JazzLobbyParticipantId,
  ) => void;
  approveAccessAll: () => void;
  kickUsers: (
    participantIds:
      | ReadonlyArray<JazzLobbyParticipantId>
      | JazzLobbyParticipantId,
  ) => void;
  kickUsersAll: () => void;
  setSettings: (settings: JazzLobbySettingsUpdate) => Promise<void>;
}>;
type JazzLobby = Readonly<{
  settings: JazzLobbySettingsQueries;
  status: Query<JazzLobbyStatus>;
  ready: (
    status?: 'connected' | 'disconnecting' | 'disconnected',
  ) => Promise<void>;
  error: Query<JazzLobbyErrorReason | undefined>;
  participants: Query<ReadonlyArray<JazzLobbyParticipant>>;
  event$: Observable<JazzLobbyEvent>;
  moderator: JazzLobbyModerator;
  hasModerator: Query<boolean>;
}>;
type JazzLobbySettings = {
  isLobbyEnabled: boolean;
};
type JazzLobbySettingsState = {
  [key in keyof JazzLobbySettings]: JazzLobbySettings[key] | undefined;
};
type JazzLobbySettingsQueries = {
  [key in keyof JazzLobbySettingsState]: Query<JazzLobbySettingsState[key]>;
};
type JazzLobbySettingsUpdate = Partial<JazzLobbySettings>;
declare function lobbyPlugin(): JazzSdkPlugin;
declare const getLobby: (jazzRoom: JazzRoom) => JazzLobby;
declare class JazzLobbyError<
  T extends JazzLobbyErrorReason = JazzLobbyErrorReason,
> extends Error {
  readonly reason: T;
  constructor(message: string, reason: T);
}
declare function activityPlugin(): JazzSdkPlugin;
type DefaultReactionType = ReactionType;
type JazzReactionType = DefaultReactionType;
type JazzParticipantReaction = Readonly<{
  timestamp: Timestamp;
  participantId: JazzRoomParticipantId;
  reaction: JazzReactionType;
}>;
type JazzActivityEventRaiseHand = Readonly<{
  type: 'raiseHand';
  payload: {
    participantId: JazzRoomParticipantId;
  };
}>;
type JazzActivityEventReleaseHand = Readonly<{
  type: 'releaseHand';
  payload: {
    participantId: JazzRoomParticipantId;
  };
}>;
type JazzActivityEventReaction = Readonly<{
  type: 'reaction';
  payload: JazzParticipantReaction;
}>;
type JazzActivityEvent =
  | JazzActivityEventRaiseHand
  | JazzActivityEventReleaseHand
  | JazzActivityEventReaction;
type JazzActivity = {
  handsRaised: Atom<ReadonlySet<JazzRoomParticipantId>>;
  getHandRaised: (participantId: JazzRoomParticipantId) => Atom<boolean>;
  raiseHand: (isRaised: boolean) => void;
  setReaction: (reaction: JazzReactionType) => void;
  event$: Observable<JazzActivityEvent>;
};
declare function getActivity(room: JazzRoom): JazzActivity;
declare const SDK_VERSION: string;
/**
 * Creates Jazz SDK for web applications.
 */
declare function createJazzSdk(options: JazzSdkOptions): Promise<JazzSdk>;
/**
 * Creates Jazz SDK for web applications.
 *
 */
declare function createJazzSdkWeb(options?: JazzSdkOptions): Promise<JazzSdk>;
/**
 * Creates Jazz SDK for web applications.
 * @description use createJazzSdkWeb
 */
declare const createJazzWebSdk: typeof createJazzSdkWeb;
export {
  createJazzWebSdk,
  createJazzSdkWeb,
  handleEvent,
  handleQuery,
  handleQueryChanges,
  handleEvents,
  SDK_VERSION,
  createSdkToken,
  createJazzSdk,
  USER_MEDIA_TYPE,
  DISPLAY_MEDIA_TYPE,
  LOCAL_MEDIA_DEVICE_KIND,
  MEDIA_PERMISSION,
  createJazzClient,
  AuthorizationRequiredError,
  RoomConnectedError,
  JazzRoomError,
  PermissionDeniedError,
  getJazzClient,
  localDeviceManagerPlugin,
  getLocalDevices,
  displayEndpointsPlugin,
  getDisplayEndpoints,
  lobbyPlugin,
  getLobby,
  JazzLobbyError,
  JAZZ_LOBBY_STATUS,
  getActivity,
  activityPlugin,
  OrderDisplayTrackError,
  RequiredDeviceIdError,
  ScreenShareUserCanceledError,
  NotReadableError,
  DisplayPermissionDeniedError,
  UserDeniedPermissionError,
  DevicesNotFoundError,
};
export type {
  Query$0 as Query,
  Unsubscriber,
  JazzSdk,
  JazzSdkEvent,
  JazzSdkOptions,
  JazzSdkPlugin,
  JazzSdkAdditionalPlugins,
  JazzSdkModuleDeclaration,
  JazzSdkModuleFactoryProps,
  JazzSdkModule,
  JazzSdkModuleFactory,
  DisplayMediaPermissionState,
  DisplayMediaType,
  LocalAudioInputDevice,
  LocalAudioOutputDevice,
  LocalMediaDeviceId,
  LocalMediaDevice,
  LocalMediaDeviceKind,
  LocalVideoInputDevice,
  MediaPermission,
  UserMediaPermissionState,
  UserMediaType,
  MediaType$0 as MediaType,
  MediaPermissionErrorKind,
  MediaPermissionErrorType,
  JazzClient,
  JazzClientOptions,
  JazzClientEvent,
  JazzClientEventAddRoom,
  JazzClientEventDestroy,
  JazzClientEventRemoveRoom,
  JazzSdkAuthEvent,
  JazzSdkAuthService,
  JazzSdkUserInfo,
  JazzSdkUserInfoAuthError,
  JazzSdkUserInfoAuthType,
  JazzSdkUserInfoServerFeatures,
  JazzSdkConferenceManager,
  JazzSdkConferenceRoomDetails,
  JazzSdkCreateAnonymousRoomDetails,
  JazzSdkCreateAnonymousRoomError,
  JazzSdkCreateAnonymousRoomParams,
  JazzSdkCreateAnonymousRoomResult,
  JazzSdkCreateConferenceDetails,
  JazzSdkCreateConferenceError,
  JazzSdkCreateConferenceParams,
  JazzSdkCreateConferenceResult,
  JazzSdkGetRoomDetailsError,
  JazzSdkRoomDetails,
  JazzSdkRoomDetailsParams,
  JazzClientRoomRestrictions,
  AccessByPermissionError,
  ExceededMaxSdkMeetingsError,
  RoomNotFoundError,
  RoomNotSupportedByClientError,
  JazzRoom,
  JazzRoomAudioSource,
  JazzRoomAudioSourceState,
  JazzRoomConferenceId,
  JazzRoomReconnectingReason,
  JazzRoomConnectionStatus,
  JazzRoomErrorReason,
  JazzRoomEvent,
  JazzRoomEventAccessByPermission,
  JazzRoomEventAddTrack,
  JazzRoomEventConnected,
  JazzRoomEventConnecting,
  JazzRoomEventConnectionChanged,
  JazzRoomEventConnectionConnecting,
  JazzRoomEventConnectionDisconnected,
  JazzRoomEventConnectionFailed,
  JazzRoomEventReconnecting,
  JazzRoomEventConnectionOpen,
  JazzRoomEventDestroy,
  JazzRoomEventDisconnected,
  JazzRoomEventDisconnecting,
  JazzRoomEventDominantSpeakerChanged,
  JazzRoomEventError,
  JazzRoomEventLocalParticipantChanged,
  JazzRoomEventTrackUpdated,
  JazzRoomEventRemoveTrack,
  JazzRoomEventSettingsChanged,
  JazzRoomEventStatusChanged,
  JazzRoomEventTrackMuteChanged,
  JazzRoomEventTrackMuteChangeRejected,
  JazzRoomEventParamsChanged,
  JazzRoomEventKicked,
  JazzRoomEventLeave,
  JazzRoomLeaveReason,
  JazzRoomId,
  JazzRoomMediaSourceState,
  JazzRoomParams,
  JazzRoomPartialUserPermissions,
  JazzRoomPermissionRequest,
  JazzRoomPermissionRequestResolution,
  JazzRoomQuality,
  JazzRoomSettingsQueries,
  JazzRoomSettingsUpdate,
  JazzRoomSettings,
  JazzRoomSources,
  JazzRoomStatus,
  JazzRoomStatusMap,
  JazzRoomType,
  JazzRoomUserPermissionKey,
  JazzRoomUserPermissionRequest,
  JazzRoomUserPermissions,
  JazzRoomVideoQuality,
  JazzRoomVideoRequest,
  JazzRoomVideoSource,
  JazzRoomVideoSourceState,
  JazzRoomParamsUpdate,
  NetworkError,
  NotAllowedError,
  OpenConnectionError,
  UnknownError,
  JazzRoomUserPermissionRequests,
  JazzRoomRolePermissions,
  JazzRoomPermissionRequests,
  JazzRoomPermissionRequestResolutions,
  JazzRoomGrantedPermissions,
  JazzRoomEventPermissionGranted,
  JazzRoomEventPermissionDenied,
  JazzRoomEventRolePermissionsChanged,
  JazzRoomEventPermissionRequested,
  JazzRoomParticipant,
  JazzRoomParticipantId,
  JazzRoomParticipantRole,
  JazzRoomEventParticipantJoined,
  JazzRoomEventParticipantLeft,
  JazzRoomEventParticipants,
  JazzRoomEventParticipantUpdate,
  DisplayCaptureMode,
  LocalDevicesEvent,
  LocalDevicesManager,
  LocalDevicesEventAddTrack,
  LocalDevicesEventAudioAGCChanged,
  LocalDevicesEventAudioInputChanged,
  LocalDevicesEventAudioOutputChanged,
  LocalDevicesEventDisposeTrack,
  LocalDevicesEventLocalTrackUpdated,
  LocalDevicesEventMediaDevicesChanged,
  LocalDevicesEventMuteTrackChanged,
  LocalDevicesEventPermissionsChanged,
  LocalDevicesEventRemoveTrack,
  LocalDevicesEventVideoInputChanged,
  LocalDevicesEventErrorDevicePermissions,
  LocalDevicesEventRequestDevicePermissions,
  LocalDevicesEventSuccessDevicePermissions,
  DisplayEndpointsService,
  DisplayEndpointsManager,
  RegisterId,
  JazzLobby,
  JazzLobbyEvent,
  JazzLobbyEventParticipantJoined,
  JazzLobbyEventParticipantLeft,
  JazzLobbyEventAccessDenied,
  JazzLobbyEventAccessGranted,
  JazzLobbyEventConnected,
  JazzLobbyEventConnecting,
  JazzLobbyEventDisconnected,
  JazzLobbyEventDisconnecting,
  JazzLobbyEventError,
  JazzLobbyEventStatusChanged,
  JazzLobbyEventSettingsChanged,
  JazzLobbyStatusMap,
  JazzLobbyParticipant,
  JazzLobbyParticipantId,
  JazzLobbyStatus,
  AccessDeniedError,
  JazzLobbyErrorReason,
  JazzLobbyModerator,
  JazzLobbySettingsUpdate,
  JazzLobbySettings,
  JazzLobbySettingsQueries,
  JazzActivity,
  JazzActivityEvent,
  JazzActivityEventRaiseHand,
  JazzActivityEventReaction,
  JazzActivityEventReleaseHand,
  JazzParticipantReaction,
  JazzReactionType,
  LocalTrackEffect,
  QueryAtom,
  AudioInputOptions,
  DisplayInputOptions,
  GetSelectedAudioInputOptions,
  GetSelectedVideoInputOptions,
  VideoInputOptions,
};