@100mslive/react-native-hms 1.10.8 → 1.10.9

package/src/classes/HMSConfig.ts

@@ -1,3 +1,30 @@
+/**
+ * Represents the configuration needed to join a room in the HMS ecosystem.
+ *
+ * This class encapsulates all necessary details required to initiate a connection to a room, including user identification,
+ * authentication token, optional endpoint for different server connections, metadata for additional information about the connection,
+ * and a flag to capture network quality during the preview phase.
+ *
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/set-up-video-conferencing/join
+ *
+ * @param {Object} params - The configuration parameters.
+ * @param {string} params.username - The username of the participant.
+ * @param {string} params.authToken - The authentication token for room access.
+ * @param {string} [params.endpoint] - Optional. The endpoint URL for the connection.
+ * @param {string} [params.metadata] - Optional. Additional metadata associated with the Local Peer.
+ * @param {boolean} [params.captureNetworkQualityInPreview] - Optional. Flag to capture network quality in the preview phase.
+ * @constructor
+ *
+ * @example
+ * const config = new HMSConfig({
+ *  username: 'username',
+ *  authToken: 'authToken',
+ *  metadata: 'metadata',
+ *  captureNetworkQualityInPreview: true,
+ * });
+ *
+ */
 export class HMSConfig {
   username: string;
   authToken: string;

package/src/classes/HMSException.ts

@@ -1,3 +1,21 @@
+/**
+ * Represents an exception specific to the HMS SDK in a React Native context.
+ *
+ * This class encapsulates detailed information about errors that can occur while interacting with the HMS SDK.
+ * It includes a numeric code to identify the type of error, a human-readable description, and optionally,
+ * a message, name, and action that are primarily available on Android. Additionally, it indicates whether
+ * the error is terminal (i.e., cannot be recovered from) and whether a retry might be possible.
+ *
+ * @class HMSException
+ * @property {number} code - Numeric error code representing the type of error.
+ * @property {string} description - A brief, human-readable description of the error.
+ * @property {string} [message] - Additional message information about the error (Android only).
+ * @property {string} [name] - The name of the error (Android only).
+ * @property {string} [action] - The action during which the error occurred (Android only).
+ * @property {boolean} isTerminal - Indicates whether the error is terminal.
+ * @property {boolean} [canRetry] - Indicates whether the operation that caused the error can be retried (Android only).
+ *
+ */
 export class HMSException {
   code: number;
   description: string;

package/src/classes/HMSHLSTimedMetadata.ts

@@ -1,3 +1,15 @@
+/**
+ * Defines the structure for HLS (HTTP Live Streaming) timed metadata.
+ *
+ * This interface is used to represent metadata that can be synchronized with HLS video playback.
+ * The metadata includes a payload, which is the content of the metadata, and a duration, specifying how long (in seconds)
+ * the metadata should be displayed during the stream.
+ * This can be used for a variety of purposes such as displaying song titles, advertisements, or other relevant information at specific times during the stream.
+ *
+ * @interface HMSHLSTimedMetadata
+ * @property {string} payload - The content of the metadata to be displayed.
+ * @property {number} duration - The duration (in seconds) for which the metadata should be displayed.
+ */
 export interface HMSHLSTimedMetadata {
   payload: string;
   duration: number;

package/src/classes/HMSIOSAudioMode.ts

@@ -1,3 +1,18 @@
+/**
+ * Enum for specifying the audio mode in an iOS environment within a 100ms (HMS) application.
+ *
+ * This enumeration provides options to configure the audio mode for an iOS application using the 100ms (HMS) SDK.
+ * It allows for the selection between `voice` and `music` modes, catering to different use cases such as
+ * prioritizing voice clarity or enhancing music quality during a session.
+ *
+ * @enum {string}
+ * @property {string} VOICE - Configures the audio session for optimized voice communication.
+ *                            This mode enhances voice clarity, making it suitable for calls or conferences.
+ * @property {string} MUSIC - Configures the audio session for music playback.
+ *                            This mode enhances music fidelity, making it suitable for streams or recordings that prioritize music quality.
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/configure-your-device/microphone/music-mode
+ */
 export enum HMSIOSAudioMode {
   VOICE = 'voice',
   MUSIC = 'music',

package/src/classes/HMSLogAlarmManager.ts

@@ -1,3 +1,15 @@
+/**
+ * Enumeration for managing log alarm settings in HMS SDK for React Native applications. Android only.
+ *
+ * This enumeration defines constants used to configure the alarm manager for log files in the HMS SDK.
+ * It includes settings for the default directory size, default log file name, and maximum directory size,
+ * allowing for detailed control over how log files are managed and stored.
+ *
+ * @enum {string}
+ * @property {string} DEFAULT_DIR_SIZE - Represents the default size for the log directory.
+ * @property {string} DEFAULT_LOGS_FILE_NAME - Represents the default name for log files.
+ * @property {string} MAX_DIR_SIZE - Represents the maximum size for the log directory.
+ */
 export enum HMSLogAlarmManager {
   DEFAULT_DIR_SIZE = 'DEFAULT_DIR_SIZE',
   DEFAULT_LOGS_FILE_NAME = 'DEFAULT_LOGS_FILE_NAME',

package/src/classes/HMSLogLevel.ts

@@ -1,3 +1,15 @@
+/**
+ * Enumeration for defining log levels in the HMS SDK for React Native applications.
+ *
+ * This enumeration provides a set of predefined log levels that can be used to control the verbosity of logging
+ * within the HMS SDK. It allows developers to specify how much detail they want in their logs, which can be
+ * helpful for debugging or monitoring the application's behavior.
+ *
+ * @enum {string}
+ * @property {string} VERBOSE - Represents the most verbose log level, including detailed debug information.
+ * @property {string} WARNING - Represents a log level for warning messages that might indicate potential issues.
+ * @property {string} ERROR - Represents a log level for error messages indicating failures that need attention.
+ */
 export enum HMSLogLevel {
   VERBOSE = 'VERBOSE',
   WARNING = 'WARNING',

package/src/classes/HMSLogSettings.ts

@@ -1,6 +1,20 @@
 import type { HMSLogAlarmManager } from './HMSLogAlarmManager';
 import type { HMSLogLevel } from './HMSLogLevel';
 
+/**
+ * Represents the logging settings for the HMS SDK.
+ *
+ * This class encapsulates the settings related to logging within the HMS SDK, including the log level,
+ * whether log storage is enabled, and the maximum directory size for log storage.
+ * It is used to configure how logs are handled by the SDK, allowing for customization of log verbosity and storage requirements.
+ *
+ * @class HMSLogSettings
+ * @property {HMSLogLevel} level - The log level setting, determining the verbosity of the logs.
+ * @property {boolean} isLogStorageEnabled - Flag indicating whether log storage is enabled. Android only.
+ * @property {HMSLogAlarmManager} maxDirSizeInBytes - The maximum size of the log directory in bytes, managed by an instance of HMSLogAlarmManager. Android only.
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/debugging/logger
+ */
 export class HMSLogSettings {
   level: HMSLogLevel;
   isLogStorageEnabled: boolean;

package/src/classes/HMSNetworkQuality.ts

@@ -1,3 +1,14 @@
+/**
+ * Represents the network quality of a connection in the HMS (100ms) system.
+ *
+ * This class encapsulates the network quality information, specifically focusing on the downlink quality of the connection.
+ * The downlink quality is represented as a numerical value, providing a quantifiable measure of the receiving end's network performance.
+ *
+ * @param {Object} params - The constructor parameters.
+ * @param {number} params.downlinkQuality - The downlink quality of the network connection.
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/measure-network-quality-and-performance/network-quality
+ */
 export class HMSNetworkQuality {
   downlinkQuality: number;
 

package/src/classes/HMSNoiseCancellationPlugin.ts

@@ -3,18 +3,49 @@ import { HMSConstants } from './HMSConstants';
 import { logger } from './HMSLogger';
 
 /**
- * Class representing an HMS Noise Cancellation Plugin.
- * Checkout {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/extend-capabilities/noise-cancellation} for more info
+ * Represents the HMS Noise Cancellation Plugin.
+ * This class encapsulates the functionality for managing noise cancellation within a room, including enabling, disabling, and checking the availability and current state of noise cancellation.
+ *
+ * @property {HMSNoiseCancellationModels} modelName - Specifies the model of noise cancellation to be used.
+ * This property determines the algorithm and intensity of noise cancellation, allowing for customization
+ * based on the requirements of the room or application.
+ *
+ * @property {HMSNoiseCancellationInitialState} initialState - Defines the initial state of noise cancellation
+ * when the plugin is instantiated. This can be either enabled or disabled, providing control over the
+ * noise cancellation feature's activation upon initialization.
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/extend-capabilities/noise-cancellation
  */
 export class HMSNoiseCancellationPlugin {
+  /**
+   * The `modelName` property specifies the model of noise cancellation to be used within the HMS Noise Cancellation Plugin.
+   * This property determines the algorithm and intensity of noise cancellation, allowing for customization
+   * based on the specific requirements of the room or application. It is of type `HMSNoiseCancellationModels`,
+   * an enum that defines the available noise cancellation models.
+   */
   modelName: HMSNoiseCancellationModels;
+
+  /**
+   * Defines the initial state of noise cancellation when the plugin is instantiated.
+   * This property can be set to either `HMSNoiseCancellationInitialState.Enabled`
+   * or `HMSNoiseCancellationInitialState.Disabled`, determining whether noise cancellation should be active
+   * immediately upon the plugin's instantiation. This allows for control over the feature's initial activation state,
+   * catering to scenarios where noise cancellation needs to be either immediately available or manually activated later.
+   */
   initialState: HMSNoiseCancellationInitialState;
 
   /**
-   * Creates an instance of HMSNoiseCancellationPlugin.
-   * @param {Object} [config] - The configuration options.
-   * @param {HMSNoiseCancellationModels} [config.modelName] - The model name for noise cancellation.
-   * @param {HMSNoiseCancellationInitialState} [config.initialState] - The initial state for noise cancellation.
+   * Constructs a new HMSNoiseCancellationPlugin instance with optional configuration settings.
+   * This constructor allows for the initialization of the plugin with specific noise cancellation
+   * model and initial state settings, providing flexibility in how noise cancellation is applied
+   * within the application.
+   *
+   * @param {Object} [config] - Optional configuration object for the plugin.
+   * @param {HMSNoiseCancellationModels} [config.modelName] - Specifies the noise cancellation model to be used.
+   *        This determines the algorithm and intensity of noise cancellation. If not provided, a default
+   *        model is used.
+   * @param {HMSNoiseCancellationInitialState} [config.initialState] - Sets the initial state of noise cancellation
+   *        (enabled or disabled) when the plugin is instantiated. Defaults to disabled if not specified.
    */
   constructor(config?: {
     modelName: HMSNoiseCancellationModels;
@@ -45,7 +76,7 @@ export class HMSNoiseCancellationPlugin {
     );
 
     try {
-      return HMSManagerModule.isNoiseCancellationPluginAvailable(data);
+      return await HMSManagerModule.isNoiseCancellationPluginAvailable(data);
     } catch (e) {
       logger?.error(
         '#Error in #Function HMSNoiseCancellationPlugin#isNoiseCancellationAvailable ',
@@ -64,7 +95,7 @@ export class HMSNoiseCancellationPlugin {
     logger?.verbose('#Function HMSNoiseCancellationPlugin#enable', data);
 
     try {
-      return HMSManagerModule.enableNoiseCancellationPlugin(data);
+      return await HMSManagerModule.enableNoiseCancellationPlugin(data);
     } catch (e) {
       logger?.error(
         '#Error in #Function HMSNoiseCancellationPlugin#enable ',
@@ -83,7 +114,7 @@ export class HMSNoiseCancellationPlugin {
     logger?.verbose('#Function HMSNoiseCancellationPlugin#disable', data);
 
     try {
-      return HMSManagerModule.disableNoiseCancellationPlugin(data);
+      return await HMSManagerModule.disableNoiseCancellationPlugin(data);
     } catch (e) {
       logger?.error(
         '#Error in #Function HMSNoiseCancellationPlugin#disable ',
@@ -102,7 +133,7 @@ export class HMSNoiseCancellationPlugin {
     logger?.verbose('#Function HMSNoiseCancellationPlugin#isEnabled', data);
 
     try {
-      return HMSManagerModule.isNoiseCancellationPluginEnabled(data);
+      return await HMSManagerModule.isNoiseCancellationPluginEnabled(data);
     } catch (e) {
       logger?.error(
         '#Error in #Function HMSNoiseCancellationPlugin#isEnabled ',

package/src/classes/HMSPIPConfig.ts

@@ -1,36 +1,53 @@
 import type { HMSVideoViewMode } from './HMSVideoViewMode';
 
+/**
+ * Configuration options for Picture-in-Picture (PIP) mode in a React Native application using HMS.
+ *
+ * This interface defines the settings available for customizing the PIP window that can appear when the app enters background mode.
+ * It includes options for automatically entering PIP mode, adjusting the aspect ratio and scale type of the PIP window, and toggling
+ * the visibility of various control buttons specific to Android or iOS platforms.
+ *
+ * @interface HMSPIPConfig
+ * @property {boolean} [autoEnterPipMode] - Determines whether the app should automatically enter PIP mode when it goes into the background.
+ * @property {[number, number]} [aspectRatio] - Sets the aspect ratio of the PIP window. Defaults are platform-specific: [16, 9] for Android and [9, 16] for iOS.
+ * @property {HMSVideoViewMode} [scaleType] - Defines the scaling behavior of the video within the PIP window. Options are `ASPECT_FILL` (default), `ASPECT_FIT`, and `ASPECT_BALANCED`. Applies only to iOS.
+ * @property {boolean} [useActiveSpeaker] - Whether the PIP window should automatically show the active speaker. Default is true. Applies only to iOS.
+ * @property {boolean} [endButton] - Controls the visibility of the end call button within the PIP window. Default is true. Applies only to Android.
+ * @property {boolean} [audioButton] - Controls the visibility of the audio mute/unmute button within the PIP window. Default is true. Applies only to Android.
+ * @property {boolean} [videoButton] - Controls the visibility of the video mute/unmute button within the PIP window. Default is true. Applies only to Android.
+ */
 export interface HMSPIPConfig {
-  /*
+  /**
    * Whether to automatically enter PIP mode when app enters background.
    */
   autoEnterPipMode?: boolean;
 
-  /*
-   * The aspect ratio of the PIP window. Default is [9, 16]. Other values can be [3, 4], [1, 1], [4, 3], [16, 9].
+  /**
+   * The aspect ratio of the PIP window. Default is [16, 9] on Android & [9, 16] on iOS. Other values can be [3, 4], [1, 1], [4, 3], [16, 9].
    */
   aspectRatio?: [number, number];
 
-  /*
+  /**
    * The scale type of the PIP window. Default is ASPECT_FILL. Other values can be ASPECT_FIT, ASPECT_BALANCED. iOS Only.
    */
   scaleType?: HMSVideoViewMode;
 
-  /*
+  /**
    * Whether to show the Active Speaker in the PIP window. Default is true. iOS only.
    */
   useActiveSpeaker?: boolean;
-  /*
+
+  /**
    * Whether to show the end button in the PIP window. Default is true. Android only.
    */
   endButton?: boolean;
 
-  /*
+  /**
    * Whether to show the audio mute/unmute button in the PIP window. Default is true. Android only.
    */
   audioButton?: boolean;
 
-  /*
+  /**
    * Whether to show the video mute/unmute button in the PIP window. Default is true. Android only.
    */
   videoButton?: boolean;

package/src/classes/HMSPIPListenerActions.ts

@@ -1,4 +1,22 @@
+/**
+ * Enum for HMS Picture-in-Picture (PIP) Listener Actions.
+ *
+ * This enum defines the types of actions/events related to the Picture-in-Picture (PIP) mode that can be listened to
+ * within the HMS SDK. These actions allow the application to respond to changes in PIP mode or when the room is left
+ * while in PIP mode.
+ *
+ * @enum {string}
+ */
 export enum HMSPIPListenerActions {
+  /**
+   * Action triggered when the Picture-in-Picture mode changes.
+   * This can be used to handle UI changes or other logic when entering or exiting PIP mode.
+   */
   ON_PIP_MODE_CHANGED = 'ON_PIP_MODE_CHANGED',
+
+  /**
+   * Action triggered when the room is left while in Picture-in-Picture mode. Android only.
+   * This can be used to clean up resources or update the UI accordingly.
+   */
   ON_PIP_ROOM_LEAVE = 'ON_PIP_ROOM_LEAVE',
 }

package/src/classes/HMSPeer.ts

@@ -7,6 +7,22 @@ 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;
   private _name: string | undefined;
@@ -71,6 +87,16 @@ export class HMSPeer {
     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;
@@ -91,6 +117,15 @@ export class HMSPeer {
     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();
 
@@ -108,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();
 
@@ -125,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();
 
@@ -139,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();
 
@@ -156,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();
 
@@ -173,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();
 
@@ -190,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();
 
@@ -204,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();
 
@@ -218,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();
 
@@ -232,6 +356,19 @@ export class HMSPeer {
     );
   }
 
+  /**
+   * 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();
 

package/src/classes/HMSPeerType.ts

@@ -1,6 +1,17 @@
+/**
+ * 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',
-  REGULAR = 'REGULAR',
+  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([

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/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/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;