mediasfu-angular 1.0.0 → 1.0.2

package/dist/lib/methods/participants-methods/remove-participants.service.d.ts

@@ -14,6 +14,51 @@ export interface RemoveParticipantsOptions {
     updateParticipants: (participants: Participant[]) => void;
 }
 export type RemoveParticipantsType = (options: RemoveParticipantsOptions) => Promise<void>;
+/**
+ * Removes a participant from the room if the user has the appropriate permissions.
+ *
+ * This method checks the current user's level and their co-host responsibilities
+ * to determine if they are allowed to remove a specified participant. If allowed,
+ * the method emits a socket event to disconnect the participant and updates
+ * the local list of participants. If not allowed, an alert is displayed.
+ *
+ * @param {RemoveParticipantsOptions} options - The options for removing a participant.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - The responsibilities of the co-host.
+ * @param {Participant} options.participant - The participant to be removed.
+ * @param {string} options.member - The current member attempting to remove the participant.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {Function} [options.showAlert] - Optional function to show alert messages.
+ * @param {string} options.coHost - The co-host information.
+ * @param {Participant[]} options.participants - The list of current participants.
+ * @param {Socket} options.socket - The socket instance for emitting events.
+ * @param {string} options.roomName - The name of the room.
+ * @param {Function} options.updateParticipants - Function to update the participants list.
+ *
+ * @returns {Promise<void>} A promise that resolves when the participant is removed.
+ *
+ * @throws Will log an error if there is an issue accessing co-host responsibilities.
+ *
+ * @example
+ * ```typescript
+ * const removeParticipantsService = new RemoveParticipants();
+ * await removeParticipantsService.removeParticipants({
+ *   coHostResponsibility: [{ name: 'participants', value: true }],
+ *   participant: { id: '123', name: 'John', islevel: '1' },
+ *   member: 'Alice',
+ *   islevel: '1',
+ *   showAlert: ({ message, type }) => {
+ *     console.log(`Alert: ${message} - Type: ${type}`);
+ *   },
+ *   coHost: 'Bob',
+ *   participants: [{ id: '123', name: 'John', islevel: '1' }],
+ *   socket: socketInstance,
+ *   roomName: 'room1',
+ *   updateParticipants: (updatedList) => {
+ *     console.log('Updated participants:', updatedList);
+ *   },
+ * });
+ * ```
+ */
 export declare class RemoveParticipants {
     /**
      * Removes a participant from the room if the user has the appropriate permissions.

package/dist/lib/methods/polls-methods/handle-create-poll.service.d.ts

@@ -9,6 +9,44 @@ export interface HandleCreatePollOptions {
     updateIsPollModalVisible: (visible: boolean) => void;
 }
 export type HandleCreatePollType = (options: HandleCreatePollOptions) => Promise<void>;
+/**
+ * Handles the creation of a poll.
+ *
+ * This method sends a request to create a poll in the specified room via a socket event.
+ * It also handles the response from the server to notify the user whether the poll was
+ * created successfully or if there was an error.
+ *
+ * @param {HandleCreatePollOptions} options - The options for creating the poll.
+ * @param {Poll} options.poll - The poll object containing the poll details.
+ * @param {Socket} options.socket - The socket instance for emitting events.
+ * @param {string} options.roomName - The name of the room where the poll will be created.
+ * @param {Function} [options.showAlert] - Optional function to show alert messages.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+ *
+ * @returns {Promise<void>} A promise that resolves when the poll is created successfully.
+ *
+ * @throws Will handle any errors during the poll creation process silently.
+ *
+ * @example
+ * ```typescript
+ * const handleCreatePollService = new HandleCreatePoll();
+ * const pollData = {
+ *   question: 'What is your favorite color?',
+ *   options: ['Red', 'Blue', 'Green'],
+ * };
+ * await handleCreatePollService.handleCreatePoll({
+ *   poll: pollData,
+ *   socket: socketInstance,
+ *   roomName: 'room1',
+ *   showAlert: ({ message, type }) => {
+ *     console.log(`Alert: ${message} - Type: ${type}`);
+ *   },
+ *   updateIsPollModalVisible: (isVisible) => {
+ *     console.log('Poll modal visibility:', isVisible);
+ *   },
+ * });
+ * ```
+ */
 export declare class HandleCreatePoll {
     /**
      * Handles the creation of a poll.

package/dist/lib/methods/polls-methods/handle-end-poll.service.d.ts

@@ -9,6 +9,38 @@ export interface HandleEndPollOptions {
     updateIsPollModalVisible: (visible: boolean) => void;
 }
 export type HandleEndPollType = (options: HandleEndPollOptions) => Promise<void>;
+/**
+ * Handles the end of a poll by emitting an "endPoll" event through the provided socket.
+ * Displays an alert based on the success or failure of the operation.
+ *
+ * @param {HandleEndPollOptions} options - The options for ending the poll.
+ * @param {string} options.pollId - The ID of the poll to end.
+ * @param {Socket} options.socket - The socket instance to emit the event.
+ * @param {Function} [options.showAlert] - Optional function to display alerts.
+ * @param {string} options.roomName - The name of the room where the poll is being conducted.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+ *
+ * @returns {Promise<void>} A promise that resolves when the poll end operation is complete.
+ *
+ * @throws Will log an error if the operation fails to emit the end poll event.
+ *
+ * @example
+ * ```typescript
+ * const handleEndPollService = new HandleEndPoll();
+ * const pollId = '12345';
+ * await handleEndPollService.handleEndPoll({
+ *   pollId: pollId,
+ *   socket: socketInstance,
+ *   roomName: 'room1',
+ *   showAlert: ({ message, type }) => {
+ *     console.log(`Alert: ${message} - Type: ${type}`);
+ *   },
+ *   updateIsPollModalVisible: (isVisible) => {
+ *     console.log('Poll modal visibility:', isVisible);
+ *   },
+ * });
+ * ```
+ */
 export declare class HandleEndPoll {
     /**
      * Handles the end of a poll by emitting an "endPoll" event through the provided socket.

package/dist/lib/methods/polls-methods/handle-vote-poll.service.d.ts

@@ -11,6 +11,40 @@ export interface HandleVotePollOptions {
     updateIsPollModalVisible: (isVisible: boolean) => void;
 }
 export type HandleVotePollType = (options: HandleVotePollOptions) => Promise<void>;
+/**
+ * Handles the voting process for a poll.
+ *
+ * @param {HandleVotePollOptions} options - The options for handling the vote.
+ * @param {string} options.pollId - The ID of the poll.
+ * @param {number} options.optionIndex - The index of the selected option.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {Function} [options.showAlert] - Optional function to show alerts.
+ * @param {string} options.member - The member who is voting.
+ * @param {string} options.roomName - The name of the room where the poll is conducted.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+ *
+ * @returns {Promise<void>} A promise that resolves when the vote is handled.
+ *
+ * @throws Will log an error message if there is an issue submitting the vote.
+ *
+ * @example
+ * ```typescript
+ * const handleVotePollService = new HandleVotePoll();
+ * await handleVotePollService.handleVotePoll({
+ *   pollId: '12345',
+ *   optionIndex: 1,
+ *   socket: socketInstance,
+ *   member: 'user1',
+ *   roomName: 'room1',
+ *   showAlert: ({ message, type }) => {
+ *     console.log(`Alert: ${message} - Type: ${type}`);
+ *   },
+ *   updateIsPollModalVisible: (isVisible) => {
+ *     console.log('Poll modal visibility:', isVisible);
+ *   },
+ * });
+ * ```
+ */
 export declare class HandleVotePoll {
     /**
      * Handles the voting process for a poll.

package/dist/lib/methods/polls-methods/launch-poll.service.d.ts

@@ -4,6 +4,26 @@ export interface LaunchPollOptions {
     isPollModalVisible: boolean;
 }
 export type LaunchPollType = (options: LaunchPollOptions) => void;
+/**
+ * Toggles the visibility of the poll modal.
+ *
+ * @param {LaunchPollOptions} options - The options object containing necessary variables and functions.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility state of the poll modal.
+ * @param {boolean} options.isPollModalVisible - Current visibility state of the poll modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const launchPollService = new LaunchPoll();
+ * launchPollService.launchPoll({
+ *   updateIsPollModalVisible: (isVisible) => {
+ *     console.log('Poll modal visibility:', isVisible);
+ *   },
+ *   isPollModalVisible: false,
+ * });
+ * ```
+ */
 export declare class LaunchPoll {
     /**
      * Toggles the visibility of the poll modal.

package/dist/lib/methods/polls-methods/poll-updated.service.d.ts

@@ -12,6 +12,37 @@ export interface PollUpdatedOptions {
     updateIsPollModalVisible: (isVisible: boolean) => void;
 }
 export type PollUpdatedType = (options: PollUpdatedOptions) => Promise<void>;
+/**
+ * Updates the poll state based on the provided data.
+ *
+ * @param {PollUpdatedOptions} options - The options for updating the poll.
+ * @param {PollUpdatedData} options.data - The data containing poll information.
+ * @param {Poll[]} options.polls - The current list of polls.
+ * @param {Poll} options.poll - The current poll.
+ * @param {string} options.member - The member identifier.
+ * @param {string} options.islevel - The level of the member.
+ * @param {Function} [options.showAlert] - Function to show alerts.
+ * @param {Function} options.updatePolls - Function to update the list of polls.
+ * @param {Function} options.updatePoll - Function to update the current poll.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+ * @returns {Promise<void>} A promise that resolves when the poll update is complete.
+ *
+ * @example
+ * ```typescript
+ * const pollUpdatedService = new PollUpdated();
+ * pollUpdatedService.pollUpdated({
+ *   data: { polls: [], poll: { id: '123', question: 'Sample Poll?', status: 'started' } },
+ *   polls: [],
+ *   poll: { id: '123', question: 'Sample Poll?', status: 'started' },
+ *   member: 'user1',
+ *   islevel: '1',
+ *   showAlert: (alert) => console.log(alert.message),
+ *   updatePolls: (polls) => console.log('Updated polls:', polls),
+ *   updatePoll: (poll) => console.log('Updated poll:', poll),
+ *   updateIsPollModalVisible: (visible) => console.log('Poll modal visibility:', visible),
+ * });
+ * ```
+ */
 export declare class PollUpdated {
     /**
      * Updates the poll state based on the provided data.

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

@@ -8,6 +8,30 @@ export interface CheckPauseStateOptions {
     showAlert?: ShowAlert;
 }
 export type CheckPauseStateType = (options: CheckPauseStateOptions) => Promise<boolean>;
+/**
+ * Checks if the recording can be paused based on the current pause count and the allowed pause limits.
+ *
+ * @param {CheckPauseStateOptions} options - The options for checking the pause 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 recordings.
+ * @param {number} options.recordingAudioPausesLimit - The maximum number of pauses allowed for audio recordings.
+ * @param {number} options.pauseRecordCount - The current count of pauses that have been made.
+ * @param {Function} [options.showAlert] - A function to show an alert message if the pause limit is reached.
+ * @returns {Promise<boolean>} A promise that resolves to `true` if the recording can be paused, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * const checkPauseStateService = new CheckPauseState();
+ * const canPause = await checkPauseStateService.checkPauseState({
+ *   recordingMediaOptions: 'video',
+ *   recordingVideoPausesLimit: 3,
+ *   recordingAudioPausesLimit: 5,
+ *   pauseRecordCount: 2,
+ *   showAlert: (alert) => console.log(alert.message),
+ * });
+ * console.log('Can pause recording:', canPause);
+ * ```
+ */
 export declare class CheckPauseState {
     /**
      * Checks if the recording can be paused based on the current pause count and the allowed pause limits.

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

@@ -38,6 +38,56 @@ 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 {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;