@100mslive/hms-video-store 0.2.82 → 0.2.83

package/src/core/hmsSDKStore/adapter.ts

@@ -1,244 +0,0 @@
-import {
-  HMSLocalAudioTrack as SDKHMSLocalAudioTrack,
-  HMSLocalVideoTrack as SDKHMSLocalVideoTrack,
-  HMSRemoteAudioTrack as SDKHMSRemoteAudioTrack,
-  HMSRemoteVideoTrack as SDKHMSRemoteVideoTrack,
-  HMSRoleChangeRequest as SDKHMSRoleChangeRequest,
-  HMSTrack as SDKHMSTrack,
-} from '@100mslive/hms-video';
-import {
-  HMSDeviceChangeEvent,
-  HMSException,
-  HMSMessage,
-  HMSPeer,
-  HMSPeerID,
-  HMSPlaylistItem,
-  HMSPlaylistType,
-  HMSRole,
-  HMSRoleChangeStoreRequest,
-  HMSRoleName,
-  HMSRoom,
-  HMSTrack,
-} from '../schema';
-
-import * as sdkTypes from './sdkTypes';
-import { areArraysEqual } from './sdkUtils/storeMergeUtils';
-
-export class SDKToHMS {
-  static convertPeer(sdkPeer: sdkTypes.HMSPeer): Partial<HMSPeer> & Pick<HMSPeer, 'id'> {
-    return {
-      id: sdkPeer.peerId,
-      name: sdkPeer.name,
-      roleName: sdkPeer.role?.name,
-      isLocal: sdkPeer.isLocal,
-      videoTrack: sdkPeer.videoTrack?.trackId,
-      audioTrack: sdkPeer.audioTrack?.trackId,
-      auxiliaryTracks: sdkPeer.auxiliaryTracks.map(track => track.trackId),
-      customerUserId: sdkPeer.customerUserId,
-      customerDescription: sdkPeer.metadata,
-      metadata: sdkPeer.metadata,
-    };
-  }
-
-  static convertTrack(sdkTrack: SDKHMSTrack, peerId?: HMSPeerID): HMSTrack {
-    const track: HMSTrack = {
-      id: sdkTrack.trackId,
-      source: sdkTrack.source,
-      type: sdkTrack.type,
-      enabled: sdkTrack.enabled,
-      displayEnabled: sdkTrack.enabled,
-      peerId: sdkTrack.peerId || peerId,
-    };
-    this.enrichTrack(track, sdkTrack);
-    return track;
-  }
-
-  static enrichTrack(track: HMSTrack, sdkTrack: SDKHMSTrack) {
-    const mediaSettings = sdkTrack.getMediaTrackSettings();
-    if (track.source === 'screen' && track.type === 'video') {
-      // @ts-ignore
-      track.displaySurface = mediaSettings.displaySurface;
-    }
-    track.height = mediaSettings.height;
-    track.width = mediaSettings.width;
-    if (sdkTrack instanceof SDKHMSRemoteAudioTrack) {
-      track.volume = sdkTrack.getVolume() || 0;
-    }
-    SDKToHMS.updateDeviceID(track, sdkTrack);
-    SDKToHMS.enrichVideoTrack(track, sdkTrack);
-    SDKToHMS.enrichPluginsDetails(track, sdkTrack);
-  }
-
-  static updateDeviceID(track: HMSTrack, sdkTrack: SDKHMSTrack) {
-    if (sdkTrack instanceof SDKHMSLocalVideoTrack || sdkTrack instanceof SDKHMSLocalAudioTrack) {
-      track.deviceID = sdkTrack.settings.deviceId;
-    } else {
-      track.deviceID = sdkTrack.getMediaTrackSettings()?.deviceId;
-    }
-  }
-
-  static enrichVideoTrack(track: HMSTrack, sdkTrack: SDKHMSTrack) {
-    if (sdkTrack instanceof SDKHMSRemoteVideoTrack) {
-      track.layer = sdkTrack.getSimulcastLayer();
-      track.degraded = sdkTrack.degraded;
-      if (!areArraysEqual(sdkTrack.getSimulcastDefinitions(), track.layerDefinitions)) {
-        track.layerDefinitions = sdkTrack.getSimulcastDefinitions();
-      }
-    }
-  }
-
-  static enrichPluginsDetails(track: HMSTrack, sdkTrack: SDKHMSTrack) {
-    if (sdkTrack instanceof SDKHMSLocalVideoTrack || sdkTrack instanceof SDKHMSLocalAudioTrack) {
-      if (!areArraysEqual(sdkTrack.getPlugins(), track.plugins)) {
-        track.plugins = sdkTrack.getPlugins();
-      }
-    }
-  }
-
-  static convertRoom(sdkRoom: sdkTypes.HMSRoom): Partial<HMSRoom> {
-    return {
-      id: sdkRoom.id,
-      name: sdkRoom.name,
-      localPeer: sdkRoom.localPeer?.peerId ?? '',
-      hasWaitingRoom: sdkRoom.hasWaitingRoom,
-      shareableLink: sdkRoom.shareableLink,
-      recording: {
-        browser: {
-          running: !!sdkRoom.recording?.browser.running,
-        },
-        server: { running: !!sdkRoom.recording?.server.running },
-      },
-      rtmp: { running: !!sdkRoom.rtmp?.running },
-    };
-  }
-
-  static convertMessage(
-    sdkMessage: sdkTypes.HMSMessage,
-  ): Partial<HMSMessage> & Pick<HMSMessage, 'sender'> {
-    return {
-      sender: sdkMessage.sender.peerId,
-      senderName: sdkMessage.sender.name,
-      senderRole: sdkMessage.sender.role?.name,
-      senderUserId: sdkMessage.sender.customerUserId,
-      recipientPeer: sdkMessage.recipientPeer?.peerId,
-      recipientRoles: sdkMessage.recipientRoles?.map(role => role.name),
-      time: sdkMessage.time,
-      type: sdkMessage.type,
-      message: sdkMessage.message,
-    };
-  }
-
-  static convertRoles(sdkRoles: HMSRole[]): Record<HMSRoleName, HMSRole> {
-    const roles: Record<HMSRoleName, HMSRole> = {};
-    if (sdkRoles) {
-      sdkRoles.forEach(role => {
-        roles[role.name] = role;
-      });
-    }
-    return roles;
-  }
-
-  static convertRoleChangeRequest(req: SDKHMSRoleChangeRequest): HMSRoleChangeStoreRequest {
-    return {
-      requestedBy: req.requestedBy.peerId,
-      roleName: req.role.name,
-      token: req.token,
-    };
-  }
-
-  static convertException(sdkException: sdkTypes.HMSException): HMSException {
-    return {
-      code: sdkException.code,
-      action: sdkException.action,
-      name: sdkException.name,
-      message: sdkException.message,
-      description: sdkException.description,
-      isTerminal: sdkException.isTerminal,
-      nativeError: sdkException.nativeError,
-      timestamp: new Date(),
-    };
-  }
-
-  static convertDeviceChangeUpdate(
-    sdkDeviceChangeEvent: sdkTypes.HMSDeviceChangeEvent,
-  ): HMSDeviceChangeEvent {
-    const convertedData: HMSDeviceChangeEvent = {
-      devices: sdkDeviceChangeEvent.devices,
-      selection: sdkDeviceChangeEvent.selection,
-      type: sdkDeviceChangeEvent.type,
-    };
-    if (sdkDeviceChangeEvent.error) {
-      convertedData.error = this.convertException(sdkDeviceChangeEvent.error);
-    }
-    return convertedData;
-  }
-
-  static convertPlaylist(playlistManager: sdkTypes.HMSPlaylistManager) {
-    const audioPlaylist = this.getConvertedPlaylistType(playlistManager, HMSPlaylistType.audio);
-    const videoPlaylist = this.getConvertedPlaylistType(playlistManager, HMSPlaylistType.video);
-    return { audio: audioPlaylist, video: videoPlaylist };
-  }
-
-  static convertPlaylistItem<T>(
-    playlistManager: sdkTypes.HMSPlaylistManager,
-    playlistItem: sdkTypes.HMSPlaylistItem<T>,
-  ): HMSPlaylistItem<T> {
-    const type = playlistItem.type;
-    const currentSelection = playlistManager.getCurrentSelection(type);
-    const isPlaying = playlistManager.isPlaying(type);
-    const isSelected = playlistItem.url === currentSelection?.url;
-
-    return {
-      ...playlistItem,
-      type: playlistItem.type as HMSPlaylistType,
-      selected: isSelected,
-      playing: isSelected && isPlaying,
-    };
-  }
-
-  private static getConvertedPlaylistType(
-    playlistManager: sdkTypes.HMSPlaylistManager,
-    type: HMSPlaylistType,
-  ) {
-    const convertedPlaylist: Record<string, HMSPlaylistItem<any>> = {};
-    const currentSelection = playlistManager.getCurrentSelection(type);
-    const progress = playlistManager.getCurrentProgress(type);
-    const volume = playlistManager.getVolume(type);
-    const list = playlistManager.getList(type);
-    const currentIndex = playlistManager.getCurrentIndex(type);
-
-    playlistManager.getList(type).forEach(playlistItem => {
-      convertedPlaylist[playlistItem.id] = SDKToHMS.convertPlaylistItem(
-        playlistManager,
-        playlistItem,
-      );
-    });
-    return {
-      list: convertedPlaylist,
-      selection: {
-        id: currentSelection?.id,
-        hasPrevious: currentIndex > 0,
-        hasNext: currentIndex < list.length - 1,
-      },
-      progress,
-      volume,
-      currentTime: playlistManager.getCurrentTime(type),
-      playbackRate: playlistManager.getPlaybackRate(type),
-    };
-  }
-
-  static convertRecordingRTMPState(
-    recording: sdkTypes.HMSRecording | undefined,
-    rtmp: sdkTypes.HMSRTMP | undefined,
-  ): { recording: sdkTypes.HMSRecording; rtmp: sdkTypes.HMSRTMP } {
-    return {
-      recording: {
-        browser: {
-          running: !!recording?.browser?.running,
-        },
-        server: { running: !!recording?.server?.running },
-      },
-      rtmp: { running: !!rtmp?.running },
-    };
-  }
-}

package/src/core/hmsSDKStore/common/mapping.ts

@@ -1,32 +0,0 @@
-import * as sdkTypes from '../sdkTypes';
-import { HMSNotificationTypes } from '../../schema';
-
-interface notifcationMap {
-  [key: number]: string;
-}
-
-export const PEER_NOTIFICATION_TYPES: notifcationMap = {
-  [sdkTypes.HMSPeerUpdate.PEER_JOINED]: HMSNotificationTypes.PEER_JOINED,
-  [sdkTypes.HMSPeerUpdate.PEER_LEFT]: HMSNotificationTypes.PEER_LEFT,
-  [sdkTypes.HMSPeerUpdate.ROLE_UPDATED]: HMSNotificationTypes.ROLE_UPDATED,
-  [sdkTypes.HMSPeerUpdate.AUDIO_TOGGLED]: 'PEER_AUDIO_UPDATED',
-  [sdkTypes.HMSPeerUpdate.VIDEO_TOGGLED]: 'PEER_VIDEO_UPDATED',
-  [sdkTypes.HMSPeerUpdate.NAME_UPDATED]: HMSNotificationTypes.NAME_UPDATED,
-  [sdkTypes.HMSPeerUpdate.METADATA_UPDATED]: HMSNotificationTypes.METADATA_UPDATED,
-};
-
-export const TRACK_NOTIFICATION_TYPES: notifcationMap = {
-  [sdkTypes.HMSTrackUpdate.TRACK_ADDED]: HMSNotificationTypes.TRACK_ADDED,
-  [sdkTypes.HMSTrackUpdate.TRACK_REMOVED]: HMSNotificationTypes.TRACK_REMOVED,
-  [sdkTypes.HMSTrackUpdate.TRACK_MUTED]: HMSNotificationTypes.TRACK_MUTED,
-  [sdkTypes.HMSTrackUpdate.TRACK_UNMUTED]: HMSNotificationTypes.TRACK_UNMUTED,
-  [sdkTypes.HMSTrackUpdate.TRACK_DEGRADED]: HMSNotificationTypes.TRACK_DEGRADED,
-  [sdkTypes.HMSTrackUpdate.TRACK_RESTORED]: HMSNotificationTypes.TRACK_RESTORED,
-};
-
-export const ACTION_TYPES: notifcationMap = {
-  [sdkTypes.HMSPeerUpdate.PEER_JOINED]: 'peerJoined',
-  [sdkTypes.HMSPeerUpdate.PEER_LEFT]: 'peerLeft',
-  [sdkTypes.HMSPeerUpdate.NAME_UPDATED]: 'peerNameUpdated',
-  [sdkTypes.HMSPeerUpdate.METADATA_UPDATED]: 'peerMetadataUpdated',
-};

package/src/core/hmsSDKStore/internalTypes.ts

@@ -1,8 +0,0 @@
-import { PartialState, State } from 'zustand/vanilla';
-
-export type NamedSetState<T extends State> = {
-  <K1 extends keyof T, K2 extends keyof T = K1, K3 extends keyof T = K2, K4 extends keyof T = K3>(
-    partial: PartialState<T, K1, K2, K3, K4>,
-    name?: string,
-  ): void;
-};

package/src/core/hmsSDKStore/sdkTypes.ts

@@ -1,55 +0,0 @@
-import {
-  HMSException,
-  HMSSimulcastLayer,
-  HMSPeerUpdate,
-  HMSRoomUpdate,
-  HMSTrackUpdate,
-  HMSAudioTrackSettings,
-  HMSVideoTrackSettings,
-  HMSPeer,
-  HMSRoom,
-  HMSMessage,
-  HMSConfig,
-  HMSSpeaker,
-  HMSRole,
-  HMSLocalPeer,
-  HMSRemotePeer,
-  SimulcastLayerDefinition,
-  DeviceMap,
-  HMSLogLevel,
-  HMSDeviceChangeEvent,
-  HMSPlaylistItem,
-  HMSPlaylistManager,
-  HMSPlaylistProgressEvent,
-  RTMPRecordingConfig,
-  HMSRecording,
-  HMSRTMP,
-} from '@100mslive/hms-video';
-
-export {
-  HMSPeer,
-  HMSRoom,
-  HMSMessage,
-  HMSSpeaker,
-  HMSConfig,
-  HMSAudioTrackSettings,
-  HMSVideoTrackSettings,
-  HMSException,
-  HMSSimulcastLayer,
-  HMSRoomUpdate,
-  HMSPeerUpdate,
-  HMSTrackUpdate,
-  HMSRole,
-  HMSLocalPeer,
-  HMSRemotePeer,
-  HMSLogLevel,
-  SimulcastLayerDefinition,
-  DeviceMap,
-  HMSDeviceChangeEvent,
-  HMSPlaylistItem,
-  HMSPlaylistManager,
-  HMSPlaylistProgressEvent,
-  RTMPRecordingConfig,
-  HMSRecording,
-  HMSRTMP,
-};

package/src/core/hmsSDKStore/sdkUtils/ActionBatcher.ts

@@ -1,63 +0,0 @@
-import { HMSStore } from '../../schema';
-import { IHMSStore } from '../../IHMSStore';
-import { HMSLogger } from '../../../common/ui-logger';
-
-type ActionName = string;
-type SetTimeOutId = number;
-type SetState = (store: HMSStore) => void;
-
-/**
- * pass in an action and an update function, the update functions will be batched and run such that
- * store updates are limited to only one action in a time interval
- *
- */
-export class ActionBatcher {
-  private queuedUpdates: Record<ActionName, SetState[]> = {};
-  private timers: Record<ActionName, SetTimeOutId> = {};
-  private DEFAULT_INTERVAL_MS = 50;
-  private store: IHMSStore;
-  constructor(store: IHMSStore) {
-    this.store = store;
-  }
-
-  setState(fn: SetState, action: ActionName) {
-    this.queuedUpdates[action] = this.queuedUpdates[action] || [];
-    this.queuedUpdates[action].push(fn);
-    if (this.timers[action]) {
-      return;
-    }
-    // set a future timeout if a timer is not there already
-    if (window) {
-      this.timers[action] = window.setTimeout(
-        () => this.setStateBatched(action),
-        this.DEFAULT_INTERVAL_MS,
-      );
-    } else {
-      // nodejs, ignore batching for now
-      this.setStateBatched(action);
-    }
-  }
-
-  private setStateBatched(action: ActionName) {
-    if (this.queuedUpdates[action]?.length > 0) {
-      const batchedFn = (draftStore: HMSStore) => {
-        this.queuedUpdates[action].forEach(fn => {
-          try {
-            fn(draftStore);
-          } catch (err) {
-            HMSLogger.w('failed to update store', err);
-          }
-        });
-      };
-      console.time(`timed-${action}`);
-      this.store.namedSetState(batchedFn, action);
-      console.timeEnd(`timed-${action}`);
-    }
-    // cleanup
-    delete this.queuedUpdates[action];
-    if (window && this.timers[action]) {
-      window.clearTimeout(this.timers[action]);
-      delete this.timers[action];
-    }
-  }
-}

package/src/core/hmsSDKStore/sdkUtils/sdkUtils.ts

@@ -1,5 +0,0 @@
-import { HMSTrack, HMSRemoteAudioTrack, HMSRemoteVideoTrack } from '@100mslive/hms-video';
-
-export function isRemoteTrack(track: HMSTrack) {
-  return track instanceof HMSRemoteAudioTrack || track instanceof HMSRemoteVideoTrack;
-}

package/src/core/hmsSDKStore/sdkUtils/storeMergeUtils.ts

@@ -1,98 +0,0 @@
-import { HMSPeer, HMSPeerID, HMSTrack, HMSTrackID } from '../../schema';
-
-/**
- * updates draftPeers with newPeers ensuring minimal reference changes
- * @remarks
- * This is mutable and impure function, it modifies the passed in data to ensure
- * minimal reference changes
- * @param draftPeers the current peers object in store, an immer draft object
- * @param newPeers the latest update which needs to be stored
- * @param newHmsTracks this will be update if required
- * @param newHmsSDkTracks this is future value of local hms tacks map
- */
-export const mergeNewPeersInDraft = (
-  draftPeers: Record<HMSPeerID, HMSPeer>,
-  newPeers: Record<HMSPeerID, Partial<HMSPeer>>,
-) => {
-  const peerIDs = union(Object.keys(draftPeers), Object.keys(newPeers));
-  for (let peerID of peerIDs) {
-    const oldPeer = draftPeers[peerID];
-    const newPeer = newPeers[peerID];
-    if (isEntityUpdated(oldPeer, newPeer)) {
-      if (areArraysEqual(oldPeer.auxiliaryTracks, newPeer.auxiliaryTracks)) {
-        newPeer.auxiliaryTracks = oldPeer.auxiliaryTracks;
-      }
-      Object.assign(oldPeer, newPeer);
-    } else if (isEntityRemoved(oldPeer, newPeer)) {
-      delete draftPeers[peerID];
-    } else if (isEntityAdded(oldPeer, newPeer)) {
-      draftPeers[peerID] = newPeer as HMSPeer;
-    }
-  }
-};
-
-export const mergeNewTracksInDraft = (
-  draftTracks: Record<HMSTrackID, HMSTrack>,
-  newTracks: Record<HMSTrackID, Partial<HMSTrack>>,
-) => {
-  const trackIDs = union(Object.keys(draftTracks), Object.keys(newTracks));
-  for (let trackID of trackIDs) {
-    const oldTrack = draftTracks[trackID];
-    const newTrack = newTracks[trackID];
-    if (isEntityUpdated(oldTrack, newTrack)) {
-      mergeTrackArrayFields(oldTrack, newTrack);
-      Object.assign(oldTrack, newTrack);
-    } else if (isEntityRemoved(oldTrack, newTrack)) {
-      delete draftTracks[trackID];
-    } else if (isEntityAdded(oldTrack, newTrack)) {
-      draftTracks[trackID] = newTrack as HMSTrack;
-    }
-  }
-};
-
-/**
- * array's are usually created with new reference, avoid that update if both arrays are same
- */
-const mergeTrackArrayFields = (oldTrack: HMSTrack, newTrack: Partial<HMSTrack>) => {
-  if (oldTrack.plugins && areArraysEqual(oldTrack.plugins, newTrack.plugins)) {
-    newTrack.plugins = oldTrack.plugins;
-  }
-  if (
-    oldTrack.layerDefinitions &&
-    areArraysEqual(oldTrack.layerDefinitions, newTrack.layerDefinitions)
-  ) {
-    newTrack.layerDefinitions = oldTrack.layerDefinitions;
-  }
-};
-
-const isEntityUpdated = <T>(oldItem: T, newItem: T) => oldItem && newItem;
-const isEntityRemoved = <T>(oldItem: T, newItem: T) => oldItem && !newItem;
-const isEntityAdded = <T>(oldItem: T, newItem: T) => !oldItem && newItem;
-
-// eslint-disable-next-line complexity
-export const areArraysEqual = <T>(arr1: T[], arr2?: T[]): boolean => {
-  if (arr1 === arr2 || (arr1.length === 0 && arr2?.length === 0)) {
-    // reference check
-    return true;
-  }
-  if (!arr1 || !arr2 || !(arr1.length === arr2.length)) {
-    return false;
-  }
-  for (let i = 0; i < arr1.length; i++) {
-    if (arr1[i] !== arr2[i]) {
-      return false;
-    }
-  }
-  return true;
-};
-
-const union = <T>(arr1: T[], arr2: T[]): T[] => {
-  const set: Set<T> = new Set();
-  for (let elem of arr1) {
-    set.add(elem);
-  }
-  for (let elem of arr2) {
-    set.add(elem);
-  }
-  return Array.from(set);
-};

package/src/core/index.ts

@@ -1,18 +0,0 @@
-export { IHMSStore, IHMSStoreReadOnly as HMSStoreWrapper } from './IHMSStore';
-export { IHMSActions as HMSActions } from './IHMSActions';
-export { IHMSNotifications as HMSNotifications } from './IHMSNotifications';
-export { HMSReactiveStore } from './hmsSDKStore/HMSReactiveStore';
-export * from './schema';
-export * from './selectors';
-export {
-  HMSConfig,
-  HMSAudioTrackSettings,
-  HMSVideoTrackSettings,
-  HMSSimulcastLayer,
-  SimulcastLayerDefinition,
-  DeviceMap,
-  HMSLogLevel,
-  RTMPRecordingConfig,
-  HMSRecording,
-  HMSRTMP,
-} from './hmsSDKStore/sdkTypes';

package/src/core/schema/device-change.ts

@@ -1,14 +0,0 @@
-import { DeviceMap } from '../hmsSDKStore/sdkTypes';
-import { HMSException } from './error';
-
-/**
- * Test fails when adding InputDeviceInfo[error TS2304: Cannot find name 'InputDeviceInfo'.]
- * InputDeviceInfo extends MediaDeviceInfo. See https://w3c.github.io/mediacapture-main/#input-specific-device-info
- * So, `selection?: MediaDeviceInfo` instead of `selection?: InputDeviceInfo | MediaDeviceInfo` is valid
- */
-export interface HMSDeviceChangeEvent {
-  error?: HMSException;
-  devices: DeviceMap;
-  selection?: MediaDeviceInfo;
-  type: 'audioOutput' | 'audioInput' | 'video';
-}

package/src/core/schema/error.ts

@@ -1,13 +0,0 @@
-/**
- * any mid call error notification will be in this format
- */
-export interface HMSException {
-  code: number;
-  action: string;
-  name: string;
-  message: string;
-  description: string;
-  isTerminal: boolean;
-  timestamp: Date;
-  nativeError?: Error;
-}

package/src/core/schema/index.ts

@@ -1,11 +0,0 @@
-export * from './schema';
-export * from './room';
-export * from './peer';
-export * from './message';
-export * from './settings';
-export * from './notification';
-export * from './role';
-export * from './error';
-export * from './requests';
-export * from './device-change';
-export * from './playlist';

package/src/core/schema/message.ts

@@ -1,35 +0,0 @@
-import { HMSPeerID } from './peer';
-import { HMSRoleName } from './role';
-
-export type HMSMessageID = string;
-
-/**
- * @internal
- */
-export enum HMSMessageType {
-  CHAT = 'chat',
-}
-
-export interface HMSMessage {
-  id: HMSMessageID;
-  sender: HMSPeerID;
-  senderName: string;
-  senderUserId?: string;
-  senderRole?: string;
-  recipientPeer?: HMSPeerID;
-  recipientRoles?: HMSRoleName[];
-  time: Date;
-  read: boolean;
-  type: string;
-  message: any;
-}
-
-/**
- * @internal
- */
-export interface HMSMessageInput {
-  recipientPeer?: HMSPeerID;
-  recipientRoles?: HMSRoleName[];
-  type?: string;
-  message: any;
-}

package/src/core/schema/notification.ts

@@ -1,41 +0,0 @@
-export interface HMSNotification {
-  id: number;
-  type: string;
-  message: string;
-  /**
-   * HMSPeer | HMSTrack | HMSMessage | HMSException
-   */
-  data?: any;
-  severity?: HMSNotificationSeverity;
-}
-export enum HMSNotificationSeverity {
-  INFO = 'info',
-  ERROR = 'error',
-  CRITICAL = 'critical',
-}
-
-export enum HMSNotificationTypes {
-  PEER_JOINED = 'PEER_JOINED',
-  PEER_LEFT = 'PEER_LEFT',
-  PEER_LIST = 'PEER_LIST',
-  NEW_MESSAGE = 'NEW_MESSAGE',
-  ERROR = 'ERROR',
-  RECONNECTING = 'RECONNECTING',
-  RECONNECTED = 'RECONNECTED',
-  TRACK_ADDED = 'TRACK_ADDED',
-  TRACK_REMOVED = 'TRACK_REMOVED',
-  TRACK_MUTED = 'TRACK_MUTED',
-  TRACK_UNMUTED = 'TRACK_UNMUTED',
-  TRACK_DEGRADED = 'TRACK_DEGRADED',
-  TRACK_RESTORED = 'TRACK_RESTORED',
-  ROLE_CHANGE_REQUEST = 'ROLE_CHANGE_REQUEST',
-  ROLE_UPDATED = 'ROLE_UPDATED',
-  CHANGE_TRACK_STATE_REQUEST = 'CHANGE_TRACK_STATE_REQUEST',
-  CHANGE_MULTI_TRACK_STATE_REQUEST = 'CHANGE_MULTI_TRACK_STATE_REQUEST',
-  ROOM_ENDED = 'ROOM_ENDED',
-  REMOVED_FROM_ROOM = 'REMOVED_FROM_ROOM',
-  DEVICE_CHANGE_UPDATE = 'DEVICE_CHANGE_UPDATE',
-  PLAYLIST_TRACK_ENDED = 'PLAYLIST_TRACK_ENDED',
-  NAME_UPDATED = 'NAME_UPDATED',
-  METADATA_UPDATED = 'METADATA_UPDATED',
-}