mediasfu-angular 1.0.1 → 2.0.0

package/dist/lib/methods/recording-methods/check-resume-state.service.d.ts

@@ -6,6 +6,28 @@ export interface CheckResumeStateOptions {
     pauseRecordCount: number;
 }
 export type CheckResumeStateType = (options: CheckResumeStateOptions) => Promise<boolean>;
+/**
+ * Checks if the recording can be resumed based on the media type and pause limits.
+ *
+ * @param {CheckResumeStateOptions} options - The options for checking resume state.
+ * @param {string} options.recordingMediaOptions - The type of media being recorded ("video" or "audio").
+ * @param {number} options.recordingVideoPausesLimit - The maximum number of pauses allowed for video recording.
+ * @param {number} options.recordingAudioPausesLimit - The maximum number of pauses allowed for audio recording.
+ * @param {number} options.pauseRecordCount - The current number of pauses that have occurred.
+ * @returns {Promise<boolean>} A promise that resolves to a boolean indicating whether the recording can be resumed.
+ *
+ * @example
+ * ```typescript
+ * const checkResumeStateService = new CheckResumeState();
+ * const canResume = await checkResumeStateService.checkResumeState({
+ *   recordingMediaOptions: 'audio',
+ *   recordingVideoPausesLimit: 3,
+ *   recordingAudioPausesLimit: 5,
+ *   pauseRecordCount: 2,
+ * });
+ * console.log('Can resume recording:', canResume);
+ * ```
+ */
 export declare class CheckResumeState {
     /**
      * Checks if the recording can be resumed based on the media type and pause limits.

package/dist/lib/methods/recording-methods/confirm-recording.service.d.ts

@@ -40,6 +40,69 @@ export interface ConfirmRecordingOptions {
     parameters: ConfirmRecordingParameters;
 }
 export type ConfirmRecordingType = (options: ConfirmRecordingOptions) => Promise<void>;
+/**
+ * Confirms the recording settings based on the provided parameters and updates the recording state.
+ *
+ * @param {ConfirmRecordingOptions} options - The options for confirming the recording.
+ * @param {ConfirmRecordingParameters} options.parameters - The parameters for the recording, including:
+ *   - {ShowAlert} [options.parameters.showAlert] - Optional function to show alert messages.
+ *   - {string} options.parameters.recordingMediaOptions - Type of media being recorded ("video" or "audio").
+ *   - {string} options.parameters.recordingAudioOptions - Audio recording options.
+ *   - {string} options.parameters.recordingVideoOptions - Video recording options.
+ *   - {string} options.parameters.recordingVideoType - Type of video recording.
+ *   - {'video' | 'media' | 'all'} options.parameters.recordingDisplayType - The display type for the recording.
+ *   - {boolean} options.parameters.recordingNameTags - Flag for including name tags in the recording.
+ *   - {string} options.parameters.recordingBackgroundColor - Background color for the recording.
+ *   - {string} options.parameters.recordingNameTagsColor - Color for the name tags.
+ *   - {string} options.parameters.recordingOrientationVideo - Orientation for video recording.
+ *   - {boolean} options.parameters.recordingAddHLS - Flag for adding HLS support.
+ *   - {boolean} options.parameters.recordingAddText - Flag for adding custom text.
+ *   - {string} options.parameters.recordingCustomText - Custom text for the recording.
+ *   - {string} options.parameters.recordingCustomTextPosition - Position of the custom text.
+ *   - {string} options.parameters.recordingCustomTextColor - Color of the custom text.
+ *   - {string} options.parameters.meetingDisplayType - Current display type of the meeting.
+ *   - {boolean} options.parameters.recordingVideoParticipantsFullRoomSupport - Support for video participants in full room.
+ *   - {boolean} options.parameters.recordingAllParticipantsSupport - Support for recording all participants.
+ *   - {boolean} options.parameters.recordingVideoParticipantsSupport - Support for video participants.
+ *   - {boolean} options.parameters.recordingSupportForOtherOrientation - Support for other orientations.
+ *   - {string} options.parameters.recordingPreferredOrientation - Preferred orientation for recording.
+ *   - {boolean} options.parameters.recordingMultiFormatsSupport - Support for multiple formats.
+ *   - {boolean} options.parameters.recordingVideoOptimized - Flag for video optimization.
+ *   - {boolean} options.parameters.recordingAllParticipantsFullRoomSupport - Support for recording all participants in full room.
+ *   - {boolean} options.parameters.meetingVideoOptimized - Flag for meeting video optimization.
+ *   - {EventType} options.parameters.eventType - Type of the event.
+ *   - {boolean} options.parameters.breakOutRoomStarted - Indicates if a breakout room has started.
+ *   - {boolean} options.parameters.breakOutRoomEnded - Indicates if a breakout room has ended.
+ *   - {Function} options.parameters.updateRecordingDisplayType - Function to update the recording display type.
+ *   - {Function} options.parameters.updateRecordingVideoOptimized - Function to update video optimization status.
+ *   - {Function} options.parameters.updateUserRecordingParams - Function to update user recording parameters.
+ *   - {Function} options.parameters.updateConfirmedToRecord - Function to confirm the recording.
+ *
+ * @returns {Promise<void>} A promise that resolves when the recording settings have been confirmed.
+ *
+ * @remarks
+ * This function performs several checks to ensure that the recording settings are valid based on the provided parameters.
+ * If any of the checks fail, an alert is shown and the function returns early without updating the recording state.
+ *
+ * The function checks for the following conditions:
+ * - Whether recording videos of all participants is allowed.
+ * - Whether recording all participants is allowed.
+ * - Whether recording other video participants is allowed.
+ * - Whether recording all orientations is allowed.
+ * - Whether recording the preferred orientation is allowed.
+ * - Whether recording all formats is allowed.
+ * - Whether the recording display type is valid based on the meeting display type.
+ * - Whether recording all participants with media is allowed.
+ *
+ * If all checks pass, the function constructs the `mainSpecs`, `dispSpecs`, and `textSpecs` objects based on the state variables,
+ * updates the user recording parameters, and confirms the recording.
+ *
+ * @example
+ * ```typescript
+ * const options: ConfirmRecordingOptions = { parameters: someParameters };
+ * await confirmRecording(options);
+ * ```
+ */
 export declare class ConfirmRecording {
     /**
      * Confirms the recording settings based on the provided parameters and updates the recording state.

package/dist/lib/methods/recording-methods/launch-recording.service.d.ts

@@ -16,6 +16,49 @@ export interface LaunchRecordingOptions {
     [key: string]: any;
 }
 export type LaunchRecordingType = (options: LaunchRecordingOptions) => void;
+/**
+ * Launches the recording process based on various conditions and updates the UI accordingly.
+ *
+ * @param {LaunchRecordingOptions} options - The options for launching the recording.
+ * @param {Function} options.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
+ * @param {boolean} options.isRecordingModalVisible - Indicates if the recording modal is currently visible.
+ * @param {Function} [options.showAlert] - Optional function to show an alert message.
+ * @param {boolean} options.stopLaunchRecord - Indicates if the recording launch should be stopped.
+ * @param {boolean} options.canLaunchRecord - Indicates if the recording can be launched.
+ * @param {boolean} options.recordingAudioSupport - Indicates if audio recording is supported.
+ * @param {boolean} options.recordingVideoSupport - Indicates if video recording is supported.
+ * @param {Function} options.updateCanRecord - Function to update the recording capability.
+ * @param {Function} options.updateClearedToRecord - Function to update the cleared-to-record status.
+ * @param {boolean} options.recordStarted - Indicates if the recording has started.
+ * @param {boolean} options.recordPaused - Indicates if the recording is paused.
+ * @param {boolean} options.localUIMode - Indicates if the local UI mode is active.
+ *
+ * @returns {void}
+ *
+ * @throws Will show an alert if:
+ * - The recording has already ended or the user is not allowed to record.
+ * - The recording initiation is not allowed due to insufficient permissions.
+ * - The recording is currently running and cannot be reconfigured unless paused.
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchRecordingOptions = {
+ *   updateIsRecordingModalVisible: (visible) => { /* update visibility logic *\/ },
+ *   isRecordingModalVisible: false,
+ *   showAlert: (alert) => { /* show alert logic *\/ },
+ *   stopLaunchRecord: false,
+ *   canLaunchRecord: true,
+ *   recordingAudioSupport: true,
+ *   recordingVideoSupport: true,
+ *   updateCanRecord: (canRecord) => { /* update record capability *\/ },
+ *   updateClearedToRecord: (cleared) => { /* update cleared status *\/ },
+ *   recordStarted: false,
+ *   recordPaused: false,
+ *   localUIMode: false,
+ * };
+ * launchRecording(options);
+ * ```
+ */
 export declare class LaunchRecording {
     /**
      * Launches the recording process based on various conditions and updates the UI accordingly.

package/dist/lib/methods/recording-methods/record-pause-timer.service.d.ts

@@ -7,6 +7,33 @@ export interface RecordPauseTimerOptions {
     showAlert?: ShowAlert;
 }
 export type RecordPauseTimerType = (options: RecordPauseTimerOptions) => boolean;
+/**
+ * Controls the pause and resume functionality of a recording timer.
+ *
+ * @param {RecordPauseTimerOptions} options - The options for controlling the timer.
+ * @param {boolean} [options.stop=false] - Indicates whether to stop the timer.
+ * @param {boolean} options.isTimerRunning - Indicates if the timer is currently running.
+ * @param {boolean} options.canPauseResume - Indicates if the timer can be paused or resumed.
+ * @param {Function} [options.showAlert] - Optional function to show an alert message.
+ * @returns {boolean} - Returns true if the timer can be paused or resumed, otherwise false.
+ *
+ * @throws Will show an alert message if:
+ * - The timer cannot be stopped, paused, or resumed due to not meeting the required time condition.
+ *
+ * @example
+ * ```typescript
+ * const options: RecordPauseTimerOptions = {
+ *   stop: false,
+ *   isTimerRunning: true,
+ *   canPauseResume: true,
+ *   showAlert: (alert) => {  },
+ * };
+ * const canPause = recordPauseTimer(options);
+ * if (canPause) {
+ *   // proceed with pausing or resuming the recording
+ * }
+ * ```
+ */
 export declare class RecordPauseTimer {
     /**
      * Controls the pause and resume functionality of a recording timer.

package/dist/lib/methods/recording-methods/record-resume-timer.service.d.ts

@@ -19,6 +19,50 @@ export interface RecordResumeTimerOptions {
     parameters: RecordResumeTimerParameters;
 }
 export type RecordResumeTimerType = (options: RecordResumeTimerOptions) => Promise<boolean>;
+/**
+ * Resumes the recording timer if it is not already running and can be paused/resumed.
+ *
+ * @param {RecordResumeTimerOptions} options - The options for resuming the recording timer.
+ * @param {Object} options.parameters - The parameters for the recording timer.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {boolean} options.parameters.isTimerRunning - Indicates if the timer is currently running.
+ * @param {boolean} options.parameters.canPauseResume - Indicates if the timer can be paused/resumed.
+ * @param {number} options.parameters.recordElapsedTime - The elapsed recording time in seconds.
+ * @param {number} options.parameters.recordStartTime - The start time of the recording.
+ * @param {NodeJS.Timeout | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.
+ * @param {Function} options.parameters.showAlert - Function to show an alert message.
+ * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.
+ * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.
+ * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running status.
+ * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume status.
+ *
+ * @returns {Promise<boolean>} - Returns a promise that resolves to true if the timer was successfully resumed, otherwise false.
+ *
+ * @throws Will show an alert if the timer cannot be resumed due to conditions not being met.
+ *
+ * @example
+ * ```typescript
+ * const options: RecordResumeTimerOptions = {
+ *   parameters: {
+ *     isTimerRunning: false,
+ *     canPauseResume: true,
+ *     recordElapsedTime: 10,
+ *     recordStartTime: Date.now(),
+ *     recordTimerInterval: null,
+ *     showAlert: (alert) => { },
+ *     updateRecordStartTime: (time) => { },
+ *     updateRecordTimerInterval: (interval) => { },
+ *     updateIsTimerRunning: (isRunning) => { },
+ *     updateCanPauseResume: (canPause) => {  },
+ *     getUpdatedAllParams: () => ({  }),
+ *   },
+ * };
+ * const canResume = await recordResumeTimer(options);
+ * if (canResume) {
+ *   // proceed with the resumed recording
+ * }
+ * ```
+ */
 export declare class RecordResumeTimer {
     private RecordUpdateTimerService;
     constructor(RecordUpdateTimerService: RecordUpdateTimer);

package/dist/lib/methods/recording-methods/record-start-timer.service.d.ts

@@ -20,6 +20,51 @@ export interface RecordStartTimerOptions {
     parameters: RecordStartTimerParameters;
 }
 export type RecordStartTimerType = (options: RecordStartTimerOptions) => Promise<void>;
+/**
+ * Starts the recording timer and manages its state.
+ *
+ * @param {RecordStartTimerOptions} options - The options for starting the recording timer.
+ * @param {Object} options.parameters - The parameters for the recording timer.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {number} options.parameters.recordStartTime - The start time of the recording.
+ * @param {NodeJS.Timeout | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.
+ * @param {boolean} options.parameters.isTimerRunning - Flag indicating if the timer is currently running.
+ * @param {boolean} options.parameters.canPauseResume - Flag indicating if pause/resume actions are enabled.
+ * @param {number} options.parameters.recordChangeSeconds - The time after which pause/resume actions are enabled.
+ * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.
+ * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.
+ * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running state.
+ * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume state.
+ *
+ * @returns {Promise<void>} A promise that resolves when the timer is started.
+ *
+ * @remarks
+ * This function initializes the recording start time and sets up an interval to update the timer every second.
+ * It also manages the state of the timer, including enabling and disabling pause/resume actions.
+ * The timer is stopped if the recording is paused, stopped, or if the room name is invalid.
+ *
+ * @example
+ * ```typescript
+ * const options: RecordStartTimerOptions = {
+ *   parameters: {
+ *     recordStartTime: Date.now(),
+ *     recordTimerInterval: null,
+ *     isTimerRunning: false,
+ *     canPauseResume: false,
+ *     recordChangeSeconds: 15,
+ *     recordPaused: false,
+ *     recordStopped: false,
+ *     roomName: 'room1',
+ *     updateRecordStartTime: (time) => {  },
+ *     updateRecordTimerInterval: (interval) => {  },
+ *     updateIsTimerRunning: (isRunning) => { },
+ *     updateCanPauseResume: (canPause) => {},
+ *     getUpdatedAllParams: () => { },
+ *   },
+ * };
+ * await recordStartTimer(options);
+ * ```
+ */
 export declare class RecordStartTimer {
     private RecordUpdateTimerService;
     constructor(RecordUpdateTimerService: RecordUpdateTimer);

package/dist/lib/methods/recording-methods/record-update-timer.service.d.ts

@@ -6,6 +6,38 @@ export interface RecordUpdateTimerOptions {
     updateRecordingProgressTime: (formattedTime: string) => void;
 }
 export type RecordUpdateTimerType = (options: RecordUpdateTimerOptions) => void;
+/**
+ * Updates the recording timer and progress time.
+ * @function
+ * @param {RecordUpdateTimerOptions} options - The options object containing necessary variables and functions.
+ */
+/**
+ * Updates the recording timer by calculating the elapsed time since the recording started
+ * and formatting it in HH:MM:SS format.
+ *
+ * @param {Object} options - The options object.
+ * @param {number} options.recordElapsedTime - The elapsed recording time in seconds.
+ * @param {number} options.recordStartTime - The timestamp when the recording started.
+ * @param {Function} options.updateRecordElapsedTime - Callback to update the elapsed recording time.
+ * @param {Function} options.updateRecordingProgressTime - Callback to update the formatted recording time.
+ * @returns {void}
+ *
+ * @remarks
+ * This function calculates the elapsed time since the recording started and formats it into
+ * a string in HH:MM:SS format. It updates both the elapsed time in seconds and the formatted
+ * time via the provided callback functions.
+ *
+ * @example
+ * ```typescript
+ * const options: RecordUpdateTimerOptions = {
+ *   recordElapsedTime: 0,
+ *   recordStartTime: Date.now(),
+ *   updateRecordElapsedTime: (elapsedTime) => { console.log(`Elapsed Time: ${elapsedTime} seconds`); },
+ *   updateRecordingProgressTime: (formattedTime) => { console.log(`Formatted Time: ${formattedTime}`); },
+ * };
+ * recordUpdateTimer(options);
+ * ```
+ */
 export declare class RecordUpdateTimer {
     /**
      * Updates the recording timer and progress time.

package/dist/lib/methods/recording-methods/start-recording.service.d.ts

@@ -7,6 +7,7 @@ export interface StartRecordingParameters extends CaptureCanvasStreamParameters,
     roomName: string;
     userRecordingParams: UserRecordingParams;
     socket: Socket;
+    localSocket?: Socket;
     updateIsRecordingModalVisible: (visible: boolean) => void;
     confirmedToRecord: boolean;
     showAlert?: ShowAlert;
@@ -38,6 +39,57 @@ export interface StartRecordingOptions {
     parameters: StartRecordingParameters;
 }
 export type StartRecordingType = (options: StartRecordingOptions) => Promise<boolean | undefined>;
+/**
+ * Starts the recording process based on the provided parameters.
+ *
+ * @param {StartRecordingOptions} options - The options for starting the recording.
+ * @param {object} options.parameters - The parameters required for starting the recording.
+ * @param {string} options.parameters.roomName - The name of the room where recording is to be started.
+ * @param {object} options.parameters.userRecordingParams - User-specific recording parameters.
+ * @param {object} options.parameters.socket - The socket instance for communication.
+ * @param {object} options.parameters.localSocket - The local socket instance for communication.
+ * @param {function} options.parameters.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
+ * @param {boolean} options.parameters.confirmedToRecord - Flag indicating if the user has confirmed to record.
+ * @param {function} options.parameters.showAlert - Function to show alerts.
+ * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+ * @param {boolean} options.parameters.videoAlreadyOn - Flag indicating if the video is already on.
+ * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if the audio is already on.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if the recording has started.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if the recording is paused.
+ * @param {boolean} options.parameters.recordResumed - Flag indicating if the recording is resumed.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if the recording is stopped.
+ * @param {boolean} options.parameters.startReport - Flag indicating if the start report is active.
+ * @param {boolean} options.parameters.endReport - Flag indicating if the end report is active.
+ * @param {boolean} options.parameters.canRecord - Flag indicating if recording is allowed.
+ * @param {function} options.parameters.updateClearedToRecord - Function to update the cleared to record status.
+ * @param {function} options.parameters.updateRecordStarted - Function to update the record started status.
+ * @param {function} options.parameters.updateRecordPaused - Function to update the record paused status.
+ * @param {function} options.parameters.updateRecordResumed - Function to update the record resumed status.
+ * @param {function} options.parameters.updateStartReport - Function to update the start report status.
+ * @param {function} options.parameters.updateEndReport - Function to update the end report status.
+ * @param {function} options.parameters.updateCanRecord - Function to update the can record status.
+ * @param {boolean} options.parameters.whiteboardStarted - Flag indicating if the whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Flag indicating if the whiteboard has ended.
+ * @param {function} options.parameters.rePort - Function to report the recording status.
+ * @param {function} options.parameters.captureCanvasStream - Function to capture the canvas stream.
+ *
+ * @returns {Promise<boolean | undefined>} - A promise that resolves to a boolean indicating if the recording attempt was successful, or undefined if not applicable.
+ *
+ * @remarks
+ * This method checks various conditions, such as whether the user has confirmed recording and whether audio or video is already on,
+ * before starting the recording. It updates the recording state, manages socket communication, and handles whiteboard functionality if applicable.
+ *
+ * @example
+ * ```typescript
+ * const options: StartRecordingOptions = { parameters: someParameters };
+ * const result = await startRecording(options);
+ * if (result) {
+ *   console.log('Recording started successfully.');
+ * } else {
+ *   console.log('Failed to start recording.');
+ * }
+ * ```
+ */
 export declare class StartRecording {
     private RecordStartTimerService;
     private RecordResumeTimerService;
@@ -50,6 +102,7 @@ export declare class StartRecording {
      * @param {string} options.parameters.roomName - The name of the room where recording is to be started.
      * @param {object} options.parameters.userRecordingParams - User-specific recording parameters.
      * @param {object} options.parameters.socket - The socket instance for communication.
+     * @param {object} options.parameters.localSocket - The local socket instance for communication.
      * @param {function} options.parameters.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
      * @param {boolean} options.parameters.confirmedToRecord - Flag indicating if the user has confirmed to record.
      * @param {function} options.parameters.showAlert - Function to show alerts.

package/dist/lib/methods/recording-methods/stop-recording.service.d.ts

@@ -1,9 +1,11 @@
 import { RecordPauseTimer } from './record-pause-timer.service';
 import { ShowAlert } from '../../@types/types';
+import { Socket } from 'socket.io-client';
 import * as i0 from "@angular/core";
 export interface StopRecordingParameters {
     roomName: string;
-    socket: any;
+    socket: Socket;
+    localSocket?: Socket;
     showAlert?: ShowAlert;
     startReport: boolean;
     endReport: boolean;
@@ -28,6 +30,45 @@ export interface StopRecordingOptions {
     parameters: StopRecordingParameters;
 }
 export type StopRecordingType = (options: StopRecordingOptions) => Promise<void>;
+/**
+ * Stops the recording process based on the provided parameters.
+ *
+ * @param {StopRecordingOptions} options - The options for stopping the recording.
+ * @param {Object} options.parameters - The parameters required for stopping the recording.
+ * @param {string} options.parameters.roomName - The name of the room where the recording is being stopped.
+ * @param {Socket} options.parameters.socket - The socket instance for communication.
+ * @param {Socket} [options.parameters.localSocket] - The local socket instance for communication.
+ * @param {Function} options.parameters.showAlert - Function to show alerts.
+ * @param {boolean} options.parameters.startReport - Flag indicating if the start report is active.
+ * @param {boolean} options.parameters.endReport - Flag indicating if the end report is active.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if the recording has started.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if the recording is paused.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if the recording is stopped.
+ * @param {Function} options.parameters.updateRecordPaused - Function to update the record paused status.
+ * @param {Function} options.parameters.updateRecordStopped - Function to update the record stopped status.
+ * @param {Function} options.parameters.updateStartReport - Function to update the start report status.
+ * @param {Function} options.parameters.updateEndReport - Function to update the end report status.
+ * @param {Function} options.parameters.updateShowRecordButtons - Function to update the visibility of recording buttons.
+ * @param {boolean} options.parameters.whiteboardStarted - Flag indicating if the whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Flag indicating if the whiteboard has ended.
+ * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+ * @param {Function} options.parameters.captureCanvasStream - Function to capture the canvas stream.
+ *
+ * @returns {Promise<void>} - A promise that resolves when the recording is stopped.
+ *
+ * @remarks
+ * This method checks if the recording has started and is not already stopped.
+ * It pauses the timer and emits a stop recording event via socket communication.
+ * If successful, it updates the recording state and alerts the user.
+ * Additionally, if the whiteboard feature is active, it captures the canvas stream.
+ *
+ * @example
+ * ```typescript
+ * const options: StopRecordingOptions = { parameters: someParameters };
+ * await stopRecording(options);
+ * console.log('Recording stopped successfully.');
+ * ```
+ */
 export declare class StopRecording {
     private RecordPauseTimerService;
     constructor(RecordPauseTimerService: RecordPauseTimer);

package/dist/lib/methods/recording-methods/update-recording.service.d.ts

@@ -9,6 +9,7 @@ export interface UpdateRecordingParameters extends RecordResumeTimerParameters,
     roomName: string;
     userRecordingParams: UserRecordingParams;
     socket: Socket;
+    localSocket?: Socket;
     updateIsRecordingModalVisible: (visible: boolean) => void;
     confirmedToRecord: boolean;
     showAlert?: ShowAlert;
@@ -41,6 +42,55 @@ export interface UpdateRecordingOptions {
     parameters: UpdateRecordingParameters;
 }
 export type UpdateRecordingType = (options: UpdateRecordingOptions) => Promise<void>;
+/**
+ * Updates the recording state based on the provided parameters.
+ *
+ * @param {UpdateRecordingOptions} options - The options for updating the recording state.
+ * @param {Object} options.parameters - The parameters required for updating the recording state.
+ * @param {string} options.parameters.roomName - The name of the room where the recording is taking place.
+ * @param {UserRecordingParams} options.parameters.userRecordingParams - User-specific recording parameters.
+ * @param {Socket} options.parameters.socket - The socket instance for communication.
+ * @param {Socket} [options.parameters.localSocket] - The local socket instance for communication.
+ * @param {Function} options.parameters.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
+ * @param {boolean} options.parameters.confirmedToRecord - Indicates if the user has confirmed to start recording.
+ * @param {Function} options.parameters.showAlert - Function to show alerts.
+ * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already turned on.
+ * @param {boolean} options.parameters.audioAlreadyOn - Indicates if the audio is already turned on.
+ * @param {boolean} options.parameters.recordStarted - Indicates if the recording has started.
+ * @param {boolean} options.parameters.recordPaused - Indicates if the recording is paused.
+ * @param {boolean} options.parameters.recordResumed - Indicates if the recording has resumed.
+ * @param {boolean} options.parameters.recordStopped - Indicates if the recording has stopped.
+ * @param {number} options.parameters.recordChangeSeconds - The interval in seconds for changing the recording state.
+ * @param {number} options.parameters.pauseRecordCount - The count of pauses during the recording.
+ * @param {boolean} options.parameters.startReport - Indicates if the start report is active.
+ * @param {boolean} options.parameters.endReport - Indicates if the end report is active.
+ * @param {boolean} options.parameters.canRecord - Indicates if recording is allowed.
+ * @param {boolean} options.parameters.canPauseResume - Indicates if pausing and resuming the recording is allowed.
+ * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume state.
+ * @param {Function} options.parameters.updatePauseRecordCount - Function to update the pause record count.
+ * @param {Function} options.parameters.updateClearedToRecord - Function to update the cleared-to-record state.
+ * @param {Function} options.parameters.updateRecordPaused - Function to update the record paused state.
+ * @param {Function} options.parameters.updateRecordResumed - Function to update the record resumed state.
+ * @param {Function} options.parameters.updateStartReport - Function to update the start report state.
+ * @param {Function} options.parameters.updateEndReport - Function to update the end report state.
+ * @param {Function} options.parameters.updateCanRecord - Function to update the can record state.
+ * @param {Function} options.parameters.rePort - Function to handle reporting.
+ *
+ * @returns {Promise<void>} A promise that resolves when the recording state has been updated.
+ *
+ * @remarks
+ * This method handles the recording state updates, including starting, pausing, resuming, and stopping the recording.
+ * It also performs necessary checks to ensure that the user can perform the requested actions based on their current state.
+ * Alerts are displayed for any issues encountered during the process.
+ *
+ * @example
+ * ```typescript
+ * const options: UpdateRecordingOptions = { parameters: someParameters };
+ * await updateRecording(options);
+ * console.log('Recording state updated successfully.');
+ * ```
+ */
 export declare class UpdateRecording {
     private CheckPauseStateService;
     private CheckResumeStateService;
@@ -56,6 +106,7 @@ export declare class UpdateRecording {
      * @property {string} roomName - The name of the room where the recording is taking place.
      * @property {any} userRecordingParams - Parameters related to the user's recording settings.
      * @property {any} socket - The socket connection used for communication.
+     * @property {any} localSocket - The local socket connection used for communication.
      * @property {Function} updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
      * @property {boolean} confirmedToRecord - Indicates if the user has confirmed to start recording.
      * @property {Function} showAlert - Function to show alert messages.

package/dist/lib/methods/requests-methods/launch-requests.service.d.ts

@@ -4,6 +4,31 @@ export interface LaunchRequestsOptions {
     isRequestsModalVisible: boolean;
 }
 export type LaunchRequestsType = (options: LaunchRequestsOptions) => void;
+/**
+ * Toggles the visibility state of the requests modal.
+ *
+ * @param {LaunchRequestsOptions} options - The options for launching requests.
+ * @param {Function} options.updateIsRequestsModalVisible - Function to update the visibility state of the requests modal.
+ * @param {boolean} options.isRequestsModalVisible - Current visibility state of the requests modal.
+ * @returns {void}
+ *
+ * @remarks
+ * This method is used to open or close the requests modal by toggling its visibility state.
+ * It takes the current visibility state as input and updates it accordingly.
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchRequestsOptions = {
+ *   updateIsRequestsModalVisible: (isVisible) => {
+ *     console.log('Requests modal visibility:', isVisible);
+ *   },
+ *   isRequestsModalVisible: false,
+ * };
+ *
+ * const launchRequestsService = new LaunchRequests();
+ * launchRequestsService.launchRequests(options);
+ * ```
+ */
 export declare class LaunchRequests {
     /**
      * Toggles the visibility state of the requests modal.

package/dist/lib/methods/requests-methods/respond-to-requests.service.d.ts

@@ -10,6 +10,45 @@ export interface RespondToRequestsOptions {
     roomName: string;
 }
 export type RespondToRequestsType = (options: RespondToRequestsOptions) => Promise<void>;
+/**
+ * Responds to incoming requests by updating the request list and emitting a response to the server.
+ *
+ * @param {RespondToRequestsOptions} options - The options for responding to requests.
+ * @param {Socket} options.socket - The socket instance used to emit the response.
+ * @param {Request} options.request - The request object containing details of the request.
+ * @param {Function} options.updateRequestList - The function to update the request list.
+ * @param {Request[]} options.requestList - The current list of requests.
+ * @param {string} options.action - The action to be taken on the request.
+ * @param {string} options.roomName - The name of the room to which the response should be emitted.
+ *
+ * @returns {Promise<void>} A promise that resolves when the response has been emitted.
+ *
+ * @remarks
+ * This method filters out the request that is being responded to from the current request list,
+ * updates the list, and emits the response to the server using the provided socket.
+ * It ensures that the state of the requests is accurately reflected in the application.
+ *
+ * @example
+ * ```typescript
+ * const options: RespondToRequestsOptions = {
+ *   socket: socketInstance,
+ *   request: {
+ *     id: 'request_id',
+ *     name: 'Request Name',
+ *     icon: 'request_icon'
+ *   },
+ *   updateRequestList: (newRequestList) => {
+ *     console.log('Updated request list:', newRequestList);
+ *   },
+ *   requestList: currentRequestList,
+ *   action: 'accept',
+ *   roomName: 'Room 1',
+ * };
+ *
+ * const respondToRequestsService = new RespondToRequests();
+ * await respondToRequestsService.respondToRequests(options);
+ * ```
+ */
 export declare class RespondToRequests {
     /**
      * Responds to incoming requests by updating the request list and emitting a response to the server.

package/dist/lib/methods/settings-methods/launch-settings.service.d.ts

@@ -4,6 +4,31 @@ export interface LaunchSettingsOptions {
     isSettingsModalVisible: boolean;
 }
 export type LaunchSettingsType = (options: LaunchSettingsOptions) => void;
+/**
+ * Toggles the visibility state of the settings modal.
+ *
+ * @param {LaunchSettingsOptions} options - The options for launching settings.
+ * @param {Function} options.updateIsSettingsModalVisible - Function to update the visibility state of the settings modal.
+ * @param {boolean} options.isSettingsModalVisible - Current visibility state of the settings modal.
+ * @returns {void}
+ *
+ * @remarks
+ * This method toggles the current visibility state of the settings modal.
+ * If the modal is currently visible, it will be hidden, and vice versa.
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchSettingsOptions = {
+ *   updateIsSettingsModalVisible: (isVisible) => {
+ *     console.log('Settings modal visibility:', isVisible);
+ *   },
+ *   isSettingsModalVisible: false,
+ * };
+ *
+ * const launchSettingsService = new LaunchSettings();
+ * launchSettingsService.launchSettings(options);
+ * ```
+ */
 export declare class LaunchSettings {
     /**
      * Toggles the visibility state of the settings modal.