@100mslive/react-native-hms 0.9.0 → 0.9.3

package/src/classes/HMSBrowserRecordingState.ts

@@ -3,9 +3,18 @@ import type { HMSException } from './HMSException';
 export class HMSBrowserRecordingState {
   running: string;
   error: HMSException;
+  startedAt: Date;
+  stoppedAt: Date;
 
-  constructor(params: { running: string; error: HMSException }) {
+  constructor(params: {
+    running: string;
+    error: HMSException;
+    startedAt: Date;
+    stoppedAt: Date;
+  }) {
     this.running = params.running;
     this.error = params.error;
+    this.startedAt = params.startedAt;
+    this.stoppedAt = params.stoppedAt;
   }
 }

package/src/classes/HMSConfig.ts

@@ -3,16 +3,19 @@ export class HMSConfig {
   authToken: string;
   endpoint?: string;
   metadata?: string;
+  captureNetworkQualityInPreview?: boolean;
 
   constructor(params: {
     username: string;
     authToken: string;
     endpoint?: string;
     metadata?: string;
+    captureNetworkQualityInPreview?: boolean;
   }) {
     this.username = params.username;
     this.authToken = params.authToken;
     this.endpoint = params.endpoint;
     this.metadata = params.metadata;
+    this.captureNetworkQualityInPreview = params.captureNetworkQualityInPreview;
   }
 }

package/src/classes/HMSEncoder.ts

@@ -15,6 +15,21 @@ import { HMSRole } from './HMSRole';
 import { HMSRoleChangeRequest } from './HMSRoleChangeRequest';
 import { HMSChangeTrackStateRequest } from './HMSChangeTrackStateRequest';
 import { HMSVideoResolution } from './HMSVideoResolution';
+import { HMSRTCStats } from './HMSRTCStats';
+import { HMSRTCStatsReport } from './HMSRTCStatsReport';
+import { HMSRemoteAudioTrack } from './HMSRemoteAudioTrack';
+import { HMSRemoteVideoTrack } from './HMSRemoteVideoTrack';
+import { HMSSpeaker } from './HMSSpeaker';
+import { HMSSpeakerUpdate } from './HMSSpeakerUpdate';
+import {
+  HMSBrowserRecordingState,
+  HMSHLSStreamingState,
+  HMSHLSVariant,
+  HMSRtmpStreamingState,
+  HMSServerRecordingState,
+} from '..';
+import { HMSHLSRecordingState } from './HMSHLSRecordingState';
+import { HMSNetworkQuality } from './HMSNetworkQuality';
 
 export class HMSEncoder {
   static encodeHmsRoom(room: HMSRoom, id: string) {
@@ -22,11 +37,23 @@ export class HMSEncoder {
       id: room?.id,
       metaData: room?.metaData,
       name: room?.name,
+      peerCount: room?.peerCount,
       peers: HMSEncoder.encodeHmsPeers(room?.peers, id),
-      browserRecordingState: room?.browserRecordingState,
-      rtmpHMSRtmpStreamingState: room?.rtmpHMSRtmpStreamingState,
-      serverRecordingState: room?.serverRecordingState,
-      hlsStreamingState: room?.hlsStreamingState,
+      browserRecordingState: HMSEncoder.encodeBrowserRecordingState(
+        room?.browserRecordingState
+      ),
+      rtmpHMSRtmpStreamingState: HMSEncoder.encodeRTMPStreamingState(
+        room?.rtmpHMSRtmpStreamingState
+      ),
+      serverRecordingState: HMSEncoder.encodeServerRecordingState(
+        room?.serverRecordingState
+      ),
+      hlsStreamingState: HMSEncoder.encodeHLSStreamingState(
+        room?.hlsStreamingState
+      ),
+      hlsRecordingState: HMSEncoder.encodeHLSRecordingState(
+        room?.hlsRecordingState
+      ),
     };
 
     return new HMSRoom(encodedObj);
@@ -46,10 +73,11 @@ export class HMSEncoder {
       peerID: peer?.peerID,
       name: peer?.name,
       isLocal: peer?.isLocal,
-      role: HMSEncoder.encodeHmsRole(peer?.role),
       customerUserID: peer?.customerUserID,
       customerDescription: peer?.customerDescription,
       metadata: peer?.metadata,
+      role: HMSEncoder.encodeHmsRole(peer?.role),
+      networkQuality: HMSEncoder.encodeHMSNetworkQuality(peer?.networkQuality),
       audioTrack: HMSEncoder.encodeHmsAudioTrack(peer?.audioTrack, id),
       videoTrack: HMSEncoder.encodeHmsVideoTrack(peer?.videoTrack, id),
       auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
@@ -118,6 +146,7 @@ export class HMSEncoder {
       customerDescription: peer.customerDescription,
       metadata: peer.metadata,
       role: HMSEncoder.encodeHmsRole(peer?.role),
+      networkQuality: HMSEncoder.encodeHMSNetworkQuality(peer?.networkQuality),
       audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack, id),
       videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id),
       auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
@@ -183,6 +212,34 @@ export class HMSEncoder {
     return new HMSVideoResolution(encodedObj);
   }
 
+  static encodeHmsLocalAudioTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      isMute: track?.isMute,
+      settings: HMSEncoder.encodeHmsAudioTrackSettings(track?.settings),
+      type: track?.type,
+    };
+
+    return new HMSLocalAudioTrack(encodedObj);
+  }
+
+  static encodeHmsLocalVideoTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      isMute: track?.isMute,
+      settings: HMSEncoder.encodeHmsVideoTrackSettings(track?.settings),
+      type: track?.type,
+    };
+
+    return new HMSLocalVideoTrack(encodedObj);
+  }
+
   static encodeHmsRemotePeers(peers: any, id: string) {
     const hmsPeers: any[] = [];
 
@@ -204,6 +261,7 @@ export class HMSEncoder {
       customerDescription: peer.customerDescription,
       metadata: peer.metadata,
       role: HMSEncoder.encodeHmsRole(peer?.role),
+      networkQuality: HMSEncoder.encodeHMSNetworkQuality(peer?.networkQuality),
       audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack, id),
       videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id),
       auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
@@ -232,6 +290,33 @@ export class HMSEncoder {
     return new HMSRemotePeer(encodedObj);
   }
 
+  static encodeHmsRemoteAudioTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      isMute: track?.isMute,
+      playbackAllowed: track?.playbackAllowed,
+    };
+
+    return new HMSRemoteAudioTrack(encodedObj);
+  }
+
+  static encodeHmsRemoteVideoTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      layer: track?.layer,
+      isMute: track?.isMute,
+      playbackAllowed: track?.playbackAllowed,
+    };
+
+    return new HMSRemoteVideoTrack(encodedObj);
+  }
+
   static encodeHmsPreviewTracks(previewTracks: any) {
     const encodedObj = {
       audioTrack: previewTracks.audioTrack
@@ -282,4 +367,122 @@ export class HMSEncoder {
 
     return new HMSChangeTrackStateRequest(encodedChangeTrackStateRequest);
   }
+
+  static encodeRTCStats(data: any) {
+    let video = this.encodeRTCStatsUnit(data?.video);
+    let audio = this.encodeRTCStatsUnit(data?.audio);
+    let combined = this.encodeRTCStatsUnit(data?.combined);
+
+    return new HMSRTCStatsReport({ video, audio, combined });
+  }
+
+  static encodeRTCStatsUnit(data: any) {
+    return new HMSRTCStats({
+      bitrateReceived: data?.bitrateReceived,
+      bitrateSent: data?.bitrateSent,
+      bytesReceived: data?.bytesReceived,
+      bytesSent: data?.bytesSent,
+      packetsLost: data?.packetsLost,
+      packetsReceived: data?.packetsReceived,
+      roundTripTime: data?.roundTripTime,
+    });
+  }
+
+  static encodeHmsSpeakerUpdate(data: any, id: string) {
+    return new HMSSpeakerUpdate({
+      event: data?.event,
+      count: data?.count,
+      peers: HMSEncoder.encodeHmsSpeakers(data?.peers, id),
+    });
+  }
+
+  static encodeHmsSpeakers(data: any, id: string) {
+    let encodedSpeakers: Array<HMSSpeaker> = [];
+
+    data?.map((item: any) => {
+      encodedSpeakers.push(HMSEncoder.encodeHmsSpeaker(item, id));
+    });
+
+    return encodedSpeakers;
+  }
+
+  static encodeHmsSpeaker(data: any, id: string) {
+    return new HMSSpeaker({
+      level: data?.level,
+      peer: HMSEncoder.encodeHmsPeer(data?.peer, id),
+      track: HMSEncoder.encodeHmsTrack(data?.track, id),
+    });
+  }
+
+  static encodeBrowserRecordingState(data: any) {
+    return new HMSBrowserRecordingState({
+      running: data?.running,
+      startedAt: new Date(parseInt(data?.startedAt)),
+      stoppedAt: new Date(parseInt(data?.stoppedAt)),
+      error: data?.error,
+    });
+  }
+
+  static encodeServerRecordingState(data: any) {
+    return new HMSServerRecordingState({
+      running: data?.running,
+      error: data?.error,
+      startedAt: new Date(parseInt(data?.startedAt)),
+    });
+  }
+
+  static encodeRTMPStreamingState(data: any) {
+    return new HMSRtmpStreamingState({
+      running: data?.running,
+      startedAt: new Date(parseInt(data?.startedAt)),
+      stoppedAt: new Date(parseInt(data?.stoppedAt)),
+      error: data?.error,
+    });
+  }
+
+  static encodeHLSStreamingState(data: any) {
+    return new HMSHLSStreamingState({
+      running: data?.running,
+      variants: this.encodeHLSVariants(data?.variants),
+    });
+  }
+
+  static encodeHLSRecordingState(data: any) {
+    if (data) {
+      return new HMSHLSRecordingState({
+        running: data?.running,
+        startedAt: new Date(parseInt(data?.startedAt)),
+        singleFilePerLayer: data?.singleFilePerLayer,
+        videoOnDemand: data?.videoOnDemand,
+      });
+    } else {
+      return undefined;
+    }
+  }
+
+  static encodeHLSVariants(data: any) {
+    let variants: HMSHLSVariant[] = [];
+
+    data?.map((item: any) => {
+      let variant = new HMSHLSVariant({
+        hlsStreamUrl: item.hlsStreamUrl,
+        meetingUrl: item.meetingUrl,
+        metadata: item?.metadata,
+        startedAt: new Date(parseInt(item?.startedAt)),
+      });
+      variants.push(variant);
+    });
+
+    return variants;
+  }
+
+  static encodeHMSNetworkQuality(data: any) {
+    if (data) {
+      return new HMSNetworkQuality({
+        downlinkQuality: data?.downlinkQuality,
+      });
+    } else {
+      return undefined;
+    }
+  }
 }

package/src/classes/HMSHLSConfig.ts

@@ -1,9 +1,15 @@
 import type { HMSHLSMeetingURLVariant } from './HMSHLSMeetingURLVariant';
+import type { HMSHLSRecordingConfig } from './HMSHLSRecordingConfig';
 
 export class HMSHLSConfig {
-  meetingURLVariants?: Array<HMSHLSMeetingURLVariant>;
+  hlsRecordingConfig?: HMSHLSRecordingConfig;
+  meetingURLVariants: Array<HMSHLSMeetingURLVariant>;
 
-  constructor(params: { meetingURLVariants?: Array<HMSHLSMeetingURLVariant> }) {
+  constructor(params: {
+    hlsRecordingConfig?: HMSHLSRecordingConfig;
+    meetingURLVariants: Array<HMSHLSMeetingURLVariant>;
+  }) {
+    this.hlsRecordingConfig = params.hlsRecordingConfig;
     this.meetingURLVariants = params.meetingURLVariants;
   }
 }

package/src/classes/HMSHLSRecordingConfig.ts

@@ -0,0 +1,9 @@
+export class HMSHLSRecordingConfig {
+  singleFilePerLayer: boolean;
+  videoOnDemand: boolean;
+
+  constructor(params: { singleFilePerLayer: boolean; videoOnDemand: boolean }) {
+    this.singleFilePerLayer = params.singleFilePerLayer;
+    this.videoOnDemand = params.videoOnDemand;
+  }
+}

package/src/classes/HMSHLSRecordingState.ts

@@ -0,0 +1,18 @@
+export class HMSHLSRecordingState {
+  singleFilePerLayer: boolean;
+  videoOnDemand: boolean;
+  running: boolean;
+  startedAt?: Date;
+
+  constructor(params: {
+    singleFilePerLayer: boolean;
+    videoOnDemand: boolean;
+    running: boolean;
+    startedAt?: Date;
+  }) {
+    this.singleFilePerLayer = params.singleFilePerLayer;
+    this.videoOnDemand = params.videoOnDemand;
+    this.running = params.running;
+    this.startedAt = params.startedAt;
+  }
+}

package/src/classes/HMSHLSVariant.ts

@@ -1,14 +1,14 @@
 export class HMSHLSVariant {
-  hlsStreamUrl: string;
-  meetingUrl: string;
-  metadata: string;
-  startedAt: number;
+  hlsStreamUrl?: string;
+  meetingUrl?: string;
+  metadata?: string;
+  startedAt?: Date;
 
   constructor(params: {
-    hlsStreamUrl: string;
-    meetingUrl: string;
-    metadata: string;
-    startedAt: number;
+    hlsStreamUrl?: string;
+    meetingUrl?: string;
+    metadata?: string;
+    startedAt?: Date;
   }) {
     this.hlsStreamUrl = params.hlsStreamUrl;
     this.meetingUrl = params.meetingUrl;

package/src/classes/HMSLocalAudioStats.ts

@@ -0,0 +1,15 @@
+export class HMSLocalAudioStats {
+  bitrate?: number;
+  bytesSent?: number;
+  roundTripTime?: number;
+
+  constructor(params: {
+    bitrate?: number;
+    bytesSent?: number;
+    roundTripTime?: number;
+  }) {
+    this.bitrate = params.bitrate;
+    this.bytesSent = params.bytesSent;
+    this.roundTripTime = params.roundTripTime;
+  }
+}

package/src/classes/HMSLocalPeer.ts

@@ -8,6 +8,7 @@ import { HMSLocalAudioTrack } from './HMSLocalAudioTrack';
 import { HMSLocalVideoTrack } from './HMSLocalVideoTrack';
 import type { HMSRole } from './HMSRole';
 import type { HMSTrackType } from './HMSTrackType';
+import type { HMSNetworkQuality } from './HMSNetworkQuality';
 
 export class HMSLocalPeer extends HMSPeer {
   private localAudio?: HMSLocalAudioTrack;
@@ -29,6 +30,7 @@ export class HMSLocalPeer extends HMSPeer {
     metadata?: string;
     audioTrack?: HMSAudioTrack;
     videoTrack?: HMSVideoTrack;
+    networkQuality?: HMSNetworkQuality;
     role?: HMSRole;
     auxiliaryTracks?: HMSTrack[];
     localAudioTrackData?: {

package/src/classes/HMSLocalVideoStats.ts

@@ -0,0 +1,23 @@
+import type { HMSVideoResolution } from './HMSVideoResolution';
+
+export class HMSLocalVideoStats {
+  bitrate?: number;
+  bytesSent?: number;
+  roundTripTime?: number;
+  frameRate?: number;
+  resolution?: HMSVideoResolution;
+
+  constructor(params: {
+    bitrate?: number;
+    bytesSent?: number;
+    roundTripTime?: number;
+    frameRate?: number;
+    resolution?: HMSVideoResolution;
+  }) {
+    this.bitrate = params.bitrate;
+    this.bytesSent = params.bytesSent;
+    this.roundTripTime = params.roundTripTime;
+    this.frameRate = params.frameRate;
+    this.resolution = params.resolution;
+  }
+}

package/src/classes/HMSLogger.ts

@@ -26,8 +26,8 @@ export class HMSLogger {
       if (this.onLog) {
         this?.onLog({ message, data });
       }
+      this.logs.push({ type: 'verbose', message, data, id: data?.id });
     }
-    this.logs.push({ type: 'verbose', message, data, id: data?.id });
   }
 
   warn(message: string, data: any) {
@@ -36,8 +36,8 @@ export class HMSLogger {
       if (this.onLog) {
         this?.onLog({ message, data });
       }
+      this.logs.push({ type: 'warn', message, data, id: data?.id });
     }
-    this.logs.push({ type: 'warn', message, data, id: data?.id });
   }
 
   error(message: string, data: any) {
@@ -46,8 +46,8 @@ export class HMSLogger {
       if (this.onLog) {
         this?.onLog({ message, data });
       }
+      this.logs.push({ type: 'error', message, data, id: data?.id });
     }
-    this.logs.push({ type: 'error', message, data, id: data?.id });
   }
 
   getLogs() {

package/src/classes/HMSMessage.ts

@@ -1,19 +1,25 @@
+import type { HMSMessageRecipient } from './HMSMessageRecipient';
+import type { HMSPeer } from './HMSPeer';
+
 export class HMSMessage {
   // endpoint: string;
   public message: string;
   public type: string;
-  public time?: string;
-  public sender?: string;
+  public time: Date;
+  public sender: HMSPeer;
+  public recipient: HMSMessageRecipient;
 
   constructor(params: {
     message: string;
     type: string;
-    time?: string;
-    sender?: string;
+    time: string;
+    sender: HMSPeer;
+    recipient: HMSMessageRecipient;
   }) {
     this.message = params.message;
     this.type = params.type;
-    this.time = params.time;
+    this.time = new Date(params.time);
     this.sender = params.sender;
+    this.recipient = params.recipient;
   }
 }

package/src/classes/HMSMessageRecipient.ts

@@ -0,0 +1,19 @@
+import type { HMSMessageRecipientType } from './HMSMessageRecipientType';
+import type { HMSPeer } from './HMSPeer';
+import type { HMSRole } from './HMSRole';
+
+export class HMSMessageRecipient {
+  public recipientType?: HMSMessageRecipientType;
+  public recipientPeer?: HMSPeer;
+  public recipientRoles?: HMSRole[];
+
+  constructor(params: {
+    recipientType: HMSMessageRecipientType;
+    recipientPeer?: HMSPeer;
+    recipientRoles?: HMSRole[];
+  }) {
+    this.recipientType = params.recipientType;
+    this.recipientPeer = params.recipientPeer;
+    this.recipientRoles = params.recipientRoles;
+  }
+}

package/src/classes/HMSMessageRecipientType.ts

@@ -0,0 +1,5 @@
+export enum HMSMessageRecipientType {
+  BROADCAST = 'BROADCAST',
+  PEER = 'PEER',
+  ROLES = 'ROLES',
+}

package/src/classes/HMSNetworkQuality.ts

@@ -0,0 +1,7 @@
+export class HMSNetworkQuality {
+  downlinkQuality: number;
+
+  constructor(params: { downlinkQuality: number }) {
+    this.downlinkQuality = params.downlinkQuality;
+  }
+}

package/src/classes/HMSPeer.ts

@@ -1,4 +1,5 @@
 import type { HMSAudioTrack } from './HMSAudioTrack';
+import type { HMSNetworkQuality } from './HMSNetworkQuality';
 import type { HMSRole } from './HMSRole';
 import type { HMSTrack } from './HMSTrack';
 import type { HMSVideoTrack } from './HMSVideoTrack';
@@ -11,10 +12,9 @@ export class HMSPeer {
   customerDescription?: string;
   metadata?: string;
   role?: HMSRole;
-
+  networkQuality?: HMSNetworkQuality;
   audioTrack?: HMSAudioTrack;
   videoTrack?: HMSVideoTrack;
-
   auxiliaryTracks?: HMSTrack[];
 
   constructor(params: {
@@ -25,6 +25,7 @@ export class HMSPeer {
     customerDescription?: string;
     metadata?: string;
     role?: HMSRole;
+    networkQuality?: HMSNetworkQuality;
     audioTrack?: HMSAudioTrack;
     videoTrack?: HMSVideoTrack;
     auxiliaryTracks?: HMSTrack[];
@@ -38,6 +39,7 @@ export class HMSPeer {
     this.videoTrack = params.videoTrack;
     this.auxiliaryTracks = params.auxiliaryTracks;
     this.role = params.role;
+    this.networkQuality = params.networkQuality;
     this.metadata = params.metadata;
   }
 }

package/src/classes/HMSPeerUpdate.ts

@@ -1,13 +1,8 @@
 export enum HMSPeerUpdate {
   PEER_JOINED = 'PEER_JOINED',
   PEER_LEFT = 'PEER_LEFT',
-  AUDIO_TOGGLED = 'AUDIO_TOGGLED',
-  VIDEO_TOGGLED = 'VIDEO_TOGGLED',
   METADATA_CHANGED = 'METADATA_CHANGED',
-  BECAME_DOMINANT_SPEAKER = 'BECAME_DOMINANT_SPEAKER',
-  NO_DOMINANT_SPEAKER = 'NO_DOMINANT_SPEAKER',
-  RESIGNED_DOMINANT_SPEAKER = 'RESIGNED_DOMINANT_SPEAKER',
-  STARTED_SPEAKING = 'STARTED_SPEAKING',
-  STOPPED_SPEAKING = 'STOPPED_SPEAKING',
   ROLE_CHANGED = 'ROLE_CHANGED',
+  NAME_CHANGED = 'NAME_CHANGED',
+  NETWORK_QUALITY_UPDATED = 'NETWORK_QUALITY_UPDATED',
 }

package/src/classes/HMSPermissions.ts

@@ -5,7 +5,7 @@ export class HMSPermissions {
   mute?: boolean;
   changeRole?: boolean;
   recording?: boolean;
-  rtmp?: boolean;
+  streaming?: boolean;
 
   constructor(params?: {
     endRoom?: boolean;
@@ -14,7 +14,7 @@ export class HMSPermissions {
     mute?: boolean;
     changeRole?: boolean;
     recording?: boolean;
-    rtmp?: boolean;
+    streaming?: boolean;
   }) {
     if (params) {
       this.endRoom = params.endRoom;
@@ -23,7 +23,7 @@ export class HMSPermissions {
       this.mute = params.mute;
       this.changeRole = params.changeRole;
       this.recording = params.recording;
-      this.rtmp = params.rtmp;
+      this.streaming = params.streaming;
     }
   }
 }

package/src/classes/HMSRTCStats.ts

@@ -0,0 +1,27 @@
+export class HMSRTCStats {
+  bitrateReceived?: number;
+  bitrateSent?: number;
+  bytesReceived?: number;
+  bytesSent?: number;
+  packetsLost?: number;
+  packetsReceived?: number;
+  roundTripTime?: number;
+
+  constructor(params: {
+    bitrateReceived?: number;
+    bitrateSent?: number;
+    bytesReceived?: number;
+    bytesSent?: number;
+    packetsLost?: number;
+    packetsReceived?: number;
+    roundTripTime?: number;
+  }) {
+    this.bitrateReceived = params.bitrateReceived;
+    this.bitrateSent = params.bitrateSent;
+    this.bytesReceived = params.bytesReceived;
+    this.bytesSent = params.bytesSent;
+    this.packetsLost = params.packetsLost;
+    this.packetsReceived = params.packetsReceived;
+    this.roundTripTime = params.roundTripTime;
+  }
+}

package/src/classes/HMSRTCStatsReport.ts

@@ -0,0 +1,17 @@
+import type { HMSRTCStats } from './HMSRTCStats';
+
+export class HMSRTCStatsReport {
+  video?: HMSRTCStats;
+  audio?: HMSRTCStats;
+  combined?: HMSRTCStats;
+
+  constructor(params: {
+    video?: HMSRTCStats;
+    audio?: HMSRTCStats;
+    combined?: HMSRTCStats;
+  }) {
+    this.audio = params.audio;
+    this.video = params.video;
+    this.combined = params.combined;
+  }
+}

package/src/classes/HMSRemoteAudioStats.ts

@@ -0,0 +1,21 @@
+export class HMSRemoteAudioStats {
+  bitrate?: number;
+  packetsReceived?: number;
+  packetsLost?: number;
+  bytesReceived?: number;
+  jitter?: number;
+
+  constructor(params: {
+    bitrate?: number;
+    packetsReceived?: number;
+    packetsLost?: number;
+    bytesReceived?: number;
+    jitter?: number;
+  }) {
+    this.bitrate = params.bitrate;
+    this.packetsReceived = params.packetsReceived;
+    this.jitter = params.jitter;
+    this.packetsLost = params.packetsLost;
+    this.bytesReceived = params.bytesReceived;
+  }
+}