mediasfu-angular 1.0.0 → 1.0.2

package/dist/lib/methods/breakout-room-methods/breakout-room-updated.service.d.ts

@@ -27,6 +27,77 @@ export interface BreakoutRoomUpdatedOptions {
     parameters: BreakoutRoomUpdatedParameters;
 }
 export type BreakoutRoomUpdatedType = (options: BreakoutRoomUpdatedOptions) => Promise<void>;
+/**
+ * Updates the state of breakout rooms based on the provided data and parameters.
+ *
+ * This method handles changes in breakout rooms, updates the relevant state variables,
+ * and triggers necessary UI updates based on the current status of the breakout rooms.
+ *
+ * @param {BreakoutRoomUpdatedOptions} options - The options object containing the data and parameters.
+ * @param {BreakoutRoomUpdatedData} options.data - The data object containing information about the breakout rooms.
+ * @param {BreakoutRoomUpdatedParameters} options.parameters - The parameters object containing various state update functions and other parameters.
+ * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room has started.
+ * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room has ended.
+ * @param {Array<BreakoutParticipant[]>} options.parameters.breakoutRooms - The list of current breakout rooms.
+ * @param {number} options.parameters.hostNewRoom - The ID of the new room for the host.
+ * @param {string} options.parameters.islevel - The level of the breakout room (e.g., '2' for host).
+ * @param {Array<Participant>} options.parameters.participantsAll - The list of all participants.
+ * @param {Array<Participant>} options.parameters.participants - The list of participants who are not banned.
+ * @param {string} options.parameters.meetingDisplayType - The current display type of the meeting.
+ * @param {string} options.parameters.prevMeetingDisplayType - The previous display type of the meeting.
+ * @param {Function} options.parameters.updateBreakoutRooms - Function to update the breakout rooms.
+ * @param {Function} options.parameters.updateBreakOutRoomStarted - Function to update the breakout room started state.
+ * @param {Function} options.parameters.updateBreakOutRoomEnded - Function to update the breakout room ended state.
+ * @param {Function} options.parameters.updateHostNewRoom - Function to update the host's new room.
+ * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.
+ * @param {Function} options.parameters.updateParticipantsAll - Function to update the list of all participants.
+ * @param {Function} options.parameters.updateParticipants - Function to update the list of participants who are not banned.
+ * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.
+ * @param {Function} options.parameters.rePort - Function to handle reporting.
+ *
+ * @returns {Promise<void>} A promise that resolves when the breakout room state has been updated.
+ *
+ * @throws Will throw an error if the update process fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   data: {
+ *     forHost: true,
+ *     newRoom: 3,
+ *     status: 'started',
+ *     members: [
+ *       { name: 'user1', isBanned: false, audioID: 'audio1', videoID: 'video1' },
+ *       { name: 'user2', isBanned: true, audioID: 'audio2', videoID: 'video2' },
+ *     ],
+ *     breakoutRooms: [[{ name: 'user1' }, { name: 'user2' }]],
+ *   },
+ *   parameters: {
+ *     socket: socketInstance,
+ *     roomName: 'mainRoom',
+ *     screenStates: [{ mainScreenPerson: 'user1', mainScreenFilled: true, adminOnMainScreen: false }],
+ *     participants: [{ name: 'admin', islevel: '2' }],
+ *     breakOutRoomStarted: false,
+ *     breakOutRoomEnded: false,
+ *     hostNewRoom: 0,
+ *     islevel: '2',
+ *     participantsAll: [],
+ *     updateBreakoutRooms: (rooms) => {},
+ *     updateBreakOutRoomStarted: (started) => {},
+ *     updateBreakOutRoomEnded: (ended) => {},
+ *     updateHostNewRoom: (room) => {},
+ *     updateMeetingDisplayType: (type) => {},
+ *     updateParticipantsAll: (participants) => {},
+ *     updateParticipants: (participants) => {},
+ *     onScreenChanges: async () => {},
+ *     rePort: async () => {},
+ *   },
+ * };
+ *
+ * const breakoutRoomService = new BreakoutRoomUpdated();
+ * await breakoutRoomService.breakoutRoomUpdated(options);
+ * ```
+ */
 export declare class BreakoutRoomUpdated {
     /**
      * Updates the state of breakout rooms based on the provided data and parameters.

package/dist/lib/methods/breakout-room-methods/launch-breakout-rooms.service.d.ts

@@ -4,6 +4,30 @@ export interface LaunchBreakoutRoomsOptions {
     isBreakoutRoomsModalVisible: boolean;
 }
 export type LaunchBreakoutRoomsType = (options: LaunchBreakoutRoomsOptions) => void;
+/**
+ * Launches the breakout rooms by toggling the visibility of the breakout rooms modal.
+ *
+ * This method is used to show or hide the breakout rooms modal based on the current visibility state.
+ *
+ * @param {LaunchBreakoutRoomsOptions} options - The options object containing necessary variables and functions.
+ * @param {Function} options.updateIsBreakoutRoomsModalVisible - Function to update the visibility state of the breakout rooms modal.
+ * @param {boolean} options.isBreakoutRoomsModalVisible - Current visibility state of the breakout rooms modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchBreakoutRoomsOptions = {
+ *   updateIsBreakoutRoomsModalVisible: (isVisible) => {
+ *     console.log('Breakout Rooms Modal is now:', isVisible ? 'Visible' : 'Hidden');
+ *   },
+ *   isBreakoutRoomsModalVisible: false,
+ * };
+ *
+ * const launchBreakoutRoomsService = new LaunchBreakoutRooms();
+ * launchBreakoutRoomsService.launchBreakoutRooms(options);
+ * ```
+ */
 export declare class LaunchBreakoutRooms {
     /**
      * Launches the breakout rooms by toggling the visibility of the breakout rooms modal.

package/dist/lib/methods/co-host-methods/launch-co-host.service.d.ts

@@ -4,6 +4,30 @@ export interface LaunchCoHostOptions {
     isCoHostModalVisible: boolean;
 }
 export type LaunchCoHostType = (options: LaunchCoHostOptions) => void;
+/**
+ * Toggles the visibility of the co-host modal.
+ *
+ * This method is used to show or hide the co-host modal based on the current visibility state.
+ *
+ * @param {LaunchCoHostOptions} options - The options object containing necessary variables and functions.
+ * @param {Function} options.updateIsCoHostModalVisible - Function to update the visibility state of the co-host modal.
+ * @param {boolean} options.isCoHostModalVisible - Current visibility state of the co-host modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchCoHostOptions = {
+ *   updateIsCoHostModalVisible: (isVisible) => {
+ *     console.log('Co-Host Modal is now:', isVisible ? 'Visible' : 'Hidden');
+ *   },
+ *   isCoHostModalVisible: false,
+ * };
+ *
+ * const launchCoHostService = new launchCoHost();
+ * launchCoHostService.launchCoHost(options);
+ * ```
+ */
 export declare class launchCoHost {
     /**
      * Toggles the visibility of the co-host modal.

package/dist/lib/methods/co-host-methods/modify-co-host-settings.service.d.ts

@@ -13,6 +13,50 @@ export interface ModifyCoHostSettingsOptions {
     socket: Socket;
 }
 export type ModifyCoHostSettingsType = (options: ModifyCoHostSettingsOptions) => Promise<void>;
+/**
+ * Modifies the co-host settings for a given room.
+ *
+ * This method allows you to update the co-host for a chat room, set their responsibilities,
+ * and emit the relevant changes to the server. It also handles demo mode restrictions.
+ *
+ * @param {ModifyCoHostSettingsOptions} options - The options for modifying co-host settings.
+ * @param {string} options.roomName - The name of the room.
+ * @param {Function} options.showAlert - Function to show an alert message.
+ * @param {string} options.selectedParticipant - The participant selected to be co-host.
+ * @param {string} options.coHost - The current co-host.
+ * @param {Array<CoHostResponsibility>} options.coHostResponsibility - The responsibilities assigned to the co-host.
+ * @param {Function} options.updateIsCoHostModalVisible - Function to update the visibility of the co-host modal.
+ * @param {Function} options.updateCoHostResponsibility - Function to update the co-host responsibility.
+ * @param {Function} options.updateCoHost - Function to update the co-host.
+ * @param {Socket} options.socket - The socket instance for emitting events.
+ *
+ * @returns {Promise<void>} A promise that resolves when the co-host settings have been modified.
+ *
+ * @remarks
+ * - If the room is in demo mode (room name starts with "d"), co-host cannot be added and an alert is shown.
+ * - If a valid participant is selected, they are set as the new co-host.
+ * - The co-host responsibility is updated.
+ * - A socket event is emitted to update the co-host information.
+ * - The co-host modal is closed after updating the settings.
+ *
+ * @example
+ * ```typescript
+ * const options: ModifyCoHostSettingsOptions = {
+ *   roomName: 'mainRoom',
+ *   showAlert: (alert) => console.log(alert.message),
+ *   selectedParticipant: 'JohnDoe',
+ *   coHost: 'No coHost',
+ *   coHostResponsibility: ['manage participants', 'start/stop recording'],
+ *   updateIsCoHostModalVisible: (isVisible) => console.log('Co-host modal visible:', isVisible),
+ *   updateCoHostResponsibility: (responsibility) => console.log('Updated co-host responsibility:', responsibility),
+ *   updateCoHost: (coHost) => console.log('New co-host:', coHost),
+ *   socket: socketInstance,
+ * };
+ *
+ * const modifyCoHostService = new ModifyCoHostSettings();
+ * await modifyCoHostService.modifyCoHostSettings(options);
+ * ```
+ */
 export declare class ModifyCoHostSettings {
     /**
      * Modifies the co-host settings for a given room.

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

@@ -4,6 +4,28 @@ export interface LaunchDisplaySettingsOptions {
     isDisplaySettingsModalVisible: boolean;
 }
 export type LaunchDisplaySettingsType = (options: LaunchDisplaySettingsOptions) => void;
+/**
+ * Toggles the visibility of the display settings modal.
+ *
+ * This method allows you to show or hide the display settings modal by updating its visibility state.
+ *
+ * @param {LaunchDisplaySettingsOptions} options - The options for launching the display settings.
+ * @param {Function} options.updateIsDisplaySettingsModalVisible - Function to update the visibility state of the display settings modal.
+ * @param {boolean} options.isDisplaySettingsModalVisible - Current visibility state of the display settings modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchDisplaySettingsOptions = {
+ *   updateIsDisplaySettingsModalVisible: (isVisible) => console.log('Display settings modal is now:', isVisible),
+ *   isDisplaySettingsModalVisible: false,
+ * };
+ *
+ * const launchDisplaySettingsService = new LaunchDisplaySettings();
+ * launchDisplaySettingsService.launchDisplaySettings(options);
+ * ```
+ */
 export declare class LaunchDisplaySettings {
     /**
      * Toggles the visibility of the display settings modal.

package/dist/lib/methods/display-settings-methods/modify-display-settings.service.d.ts

@@ -33,6 +33,81 @@ export interface ModifyDisplaySettingsOptions {
     parameters: ModifyDisplaySettingsParameters;
 }
 export type ModifyDisplaySettingsType = (options: ModifyDisplaySettingsOptions) => Promise<void>;
+/**
+ * Modifies the display settings based on the provided parameters.
+ *
+ * This method updates the display settings for the meeting based on the participant's level,
+ * recording status, and other conditions. It validates display types and shows alerts
+ * when necessary. It also handles the display settings for breakout rooms.
+ *
+ * @param {ModifyDisplaySettingsOptions} options - The options containing the parameters to modify the display settings.
+ * @param {Object} options.parameters - The parameters for modifying the display settings.
+ * @param {Function} options.parameters.showAlert - Function to show alert messages.
+ * @param {string} options.parameters.meetingDisplayType - The current meeting display type.
+ * @param {boolean} options.parameters.autoWave - Flag indicating if auto wave is enabled.
+ * @param {boolean} options.parameters.forceFullDisplay - Flag indicating if full display is forced.
+ * @param {boolean} options.parameters.meetingVideoOptimized - Flag indicating if the meeting video is optimized.
+ * @param {string} options.parameters.islevel - The current level of the meeting.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if recording has stopped.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.
+ * @param {string} options.parameters.recordingDisplayType - The current recording display type.
+ * @param {boolean} options.parameters.recordingVideoOptimized - Flag indicating if the recording video is optimized.
+ * @param {string} options.parameters.prevForceFullDisplay - The previous force full display value.
+ * @param {string} options.parameters.prevMeetingDisplayType - The previous meeting display type.
+ * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.
+ * @param {Function} options.parameters.updateAutoWave - Function to update the auto wave setting.
+ * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display setting.
+ * @param {Function} options.parameters.updateMeetingVideoOptimized - Function to update the meeting video optimization setting.
+ * @param {Function} options.parameters.updatePrevForceFullDisplay - Function to update the previous force full display setting.
+ * @param {Function} options.parameters.updatePrevMeetingDisplayType - Function to update the previous meeting display type.
+ * @param {Function} options.parameters.updateIsDisplaySettingsModalVisible - Function to update the visibility of the display settings modal.
+ * @param {Function} options.parameters.updateFirstAll - Function to update the first all setting.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+ * @param {boolean} options.parameters.breakOutRoomStarted - Flag indicating if a breakout room has started.
+ * @param {boolean} options.parameters.breakOutRoomEnded - Flag indicating if a breakout room has ended.
+ * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.
+ *
+ * @returns {Promise<void>} A promise that resolves when the display settings have been modified.
+ *
+ * @example
+ * ```typescript
+ * const options: ModifyDisplaySettingsOptions = {
+ *   parameters: {
+ *     showAlert: (alert) => console.log(alert.message),
+ *     meetingDisplayType: 'video',
+ *     autoWave: true,
+ *     forceFullDisplay: false,
+ *     meetingVideoOptimized: true,
+ *     islevel: '1',
+ *     recordStarted: false,
+ *     recordResumed: false,
+ *     recordStopped: false,
+ *     recordPaused: false,
+ *     recordingDisplayType: 'media',
+ *     recordingVideoOptimized: false,
+ *     prevForceFullDisplay: false,
+ *     prevMeetingDisplayType: 'media',
+ *     updateMeetingDisplayType: (type) => console.log('Updated display type:', type),
+ *     updateAutoWave: (wave) => console.log('Updated auto wave:', wave),
+ *     updateForceFullDisplay: (fullDisplay) => console.log('Updated force full display:', fullDisplay),
+ *     updateMeetingVideoOptimized: (optimized) => console.log('Updated video optimization:', optimized),
+ *     updatePrevForceFullDisplay: (fullDisplay) => console.log('Updated previous full display:', fullDisplay),
+ *     updatePrevMeetingDisplayType: (type) => console.log('Updated previous display type:', type),
+ *     updateIsDisplaySettingsModalVisible: (isVisible) => console.log('Display settings modal is now:', isVisible),
+ *     updateFirstAll: (firstAll) => console.log('Updated first all:', firstAll),
+ *     updateUpdateMainWindow: (update) => console.log('Updated main window:', update),
+ *     breakOutRoomStarted: false,
+ *     breakOutRoomEnded: false,
+ *     onScreenChanges: async ({ changed, parameters }) => console.log('Screen changes:', changed),
+ *   },
+ * };
+ *
+ * const modifyDisplaySettingsService = new ModifyDisplaySettings();
+ * await modifyDisplaySettingsService.modifyDisplaySettings(options);
+ * ```
+ */
 export declare class ModifyDisplaySettings {
     /**
      * Modifies the display settings based on the provided parameters.

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

@@ -7,6 +7,30 @@ export interface ConfirmExitOptions {
     ban?: boolean;
 }
 export type ConfirmExitType = (options: ConfirmExitOptions) => Promise<void>;
+/**
+ * Confirms the exit of a member from a room and optionally bans them.
+ *
+ * This method emits a socket event to disconnect the specified member from the given room.
+ * If the `ban` option is set to true, the member will be banned from rejoining the room.
+ *
+ * @param {ConfirmExitOptions} options - The options for confirming the exit.
+ * @param {Socket} options.socket - The socket instance to emit the event.
+ * @param {string} options.member - The member who is exiting.
+ * @param {string} options.roomName - The name of the room the member is exiting from.
+ * @param {boolean} [options.ban=false] - Whether to ban the member from the room.
+ * @returns {Promise<void>} A promise that resolves when the exit is confirmed.
+ *
+ * @example
+ * ```typescript
+ * const confirmExitService = new ConfirmExit();
+ * await confirmExitService.confirmExit({
+ *   socket: socketInstance,
+ *   member: 'JohnDoe',
+ *   roomName: 'Room1',
+ *   ban: true, // Optional: set to true if you want to ban the member
+ * });
+ * ```
+ */
 export declare class ConfirmExit {
     /**
      * Confirms the exit of a member from a room and optionally bans them.

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.