mediasfu-angular 1.0.1 → 1.0.2

package/dist/lib/methods/exit-methods/launch-confirm-exit.service.d.ts

@@ -4,6 +4,26 @@ export interface LaunchConfirmExitOptions {
     isConfirmExitModalVisible: boolean;
 }
 export type LaunchConfirmExitType = (options: LaunchConfirmExitOptions) => void;
+/**
+ * Toggles the visibility of the confirmation exit modal.
+ *
+ * This method updates the state of the confirmation exit modal by inverting its current visibility status.
+ *
+ * @param {LaunchConfirmExitOptions} options - The options for toggling the confirmation exit modal visibility.
+ * @param {Function} options.updateIsConfirmExitModalVisible - Function to update the visibility state of the confirmation exit modal.
+ * @param {boolean} options.isConfirmExitModalVisible - Current visibility state of the confirmation exit modal.
+ *
+ * @example
+ * ```typescript
+ * const launchConfirmExitService = new LaunchConfirmExit();
+ * launchConfirmExitService.launchConfirmExit({
+ *   updateIsConfirmExitModalVisible: (isVisible) => {
+ *     console.log('Confirm exit modal is now:', isVisible ? 'Visible' : 'Hidden');
+ *   },
+ *   isConfirmExitModalVisible: false, // Initially not visible
+ * });
+ * ```
+ */
 export declare class LaunchConfirmExit {
     /**
      * Toggles the visibility of the confirmation exit modal.

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

@@ -8,6 +8,41 @@ export interface LaunchMediaSettingsOptions {
     updateVideoInputs: (inputs: MediaDeviceInfo[]) => void;
 }
 export type LaunchMediaSettingsType = (options: LaunchMediaSettingsOptions) => Promise<void>;
+/**
+ * Launches the media settings modal and updates the available audio and video input devices.
+ *
+ * This method checks the current visibility of the media settings modal and, if it is not visible,
+ * retrieves the list of available audio and video input devices. It then updates the state with
+ * these devices and opens the modal. If the modal is already visible, it closes the modal.
+ *
+ * @param {LaunchMediaSettingsOptions} options - The options for launching media settings.
+ * @param {Function} options.updateIsMediaSettingsModalVisible - Function to update the visibility state of the media settings modal.
+ * @param {boolean} options.isMediaSettingsModalVisible - Current visibility state of the media settings modal.
+ * @param {MediaDeviceInfo[]} options.audioInputs - Array to store available audio input devices.
+ * @param {MediaDeviceInfo[]} options.videoInputs - Array to store available video input devices.
+ * @param {Function} options.updateAudioInputs - Function to update the available audio input devices.
+ * @param {Function} options.updateVideoInputs - Function to update the available video input devices.
+ * @returns {Promise<void>} A promise that resolves when the media settings have been updated.
+ *
+ * @example
+ * ```typescript
+ * const launchMediaSettingsService = new LaunchMediaSettings();
+ * launchMediaSettingsService.launchMediaSettings({
+ *   updateIsMediaSettingsModalVisible: (isVisible) => {
+ *     console.log('Media settings modal is now:', isVisible ? 'Visible' : 'Hidden');
+ *   },
+ *   isMediaSettingsModalVisible: false, // Initially not visible
+ *   audioInputs: [],
+ *   videoInputs: [],
+ *   updateAudioInputs: (inputs) => {
+ *     console.log('Available audio inputs:', inputs);
+ *   },
+ *   updateVideoInputs: (inputs) => {
+ *     console.log('Available video inputs:', inputs);
+ *   },
+ * });
+ * ```
+ */
 export declare class LaunchMediaSettings {
     /**
      * Launches the media settings modal and updates the available audio and video input devices.

package/dist/lib/methods/menu-methods/launch-menu-modal.service.d.ts

@@ -4,6 +4,28 @@ export interface LaunchMenuModalOptions {
     isMenuModalVisible: boolean;
 }
 export type LaunchMenuModalType = (options: LaunchMenuModalOptions) => void;
+/**
+ * Toggles the visibility of the menu modal.
+ *
+ * This method updates the visibility state of the menu modal by calling the provided
+ * function with the negated current visibility state. If the modal is currently visible,
+ * it will be hidden, and vice versa.
+ *
+ * @param {LaunchMenuModalOptions} options - The options for launching the menu modal.
+ * @param {Function} options.updateIsMenuModalVisible - Function to update the visibility state of the menu modal.
+ * @param {boolean} options.isMenuModalVisible - Current visibility state of the menu modal.
+ *
+ * @example
+ * ```typescript
+ * const launchMenuModalService = new LaunchMenuModal();
+ * launchMenuModalService.launchMenuModal({
+ *   updateIsMenuModalVisible: (isVisible) => {
+ *     console.log('Menu modal is now:', isVisible ? 'Visible' : 'Hidden');
+ *   },
+ *   isMenuModalVisible: false, // Initially not visible
+ * });
+ * ```
+ */
 export declare class LaunchMenuModal {
     /**
      * Toggles the visibility of the menu modal.

package/dist/lib/methods/message-methods/launch-messages.service.d.ts

@@ -4,6 +4,28 @@ export interface LaunchMessagesOptions {
     isMessagesModalVisible: boolean;
 }
 export type LaunchMessagesType = (options: LaunchMessagesOptions) => void;
+/**
+ * Toggles the visibility state of the messages modal.
+ *
+ * This method updates the visibility state of the messages modal by calling the provided
+ * function with the negated current visibility state. If the modal is currently visible,
+ * it will be closed; if it's hidden, it will be opened.
+ *
+ * @param {LaunchMessagesOptions} options - The options for launching the messages modal.
+ * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility state of the messages modal.
+ * @param {boolean} options.isMessagesModalVisible - Current visibility state of the messages modal.
+ *
+ * @example
+ * ```typescript
+ * const launchMessagesService = new LaunchMessages();
+ * launchMessagesService.launchMessages({
+ *   updateIsMessagesModalVisible: (visible) => {
+ *     console.log('Messages modal is now:', visible ? 'Visible' : 'Hidden');
+ *   },
+ *   isMessagesModalVisible: false, // Initially not visible
+ * });
+ * ```
+ */
 export declare class LaunchMessages {
     /**
      * Toggles the visibility state of the messages modal.

package/dist/lib/methods/message-methods/send-message.service.d.ts

@@ -17,6 +17,55 @@ export interface SendMessageOptions {
     socket: Socket;
 }
 export type SendMessageType = (options: SendMessageOptions) => Promise<void>;
+/**
+ * Sends a message to the specified room.
+ *
+ * This method validates the message and its recipients, checks user permissions,
+ * and then emits the message to the server via a socket connection. It also
+ * handles alerting the user for any errors encountered during the process,
+ * such as exceeding message limits or invalid input.
+ *
+ * @param {SendMessageOptions} options - The options for sending the message.
+ * @param {string} options.member - The member sending the message.
+ * @param {string} options.islevel - The level of the member.
+ * @param {Function} options.showAlert - Function to show alert messages.
+ * @param {Array} options.coHostResponsibility - List of co-host responsibilities.
+ * @param {string} options.coHost - The co-host of the room.
+ * @param {string} options.chatSetting - Chat setting for the room.
+ * @param {string} options.message - The message to be sent.
+ * @param {string} options.roomName - The name of the room.
+ * @param {number} options.messagesLength - The current number of messages in the room.
+ * @param {Array} options.receivers - List of receivers for the message.
+ * @param {boolean} options.group - Indicates if the message is for a group.
+ * @param {string} options.sender - The sender of the message.
+ * @param {Object} options.socket - The socket instance for emitting events.
+ *
+ * @returns {Promise<void>} A promise that resolves when the message is sent.
+ *
+ * @throws Will throw an error if the message count limit is exceeded.
+ * @throws Will throw an error if the message, sender, or receivers are not valid.
+ * @throws Will throw an error if the user is not allowed to send a message in the event room.
+ *
+ * @example
+ * ```typescript
+ * const sendMessageService = new SendMessage();
+ * await sendMessageService.sendMessage({
+ *   member: 'JohnDoe',
+ *   islevel: '1',
+ *   showAlert: (alert) => console.log(alert.message),
+ *   coHostResponsibility: [],
+ *   coHost: 'JaneDoe',
+ *   chatSetting: 'allowed',
+ *   message: 'Hello everyone!',
+ *   roomName: 'Room1',
+ *   messagesLength: 50,
+ *   receivers: ['user1', 'user2'],
+ *   group: true,
+ *   sender: 'JohnDoe',
+ *   socket: socketInstance,
+ * });
+ * ```
+ */
 export declare class SendMessage {
     /**
      * Sends a message to the specified room.

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

@@ -4,6 +4,30 @@ export interface LaunchParticipantsOptions {
     isParticipantsModalVisible: boolean;
 }
 export type LaunchParticipantsType = (options: LaunchParticipantsOptions) => void;
+/**
+ * Toggles the visibility of the participants modal.
+ *
+ * This method checks the current visibility state of the participants modal
+ * and updates it accordingly. If the modal is currently visible, it will be hidden.
+ * If it is hidden, it will be displayed.
+ *
+ * @param {LaunchParticipantsOptions} options - The options for toggling the participants modal.
+ * @param {Function} options.updateIsParticipantsModalVisible - Function to update the visibility state of the participants modal.
+ * @param {boolean} options.isParticipantsModalVisible - Current visibility state of the participants modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const launchParticipantsService = new LaunchParticipants();
+ * launchParticipantsService.launchParticipants({
+ *   updateIsParticipantsModalVisible: (isVisible) => {
+ *     console.log(`Participants modal is now ${isVisible ? 'visible' : 'hidden'}`);
+ *   },
+ *   isParticipantsModalVisible: false,
+ * });
+ * ```
+ */
 export declare class LaunchParticipants {
     /**
      * Toggles the visibility of the participants modal.

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

@@ -12,6 +12,52 @@ export interface MessageParticipantsOptions {
     updateStartDirectMessage: (start: boolean) => void;
 }
 export type MessageParticipantsType = (options: MessageParticipantsOptions) => void;
+/**
+ * Sends a direct message to a participant if certain conditions are met.
+ *
+ * This method checks the current user's level and their co-host responsibilities
+ * to determine if they are allowed to send a direct message to a specified participant.
+ * If the user has the appropriate permissions, the method updates the direct message
+ * details and opens the messages modal. If the user is not allowed to send the message,
+ * an alert is displayed.
+ *
+ * @param {MessageParticipantsOptions} options - The options for sending a message to a participant.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - Array of responsibilities assigned to the co-host.
+ * @param {Participant} options.participant - The participant to whom the message is to be sent.
+ * @param {string} options.member - The current member attempting to send the message.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {Function} [options.showAlert] - Function to show an alert message if the message cannot be sent.
+ * @param {string} options.coHost - The co-host member.
+ * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility of the messages modal.
+ * @param {Function} options.updateDirectMessageDetails - Function to update the details of the direct message.
+ * @param {Function} options.updateStartDirectMessage - Function to start the direct message.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const messageService = new MessageParticipants();
+ * messageService.messageParticipants({
+ *   coHostResponsibility: [{ name: 'chat', value: true }],
+ *   participant: { name: 'John', islevel: '1' },
+ *   member: 'Alice',
+ *   islevel: '1',
+ *   showAlert: ({ message, type, duration }) => {
+ *     console.log(`Alert: ${message} - Type: ${type} - Duration: ${duration}`);
+ *   },
+ *   coHost: 'Bob',
+ *   updateIsMessagesModalVisible: (isVisible) => {
+ *     console.log(`Messages modal is now ${isVisible ? 'visible' : 'hidden'}`);
+ *   },
+ *   updateDirectMessageDetails: (participant) => {
+ *     console.log(`Direct messaging: ${participant.name}`);
+ *   },
+ *   updateStartDirectMessage: (start) => {
+ *     console.log(`Direct messaging started: ${start}`);
+ *   },
+ * });
+ * ```
+ */
 export declare class MessageParticipants {
     /**
      * Sends a direct message to a participant if certain conditions are met.

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

@@ -12,6 +12,45 @@ export interface MuteParticipantsOptions {
     roomName: string;
 }
 export type MuteParticipantsType = (options: MuteParticipantsOptions) => Promise<void>;
+/**
+ * Mutes a participant in a media session if certain conditions are met.
+ *
+ * This method checks the current user's level and their co-host responsibilities
+ * to determine if they are allowed to mute a specified participant. If allowed,
+ * the method emits a socket event to mute the participant. If not allowed, an alert
+ * is displayed.
+ *
+ * @param {MuteParticipantsOptions} options - The options for muting participants.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - List of co-host responsibilities.
+ * @param {Participant} options.participant - The participant to be muted.
+ * @param {string} options.member - The current member attempting to mute.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {Function} [options.showAlert] - Optional function to show alerts.
+ * @param {string} options.coHost - The co-host information.
+ * @param {string} options.roomName - The name of the room.
+ *
+ * @returns {Promise<void>} A promise that resolves when the participant is muted.
+ *
+ * @throws Will log an error if there is an issue accessing co-host responsibilities.
+ *
+ * @example
+ * ```typescript
+ * const muteService = new MuteParticipants();
+ * muteService.muteParticipants({
+ *   socket: socketInstance,
+ *   coHostResponsibility: [{ name: 'media', value: true }],
+ *   participant: { id: '123', name: 'John', islevel: '1', muted: false },
+ *   member: 'Alice',
+ *   islevel: '1',
+ *   showAlert: ({ message, type }) => {
+ *     console.log(`Alert: ${message} - Type: ${type}`);
+ *   },
+ *   coHost: 'Bob',
+ *   roomName: 'room1',
+ * });
+ * ```
+ */
 export declare class MuteParticipants {
     /**
      * Mutes a participant in a media session if certain conditions are met.

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.