@100mslive/react-native-hms 1.1.0 → 1.2.0

package/src/classes/HMSEncoder.ts

@@ -1,3 +1,5 @@
+import { NativeModules } from 'react-native';
+
 import { HMSTrack } from './HMSTrack';
 import { HMSAudioTrack } from './HMSAudioTrack';
 import { HMSVideoTrack } from './HMSVideoTrack';
@@ -29,7 +31,19 @@ import { HMSMessage } from './HMSMessage';
 import { HMSMessageRecipient } from './HMSMessageRecipient';
 import { HMSException } from './HMSException';
 
+const { HMSManager } = NativeModules;
+
+interface InitialData {
+  roles: Record<string, HMSRole>;
+}
+
 export class HMSEncoder {
+  private static data: InitialData = { roles: {} };
+
+  static clearData() {
+    this.data = { roles: {} };
+  }
+
   static encodeHmsRoom(room: HMSRoom, id: string) {
     const encodedObj = {
       id: room?.id,
@@ -71,19 +85,24 @@ export class HMSEncoder {
   static encodeHmsPeer(peer: any, id: string) {
     const encodedObj = {
       peerID: peer?.peerID,
-      name: peer?.name,
+      name: peer?.name || '',
       isLocal: peer?.isLocal,
       customerUserID: peer?.customerUserID,
-      customerDescription: peer?.customerDescription,
+      customerDescription: peer?.customerDescription || undefined,
       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(
-        peer?.auxiliaryTracks,
-        id
-      ),
+      networkQuality: peer?.networkQuality
+        ? HMSEncoder.encodeHMSNetworkQuality(peer?.networkQuality)
+        : undefined,
+      audioTrack: peer?.audioTrack
+        ? HMSEncoder.encodeHmsAudioTrack(peer?.audioTrack, id)
+        : undefined,
+      videoTrack: peer?.videoTrack
+        ? HMSEncoder.encodeHmsVideoTrack(peer?.videoTrack, id)
+        : undefined,
+      auxiliaryTracks: Array.isArray(peer?.auxiliaryTracks)
+        ? HMSEncoder.encodeHmsAuxiliaryTracks(peer?.auxiliaryTracks, id)
+        : undefined,
     };
 
     return new HMSPeer(encodedObj);
@@ -139,42 +158,55 @@ export class HMSEncoder {
 
   static encodeHmsLocalPeer(peer: any, id: string) {
     const encodedObj = {
-      peerID: peer.peerID,
-      name: peer.name,
-      isLocal: peer.isLocal,
-      customerUserID: peer.customerUserID,
-      customerDescription: peer.customerDescription,
-      metadata: peer.metadata,
+      peerID: peer?.peerID,
+      name: peer?.name,
+      isLocal: true,
+      customerUserID: peer?.customerUserID,
+      customerDescription: peer?.customerDescription || undefined,
+      metadata: peer?.metadata || undefined,
       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(
-        peer.auxiliaryTracks,
-        id
-      ),
-      localAudioTrackData: {
-        id: id,
-        trackId: peer?.localAudioTrackData?.trackId,
-        source: peer?.localAudioTrackData?.source,
-        trackDescription: peer?.localAudioTrackData?.trackDescription,
-        isMute: peer?.localAudioTrackData?.isMute,
-        settings: HMSEncoder.encodeHmsAudioTrackSettings(
-          peer?.localAudioTrackData?.settings
-        ),
-        type: peer?.localAudioTrackData?.type,
-      },
-      localVideoTrackData: {
-        id: id,
-        trackId: peer?.localVideoTrackData?.trackId,
-        source: peer?.localVideoTrackData?.source,
-        trackDescription: peer?.localVideoTrackData?.trackDescription,
-        isMute: peer?.localVideoTrackData?.isMute,
-        settings: HMSEncoder.encodeHmsVideoTrackSettings(
-          peer?.localVideoTrackData?.settings
-        ),
-        type: peer?.localVideoTrackData?.type,
-      },
+      networkQuality: peer?.networkQuality
+        ? HMSEncoder.encodeHMSNetworkQuality(peer?.networkQuality)
+        : undefined,
+      audioTrack: peer?.audioTrack
+        ? HMSEncoder.encodeHmsAudioTrack(peer?.audioTrack, id)
+        : undefined,
+      videoTrack: peer?.videoTrack
+        ? HMSEncoder.encodeHmsVideoTrack(peer?.videoTrack, id)
+        : undefined,
+      auxiliaryTracks: Array.isArray(peer?.auxiliaryTracks)
+        ? HMSEncoder.encodeHmsAuxiliaryTracks(peer?.auxiliaryTracks, id)
+        : undefined,
+      localAudioTrackData: peer?.localAudioTrackData?.trackId
+        ? {
+            id: id,
+            trackId: peer?.localAudioTrackData?.trackId,
+            source: peer?.localAudioTrackData?.source,
+            trackDescription: peer?.localAudioTrackData?.trackDescription,
+            isMute: peer?.localAudioTrackData?.isMute,
+            settings: peer?.localAudioTrackData?.settings
+              ? HMSEncoder.encodeHmsAudioTrackSettings(
+                  peer?.localAudioTrackData?.settings
+                )
+              : undefined,
+            type: peer?.localAudioTrackData?.type,
+          }
+        : undefined,
+      localVideoTrackData: peer?.localVideoTrackData?.trackId
+        ? {
+            id: id,
+            trackId: peer?.localVideoTrackData?.trackId,
+            source: peer?.localVideoTrackData?.source,
+            trackDescription: peer?.localVideoTrackData?.trackDescription,
+            isMute: peer?.localVideoTrackData?.isMute,
+            settings: peer?.localVideoTrackData?.settings
+              ? HMSEncoder.encodeHmsVideoTrackSettings(
+                  peer?.localVideoTrackData?.settings
+                )
+              : undefined,
+            type: peer?.localVideoTrackData?.type,
+          }
+        : undefined,
     };
 
     return new HMSLocalPeer(encodedObj);
@@ -217,7 +249,9 @@ export class HMSEncoder {
       source: track?.source,
       trackDescription: track?.trackDescription,
       isMute: track?.isMute,
-      settings: HMSEncoder.encodeHmsAudioTrackSettings(track?.settings),
+      settings: track?.settings
+        ? HMSEncoder.encodeHmsAudioTrackSettings(track?.settings)
+        : undefined,
       type: track?.type,
     };
 
@@ -231,7 +265,9 @@ export class HMSEncoder {
       source: track?.source,
       trackDescription: track?.trackDescription,
       isMute: track?.isMute,
-      settings: HMSEncoder.encodeHmsVideoTrackSettings(track?.settings),
+      settings: track?.settings
+        ? HMSEncoder.encodeHmsVideoTrackSettings(track?.settings)
+        : undefined,
       type: track?.type,
     };
 
@@ -252,37 +288,46 @@ export class HMSEncoder {
 
   static encodeHmsRemotePeer(peer: any, id: string) {
     const encodedObj = {
-      peerID: peer.peerID,
-      name: peer.name,
-      isLocal: peer.isLocal,
-      customerUserID: peer.customerUserID,
+      peerID: peer?.peerID,
+      name: peer?.name,
+      isLocal: false,
+      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(
-        peer.auxiliaryTracks,
-        id
-      ),
-      remoteAudioTrackData: {
-        id: id,
-        trackId: peer?.remoteAudioTrackData?.trackId,
-        source: peer?.remoteAudioTrackData?.source,
-        trackDescription: peer?.remoteAudioTrackData?.trackDescription,
-        isMute: peer?.remoteAudioTrackData?.isMute,
-        playbackAllowed: peer?.remoteAudioTrackData?.playbackAllowed,
-      },
-      remoteVideoTrackData: {
-        id: id,
-        trackId: peer?.remoteVideoTrackData?.trackId,
-        source: peer?.remoteVideoTrackData?.source,
-        trackDescription: peer?.remoteVideoTrackData?.trackDescription,
-        layer: peer?.remoteVideoTrackData?.layer,
-        isMute: peer?.remoteVideoTrackData?.isMute,
-        playbackAllowed: peer?.remoteVideoTrackData?.playbackAllowed,
-      },
+      networkQuality: peer?.networkQuality
+        ? HMSEncoder.encodeHMSNetworkQuality(peer?.networkQuality)
+        : undefined,
+      audioTrack: peer?.audioTrack
+        ? HMSEncoder.encodeHmsAudioTrack(peer?.audioTrack, id)
+        : undefined,
+      videoTrack: peer?.videoTrack
+        ? HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id)
+        : undefined,
+      auxiliaryTracks: Array.isArray(peer?.auxiliaryTracks)
+        ? HMSEncoder.encodeHmsAuxiliaryTracks(peer?.auxiliaryTracks, id)
+        : undefined,
+      remoteAudioTrackData: peer?.remoteAudioTrackData?.trackId
+        ? {
+            id: id,
+            trackId: peer?.remoteAudioTrackData?.trackId,
+            source: peer?.remoteAudioTrackData?.source,
+            trackDescription: peer?.remoteAudioTrackData?.trackDescription,
+            isMute: peer?.remoteAudioTrackData?.isMute,
+            playbackAllowed: peer?.remoteAudioTrackData?.playbackAllowed,
+          }
+        : undefined,
+      remoteVideoTrackData: peer?.remoteVideoTrackData?.trackId
+        ? {
+            id: id,
+            trackId: peer?.remoteVideoTrackData?.trackId,
+            source: peer?.remoteVideoTrackData?.source,
+            trackDescription: peer?.remoteVideoTrackData?.trackDescription,
+            layer: peer?.remoteVideoTrackData?.layer,
+            isMute: peer?.remoteVideoTrackData?.isMute,
+            playbackAllowed: peer?.remoteVideoTrackData?.playbackAllowed,
+          }
+        : undefined,
     };
 
     return new HMSRemotePeer(encodedObj);
@@ -332,14 +377,37 @@ export class HMSEncoder {
   }
 
   static encodeHmsRole(role: any) {
-    const hmsRole = new HMSRole(role);
+    if (!role) {
+      return new HMSRole(role);
+    }
+
+    const rolesCache = this.data.roles;
+
+    const cachedRole = rolesCache[role.name];
+
+    // create new HMSRole instance, if cached role does not exist OR `role.publishSettings?.allowed` does not exist
+    if (!cachedRole || !cachedRole.publishSettings?.allowed) {
+      // Creating HMSRole object with data
+      const hmsRole = new HMSRole(role);
+
+      // saving the created HMSRole object into cache
+      rolesCache[role.name] = hmsRole;
 
-    return hmsRole;
+      // If the created HMSRole object is complete,
+      // sending notification to Native Side to stop sending data for this role
+      if (hmsRole.publishSettings?.allowed) {
+        HMSManager.restrictData({ id: "12345", roleName: hmsRole.name });
+      }
+    }
+
+    return rolesCache[role.name];
   }
 
   static encodeHmsRoleChangeRequest(data: any, id: string) {
     const encodedRoleChangeRequest = {
-      requestedBy: HMSEncoder.encodeHmsPeer(data.requestedBy, id),
+      requestedBy: data.requestedBy
+        ? HMSEncoder.encodeHmsPeer(data.requestedBy, id)
+        : undefined,
       suggestedRole: HMSEncoder.encodeHmsRole(data.suggestedRole),
     };
 
@@ -351,7 +419,9 @@ export class HMSEncoder {
     id: string
   ) {
     const encodedChangeTrackStateRequest = {
-      requestedBy: HMSEncoder.encodeHmsPeer(data.requestedBy, id),
+      requestedBy: data?.requestedBy
+        ? HMSEncoder.encodeHmsPeer(data?.requestedBy, id)
+        : undefined,
       trackType: data.trackType,
       mute: data.mute,
     };
@@ -399,44 +469,57 @@ export class HMSEncoder {
 
   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,
+      running: data?.running || false,
+      startedAt: HMSEncoder.encodeDate(data?.startedAt),
+      stoppedAt: HMSEncoder.encodeDate(data?.stoppedAt),
+      error: data?.error || undefined,
     });
   }
 
   static encodeServerRecordingState(data: any) {
     return new HMSServerRecordingState({
-      running: data?.running,
-      error: data?.error,
-      startedAt: new Date(parseInt(data?.startedAt)),
+      running: data?.running || false,
+      error: data?.error || undefined,
+      startedAt: HMSEncoder.encodeDate(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,
+      running: data?.running || false,
+      startedAt: HMSEncoder.encodeDate(data?.startedAt),
+      stoppedAt: HMSEncoder.encodeDate(data?.stoppedAt),
+      error: data?.error || undefined,
     });
   }
 
+  static encodeDate(dateData: any) {
+    if (!dateData) {
+      return undefined;
+    }
+    const dateNum = parseInt(dateData);
+    if (isNaN(dateNum)) {
+      return undefined;
+    }
+    return new Date(dateNum);
+  }
+
   static encodeHLSStreamingState(data: any) {
     return new HMSHLSStreamingState({
-      running: data?.running,
-      variants: this.encodeHLSVariants(data?.variants),
+      running: data?.running || false,
+      variants: Array.isArray(data?.variants)
+        ? this.encodeHLSVariants(data?.variants)
+        : undefined,
     });
   }
 
   static encodeHLSRecordingState(data: any) {
     if (data) {
       return new HMSHLSRecordingState({
-        running: data?.running,
-        startedAt: new Date(parseInt(data?.startedAt)),
-        singleFilePerLayer: data?.singleFilePerLayer,
-        videoOnDemand: data?.videoOnDemand,
+        running: data?.running || false,
+        startedAt: HMSEncoder.encodeDate(data?.startedAt),
+        singleFilePerLayer: data?.singleFilePerLayer || false,
+        videoOnDemand: data?.videoOnDemand || false,
       });
     } else {
       return undefined;
@@ -450,8 +533,8 @@ export class HMSEncoder {
       let variant = new HMSHLSVariant({
         hlsStreamUrl: item.hlsStreamUrl,
         meetingUrl: item.meetingUrl,
-        metadata: item?.metadata,
-        startedAt: new Date(parseInt(item?.startedAt)),
+        metadata: item?.metaData ? item?.metadata : undefined,
+        startedAt: HMSEncoder.encodeDate(item?.startedAt),
       });
       variants.push(variant);
     });
@@ -486,8 +569,12 @@ export class HMSEncoder {
   static encodeHMSMessageRecipient(data: any, id: string) {
     return new HMSMessageRecipient({
       recipientType: data?.recipientType,
-      recipientPeer: this.encodeHmsPeer(data?.recipientPeer, id),
-      recipientRoles: this.encodeHmsRoles(data?.recipientRoles),
+      recipientPeer: data?.recipientPeer
+        ? this.encodeHmsPeer(data.recipientPeer, id)
+        : undefined,
+      recipientRoles: Array.isArray(data?.recipientRoles)
+        ? this.encodeHmsRoles(data.recipientRoles)
+        : [],
     });
   }
 

package/src/classes/HMSHLSStreamingState.ts

@@ -2,9 +2,9 @@ import type { HMSHLSVariant } from './HMSHLSVariant';
 
 export class HMSHLSStreamingState {
   running: boolean;
-  variants: Array<HMSHLSVariant>;
+  variants?: Array<HMSHLSVariant>;
 
-  constructor(params: { running: boolean; variants: Array<HMSHLSVariant> }) {
+  constructor(params: { running: boolean; variants?: Array<HMSHLSVariant> }) {
     this.running = params.running;
     this.variants = params.variants;
   }

package/src/classes/HMSLocalVideoTrack.ts

@@ -13,8 +13,6 @@ const {
 
 export class HMSLocalVideoTrack extends HMSVideoTrack {
   settings?: HMSVideoTrackSettings;
-  startCapturing?: Function;
-  stopCapturing?: Function;
   id: string;
 
   /**

package/src/classes/HMSMessageRecipient.ts

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

package/src/classes/HMSNativeEventEmitter.ts

@@ -0,0 +1,86 @@
+import { EventSubscription, NativeEventEmitter } from "react-native";
+import { logger } from './HMSLogger';
+
+export type HMSEventSubscription = {
+  remove(): void;
+};
+
+export class HMSNativeEventEmitter {
+  private _nativeEventEmitter: NativeEventEmitter;
+  private _nativeModule: any;
+
+  constructor(nativeModule: any) {
+    this._nativeModule = nativeModule;
+    this._nativeEventEmitter = new NativeEventEmitter(nativeModule);
+  }
+
+  listenerCount(eventType: string): number {
+    // For RN version < v0.64, listenerCount method is not available
+    // @ts-ignore - typescript is giving error because we are running it with RN types version >= 0.64
+    if (typeof this._nativeEventEmitter.listeners === 'function') {
+      // @ts-ignore - typescript is giving error because we are running it with RN types version >= 0.64
+      const count = this._nativeEventEmitter.listeners(eventType).length;
+
+      logger?.verbose('#Function HMSNativeEventEmitter.listenerCount', { eventType, count });
+      return count;
+    }
+
+    // For RN version >= v0.64
+    const count = this._nativeEventEmitter.listenerCount(eventType);
+
+    logger?.verbose('#Function HMSNativeEventEmitter.listenerCount', { eventType, count });
+    return count;
+  }
+
+  addListener(id: string, eventType: string, listener: (...args: any[]) => any): HMSEventSubscription {
+    logger?.verbose('#Function HMSNativeEventEmitter.addListener', { id, eventType, listener });
+
+    // enable `eventType` on `HMSSDK`, if no listeners were added before
+    // if some listeners were added before, then `eventType` on `HMSSDK` should already be enabled
+    if (this.listenerCount(eventType) <= 0) {
+      this.enableHMSEventType(id, eventType);
+    }
+    
+    let subscription: EventSubscription | null = this._nativeEventEmitter.addListener(eventType, listener);
+
+    return {
+      remove: () => {
+        console.log('#Function EventSubscription.remove', { id, eventType, listener });
+        if (
+          subscription &&
+          Object.getOwnPropertyNames(subscription).includes('remove') &&
+          typeof subscription.remove === 'function'
+        ) {
+          subscription.remove();
+          subscription = null;
+        } else {
+          this._nativeEventEmitter.removeListener(eventType, listener);
+        }
+
+        // disable `eventType` on `HMSSDK`, if all listeners has been removed
+        if (this.listenerCount(eventType) <= 0) {
+          this.disableHMSEventType(id, eventType);
+        }
+      }
+    };
+  }
+
+  removeAllListeners(id: string, eventType: string) {
+    logger?.verbose('#Function HMSNativeEventEmitter.removeAllListeners', { id, eventType });
+
+    // disable `eventType` on `HMSSDK`
+    this.disableHMSEventType(id, eventType);
+
+    return this._nativeEventEmitter.removeAllListeners(eventType);
+  }
+
+  private enableHMSEventType(id: string, eventType: string) {
+    logger?.verbose('#Function HMSNativeEventEmitter.enableHMSEventType', { id, eventType });
+    this._nativeModule.enableEvent({ id, eventType });
+  }
+
+  private disableHMSEventType(id: string, eventType: string) {
+    logger?.verbose('#Function HMSNativeEventEmitter.disableHMSEventType', { id, eventType });
+    this._nativeModule.disableEvent({ id, eventType });
+  }
+}

package/src/classes/HMSPeer.ts

@@ -9,6 +9,10 @@ export class HMSPeer {
   name: string;
   isLocal?: boolean;
   customerUserID?: string;
+
+  /*
+   * @deprecated customerDescription has been deprecated in favor of metadata
+   */
   customerDescription?: string;
   metadata?: string;
   role?: HMSRole;

package/src/classes/HMSPublishSettings.ts

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

package/src/classes/HMSRole.ts

@@ -8,9 +8,6 @@ export class HMSRole {
   subscribeSettings?: HMSSubscribeSettings;
   permissions?: HMSPermissions;
   priority?: number;
-  generalPermissions?: any;
-  internalPlugins?: any;
-  externalPlugins?: any;
 
   constructor(params?: {
     name?: string;
@@ -18,9 +15,6 @@ export class HMSRole {
     permissions?: HMSPermissions;
     publishSettings?: HMSPublishSettings;
     subscribeSettings?: HMSSubscribeSettings;
-    generalPermissions?: any;
-    internalPlugins?: any;
-    externalPlugins?: any;
   }) {
     if (params) {
       this.name = params.name;
@@ -28,9 +22,6 @@ export class HMSRole {
       this.permissions = params.permissions;
       this.publishSettings = params.publishSettings;
       this.subscribeSettings = params.subscribeSettings;
-      this.generalPermissions = params.generalPermissions;
-      this.internalPlugins = params.internalPlugins;
-      this.externalPlugins = params.externalPlugins;
     }
   }
 }

package/src/classes/HMSRoleChangeRequest.ts

@@ -2,11 +2,13 @@ import type { HMSRole } from './HMSRole';
 import type { HMSPeer } from './HMSPeer';
 
 export class HMSRoleChangeRequest {
-  requestedBy: HMSPeer;
+  requestedBy?: HMSPeer;
   suggestedRole: HMSRole;
 
-  constructor(params: { requestedBy: HMSPeer; suggestedRole: HMSRole }) {
-    this.requestedBy = params.requestedBy;
+  constructor(params: { requestedBy?: HMSPeer; suggestedRole: HMSRole }) {
+    if (params.requestedBy) {
+      this.requestedBy = params.requestedBy;
+    }
     this.suggestedRole = params.suggestedRole;
   }
 }

package/src/classes/HMSRtmpStreamingState.ts

@@ -3,14 +3,14 @@ import type { HMSException } from './HMSException';
 export class HMSRtmpStreamingState {
   running: boolean;
   error?: HMSException;
-  startedAt: Date;
-  stoppedAt: Date;
+  startedAt?: Date;
+  stoppedAt?: Date;
 
   constructor(params: {
     running: boolean;
     error?: HMSException;
-    startedAt: Date;
-    stoppedAt: Date;
+    startedAt?: Date;
+    stoppedAt?: Date;
   }) {
     this.running = params.running;
     this.error = params.error;