@100mslive/react-native-hms 1.4.0 → 1.5.0

package/sdk-versions.json

@@ -1,5 +1,5 @@
 {
-  "ios": "0.9.1",
-  "iOSBroadcastExtension": "0.0.8",
-  "android": "2.6.0"
+  "ios": "0.9.2",
+  "iOSBroadcastExtension": "0.0.9",
+  "android": "2.6.1"
 }

package/src/classes/HMSCameraControl.ts

@@ -0,0 +1,21 @@
+import { NativeModules } from 'react-native';
+import { HMSConstants } from './HMSConstants';
+
+const { HMSManager } = NativeModules;
+
+export class HMSCameraControl {
+  /**
+   * It captures the image from the device camera at max possible resolution.
+   *
+   * @param {boolean} [flash=false] flash - value indicating whether to use flash while capturing image or not
+   * @returns Promise - which is resolved with the file path of the captured image saved on the disk
+   */
+  static captureImageAtMaxSupportedResolution(
+    flash: boolean = false
+  ): Promise<string> {
+    return HMSManager.captureImageAtMaxSupportedResolution({
+      id: HMSConstants.DEFAULT_SDK_ID,
+      flash,
+    });
+  }
+}

package/src/classes/HMSEncoder.ts

@@ -32,6 +32,13 @@ import { HMSMessageRecipient } from './HMSMessageRecipient';
 import { HMSException } from './HMSException';
 import { HMSConstants } from './HMSConstants';
 import { HMSPeerUpdateOrdinals } from './HMSPeerUpdate';
+import { HMSLocalAudioStats } from './HMSLocalAudioStats';
+import { HMSLocalVideoStats } from './HMSLocalVideoStats';
+import { HMSRemoteAudioStats } from './HMSRemoteAudioStats';
+import { HMSRemoteVideoStats } from './HMSRemoteVideoStats';
+import { HMSLayer } from './HMSLayer';
+import { HMSSimulcastLayerDefinition } from './HMSSimulcastLayerDefinition';
+import { HMSQualityLimitationReasons } from './HMSQualityLimitationReasons';
 
 const { HMSManager } = NativeModules;
 
@@ -46,10 +53,10 @@ export class HMSEncoder {
     this.data = { roles: {} };
   }
 
-  static encodeHmsRoom(room: HMSRoom, id: string) {
+  static encodeHmsRoom(room: any, id: string) {
     const encodedObj = {
       id: room?.id,
-      sessionId: room?.sessionId,
+      sessionId: room?.sessionId || undefined,
       metaData: room?.metaData,
       name: room?.name,
       peerCount: room?.peerCount,
@@ -70,6 +77,7 @@ export class HMSEncoder {
         room?.hlsRecordingState
       ),
       localPeer: HMSEncoder.encodeHmsLocalPeer(room?.localPeer, id),
+      // startedAt: HMSEncoder.encodeDate(room?.startedAt),
     };
 
     return new HMSRoom(encodedObj);
@@ -278,7 +286,6 @@ export class HMSEncoder {
             trackId: peer?.remoteVideoTrackData?.trackId,
             source: peer?.remoteVideoTrackData?.source,
             trackDescription: peer?.remoteVideoTrackData?.trackDescription,
-            layer: peer?.remoteVideoTrackData?.layer,
             isMute: peer?.remoteVideoTrackData?.isMute,
             playbackAllowed: peer?.remoteVideoTrackData?.playbackAllowed,
           }
@@ -307,7 +314,6 @@ export class HMSEncoder {
       trackId: track?.trackId,
       source: track?.source,
       trackDescription: track?.trackDescription,
-      layer: track?.layer,
       isMute: track?.isMute,
       playbackAllowed: track?.playbackAllowed,
     };
@@ -393,14 +399,24 @@ export class HMSEncoder {
   }
 
   static encodeRTCStatsUnit(data: any) {
+    const [
+      bitrateReceived,
+      bitrateSent,
+      bytesReceived,
+      bytesSent,
+      packetsLost,
+      packetsReceived,
+      roundTripTime,
+    ] = data;
+
     return new HMSRTCStats({
-      bitrateReceived: data?.bitrateReceived,
-      bitrateSent: data?.bitrateSent,
-      bytesReceived: data?.bytesReceived,
-      bytesSent: data?.bytesSent,
-      packetsLost: data?.packetsLost,
-      packetsReceived: data?.packetsReceived,
-      roundTripTime: data?.roundTripTime,
+      bitrateReceived,
+      bitrateSent,
+      bytesReceived,
+      bytesSent,
+      packetsLost,
+      packetsReceived,
+      roundTripTime,
     });
   }
 
@@ -544,4 +560,102 @@ export class HMSEncoder {
       canRetry: data?.error?.canRetry,
     });
   }
+
+  static encodeHMSLocalAudioStats(data: any) {
+    const [bitrate, bytesSent, roundTripTime] = data;
+
+    return new HMSLocalAudioStats({
+      bitrate: bitrate >= 0 ? bitrate : undefined,
+      bytesSent: bytesSent ? bytesSent : undefined,
+      roundTripTime: roundTripTime >= 0 ? roundTripTime : undefined,
+    });
+  }
+
+  static encodeHMSLocalVideoStats(data: any[]) {
+    return data.map((item: any) => {
+      const [
+        bitrate,
+        bytesSent,
+        roundTripTime,
+        frameRate,
+        resolution,
+        layer,
+        qualityLimitationReasons,
+      ] = item;
+
+      return new HMSLocalVideoStats({
+        bitrate: bitrate >= 0 ? bitrate : undefined,
+        bytesSent: bytesSent ? bytesSent : undefined,
+        roundTripTime: roundTripTime >= 0 ? roundTripTime : undefined,
+        frameRate: frameRate >= 0 ? frameRate : undefined,
+        resolution: resolution
+          ? { width: resolution[0], height: resolution[1] }
+          : undefined, // resolution: [width, height]
+        layer: layer ? layer : undefined,
+        qualityLimitationReasons: qualityLimitationReasons
+          ? this.encodeHMSQualityLimitationReasons(qualityLimitationReasons)
+          : undefined,
+      });
+    });
+  }
+
+  static encodeHMSRemoteAudioStats(data: any) {
+    const [bitrate, bytesReceived, jitter, packetsLost, packetsReceived] = data;
+
+    return new HMSRemoteAudioStats({
+      bitrate: bitrate >= 0 ? bitrate : undefined,
+      bytesReceived: bytesReceived ? bytesReceived : undefined,
+      jitter: jitter >= 0 ? jitter : undefined,
+      packetsLost: packetsLost >= 0 ? packetsLost : undefined,
+      packetsReceived: packetsReceived ? packetsReceived : undefined,
+    });
+  }
+
+  static encodeHMSRemoteVideoStats(data: any) {
+    const [
+      bitrate,
+      bytesReceived,
+      frameRate,
+      jitter,
+      packetsLost,
+      packetsReceived,
+      resolution,
+    ] = data;
+
+    return new HMSRemoteVideoStats({
+      bitrate: bitrate >= 0 ? bitrate : undefined,
+      bytesReceived: bytesReceived ? bytesReceived : undefined,
+      frameRate: frameRate >= 0 ? frameRate : undefined,
+      jitter: jitter >= 0 ? jitter : undefined,
+      packetsLost: packetsLost >= 0 ? packetsLost : undefined,
+      packetsReceived: packetsReceived ? packetsReceived : undefined,
+      resolution: resolution
+        ? { width: resolution[0], height: resolution[1] }
+        : undefined, // resolution: [width, height]
+    });
+  }
+
+  static encodeHMSSimulcastLayerDefinition(data: any[]) {
+    return data.map((sld) => {
+      return new HMSSimulcastLayerDefinition({
+        layer: HMSLayer[sld.layer as HMSLayer], // DOUBT: This can be invalid. Should we throw error?
+        resolution: this.encodeHmsVideoResolution({
+          width: sld.resolution[0],
+          height: sld.resolution[1],
+        }),
+      });
+    });
+  }
+
+  static encodeHMSQualityLimitationReasons(data: any) {
+    return new HMSQualityLimitationReasons({
+      reason: data.reason,
+      bandwidth: data.bandwidth,
+      cpu: data.cpu,
+      none: data.none,
+      other: data.other,
+      qualityLimitationResolutionChanges:
+        data.qualityLimitationResolutionChanges,
+    });
+  }
 }

package/src/classes/HMSLayer.ts

@@ -0,0 +1,5 @@
+export enum HMSLayer {
+  LOW = 'LOW',
+  MEDIUM = 'MEDIUM',
+  HIGH = 'HIGH',
+}

package/src/classes/HMSLocalVideoStats.ts

@@ -1,23 +1,44 @@
+import type { HMSLayer } from './HMSLayer';
+import type { HMSQualityLimitationReasons } from './HMSQualityLimitationReasons';
 import type { HMSVideoResolution } from './HMSVideoResolution';
 
 export class HMSLocalVideoStats {
+  // Outgoing bitrate of this track observed since previous report in Kb/s.
   bitrate?: number;
+
+  // Total bytes sent by this track in the current session.
   bytesSent?: number;
+
+  // Round trip time observed since previous report
   roundTripTime?: number;
+
+  // Frame rate of video frames being sent (FPS)
   frameRate?: number;
+
+  // Resolution of video frames being sent
   resolution?: HMSVideoResolution;
 
+  // Reason for quality limitations
+  qualityLimitationReasons?: HMSQualityLimitationReasons;
+
+  /// Simulcast Layer
+  layer?: HMSLayer;
+
   constructor(params: {
     bitrate?: number;
     bytesSent?: number;
     roundTripTime?: number;
     frameRate?: number;
     resolution?: HMSVideoResolution;
+    qualityLimitationReasons?: HMSQualityLimitationReasons;
+    layer?: HMSLayer;
   }) {
     this.bitrate = params.bitrate;
     this.bytesSent = params.bytesSent;
     this.roundTripTime = params.roundTripTime;
     this.frameRate = params.frameRate;
     this.resolution = params.resolution;
+    this.qualityLimitationReasons = params.qualityLimitationReasons;
+    this.layer = params.layer;
   }
 }

package/src/classes/HMSPeer.ts

@@ -9,7 +9,7 @@ import { HMSConstants } from './HMSConstants';
 export class HMSPeer {
   peerID: string;
   /**
-   * @deprecated customerDescription has been deprecated in favor of metadata
+   * @deprecated customerDescription property has been deprecated in favor of metadata property
    */
   customerDescription?: string;
 

package/src/classes/HMSPublishSettings.ts

@@ -1,21 +1,25 @@
 import type { HMSAudioSettings } from './HMSAudioSettings';
 import type { HMSVideoSettings } from './HMSVideoSettings';
+import type { HMSSimulcastSettings } from './HMSSimulcastSettings';
 
 export class HMSPublishSettings {
   audio?: HMSAudioSettings;
   video?: HMSVideoSettings;
   screen?: HMSVideoSettings;
   allowed?: string[];
+  simulcast?: HMSSimulcastSettings;
 
   constructor(params: {
     audio?: HMSAudioSettings;
     video?: HMSVideoSettings;
     screen?: HMSVideoSettings;
     allowed?: string[];
+    simulcast?: HMSSimulcastSettings;
   }) {
     this.audio = params.audio;
     this.video = params.video;
     this.screen = params.screen;
     this.allowed = params.allowed;
+    this.simulcast = params.simulcast;
   }
 }

package/src/classes/HMSQualityLimitationReason.ts

@@ -0,0 +1,7 @@
+export enum HMSQualityLimitationReason {
+  BANDWIDTH = 'BANDWIDTH',
+  CPU = 'CPU',
+  NONE = 'NONE',
+  OTHER = 'OTHER',
+  UNKNOWN = 'UNKNOWN',
+}

package/src/classes/HMSQualityLimitationReasons.ts

@@ -0,0 +1,27 @@
+import type { HMSQualityLimitationReason } from './HMSQualityLimitationReason';
+
+export class HMSQualityLimitationReasons {
+  bandwidth?: number;
+  cpu?: number;
+  none?: number;
+  other?: number;
+  qualityLimitationResolutionChanges?: number;
+  reason: HMSQualityLimitationReason;
+
+  constructor(params: {
+    bandwidth?: number;
+    cpu?: number;
+    none?: number;
+    other?: number;
+    qualityLimitationResolutionChanges?: number;
+    reason: HMSQualityLimitationReason;
+  }) {
+    this.bandwidth = params.bandwidth;
+    this.cpu = params.cpu;
+    this.none = params.none;
+    this.other = params.other;
+    this.qualityLimitationResolutionChanges =
+      params.qualityLimitationResolutionChanges;
+    this.reason = params.reason;
+  }
+}

package/src/classes/HMSRemotePeer.ts

@@ -30,7 +30,6 @@ export class HMSRemotePeer extends HMSPeer {
       source?: number | string;
       trackDescription?: string;
       isMute?: boolean;
-      layer?: any;
       playbackAllowed?: boolean;
       id: string;
     };

package/src/classes/HMSRemoteVideoTrack.ts

@@ -2,6 +2,9 @@ import { NativeModules } from 'react-native';
 import { getLogger } from './HMSLogger';
 import { HMSVideoTrack } from './HMSVideoTrack';
 import type { HMSTrackType } from './HMSTrackType';
+import type { HMSLayer } from './HMSLayer';
+import type { HMSSimulcastLayerDefinition } from './HMSSimulcastLayerDefinition';
+import { HMSEncoder } from './HMSEncoder';
 
 const {
   /**
@@ -11,8 +14,6 @@ const {
 } = NativeModules;
 
 export class HMSRemoteVideoTrack extends HMSVideoTrack {
-  layer?: any; //TODO: layer to be made HMSSimulcastLayer type
-
   /**
    * Switches Video of remote user on/off depending upon the value of playbackAllowed
    *
@@ -54,17 +55,64 @@ export class HMSRemoteVideoTrack extends HMSVideoTrack {
     }
   };
 
+  async getLayer() {
+    const logger = getLogger();
+    logger?.verbose('#Function getLayer', {
+      id: this.id,
+      trackId: this.trackId,
+    });
+
+    const layer: HMSLayer = await HMSManager.getVideoTrackLayer({
+      id: this.id,
+      trackId: this.trackId,
+    });
+
+    return layer;
+  }
+
+  async getLayerDefinition() {
+    const logger = getLogger();
+    logger?.verbose('#Function getLayerDefinition', {
+      id: this.id,
+      trackId: this.trackId,
+    });
+
+    const layerDefinition: HMSSimulcastLayerDefinition[] =
+      await HMSManager.getVideoTrackLayerDefinition({
+        id: this.id,
+        trackId: this.trackId,
+      });
+
+    return HMSEncoder.encodeHMSSimulcastLayerDefinition(layerDefinition);
+  }
+
+  async setLayer(layer: HMSLayer) {
+    const logger = getLogger();
+    logger?.verbose('#Function setVideoTrackLayer', {
+      id: this.id,
+      trackId: this.trackId,
+      layer,
+    });
+
+    const success = await HMSManager.setVideoTrackLayer({
+      id: this.id,
+      trackId: this.trackId,
+      layer,
+    });
+
+    return success;
+  }
+
   constructor(params: {
     trackId: string;
     source?: number | string;
     trackDescription?: string;
     isMute?: boolean;
-    layer?: any;
     playbackAllowed?: boolean;
     id: string;
+    isDegraded?: boolean;
     type?: HMSTrackType;
   }) {
     super(params);
-    this.layer = params.layer;
   }
 }

package/src/classes/HMSRoom.ts

@@ -10,9 +10,11 @@ import { HMSConstants } from './HMSConstants';
 
 export class HMSRoom {
   id: string;
+  // startedAt?: Date;
 
   constructor(params: { id: string }) {
     this.id = params.id;
+    // this.startedAt = params.startedAt;
   }
 
   get sessionId(): string {

package/src/classes/HMSRoomUpdate.ts

@@ -6,4 +6,5 @@ export enum HMSRoomUpdate {
   BROWSER_RECORDING_STATE_UPDATED = 'BROWSER_RECORDING_STATE_UPDATED',
   HLS_STREAMING_STATE_UPDATED = 'HLS_STREAMING_STATE_UPDATED',
   HLS_RECORDING_STATE_UPDATED = 'HLS_RECORDING_STATE_UPDATED',
+  ROOM_PEER_COUNT_UPDATED = 'ROOM_PEER_COUNT_UPDATED',
 }

package/src/classes/HMSSDK.tsx

@@ -1,15 +1,11 @@
 import React from 'react';
-import { AppState, NativeModules, Platform, ViewStyle } from 'react-native';
+import { AppState, NativeModules, Platform } from 'react-native';
 import { HMSEncoder } from './HMSEncoder';
 import { HMSHelper } from './HMSHelper';
-import { HMSLocalAudioStats } from './HMSLocalAudioStats';
-import { HMSLocalVideoStats } from './HMSLocalVideoStats';
 import { getLogger, logger, setLogger } from './HMSLogger';
-import { HMSRemoteAudioStats } from './HMSRemoteAudioStats';
-import { HMSRemoteVideoStats } from './HMSRemoteVideoStats';
 import { HMSTrackType } from './HMSTrackType';
 import { HMSUpdateListenerActions } from './HMSUpdateListenerActions';
-import { HmsViewComponent } from './HmsView';
+import { HmsViewComponent, HmsComponentProps } from './HmsView';
 
 import type { HMSConfig } from './HMSConfig';
 import type { HMSLocalPeer } from './HMSLocalPeer';
@@ -47,14 +43,9 @@ import {
 } from './HMSRoomCache';
 import { HMSPeerUpdateOrdinals } from './HMSPeerUpdate';
 
-interface HmsViewProps {
-  trackId: string;
-  style?: ViewStyle;
-  mirror?: boolean;
-  scaleType?: HMSVideoViewMode;
-  setZOrderMediaOverlay?: boolean;
-}
+type HmsViewProps = Omit<HmsComponentProps, 'id'>;
 
+// TODO: Rename to HMSPIPConfig & to be moved to a separate file
 interface PIPConfig {
   aspectRatio?: [number, number];
   endButton?: boolean;
@@ -250,6 +241,7 @@ export class HMSSDK {
    * - The appearance of tile is completely customizable with style prop.
    * - Scale type can determine how the incoming video will fit in the canvas check {@link HMSVideoViewMode} for more information.
    * - Mirror to flip the video vertically.
+   * - Auto Simulcast to automatically select the best Streaming Quality of track if feature is enabled in Room.
    *
    * checkout {@link https://www.100ms.live/docs/react-native/v2/features/render-video} for more info
    *
@@ -257,12 +249,20 @@ export class HMSSDK {
    * @memberof HMSSDK
    */
   HmsView = React.forwardRef<any, HmsViewProps>((props, ref) => {
-    const { trackId, style, mirror, scaleType, setZOrderMediaOverlay } = props;
+    const {
+      trackId,
+      style,
+      mirror,
+      scaleType,
+      setZOrderMediaOverlay,
+      autoSimulcast,
+    } = props;
     return (
       <HmsViewComponent
         ref={ref}
         trackId={trackId}
         style={style}
+        autoSimulcast={autoSimulcast}
         setZOrderMediaOverlay={setZOrderMediaOverlay}
         mirror={mirror}
         scaleType={scaleType}
@@ -845,36 +845,6 @@ export class HMSSDK {
     return await HMSManager.stopScreenshare({ id: this.id });
   };
 
-  /**
-   * - enableRTCStats sets a boolean in native side which in turn allows several events to be passed
-   * through the bridge these events are {@link RTCStatsListener}, {@link onRemoteVideoStatsListener},
-   * {@link onRemoteAudioStatsListener}, {@link onLocalAudioStatsListener} and {@link onLocalVideoStatsListener}
-   *
-   * - These listeners get various dataPoints for current peers and their connectivity to the room
-   * such as jitter, latency etc.
-   *
-   * - currently available for iOS only
-   *
-   * @memberof HMSSDK
-   */
-  enableRTCStats = () => {
-    logger?.verbose('#Function enableRTCStats', { id: this.id });
-    HMSManager.enableRTCStats({ id: this.id });
-  };
-
-  /**
-   * - disable RTCStats sets the same boolean to false that was set true by enableRTCStats.
-   * that activates a check which filters out the events acquired in native listeners and don't
-   * let them pass through bridge
-   *
-   * - currently available for iOS only.
-   * @memberof HMSSDK
-   */
-  disableRTCStats = () => {
-    logger?.verbose('#Function disableRTCStats', { id: this.id });
-    HMSManager.disableRTCStats({ id: this.id });
-  };
-
   enableNetworkQualityUpdates = () => {
     logger?.verbose('#Function enableNetworkQualityUpdates', { id: this.id });
     HMSManager.enableNetworkQualityUpdates({ id: this.id });
@@ -1106,6 +1076,34 @@ export class HMSSDK {
     return await HMSManager.getSessionMetaData({ id: this.id });
   };
 
+  getRemoteVideoTrackFromTrackId = async (trackId: string) => {
+    logger?.verbose('#Function getRemoteVideoTrackFromTrackId', {
+      id: this.id,
+      trackId,
+    });
+
+    const remoteVideoTrackData =
+      await HMSManager.getRemoteVideoTrackFromTrackId({
+        id: this.id,
+        trackId,
+      });
+    return HMSEncoder.encodeHmsRemoteVideoTrack(remoteVideoTrackData, this.id);
+  };
+
+  getRemoteAudioTrackFromTrackId = async (trackId: string) => {
+    logger?.verbose('#Function getRemoteAudioTrackFromTrackId', {
+      id: this.id,
+      trackId,
+    });
+
+    const remoteAudioTrackData =
+      await HMSManager.getRemoteAudioTrackFromTrackId({
+        id: this.id,
+        trackId,
+      });
+    return HMSEncoder.encodeHmsRemoteAudioTrack(remoteAudioTrackData, this.id);
+  };
+
   /**
    * - This is a prototype event listener that takes action and listens for updates related to that particular action
    *
@@ -2105,7 +2103,9 @@ export class HMSSDK {
       return;
     }
 
-    let localAudioStats = new HMSLocalAudioStats(data.localAudioStats);
+    let localAudioStats = HMSEncoder.encodeHMSLocalAudioStats(
+      data.localAudioStats
+    );
     let peer = HMSEncoder.encodeHmsPeer(data.peer);
     let track = HMSEncoder.encodeHmsLocalAudioTrack(data.track, this.id);
 
@@ -2125,7 +2125,9 @@ export class HMSSDK {
       return;
     }
 
-    let localVideoStats = new HMSLocalVideoStats(data.localVideoStats);
+    let localVideoStats = HMSEncoder.encodeHMSLocalVideoStats(
+      data.localVideoStats
+    );
     let peer = HMSEncoder.encodeHmsPeer(data.peer);
     let track = HMSEncoder.encodeHmsLocalVideoTrack(data.track, this.id);
 
@@ -2145,7 +2147,9 @@ export class HMSSDK {
       return;
     }
 
-    let remoteAudioStats = new HMSRemoteAudioStats(data.remoteAudioStats);
+    let remoteAudioStats = HMSEncoder.encodeHMSRemoteAudioStats(
+      data.remoteAudioStats
+    );
     let peer = HMSEncoder.encodeHmsPeer(data.peer);
     let track = HMSEncoder.encodeHmsRemoteAudioTrack(data.track, this.id);
 
@@ -2170,7 +2174,9 @@ export class HMSSDK {
       return;
     }
 
-    let remoteVideoStats = new HMSRemoteVideoStats(data.remoteVideoStats);
+    let remoteVideoStats = HMSEncoder.encodeHMSRemoteVideoStats(
+      data.remoteVideoStats
+    );
     let peer = HMSEncoder.encodeHmsPeer(data.peer);
     let track = HMSEncoder.encodeHmsRemoteVideoTrack(data.track, this.id);
 

package/src/classes/HMSSimulcastLayerDefinition.ts

@@ -0,0 +1,12 @@
+import type { HMSLayer } from './HMSLayer';
+import type { HMSVideoResolution } from './HMSVideoResolution';
+
+export class HMSSimulcastLayerDefinition {
+  layer: HMSLayer;
+  resolution: HMSVideoResolution;
+
+  constructor(params: { layer: HMSLayer; resolution: HMSVideoResolution }) {
+    this.layer = params.layer;
+    this.resolution = params.resolution;
+  }
+}

package/src/classes/HMSSimulcastLayerSettingsPolicy.ts

@@ -0,0 +1,18 @@
+export class HMSSimulcastLayerSettingsPolicy {
+  rid?: string;
+  scaleResolutionDownBy?: number;
+  maxBitrate?: number;
+  maxFramerate?: number;
+
+  constructor(params: {
+    rid?: string;
+    scaleResolutionDownBy?: number;
+    maxBitrate?: number;
+    maxFramerate?: number;
+  }) {
+    this.rid = params.rid;
+    this.scaleResolutionDownBy = params.scaleResolutionDownBy;
+    this.maxBitrate = params.maxBitrate;
+    this.maxFramerate = params.maxFramerate;
+  }
+}

package/src/classes/HMSSimulcastSettings.ts

@@ -1,5 +1,14 @@
+import type { HMSSimulcastSettingsPolicy } from './HMSSimulcastSettingsPolicy';
+
 export class HMSSimulcastSettings {
-  low: any;
-  med: any;
-  high: any;
+  video?: HMSSimulcastSettingsPolicy;
+  screen?: HMSSimulcastSettingsPolicy;
+
+  constructor(params: {
+    video?: HMSSimulcastSettingsPolicy;
+    screen?: HMSSimulcastSettingsPolicy;
+  }) {
+    this.video = params.video;
+    this.screen = params.screen;
+  }
 }