@100mslive/react-native-hms 2.0.0-alpha.0 → 2.0.0-alpha.1

package/src/classes/HMSPeer.ts

@@ -5,15 +5,40 @@ import type { HMSTrack } from './HMSTrack';
 import type { HMSVideoTrack } from './HMSVideoTrack';
 import { getHmsPeersCache, getPeerPropertyFromNative } from './HMSPeersCache';
 import { HMSConstants } from './HMSConstants';
-
+import { HMSPeerType } from './HMSPeerType';
+
+/**
+ * Represents a peer in the HMS ecosystem.
+ *
+ * This class encapsulates the properties and state of a peer within a session, including their ID, name, role, and various status flags.
+ *
+ * @export
+ * @class HMSPeer
+ * @property {string} peerID - The unique identifier for the peer.
+ * @property {string | undefined} _name - The name of the peer. Private access.
+ * @property {boolean | undefined} _isLocal - Flag indicating whether the peer is the local user. Private access.
+ * @property {string | undefined} _customerUserID - An optional custom user ID set by the application. Private access.
+ * @property {string | undefined} _metadata - Optional metadata associated with the peer. Private access.
+ * @property {HMSRole | undefined} _role - The role assigned to the peer within the session. Private access.
+ * @property {boolean} _isHandRaised - Flag indicating whether the peer has raised their hand. Defaults to false. Private access.
+ * @property {HMSPeerType} _type - The type of the peer, e.g., regular, screen share. Defaults to `HMSPeerType.REGULAR`. Private access.
+ */
 export class HMSPeer {
   peerID: string;
-  name: string;
+  private _name: string | undefined;
   private _isLocal: boolean | undefined;
   private _customerUserID: string | undefined;
   private _metadata: string | undefined;
   private _role: HMSRole | undefined;
   private _isHandRaised: boolean = false;
+  private _type: HMSPeerType = HMSPeerType.REGULAR;
+
+  private _updateName(value: string) {
+    // If `_isLocal` is outdated, update it
+    if (this._name !== value) {
+      this._name = value;
+    }
+  }
 
   private _updateIsLocal(value: boolean) {
     // If `_isLocal` is outdated, update it
@@ -50,11 +75,57 @@ export class HMSPeer {
     }
   }
 
+  private _updateType(value: HMSPeerType) {
+    // If `_type` is outdated, update it
+    if (this._type !== value) {
+      this._type = value;
+    }
+  }
+
   constructor(params: { peerID: string; name: string }) {
     this.peerID = params.peerID;
-    this.name = params.name;
+    this._name = params.name;
+  }
+
+  /**
+   * Gets the name of the peer.
+   *
+   * This getter method retrieves the name of the peer. If the name has already been set locally, it returns that value.
+   * Otherwise, it attempts to retrieve the name from the HMS peers cache. If the cache does not contain the name,
+   * it falls back to fetching the name directly from the native layer using the peer's ID.
+   * Once a value is retrieved, it updates the local `_name` property to ensure consistency.
+   *
+   * @returns {string | undefined} The name of the peer if available, otherwise `undefined`.
+   */
+  get name(): string | undefined {
+    if (this._name) {
+      return this._name;
+    }
+    const hmsPeersCache = getHmsPeersCache();
+
+    const value = hmsPeersCache
+      ? hmsPeersCache.getProperty(this.peerID, 'name')
+      : getPeerPropertyFromNative(
+          HMSConstants.DEFAULT_SDK_ID,
+          this.peerID,
+          'name'
+        );
+
+    if (typeof value === 'string') {
+      this._updateName(value);
+    }
+    return value ?? this._name;
   }
 
+  /**
+   * Determines if the peer is the local user.
+   *
+   * This getter method checks if the peer is the local user by first attempting to retrieve the 'isLocal' property value from the HMS peers cache.
+   * If the value is not found in the cache, it falls back to fetching the property directly from the native layer using the peer's ID.
+   * Once a value is retrieved, it updates the local `_isLocal` property to ensure the value is current.
+   *
+   * @returns {boolean | undefined} True if the peer is the local user, false otherwise. Returns `undefined` if the information is not available.
+   */
   get isLocal(): boolean | undefined {
     const hmsPeersCache = getHmsPeersCache();
 
@@ -72,6 +143,18 @@ export class HMSPeer {
     return value ?? this._isLocal;
   }
 
+  /**
+   * Checks if the peer has raised their hand.
+   *
+   * This getter method determines whether the peer has their hand raised in the session. It first attempts to retrieve the 'isHandRaised' property value
+   * from the HMS peers cache. If the value is not found in the cache, it falls back to fetching the property directly from the native layer using the peer's ID.
+   * Once a value is retrieved, it updates the local `_isHandRaised` property to ensure the value is current and consistent.
+   *
+   * @returns {boolean} True if the peer has their hand raised, false otherwise. Defaults to false if the information is not available.
+   *
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/peer/large-room
+   *
+   */
   get isHandRaised(): boolean {
     const hmsPeersCache = getHmsPeersCache();
 
@@ -89,6 +172,18 @@ export class HMSPeer {
     return value ?? this._isHandRaised;
   }
 
+  /**
+   * Retrieves the network quality of the peer.
+   *
+   * This getter method attempts to obtain the network quality of the peer, which is an indicator of the current network conditions affecting the peer's connection.
+   * It first tries to get this information from the HMS peers cache. If the information is not available in the cache,
+   * it falls back to fetching the network quality directly from the native layer using the peer's ID.
+   * The network quality is represented by the `HMSNetworkQuality` type, which may include values such as 'good', 'poor', etc., depending on the implementation.
+   *
+   * @returns {HMSNetworkQuality | undefined} The network quality of the peer if available, otherwise `undefined`.
+   *
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/measure-network-quality-and-performance/network-quality
+   */
   get networkQuality(): HMSNetworkQuality | undefined {
     const hmsPeersCache = getHmsPeersCache();
 
@@ -103,6 +198,16 @@ export class HMSPeer {
     );
   }
 
+  /**
+   * Retrieves the custom user ID of the peer.
+   *
+   * This getter method attempts to obtain the custom user ID of the peer, which is an optional identifier that can be set by the application.
+   * It first tries to get this information from the HMS peers cache. If the information is not available in the cache,
+   * it falls back to fetching the custom user ID directly from the native layer using the peer's ID.
+   * Once a value is retrieved, it updates the local `_customerUserID` property to ensure the value is current and consistent.
+   *
+   * @returns {string | undefined} The custom user ID of the peer if available, otherwise `undefined`.
+   */
   get customerUserID(): string | undefined {
     const hmsPeersCache = getHmsPeersCache();
 
@@ -120,6 +225,18 @@ export class HMSPeer {
     return value ?? this._customerUserID;
   }
 
+  /**
+   * Retrieves the metadata associated with the peer.
+   *
+   * This getter method attempts to obtain the metadata of the peer, which can include any additional information set by the application.
+   * It first tries to get this information from the HMS peers cache. If the information is not available in the cache,
+   * it falls back to fetching the metadata directly from the native layer using the peer's ID.
+   * Once a value is retrieved, it updates the local `_metadata` property to ensure the value is current and consistent.
+   *
+   * @returns {string | undefined} The metadata of the peer if available, otherwise `undefined`.
+   *
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/peer/change-metadata
+   */
   get metadata(): string | undefined {
     const hmsPeersCache = getHmsPeersCache();
 
@@ -137,6 +254,18 @@ export class HMSPeer {
     return value ?? this._metadata;
   }
 
+  /**
+   * Retrieves the role of the peer.
+   *
+   * This getter method attempts to obtain the role assigned to the peer within the session. The role can define permissions and capabilities
+   * within the session context. It first tries to get this information from the HMS peers cache. If the role information is not available in the cache,
+   * it falls back to fetching the role directly from the native layer using the peer's ID. Once a value is retrieved, it updates the local `_role`
+   * property to ensure the value is current and consistent.
+   *
+   * @returns {HMSRole | undefined} The role of the peer if available, otherwise `undefined`.
+   *
+   * @see https://www.100ms.live/docs/get-started/v2/get-started/concepts/templates-and-roles
+   */
   get role(): HMSRole | undefined {
     const hmsPeersCache = getHmsPeersCache();
 
@@ -154,6 +283,15 @@ export class HMSPeer {
     return value ?? this._role;
   }
 
+  /**
+   * Retrieves the audio track associated with the peer.
+   *
+   * This getter method attempts to obtain the audio track of the peer. It first tries to get this information from the HMS peers cache.
+   * If the audio track information is not available in the cache, it falls back to fetching the audio track directly from the native layer using the peer's ID.
+   * This allows for real-time access to the peer's audio track, which can be used for various audio-related functionalities within the application.
+   *
+   * @returns {HMSAudioTrack | undefined} The audio track of the peer if available, otherwise `undefined`.
+   */
   get audioTrack(): HMSAudioTrack | undefined {
     const hmsPeersCache = getHmsPeersCache();
 
@@ -168,6 +306,16 @@ export class HMSPeer {
     );
   }
 
+  /**
+   * Retrieves the video track associated with the peer.
+   *
+   * This getter method attempts to obtain the video track of the peer. It first tries to get this information from the HMS peers cache.
+   * If the video track information is not available in the cache, it falls back to fetching the video track directly from the native layer using the peer's ID.
+   * This allows for real-time access to the peer's video track, which can be used for various video-related functionalities within the application.
+   *
+   * @returns {HMSVideoTrack | undefined} The video track of the peer if available, otherwise `undefined`.
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/set-up-video-conferencing/render-video/overview
+   */
   get videoTrack(): HMSVideoTrack | undefined {
     const hmsPeersCache = getHmsPeersCache();
 
@@ -182,6 +330,18 @@ export class HMSPeer {
     );
   }
 
+  /**
+   * Retrieves the auxiliary tracks associated with the peer.
+   *
+   * This getter method attempts to obtain the auxiliary tracks of the peer, which can include tracks like screen shares or additional media streams.
+   * It first tries to get this information from the HMS peers cache. If the auxiliary track information is not available in the cache,
+   * it falls back to fetching the auxiliary tracks directly from the native layer using the peer's ID.
+   * This allows for real-time access to the peer's auxiliary tracks, which can be used for various functionalities within the application,
+   * such as displaying a screen share or additional video feeds.
+   *
+   * @returns {HMSTrack[] | undefined} The auxiliary tracks of the peer if available, otherwise `undefined`.
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/set-up-video-conferencing/screenshare
+   */
   get auxiliaryTracks(): HMSTrack[] | undefined {
     const hmsPeersCache = getHmsPeersCache();
 
@@ -195,4 +355,34 @@ export class HMSPeer {
       'auxiliaryTracks'
     );
   }
+
+  /**
+   * Retrieves the type of the peer.
+   *
+   * This getter method attempts to obtain the type of the peer, which can indicate whether the peer is a regular participant,
+   * a screen share, or another type defined within the `HMSPeerType` enum. It first tries to get this information from the HMS peers cache.
+   * If the type information is not available in the cache, it falls back to fetching the type directly from the native layer using the peer's ID.
+   * This ensures that the application has real-time access to the peer's type, which can be crucial for handling different peer types differently,
+   * such as displaying a screen share in a distinct manner. Once a value is retrieved, it updates the local `_type` property to ensure the value is current.
+   *
+   * @returns {HMSPeerType} The type of the peer, defaulting to the value stored in `_type` if the information is not available.
+   *
+   * @see https://www.100ms.live/docs/server-side/v2/how-to-guides/Session%20Initiation%20Protocol%20(SIP)/SIP-Interconnect
+   */
+  get type(): HMSPeerType {
+    const hmsPeersCache = getHmsPeersCache();
+
+    const value = hmsPeersCache
+      ? hmsPeersCache.getProperty(this.peerID, 'type')
+      : getPeerPropertyFromNative(
+          HMSConstants.DEFAULT_SDK_ID,
+          this.peerID,
+          'type'
+        );
+
+    if (value) {
+      this._updateType(value);
+    }
+    return value ?? this._type;
+  }
 }

package/src/classes/HMSPeerListIterator.ts

@@ -1,14 +1,21 @@
 // import type { HMSException } from "./HMSException";
 import type { HMSPeer } from './HMSPeer';
-import HMSManagerModule from './HMSManagerModule';
+import HMSManagerModule from '../modules/HMSManagerModule';
 import { HMSEncoder, logger } from '@100mslive/react-native-hms';
 import { HMSConstants } from './HMSConstants';
+import { getHmsPeersCache } from './HMSPeersCache';
 
 export class HMSPeerListIterator {
-  private readonly uniqueId: number;
+  private readonly uniqueId: string;
+  private _totalCount: number = 0;
 
-  constructor(uniqueId: number) {
+  get totalCount() {
+    return this._totalCount;
+  }
+
+  constructor(uniqueId: string, totalCount: number) {
     this.uniqueId = uniqueId;
+    this._totalCount = totalCount;
   }
 
   async hasNext(): Promise<boolean> {
@@ -27,10 +34,25 @@ export class HMSPeerListIterator {
   async next(): Promise<HMSPeer[]> {
     logger?.verbose('#Function HMSPeerListIterator#next', this.uniqueId);
     try {
-      const peers = await HMSManagerModule.peerListIteratorNext({
-        id: HMSConstants.DEFAULT_SDK_ID,
-        uniqueId: this.uniqueId,
-      });
+      const { totalCount, peers } = await HMSManagerModule.peerListIteratorNext(
+        {
+          id: HMSConstants.DEFAULT_SDK_ID,
+          uniqueId: this.uniqueId,
+        }
+      );
+
+      this._totalCount = totalCount;
+
+      if (Array.isArray(peers) && peers.length > 0) {
+        const hmsPeersCache = getHmsPeersCache();
+
+        if (hmsPeersCache) {
+          peers.forEach((peer) => {
+            hmsPeersCache.updatePeerCache(peer.peerID, peer);
+          });
+        }
+      }
+
       return HMSEncoder.encodeHmsPeers(peers);
     } catch (e) {
       logger?.error('#Error in #Function HMSPeerListIterator#next ', e);

package/src/classes/HMSPeerListIteratorOptions.ts

@@ -1,5 +1,26 @@
+/**
+ * options for creating `HMSPeerListIterator` instance
+ *
+ * ```
+ * const peerListIterator =  hmsInstance.getPeerListIterator({
+ *   limit: 10,
+ *   byRoleName: 'viewer-realtime',
+ * });
+ * ```
+ */
 export interface HMSPeerListIteratorOptions {
+  /**
+   * filter by role of the peers
+   */
   byRoleName?: string;
+
+  /**
+   * `peerID`s of the peers you want to fetch with iterator.
+   */
   byPeerIds?: string[];
+
+  /**
+   * number of peers fetched by the iterator in `next` method call. Default value is `10`
+   */
   limit?: number;
 }

package/src/classes/HMSPeerType.ts

@@ -0,0 +1,20 @@
+/**
+ * Enum for HMSPeerType.
+ *
+ * Defines the types of peers within the HMS (100ms) system. This enumeration is used to distinguish between different
+ * kinds of peers, such as SIP (Session Initiation Protocol) peers and regular peers. Each peer type has specific
+ * characteristics and roles within the video conferencing or communication context.
+ *
+ * @enum {string}
+ *
+ * @see https://www.100ms.live/docs/server-side/v2/how-to-guides/Session%20Initiation%20Protocol%20(SIP)/SIP-Interconnect
+ */
+export enum HMSPeerType {
+  SIP = 'SIP', // Represents a SIP peer, typically used for integrating with traditional telephony systems.
+  REGULAR = 'REGULAR', // Represents a regular peer, such as a standard user in a video call.
+}
+
+export const HMSPeerTypeOrdinals = new Map([
+  ['0', HMSPeerType.SIP],
+  ['1', HMSPeerType.REGULAR],
+]);

package/src/classes/HMSPeersCache.ts

@@ -1,4 +1,4 @@
-import HMSManager from './HMSManagerModule';
+import HMSManager from '../modules/HMSManagerModule';
 
 import { HMSEncoder } from './HMSEncoder';
 import { HMSPeerUpdate } from './HMSPeerUpdate';
@@ -10,6 +10,7 @@ import type { HMSNetworkQuality } from './HMSNetworkQuality';
 import type { HMSRole } from './HMSRole';
 import type { HMSAudioTrack } from './HMSAudioTrack';
 import type { HMSVideoTrack } from './HMSVideoTrack';
+import type { HMSPeerType } from './HMSPeerType';
 
 export let hmsPeersCache: HMSPeersCache | undefined;
 
@@ -40,6 +41,7 @@ export type HMSPeerCacheProps = {
   videoTrack?: HMSVideoTrack | undefined;
   auxiliaryTracks?: HMSTrack[] | undefined;
   isHandRaised?: boolean | undefined;
+  type?: HMSPeerType | undefined;
 };
 
 export class HMSPeersCache {

package/src/classes/HMSPermissions.ts

@@ -1,3 +1,16 @@
+import type { TranscriptionsMode } from './transcriptions';
+
+export interface HMSWhiteboardPermission {
+  admin?: boolean;
+  write?: boolean;
+  read?: boolean;
+}
+
+export interface HMSTranscriptionPermissions {
+  admin: boolean;
+  mode?: TranscriptionsMode;
+}
+
 export class HMSPermissions {
   endRoom?: boolean;
   removeOthers?: boolean;
@@ -7,6 +20,10 @@ export class HMSPermissions {
   browserRecording?: boolean;
   hlsStreaming?: boolean;
   rtmpStreaming?: boolean;
+  pollRead?: boolean;
+  pollWrite?: boolean;
+  whiteboard?: HMSWhiteboardPermission;
+  transcriptions?: Array<HMSTranscriptionPermissions>;
 
   constructor(params?: {
     endRoom?: boolean;
@@ -17,6 +34,10 @@ export class HMSPermissions {
     browserRecording?: boolean;
     hlsStreaming?: boolean;
     rtmpStreaming?: boolean;
+    pollRead?: boolean;
+    pollWrite?: boolean;
+    whiteboard?: HMSWhiteboardPermission;
+    transcriptions?: Array<HMSTranscriptionPermissions>;
   }) {
     if (params) {
       this.endRoom = params.endRoom;
@@ -27,6 +48,10 @@ export class HMSPermissions {
       this.browserRecording = params.browserRecording;
       this.hlsStreaming = params.hlsStreaming;
       this.rtmpStreaming = params.rtmpStreaming;
+      this.pollRead = params.pollRead;
+      this.pollWrite = params.pollWrite;
+      this.whiteboard = params.whiteboard;
+      this.transcriptions = params.transcriptions;
     }
   }
 }

package/src/classes/HMSPollsListenerActions.ts

@@ -0,0 +1,3 @@
+export enum HMSPollsListenerActions {
+  ON_POLL_UPDATE = 'ON_POLL_UPDATE',
+}

package/src/classes/HMSRTMPConfig.ts

@@ -1,5 +1,19 @@
 import type { HMSRtmpVideoResolution } from './HMSRtmpVideoResolution';
 
+/**
+ * Configuration class for RTMP streaming in the HMS (100ms) system.
+ *
+ * This class encapsulates the settings required to configure RTMP (Real-Time Messaging Protocol) streaming for a meeting.
+ * It includes options for the meeting URL, RTMP URLs for streaming, whether recording should be enabled, and the video resolution for the stream.
+ *
+ * @param {Object} params - The constructor parameters.
+ * @param {string} [params.meetingURL] - The URL of the meeting to be streamed. Optional.
+ * @param {Array<string>} [params.rtmpURLs] - An array of RTMP URLs to which the meeting will be streamed. Optional.
+ * @param {boolean} params.record - Flag indicating whether the stream should be recorded.
+ * @param {HMSRtmpVideoResolution} [params.resolution] - The resolution of the video to be streamed. Optional.
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/record-and-live-stream/recording
+ */
 export class HMSRTMPConfig {
   meetingURL?: string;
   rtmpURLs?: Array<string>;

package/src/classes/HMSRecordingState.ts

@@ -0,0 +1,9 @@
+export enum HMSRecordingState {
+  NONE = 'NONE',
+  STARTING = 'STARTING',
+  STARTED = 'STARTED',
+  PAUSED = 'PAUSED',
+  RESUMED = 'RESUMED',
+  STOPPED = 'STOPPED',
+  FAILED = 'FAILED',
+}

package/src/classes/HMSRole.ts

@@ -2,6 +2,23 @@ import type { HMSPermissions } from './HMSPermissions';
 import type { HMSPublishSettings } from './HMSPublishSettings';
 import type { HMSSubscribeSettings } from './HMSSubscribeSettings';
 
+/**
+ * Represents a role within the HMS ecosystem.
+ *
+ * A role defines the capabilities and permissions a user has in a session, such as publishing or subscribing to streams,
+ * and the priority of the user in the session. This class encapsulates the properties of a role, including its name,
+ * publishing settings, subscribing settings, permissions, and priority.
+ *
+ * @class HMSRole
+ * @property {string} [name] - The name of the role.
+ * @property {HMSPublishSettings} [publishSettings] - Settings related to publishing streams for this role.
+ * @property {HMSSubscribeSettings} [subscribeSettings] - Settings related to subscribing to streams for this role.
+ * @property {HMSPermissions} [permissions] - Permissions granted to this role.
+ * @property {number} [priority] - The priority of the role, determining its precedence in the session.
+ *
+ * @see https://www.100ms.live/docs/get-started/v2/get-started/concepts/templates-and-roles
+ *
+ */
 export class HMSRole {
   name?: string;
   publishSettings?: HMSPublishSettings;

package/src/classes/HMSRoom.ts

@@ -7,6 +7,7 @@ import type { HMSHLSRecordingState } from './HMSHLSRecordingState';
 import type { HMSLocalPeer } from './HMSLocalPeer';
 import { getHmsRoomCache, getHMSRoomPropertyFromNative } from './HMSRoomCache';
 import { HMSConstants } from './HMSConstants';
+import type { Transcriptions } from './transcriptions/Transcriptions';
 
 export class HMSRoom {
   id: string;
@@ -153,4 +154,30 @@ export class HMSRoom {
       'localPeer'
     );
   }
+
+  get isLargeRoom(): boolean {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('isLargeRoom');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'isLargeRoom'
+    );
+  }
+
+  get transcriptions(): Array<Transcriptions> {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('transcriptions');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'transcriptions'
+    );
+  }
 }

package/src/classes/HMSRoomCache.ts

@@ -1,4 +1,4 @@
-import HMSManager from './HMSManagerModule';
+import HMSManager from '../modules/HMSManagerModule';
 
 import type { HMSRoom } from './HMSRoom';
 import { HMSEncoder } from './HMSEncoder';
@@ -99,6 +99,13 @@ export class HMSRoomCache {
         );
         break;
       }
+      case HMSRoomUpdate.TRANSCRIPTIONS_UPDATED: {
+        this._data.set(
+          'transcriptions',
+          encodeHMSRoomProperty(this.id, 'transcriptions', data)
+        );
+        break;
+      }
       default: {
         for (const key in data) {
           const property = key as keyof HMSRoomCacheProps;
@@ -153,6 +160,8 @@ function encodeHMSRoomProperty<T extends keyof HMSRoomCacheProps>(
     value = HMSEncoder.encodeHLSStreamingState(data.hlsStreamingState);
   } else if (property === 'hlsRecordingState') {
     value = HMSEncoder.encodeHLSRecordingState(data.hlsRecordingState);
+  } else if (property === 'transcriptions') {
+    value = HMSEncoder.encodeTranscriptions(data.transcriptions);
   } else if (property === 'localPeer') {
     value = HMSEncoder.encodeHmsLocalPeer(data.localPeer, id);
   } else if (property === 'peerCount') {

package/src/classes/HMSRoomUpdate.ts

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

package/src/classes/HMSRtmpStreamingState.ts

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

package/src/classes/HMSRtmpVideoResolution.ts

@@ -1,3 +1,16 @@
+/**
+ * Represents the video resolution for RTMP streaming in the HMS (100ms) system.
+ *
+ * This class encapsulates the dimensions (height and width) of the video resolution to be used for RTMP streaming.
+ * It allows for specifying the video quality by defining the resolution, which is crucial for optimizing the streaming experience
+ * based on the bandwidth available and the requirements of the streaming platform.
+ *
+ * @param {Object} params - The constructor parameters.
+ * @param {number} params.height - The height of the video resolution.
+ * @param {number} params.width - The width of the video resolution.
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/record-and-live-stream/recording
+ */
 export class HMSRtmpVideoResolution {
   height: number;
   width: number;