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

package/src/classes/HMSServerRecordingState.ts

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

package/src/classes/HMSSessionStore.ts

@@ -1,7 +1,7 @@
 import { DeviceEventEmitter } from 'react-native';
 import type { EmitterSubscription as RNEmitterSubscription } from 'react-native';
 
-import HMSManager from './HMSManagerModule';
+import HMSManager from '../modules/HMSManagerModule';
 
 import { HMSConstants } from './HMSConstants';
 import { getLogger } from './HMSLogger';
@@ -9,14 +9,17 @@ import { HMSUpdateListenerActions } from './HMSUpdateListenerActions';
 import { EventEmitter } from '../utils';
 import type { EmitterSubscription } from '../utils';
 
-type Nullable<T> = T | null | undefined;
-
-export type HMSSessionStoreValue = Nullable<string>;
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonMap = {
+  [key: string]: JsonPrimitive | JsonMap | JsonArray;
+};
+export type JsonArray = Array<JsonPrimitive | JsonMap | JsonArray>;
+export type JsonValue = JsonPrimitive | JsonMap | JsonArray;
 
 /**
- * Session store is a shared realtime key-value store that is accessible by everyone in the room.
+ * Session store is a shared realtime key-value store that is accessible by all Peers in a Room.
  * It can be utilized to implement features such as pinned text, spotlight (which brings a particular
- * peer to the center stage for everyone in the room) and more.
+ * peer to the center stage for everyone in the room) and more, enhancing interactive experiences.
  *
  * To get an instance of `HMSSessionStore` class, You can add an event listener for `ON_SESSION_STORE_AVAILABLE`
  * event on the `HMSSDK` instance
@@ -38,52 +41,49 @@ export class HMSSessionStore {
    * Once a value is assigned, it will be available for other peers in the room
    * who are listening for changes in value for that specific key.
    *
-   * @param {HMSSessionStoreValue} value
-   * @param {string} key
-   * @returns {Promise}
+   * @param {JsonValue} value - The value to set, which can be any JSON-compatible type.
+   * @param {string} key - The key under which to store the value.
+   * @returns {Promise} A promise that resolves when the operation is complete.
    */
-  async set(value: HMSSessionStoreValue, key: string) {
-    const data: { success: true; finalValue: HMSSessionStoreValue } =
-      await HMSManager.setSessionMetadataForKey({
-        id: HMSConstants.DEFAULT_SDK_ID,
-        key,
-        value,
-      });
+  async set(value: JsonValue, key: string) {
+    const data: { success: true } = await HMSManager.setSessionMetadataForKey({
+      id: HMSConstants.DEFAULT_SDK_ID,
+      key,
+      value,
+    });
     return data;
   }
 
   /**
-   * This method returns the value of any specified key on session store.
-   * Note that you will not get updates for any change in value of the specified key,
-   * It returns the latest value at the time it was called.
+   * Retrieves the value for a given key from the session store. This method does not subscribe
+   * to changes; it only returns the current value at the time of the call.
    *
    * To listen to value change updates use `addKeyChangeListener` method instead.
    *
-   * @param {string} key
-   * @returns {Promise}
+   * @param {string} key - The key whose value is to be retrieved.
+   * @returns {Promise} A promise that resolves with the value of the key.
    */
   async get(key: string) {
-    const data: HMSSessionStoreValue =
-      await HMSManager.getSessionMetadataForKey({
-        id: HMSConstants.DEFAULT_SDK_ID,
-        key,
-      });
+    const data: JsonValue = await HMSManager.getSessionMetadataForKey({
+      id: HMSConstants.DEFAULT_SDK_ID,
+      key,
+    });
     return data;
   }
 
   /**
-   * This method registers a callback function for listening to value changes of a particular key.
-   * Registered Callback function will be called initially with latest value and whenever the value updates
+   * Registers a callback to listen for changes to specified keys in the session store.
+   * The callback is called with the initial value and again whenever any value changes.
    *
-   * @param {string[]} forKeys
-   * @param {Function} callback
-   * @returns {Object} subscription object
+   * @param {string[]} forKeys - An array of keys to listen for changes on.
+   * @param {Function} callback - The function to call when a value changes.
+   * @returns {Object} An object with a `remove` method to unregister the listener.
    */
   addKeyChangeListener<T extends string[]>(
     forKeys: T,
     callback: (
       error: string | null,
-      data: { key: T[number]; value: HMSSessionStoreValue } | null
+      data: { key: T[number]; value: JsonValue } | null
     ) => void
   ) {
     // Add Native Device Event Emitter if it is not already added
@@ -168,19 +168,8 @@ export class HMSSessionStore {
 
     if (this._addedKeyChangeListenerCount <= 0) {
       this._addedKeyChangeListenerCount = 0;
-      if (
-        this._deviceEventEmitterSubscription &&
-        Object.getOwnPropertyNames(
-          this._deviceEventEmitterSubscription
-        ).includes('remove') &&
-        typeof this._deviceEventEmitterSubscription.remove === 'function'
-      ) {
+      if (this._deviceEventEmitterSubscription) {
         this._deviceEventEmitterSubscription.remove();
-      } else {
-        DeviceEventEmitter.removeListener(
-          HMSUpdateListenerActions.ON_SESSION_STORE_CHANGED,
-          this._deviceEventEmitterListener
-        );
       }
 
       this._deviceEventEmitterSubscription = undefined;
@@ -192,7 +181,7 @@ export class HMSSessionStore {
   private _deviceEventEmitterListener(data: {
     id: string;
     key: string;
-    value: HMSSessionStoreValue;
+    value: JsonValue;
   }) {
     // if id is different from default sdk_id, return early
     if (data.id !== HMSConstants.DEFAULT_SDK_ID) {

package/src/classes/HMSStreamingState.ts

@@ -0,0 +1,7 @@
+export enum HMSStreamingState {
+  NONE = 'NONE',
+  STARTING = 'STARTING',
+  STARTED = 'STARTED',
+  STOPPED = 'STOPPED',
+  FAILED = 'FAILED',
+}

package/src/classes/HMSTrack.ts

@@ -1,6 +1,19 @@
 import type { HMSTrackSource } from './HMSTrackSource';
 import type { HMSTrackType } from './HMSTrackType';
 
+/**
+ * Represents a generic track within the HMS (100ms) system.
+ *
+ * This class serves as a base for different types of tracks (audio, video, etc.) within the HMS system. It encapsulates
+ * common properties and functionalities that are shared across different track types.
+ *
+ * @property {string} trackId - The unique identifier for the track.
+ * @property {HMSTrackSource} [source] - The source of the track, indicating whether it's from a plugin, regular input, or screen sharing.
+ * @property {string} [trackDescription] - A brief description of the track.
+ * @property {boolean} [mute] - Indicates whether the track is currently muted.
+ * @property {string} id - A secondary identifier for the track.
+ * @property {HMSTrackType} [type] - The type of the track, distinguishing between audio and video.
+ */
 export class HMSTrack {
   trackId: string;
   source?: HMSTrackSource;

package/src/classes/HMSTrackSettings.ts

@@ -1,6 +1,16 @@
 import type { HMSAudioTrackSettings } from './HMSAudioTrackSettings';
 import type { HMSVideoTrackSettings } from './HMSVideoTrackSettings';
 
+/**
+ * Represents the settings for both video and audio tracks in a HMS (100ms) application.
+ *
+ * This class encapsulates the configurations for video and audio tracks that can be used
+ * in a HMS session.
+ *
+ * @property {HMSVideoTrackSettings} video - Optional video track settings.
+ * @property {HMSAudioTrackSettings} audio - Optional audio track settings.
+ *
+ */
 export class HMSTrackSettings {
   video?: HMSVideoTrackSettings;
   audio?: HMSAudioTrackSettings;

package/src/classes/HMSTrackSettingsInitState.ts

@@ -1,4 +1,15 @@
+/**
+ * Enum for the initial state of tracks in a 100ms (HMS) application.
+ *
+ * This enumeration defines the initial mute state for tracks (audio or video) in a 100ms (HMS) application.
+ * It allows developers to specify whether a track should start in a muted or unmuted state, providing control over the user's media state upon joining a Room.
+ *
+ * @enum {string}
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/set-up-video-conferencing/join#join-with-muted-audio-video
+ */
 export enum HMSTrackSettingsInitState {
+  /** Represents the state where the track is initially muted. */
   MUTED = 'MUTED',
+  /** Represents the state where the track is initially unmuted. */
   UNMUTED = 'UNMUTED',
 }

package/src/classes/HMSTrackSource.ts

@@ -1,3 +1,13 @@
+/**
+ * Enum for HMS Track Source types.
+ *
+ * Defines the source of an HMS track, indicating whether the track originates from a plugin, is a regular track, or is a screen-sharing track.
+ *
+ * @enum {string}
+ * @property {string} REGULAR - Represents a regular track, typically from a user's camera or microphone.
+ * @property {string} SCREEN - Represents a track that shares the screen.
+ * @property {string} PLUGIN - Represents a track sourced from a plugin.
+ */
 export enum HMSTrackSource {
   PLUGIN = 'plugin',
   REGULAR = 'regular',

package/src/classes/HMSTrackType.ts

@@ -1,3 +1,10 @@
+/**
+ * Enum for HMS Track Types.
+ *
+ * This enumeration defines the types of tracks that can be handled within the HMS (100ms) system, specifically distinguishing between audio and video tracks.
+ * - `AUDIO`: Represents an audio track, typically containing sound or voice data.
+ * - `VIDEO`: Represents a video track, typically containing visual data from a camera or other video sources.
+ */
 export enum HMSTrackType {
   AUDIO = 'AUDIO',
   VIDEO = 'VIDEO',

package/src/classes/HMSUpdateListenerActions.ts

@@ -1,30 +1,340 @@
 /**
- * These are the available events emitted by the `HMSSDK`
+ * Enum for HMSUpdateListenerActions.
  *
+ * This enumeration defines the set of possible events that can be emitted by the HMSSDK during a Session.
+ * These events cover a wide range of actions, from joining a room to receiving updates about peers and tracks, and more.
  * For more info about these events, checkout Event Listener docs
- * {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/listen-to-room-updates/event-listeners}
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/listen-to-room-updates/event-listeners
+ *
+ * @enum {string}
+ *
+ * @example
+ * ```typescript
+ * hmsInstance.addEventListener(HMSUpdateListenerActions.ON_JOIN, ({ room: HMSRoom }}) => {
+ *  console.log('Joined room', data);
+ *  // Handle the event
+ * });
+ * ```
+ *
+ * @property {string} ON_PREVIEW - Emitted when the local preview is available.
+ * @property {string} ON_JOIN - Emitted when the local user joins the room.
+ * @property {string} ON_ROOM_UPDATE - Emitted when there is an update related to the room.
+ * @property {string} ON_PEER_UPDATE - Emitted when there is an update related to a peer in the room.
+ * @property {string} ON_TRACK_UPDATE - Emitted when there is an update related to a track in the room.
+ * @property {string} ON_ERROR - Emitted when an error occurs.
+ * @property {string} ON_MESSAGE - Emitted when a message is received.
+ * @property {string} ON_SPEAKER - Emitted when there is an update on the current speaker.
+ * @property {string} RECONNECTING - Emitted when the SDK is attempting to reconnect to the room.
+ * @property {string} RECONNECTED - Emitted when the SDK has successfully reconnected to the room.
+ * @property {string} ON_ROLE_CHANGE_REQUEST - Emitted when there is a request to change the role of a peer.
+ * @property {string} ON_CHANGE_TRACK_STATE_REQUEST - Emitted when there is a request to change the state of a track.
+ * @property {string} ON_REMOVED_FROM_ROOM - Emitted when the local user is removed from the room.
+ * @property {string} ON_RTC_STATS - Emitted when RTC stats are available.
+ * @property {string} ON_LOCAL_AUDIO_STATS - Emitted when stats for the local audio track are available.
+ * @property {string} ON_LOCAL_VIDEO_STATS - Emitted when stats for the local video track are available.
+ * @property {string} ON_REMOTE_AUDIO_STATS - Emitted when stats for a remote audio track are available.
+ * @property {string} ON_REMOTE_VIDEO_STATS - Emitted when stats for a remote video track are available.
+ * @property {string} ON_AUDIO_DEVICE_CHANGED - Emitted when the audio device has changed.
+ * @property {string} ON_SESSION_STORE_AVAILABLE - Emitted when the session store is available.
+ * @property {string} ON_SESSION_STORE_CHANGED - Emitted when the session store has changed.
+ * @property {string} ON_PEER_LIST_UPDATED - Emitted when the list of peers is updated.
+ * @property {string} ON_TRANSCRIPTS - Emitted when transcripts are available.
+ * @property {string} ON_PERMISSIONS_REQUESTED - Emitted when permissions are requested.
  */
 export enum HMSUpdateListenerActions {
+  /**
+   * Event emitted when the local preview is available.
+   *
+   * This event is triggered once the local user's video preview becomes available.
+   * It allows the application to display the local video stream to the user,
+   * ensuring they can see their own feed before interacting with others in the room.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/set-up-video-conferencing/preview
+   */
   ON_PREVIEW = 'ON_PREVIEW',
+
+  /**
+   * Event emitted when the local user joins the room.
+   *
+   * This event signifies that the local user has successfully connected to the room and is now part of the session.
+   * It is a critical event for initiating further actions within the room, such as fetching current participants,
+   * subscribing to tracks, or sending messages. Handling this event properly is essential for setting up the user's
+   * environment and ensuring a smooth experience in the room.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/set-up-video-conferencing/join
+   */
   ON_JOIN = 'ON_JOIN',
+
+  /**
+   * Event emitted when there is an update related to the room.
+   *
+   * This event is triggered by various room-related changes, such as updates to the room's metadata, changes in the room's state,
+   * or modifications to the list of available tracks. It serves as a general notification to the application that some aspect of the
+   * room's configuration or status has changed, enabling the application to respond appropriately, such as updating the UI or querying
+   * for new information to reflect the current state of the room.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/listen-to-room-updates/event-listeners
+   */
   ON_ROOM_UPDATE = 'ON_ROOM_UPDATE',
+
+  /**
+   * Event emitted when there is an update related to a peer in the room.
+   *
+   * This event is triggered whenever a peer's state changes within the room, such as when a peer's video or audio track is enabled or disabled,
+   * or when a peer's metadata is updated. It provides a way for the application to react to changes in a peer's status, ensuring that the UI
+   * and application state can be updated to reflect the current state of peers in the room.
+   *
+   * @type {string}
+   * @see  https://www.100ms.live/docs/react-native/v2/how-to-guides/listen-to-room-updates/event-listeners
+   */
   ON_PEER_UPDATE = '3',
+
+  /**
+   * Event emitted when the list of peers in the room is updated.
+   *
+   * This event is triggered whenever there is a change in the list of peers present in the room, such as when a new peer joins,
+   * an existing peer leaves. It allows the application to react to changes in the room's
+   * participant list, enabling dynamic updates to the UI or other logic based on the current set of participants.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/peer/large-room
+   */
+  ON_PEER_LIST_UPDATED = 'ON_PEER_LIST_UPDATED',
+
+  /**
+   * Event emitted when there is an update related to a track in the room.
+   *
+   * This event is triggered whenever a track's state changes within the room, such as when a video or audio track is enabled or disabled,
+   * or when a track's settings are modified. It provides a way for the application to react to changes in a track's status, ensuring that
+   * the UI and application state can be updated to reflect the current state of tracks in the room.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/listen-to-room-updates/event-listeners
+   */
   ON_TRACK_UPDATE = 'ON_TRACK_UPDATE',
+
+  /**
+   * Event emitted when an error occurs.
+   *
+   * This event is triggered whenever the HMS SDK encounters an error during its operation. It could be due to network issues,
+   * permissions being denied, or any other error that prevents the SDK from functioning as expected. Handling this event allows
+   * the application to inform the user about the issue and possibly take corrective action or log the error for further analysis.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/debugging/error-handling
+   */
   ON_ERROR = 'ON_ERROR',
+
+  /**
+   * Event emitted when a message is received.
+   *
+   * This event is triggered whenever a message is sent by a peer in the room and received by the local user.
+   * It is crucial for enabling real-time communication within the room, allowing participants to exchange text messages,
+   * notifications, or commands. Handling this event is essential for applications that support chat or command-based interactions
+   * among participants.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/set-up-video-conferencing/chat
+   */
   ON_MESSAGE = 'ON_MESSAGE',
+
+  /**
+   * Event emitted when there is an update on the current speaker.
+   *
+   * This event is triggered whenever the active speaker in the room changes, such as when a new participant starts speaking or the current speaker stops.
+   * It allows the application to highlight the current speaker in the UI, enhancing the user experience by making it easier to follow the conversation flow.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/set-up-video-conferencing/render-video/show-audio-level
+   */
   ON_SPEAKER = 'ON_SPEAKER',
+
+  /**
+   * Event emitted when the SDK is attempting to reconnect to the room.
+   *
+   * This event is triggered when the connection to the room is lost, and the HMS SDK is trying to re-establish the connection.
+   * It indicates that the SDK is in the process of reconnecting, allowing the application to notify users about the reconnection attempt
+   * and possibly display a loading or waiting indicator. Handling this event is crucial for maintaining a smooth user experience during
+   * network interruptions.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/handle-interruptions/reconnection-handling
+   */
   RECONNECTING = 'RECONNECTING',
+
+  /**
+   * Event emitted when the SDK has successfully reconnected to the room.
+   *
+   * This event signifies that after a disconnection, the HMS SDK has managed to re-establish the connection to the room successfully.
+   * It is crucial for applications to handle this event to update the UI and inform the user that the connection has been restored,
+   * ensuring a seamless experience. This event can trigger re-initialization of room-related functionalities or refreshes of the UI
+   * to reflect the current state of the room.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/handle-interruptions/reconnection-handling
+   */
   RECONNECTED = 'RECONNECTED',
+
+  /**
+   * Event emitted when there is a request to change the role of a peer.
+   *
+   * This event is triggered whenever a request is made to change the role of a participant in the room, such as from a viewer to a speaker or vice versa.
+   * Handling this event allows the application to manage user roles dynamically, ensuring that participants have the correct permissions for their intended
+   * actions within the room. It is crucial for applications that implement role-based access control or need to change user permissions on the fly.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/peer/change-role
+   */
   ON_ROLE_CHANGE_REQUEST = 'ON_ROLE_CHANGE_REQUEST',
+
+  /**
+   * Event emitted when there is a request to change the state of a track.
+   *
+   * This event is triggered whenever a request is made to change the state of a track within the room, such as enabling or disabling a video or audio track.
+   * Handling this event allows the application to respond to changes in track states, ensuring that participants can control their audio and video streams
+   * as needed. It is crucial for applications that allow users to manage their media streams dynamically during a session.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/track/remote-mute
+   */
   ON_CHANGE_TRACK_STATE_REQUEST = 'ON_CHANGE_TRACK_STATE_REQUEST',
+
+  /**
+   * Event emitted when the local user is removed from the room.
+   *
+   * This event is triggered whenever the local user is explicitly removed from the room by an action from another participant with sufficient permissions or due to room policy violations. Handling this event is crucial for applications to gracefully disconnect the user from the session, possibly clear user-related data, and inform the user about the removal reason if applicable.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/room/end-room
+   */
   ON_REMOVED_FROM_ROOM = 'ON_REMOVED_FROM_ROOM',
+
+  /**
+   * Event emitted when RTC stats are available.
+   *
+   * This event is triggered when real-time communication (RTC) statistics become available from the HMS SDK.
+   * RTC stats provide detailed information about the performance and quality of the media streams in the session,
+   * including metrics such as packet loss, jitter, round-trip time (RTT), and more. Handling this event allows
+   * the application to monitor and react to the quality of the connection, potentially informing users about
+   * the current call quality or troubleshooting issues in real-time.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/measure-network-quality-and-performance/rtc-stats
+   */
   ON_RTC_STATS = 'ON_RTC_STATS',
+
+  /**
+   * Event emitted when stats for the local audio track are available.
+   *
+   * This event is triggered when statistics related to the local user's audio track become available from the HMS SDK.
+   * These statistics can include metrics such as round trip time, bitrate, and bytesSent, which are crucial for monitoring
+   * the quality of the audio being transmitted. Handling this event allows the application to react to the audio quality,
+   * potentially adjusting settings or notifying the user about issues in real-time.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/measure-network-quality-and-performance/rtc-stats
+   */
   ON_LOCAL_AUDIO_STATS = 'ON_LOCAL_AUDIO_STATS',
+
+  /**
+   * Event emitted when stats for the local video track are available.
+   *
+   * This event is triggered when statistics related to the local user's video track become available from the HMS SDK.
+   * These statistics can include metrics such as frame rate, resolution, and bitrate, which are crucial for monitoring
+   * the quality of the video being transmitted. Handling this event allows the application to react to the video quality,
+   * potentially adjusting settings or notifying the user about issues in real-time.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/measure-network-quality-and-performance/rtc-stats
+   */
   ON_LOCAL_VIDEO_STATS = 'ON_LOCAL_VIDEO_STATS',
+
+  /**
+   * Event emitted when statistics for a remote audio track are available.
+   *
+   * This event is triggered when statistics related to an audio track from a remote user become available from the HMS SDK.
+   * These statistics can include metrics such as bitrate, packet loss, and jitter, which are crucial for monitoring
+   * the quality of the audio being received. Handling this event allows the application to react to the audio quality,
+   * potentially adjusting settings or notifying the user about issues in real-time.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/measure-network-quality-and-performance/rtc-stats
+   */
   ON_REMOTE_AUDIO_STATS = 'ON_REMOTE_AUDIO_STATS',
+
+  /**
+   * Event emitted when statistics for a remote video track are available.
+   *
+   * This event is triggered when statistics related to a video track from a remote user become available from the HMS SDK.
+   * These statistics can include metrics such as frame rate, resolution, bitrate, and packet loss, which are crucial for monitoring
+   * the quality of the video being received. Handling this event allows the application to react to the video quality,
+   * potentially adjusting settings or notifying the user about issues in real-time.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/measure-network-quality-and-performance/rtc-stats
+   */
   ON_REMOTE_VIDEO_STATS = 'ON_REMOTE_VIDEO_STATS',
+
+  /**
+   * Event emitted when the audio device has changed. Android only.
+   *
+   * This event is triggered whenever there is a change in the audio output device, such as switching from the built-in speaker to a Bluetooth headset.
+   * Handling this event allows the application to update any UI elements or settings related to the current audio device, ensuring that the user is always aware of which device is being used for audio output.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/configure-your-device/speaker/audio-output-routing
+   */
   ON_AUDIO_DEVICE_CHANGED = 'ON_AUDIO_DEVICE_CHANGED',
+
+  /**
+   * Event emitted when the session store becomes available.
+   *
+   * This event is triggered when the session store, which may contain critical data for the ongoing session such as user tokens, room state, or other metadata, becomes available to the application.
+   * Handling this event allows the application to perform actions that depend on session-specific data, such as initializing user interfaces or fetching additional room details.
+   * It is crucial for applications that need to ensure all necessary data is loaded before proceeding with further operations.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/room/session-store
+   */
   ON_SESSION_STORE_AVAILABLE = 'ON_SESSION_STORE_AVAILABLE',
+
+  /**
+   * Event emitted when the session store has changed.
+   *
+   * This event is triggered whenever there is a change in the session store, which may include updates to user tokens, room state, or other metadata critical for the ongoing session.
+   * Handling this event allows the application to react to changes in session-specific data in real-time, ensuring that the application's state is always synchronized with the session store.
+   * This is crucial for applications that rely on up-to-date session information for functionalities like UI updates, access control, and room management.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/room/session-store
+   */
   ON_SESSION_STORE_CHANGED = 'ON_SESSION_STORE_CHANGED',
-  ON_PEER_LIST_UPDATED = 'ON_PEER_LIST_UPDATED',
+
+  /**
+   * Event emitted when transcripts are available.
+   *
+   * This event is triggered when the HMS SDK has generated transcripts from the audio streams in the room.
+   * It allows the application to receive real-time or post-processed text versions of spoken content, which can be used for
+   * accessibility features, content analysis, or storing meeting minutes. The availability of this feature depends on the
+   * HMS service configuration and may require additional setup or permissions.
+   *
+   * @type {string}
+   * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/extend-capabilities/live-captions
+   */
+  ON_TRANSCRIPTS = 'ON_TRANSCRIPTS',
+
+  /**
+   * Event emitted when the HMS SDK requests permissions from the user. Android only.
+   *
+   * This event is triggered whenever the application needs to request permissions from the user, such as access to the camera or microphone.
+   * It is used in conjunction with the platform's permissions API to prompt the user for the necessary permissions and to inform the HMS SDK
+   * of the user's response. This is crucial for features that require explicit user consent before they can be used.
+   *
+   * @type {string}
+   */
+  ON_PERMISSIONS_REQUESTED = 'ON_PERMISSIONS_REQUESTED',
 }

package/src/classes/HMSVideoTrack.ts

@@ -2,7 +2,24 @@ import { HMSTrack } from './HMSTrack';
 import type { HMSTrackSource } from './HMSTrackSource';
 import type { HMSTrackType } from './HMSTrackType';
 
+/**
+ * Represents a video track within the HMS (100ms) system.
+ *
+ * This class extends `HMSTrack` to provide functionalities specific to video tracks. It includes additional
+ * property `isDegraded` to indicate whether the video quality has been intentionally reduced, typically for
+ * performance reasons. The constructor allows for the initialization of the video track with various parameters
+ * such as track ID, source, description, mute state, degradation state, ID, and type. These parameters provide
+ * detailed information about the video track and its characteristics.
+ *
+ * @extends HMSTrack
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/set-up-video-conferencing/render-video/overview
+ */
 export class HMSVideoTrack extends HMSTrack {
+  /**
+   * Indicates whether the video quality of the track is degraded.
+   * @type {boolean | undefined}
+   */
   isDegraded?: boolean;
 
   constructor(params: {