mediasfu-angular 1.0.1 → 1.0.2

package/dist/lib/producers/socket-receive-methods/host-request-response.service.d.ts

@@ -21,58 +21,41 @@ export interface HostRequestResponseOptions {
 }
 export type HostRequestResponseType = (options: HostRequestResponseOptions) => Promise<void>;
 /**
- * Service to handle host request responses.
- *
- * @example
- * ```typescript
- * const hostRequestResponseService = new HostRequestResponse();
- * await hostRequestResponseService.hostRequestResponse({
- *   requestResponse: { id: '1', type: 'fa-microphone', name: 'John Doe', username: 'johndoe', action: 'accepted' },
- *   showAlert: (alert) => console.log(alert),
- *   requestList: [],
- *   updateRequestList: (list) => console.log(list),
- *   updateMicAction: (state) => console.log(state),
- *   updateVideoAction: (state) => console.log(state),
- *   updateScreenAction: (state) => console.log(state),
- *   updateChatAction: (state) => console.log(state),
- *   updateAudioRequestState: (state) => console.log(state),
- *   updateVideoRequestState: (state) => console.log(state),
- *   updateScreenRequestState: (state) => console.log(state),
- *   updateChatRequestState: (state) => console.log(state),
- *   updateAudioRequestTime: (time) => console.log(time),
- *   updateVideoRequestTime: (time) => console.log(time),
- *   updateScreenRequestTime: (time) => console.log(time),
- *   updateChatRequestTime: (time) => console.log(time),
- *   updateRequestIntervalSeconds: 30,
- * });
- * ```
- *
- * @typedef {Object} HostRequestResponseOptions
- * @property {Object} requestResponse - The request response object.
- * @property {Function} showAlert - Function to show alert messages.
- * @property {Array} requestList - List of current requests.
- * @property {Function} updateRequestList - Function to update the request list.
- * @property {Function} updateMicAction - Function to update microphone action state.
- * @property {Function} updateVideoAction - Function to update video action state.
- * @property {Function} updateScreenAction - Function to update screen action state.
- * @property {Function} updateChatAction - Function to update chat action state.
- * @property {Function} updateAudioRequestState - Function to update audio request state.
- * @property {Function} updateVideoRequestState - Function to update video request state.
- * @property {Function} updateScreenRequestState - Function to update screen request state.
- * @property {Function} updateChatRequestState - Function to update chat request state.
- * @property {Function} updateAudioRequestTime - Function to update audio request time.
- * @property {Function} updateVideoRequestTime - Function to update video request time.
- * @property {Function} updateScreenRequestTime - Function to update screen request time.
- * @property {Function} updateChatRequestTime - Function to update chat request time.
- * @property {number} updateRequestIntervalSeconds - Interval in seconds to update request time.
+ * Service to handle host responses to participant requests, including updating states and showing relevant alerts.
  *
  * @class
- * @classdesc This service handles the responses to host requests, updating the state and showing alerts based on the response.
+ * @name HostRequestResponse
+ * @description
+ * Manages host responses to requests (e.g., microphone, video, screenshare, chat) by updating the state of actions and triggering alerts based on acceptance or rejection.
  *
- * @method hostRequestResponse
+ * @method
+ * hostRequestResponse
  * @async
- * @param {HostRequestResponseOptions} options - The options for handling the host request response.
- * @returns {Promise<void>} A promise that resolves when the request response has been handled.
+ *
+ * @param {HostRequestResponseOptions} options - Options for handling the host request response:
+ *   - `requestResponse` {RequestResponse}: The request response object.
+ *   - `showAlert` {Function}: Optional alert function for notifications.
+ *   - `requestList` {Request[]}: The current list of requests.
+ *   - `updateRequestList` {Function}: Updates the request list.
+ *   - `updateMicAction`, `updateVideoAction`, `updateScreenAction`, `updateChatAction` {Function}: Update functions for respective actions.
+ *   - `updateAudioRequestState`, `updateVideoRequestState`, `updateScreenRequestState`, `updateChatRequestState` {Function}: Updates request states.
+ *   - `updateAudioRequestTime`, `updateVideoRequestTime`, `updateScreenRequestTime`, `updateChatRequestTime` {Function}: Update functions for request timers.
+ *   - `updateRequestIntervalSeconds` {number}: Interval in seconds to update request time.
+ *
+ * @returns {Promise<void>} Resolves once the request response has been handled.
+ *
+ * @example
+ * const options = {
+ *   requestResponse: { id: '1', type: 'fa-microphone', action: 'accepted' },
+ *   showAlert: alert => console.log(alert.message),
+ *   requestList: [{ id: '1', type: 'fa-microphone' }],
+ *   updateRequestList: list => console.log(list),
+ *   updateMicAction: state => console.log(state),
+ *   updateAudioRequestState: state => console.log(state),
+ *   updateAudioRequestTime: time => console.log(time),
+ *   updateRequestIntervalSeconds: 30,
+ * };
+ * hostRequestResponseService.hostRequestResponse(options);
  */
 export declare class HostRequestResponse {
     hostRequestResponse: ({ requestResponse, showAlert, requestList, updateRequestList, updateMicAction, updateVideoAction, updateScreenAction, updateChatAction, updateAudioRequestState, updateVideoRequestState, updateScreenRequestState, updateChatRequestState, updateAudioRequestTime, updateVideoRequestTime, updateScreenRequestTime, updateChatRequestTime, updateRequestIntervalSeconds, }: HostRequestResponseOptions) => Promise<void>;

package/dist/lib/producers/socket-receive-methods/meeting-ended.service.d.ts

@@ -8,6 +8,35 @@ export interface MeetingEndedOptions {
     updateValidated?: (isValid: boolean) => void;
 }
 export type MeetingEndedType = (options: MeetingEndedOptions) => Promise<void>;
+/**
+ * Service to handle the end of a meeting, including showing an alert and redirecting the user.
+ *
+ * @class
+ * @name MeetingEnded
+ * @description
+ * This service provides a method to display a notification when a meeting ends and redirects the user to a specified URL or handles other post-meeting actions.
+ *
+ * @method
+ * meetingEnded
+ *
+ * @param {MeetingEndedOptions} options - Options for handling the meeting end:
+ *   - `showAlert` {Function}: Optional function to display an alert message.
+ *   - `redirectURL` {string}: URL to redirect to after the meeting ends.
+ *   - `onWeb` {boolean}: Specifies if the application is running on the web.
+ *   - `eventType` {string}: Specifies the type of event ending the meeting.
+ *
+ * @returns {Promise<void>} Completes meeting end handling by displaying an alert and performing a redirect.
+ *
+ * @example
+ * const options = {
+ *   showAlert: (options) => console.log(options.message),
+ *   redirectURL: 'https://example.com/home',
+ *   onWeb: true,
+ *   eventType: 'webinar',
+ * };
+ * meetingEndedService.meetingEnded(options);
+ * // Displays alert and redirects to specified URL
+ */
 export declare class MeetingEnded {
     /**
      * Handles the end of a meeting by showing an alert and redirecting the user.

package/dist/lib/producers/socket-receive-methods/meeting-still-there.service.d.ts

@@ -3,6 +3,29 @@ export interface MeetingStillThereOptions {
     updateIsConfirmHereModalVisible: (isVisible: boolean) => void;
 }
 export type MeetingStillThereType = (options: MeetingStillThereOptions) => Promise<void>;
+/**
+ * Service to handle the "still there?" check in a meeting by showing a confirmation modal.
+ *
+ * @class
+ * @name MeetingStillThere
+ * @description
+ * This service provides a method to display a "still there?" confirmation modal to check if participants are still active in the meeting.
+ *
+ * @method
+ * meetingStillThere
+ *
+ * @param {MeetingStillThereOptions} options - Options for managing the modal visibility:
+ *   - `updateIsConfirmHereModalVisible` {Function}: Function to set the visibility of the "still there?" confirmation modal.
+ *
+ * @returns {Promise<void>} Updates modal visibility when checking if the user is still present.
+ *
+ * @example
+ * const options = {
+ *   updateIsConfirmHereModalVisible: (isVisible) => console.log(`Modal visibility: ${isVisible}`),
+ * };
+ * meetingStillThereService.meetingStillThere(options);
+ * // Output: Sets and logs modal visibility to true
+ */
 export declare class MeetingStillThere {
     /**
      * Handles the "still there?" meeting check by updating the visibility of the confirmation modal.

package/dist/lib/producers/socket-receive-methods/meeting-time-remaining.service.d.ts

@@ -6,6 +6,33 @@ export interface MeetingTimeRemainingOptions {
     eventType: EventType;
 }
 export type MeetingTimeRemainingType = (options: MeetingTimeRemainingOptions) => Promise<void>;
+/**
+ * Service to handle the remaining time for a meeting and display an alert if necessary.
+ *
+ * @class
+ * @name MeetingTimeRemaining
+ * @description
+ * Manages the display of a time remaining alert for meetings, except when the event type is 'chat'.
+ *
+ * @method
+ * meetingTimeRemaining
+ *
+ * @param {MeetingTimeRemainingOptions} options - Options for managing meeting time:
+ *   - `timeRemaining` {number}: The remaining time in milliseconds.
+ *   - `showAlert` {Function}: Optional function to display an alert message.
+ *   - `eventType` {EventType}: The type of the event (e.g., "meeting", "broadcast", "chat").
+ *
+ * @returns {Promise<void>} Displays an alert with the remaining time for the meeting.
+ *
+ * @example
+ * const options = {
+ *   timeRemaining: 180000, // 3 minutes in milliseconds
+ *   showAlert: (options) => console.log(options.message),
+ *   eventType: 'meeting'
+ * };
+ * await meetingTimeRemainingService.meetingTimeRemaining(options);
+ * // Output: Displays "The event will end in 3:00 minutes."
+ */
 export declare class MeetingTimeRemaining {
     /**
      * Handles the remaining time for a meeting and shows an alert if the event type is not 'chat'.

package/dist/lib/producers/socket-receive-methods/participant-requested.service.d.ts

@@ -8,6 +8,37 @@ export interface ParticipantRequestedOptions {
     updateRequestList: (list: Request[]) => void;
 }
 export type ParticipantRequestedType = (options: ParticipantRequestedOptions) => Promise<void>;
+/**
+ * Service to handle participant requests in an event's waiting room.
+ *
+ * @class
+ * @name ParticipantRequested
+ * @description
+ * Manages participant requests by adding new requests to the list and updating the total count of requests and waiting room participants.
+ *
+ * @method
+ * participantRequested
+ *
+ * @param {ParticipantRequestedOptions} options - Contains request information and update functions:
+ *   - `userRequest` {Request}: The new request from a participant.
+ *   - `requestList` {Request[]}: The current list of requests.
+ *   - `waitingRoomList` {WaitingRoomParticipant[]}: The list of participants in the waiting room.
+ *   - `updateTotalReqWait` {Function}: Function to update the total count of requests and waiting room participants.
+ *   - `updateRequestList` {Function}: Function to update the request list.
+ *
+ * @returns {Promise<void>} Updates the request list and total request count.
+ *
+ * @example
+ * const options = {
+ *   userRequest: { id: '123', name: 'John Doe', icon: 'fa-user', username: 'johndoe' },
+ *   requestList: existingRequests,
+ *   waitingRoomList: waitingParticipants,
+ *   updateTotalReqWait: (count) => console.log(`Total requests: ${count}`),
+ *   updateRequestList: (list) => console.log('Updated request list', list)
+ * };
+ * await participantRequestedService.participantRequested(options);
+ * // Adds "John Doe" to request list and updates the total count.
+ */
 export declare class ParticipantRequested {
     /**
      * Handles a participant's request by adding it to the request list and updating the total count of requests and waiting room participants.

package/dist/lib/producers/socket-receive-methods/person-joined.service.d.ts

@@ -5,6 +5,31 @@ export interface PersonJoinedOptions {
     name: string;
 }
 export type PersonJoinedType = (options: PersonJoinedOptions) => Promise<void>;
+/**
+ * Service to handle actions when a person joins an event.
+ *
+ * @class
+ * @name PersonJoined
+ * @description
+ * Displays a notification when a person joins the event, using the `showAlert` function if provided.
+ *
+ * @method
+ * personJoined
+ *
+ * @param {PersonJoinedOptions} options - Contains information about the person and alert display function:
+ *   - `name` {string}: The name of the person who joined.
+ *   - `showAlert` {Function} (optional): Function to display a notification when the person joins.
+ *
+ * @returns {void} Executes alert display through `showAlert` if defined.
+ *
+ * @example
+ * const options = {
+ *   name: 'Alice',
+ *   showAlert: ({ message, type, duration }) => console.log(message)
+ * };
+ * personJoinedService.personJoined(options);
+ * // Logs: "Alice joined the event."
+ */
 export declare class PersonJoined {
     /**
      * Handles the event when a person joins.

package/dist/lib/producers/socket-receive-methods/producer-media-closed.service.d.ts

@@ -21,6 +21,67 @@ export interface ProducerMediaClosedOptions {
     parameters: ProducerMediaClosedParameters;
 }
 export type ProducerMediaClosedType = (options: ProducerMediaClosedOptions) => Promise<void>;
+/**
+ * Service to handle closing a media producer and associated UI and state updates.
+ *
+ * @class
+ * @name ProducerMediaClosed
+ * @description
+ * Manages the closure of a media producer by identifying associated consumer transports, closing necessary resources,
+ * and updating the user interface to reflect the change. For screen sharing, it resets the shared state and adjusts the main view.
+ *
+ * @method
+ * producerMediaClosed
+ *
+ * @param {ProducerMediaClosedOptions} options - Contains details on the producer and parameters for state updates:
+ *   - `producerId` {string}: ID of the producer to close.
+ *   - `kind` {string}: The type of media to close (e.g., "screenshare" or "audio").
+ *   - `parameters` {ProducerMediaClosedParameters}: Settings and update functions to manage the closure process.
+ *      - `consumerTransports` {Transport[]}: List of active transports for consumers.
+ *      - `updateConsumerTransports` {Function}: Updates the list of active consumer transports.
+ *      - `hostLabel` {string}: Label of the host to revert to if screen sharing ends.
+ *      - `shared` {boolean}: Indicates whether a screen is currently shared.
+ *      - `updateShared` {Function}: Updates the shared screen state.
+ *      - `updateShareScreenStarted` {Function}: Marks the start or end of screen sharing.
+ *      - `updateScreenId` {Function}: Clears the screen ID when screen sharing ends.
+ *      - `updateShareEnded` {Function}: Marks the end of screen sharing.
+ *      - `closeAndResize` {Function}: Adjusts the screen display upon closing the media.
+ *      - `prepopulateUserMedia` {Function}: Loads default media after screen sharing ends.
+ *      - `reorderStreams` {Function}: Reorders streams to optimize layout when media is closed.
+ *
+ * @returns {Promise<void>} Resolves when all updates are complete and the producer closure is handled.
+ *
+ * @example
+ * const options = {
+ *   producerId: '12345',
+ *   kind: 'screenshare',
+ *   parameters: {
+ *     consumerTransports: [...],
+ *     updateConsumerTransports: (transports) => { ... },
+ *     hostLabel: 'Host',
+ *     shared: true,
+ *     updateShared: (shared) => { ... },
+ *     updateShareScreenStarted: (started) => { ... },
+ *     updateScreenId: (id) => { ... },
+ *     updateShareEnded: (ended) => { ... },
+ *     closeAndResize: ({ producerId, kind, parameters }) => { ... },
+ *     prepopulateUserMedia: ({ name, parameters }) => { ... },
+ *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },
+ *   }
+ * };
+ *
+ * producerMediaClosedService.producerMediaClosed(options)
+ *   .then(() => console.log('Producer closed successfully'))
+ *   .catch(error => console.error('Error:', error));
+ *
+ * @remarks
+ * This service performs the following steps:
+ * 1. Retrieves updated parameters.
+ * 2. Finds and closes the transport associated with the producer.
+ * 3. Updates the list of consumer transports.
+ * 4. Adjusts the display layout with `closeAndResize`.
+ * 5. If the producer is a screen share, resets shared state and reloads default media.
+ */
 export declare class ProducerMediaClosed {
     /**
      * Handles the closure of a media producer.

package/dist/lib/producers/socket-receive-methods/producer-media-paused.service.d.ts

@@ -26,6 +26,68 @@ export interface ProducerMediaPausedOptions {
     parameters: ProducerMediaPausedParameters;
 }
 export type ProducerMediaPausedType = (options: ProducerMediaPausedOptions) => Promise<void>;
+/**
+ * Service to handle the paused state of media for a producer.
+ *
+ * @class
+ * @name ProducerMediaPaused
+ * @description
+ * Handles the actions required when media is paused for a specified producer, including UI updates, participant state handling, and managing meeting display optimizations.
+ *
+ * @method
+ * producerMediaPaused
+ *
+ * @param {ProducerMediaPausedOptions} options - Options to specify the producer and event details:
+ *   - `producerId` {string}: The ID of the paused producer.
+ *   - `kind` {string}: The type of media paused (e.g., "audio", "video").
+ *   - `name` {string}: Name of the producer whose media is paused.
+ *   - `parameters` {ProducerMediaPausedParameters}: Configuration and state parameters for the meeting.
+ *      - `activeSounds` {string[]}: Active audio streams currently displayed.
+ *      - `meetingDisplayType` {string}: Current meeting layout type (e.g., "media", "video").
+ *      - `meetingVideoOptimized` {boolean}: Indicates if video is optimized.
+ *      - `participants` {Participant[]}: List of all meeting participants.
+ *      - `oldSoundIds` {string[]}: List of previously active audio stream IDs.
+ *      - `shared` {boolean}: Indicates if the screen is currently shared.
+ *      - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.
+ *      - `updateMainWindow` {boolean}: Specifies if the main display window should update.
+ *      - `hostLabel` {string}: The label representing the host participant.
+ *      - `islevel` {string}: The access level of the participant.
+ *      - `updateActiveSounds` {Function}: Updates the list of active audio streams.
+ *      - `updateUpdateMainWindow` {Function}: Updates the status of the main display window.
+ *      - `reorderStreams` {Function}: Reorders media streams for optimized display.
+ *      - `prepopulateUserMedia` {Function}: Preloads user media based on display needs.
+ *      - `reUpdateInter` {Function}: Refreshes participant interactions on the UI.
+ *
+ * @returns {Promise<void>} Resolves when media pause handling is complete.
+ *
+ * @example
+ * const options = {
+ *   producerId: '12345',
+ *   kind: 'audio',
+ *   name: 'Participant A',
+ *   parameters: {
+ *     activeSounds: ['Participant B'],
+ *     meetingDisplayType: 'video',
+ *     meetingVideoOptimized: false,
+ *     participants: [...],
+ *     oldSoundIds: ['Participant A'],
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     updateMainWindow: true,
+ *     hostLabel: 'Host',
+ *     islevel: '1',
+ *     updateActiveSounds: (sounds) => { ... },
+ *     updateUpdateMainWindow: (status) => { ... },
+ *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },
+ *     prepopulateUserMedia: ({ name, parameters }) => { ... },
+ *     reUpdateInter: ({ name, add, force, parameters }) => { ... }
+ *   }
+ * };
+ *
+ * producerMediaPausedService.producerMediaPaused(options)
+ *   .then(() => console.log('Media pause handled'))
+ *   .catch(error => console.error('Error:', error));
+ */
 export declare class ProducerMediaPaused {
     /**
      * Handles the event when media is paused for a producer.

package/dist/lib/producers/socket-receive-methods/producer-media-resumed.service.d.ts

@@ -19,6 +19,51 @@ export interface ProducerMediaResumedOptions {
     parameters: ProducerMediaResumedParameters;
 }
 export type ProducerMediaResumedType = (options: ProducerMediaResumedOptions) => Promise<void>;
+/**
+ * Service to handle resuming media for a specific participant in a meeting.
+ *
+ * @class
+ * @name ProducerMediaResumed
+ * @description Resumes media (audio only) for a participant and updates the meeting display based on the meeting layout and participant status.
+ *
+ * @method
+ * producerMediaResumed
+ *
+ * @param {ProducerMediaResumedOptions} options - Options to control media resumption:
+ *   - `name` {string}: Name of the participant whose media is to be resumed.
+ *   - `parameters` {ProducerMediaResumedParameters}: Meeting and participant-specific configurations.
+ *      - `meetingDisplayType` {string}: Type of meeting display (e.g., "media").
+ *      - `participants` {Participant[]}: List of participants in the meeting.
+ *      - `shared` {boolean}: Indicates if the screen is currently shared.
+ *      - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.
+ *      - `mainScreenFilled` {boolean}: Indicates if the main screen is filled.
+ *      - `hostLabel` {string}: Label or name of the host.
+ *      - `updateUpdateMainWindow` {Function}: Function to update the main window display.
+ *      - `reorderStreams` {Function}: Function to manage stream ordering when display changes.
+ *      - `prepopulateUserMedia` {Function}: Function to preload user media for the main screen.
+ *
+ * @returns {Promise<void>} Resolves when media for the specified participant has resumed.
+ *
+ * @example
+ * const options = {
+ *   name: 'Participant A',
+ *   parameters: {
+ *     meetingDisplayType: 'media',
+ *     participants: [...],
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     mainScreenFilled: false,
+ *     hostLabel: 'Host',
+ *     updateUpdateMainWindow: (updateMainWindow) => { ... },
+ *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },
+ *     prepopulateUserMedia: ({ name, parameters }) => { ... }
+ *   }
+ * };
+ *
+ * producerMediaResumedService.producerMediaResumed(options)
+ *   .then(() => console.log('Media resumed'))
+ *   .catch(error => console.error('Error:', error));
+ */
 export declare class ProducerMediaResumed {
     /**
      * Resumes media for a specific participant in a meeting.

package/dist/lib/producers/socket-receive-methods/re-initiate-recording.service.d.ts

@@ -7,6 +7,35 @@ export interface ReInitiateRecordingOptions {
     adminRestrictSetting: boolean;
 }
 export type ReInitiateRecordingType = (options: ReInitiateRecordingOptions) => Promise<void>;
+/**
+ * Service to re-initiate recording in a specific room, considering administrative restrictions.
+ *
+ * @class
+ * @name ReInitiateRecording
+ * @description Attempts to re-initiate recording if administrative restrictions permit.
+ *
+ * @method
+ * reInitiateRecording
+ *
+ * @param {ReInitiateRecordingOptions} options - Configuration options for re-initiating recording:
+ *   - `roomName` {string}: The name of the room to start recording in.
+ *   - `member` {string}: The name of the member initiating the recording.
+ *   - `socket` {Socket}: The socket instance for server communication.
+ *   - `adminRestrictSetting` {boolean}: Flag indicating if the admin restrict setting is active, preventing re-initiation.
+ *
+ * @returns {Promise<void>} Resolves if recording is successfully re-initiated; otherwise, it throws an error if re-initiation fails.
+ *
+ * @example
+ * const options = {
+ *   roomName: 'Room101',
+ *   member: 'Alice',
+ *   socket: mySocketInstance,
+ *   adminRestrictSetting: false
+ * };
+ * reInitiateRecordingService.reInitiateRecording(options)
+ *   .then(() => console.log('Recording re-initiated'))
+ *   .catch(error => console.error(error.message));
+ */
 export declare class ReInitiateRecording {
     /**
      * Re-initiates recording based on specific conditions.

package/dist/lib/producers/socket-receive-methods/receive-message.service.d.ts

@@ -12,6 +12,44 @@ export interface ReceiveMessageOptions {
     updateShowMessagesBadge: (showBadge: boolean) => void;
 }
 export type ReceiveMessageType = (options: ReceiveMessageOptions) => Promise<void>;
+/**
+ * Service for receiving and processing messages, including handling group and direct messages, filtering banned senders, and updating message states.
+ *
+ * @class
+ * @name ReceiveMessage
+ * @description Manages incoming messages, appends them to the existing messages array, filters out banned senders, and updates message badge visibility as needed.
+ *
+ * @method
+ * receiveMessage
+ *
+ * @param {ReceiveMessageOptions} options - Options for handling a received message:
+ *   - `message` {Message}: The new message object to process.
+ *   - `messages` {Message[]}: The current list of messages.
+ *   - `participantsAll` {Participant[]}: All participants in the chat.
+ *   - `member` {string}: The current member's name.
+ *   - `eventType` {EventType}: The type of event (e.g., "broadcast" or "chat").
+ *   - `islevel` {string}: The level of the current user.
+ *   - `coHost` {string}: The name of the co-host.
+ *   - `updateMessages` {Function}: A function to update the messages list.
+ *   - `updateShowMessagesBadge` {Function}: A function to toggle the visibility of the message badge.
+ *
+ * @returns {Promise<void>} Resolves when the message processing and updates are complete.
+ *
+ * @example
+ * const message = { sender: 'Alice', receivers: ['Bob'], message: 'Hello!', timestamp: Date.now(), group: false };
+ * const options = {
+ *   message,
+ *   messages: [],
+ *   participantsAll: [{ name: 'Alice' }, { name: 'Bob' }],
+ *   member: 'Bob',
+ *   eventType: 'chat',
+ *   islevel: '1',
+ *   coHost: 'Charlie',
+ *   updateMessages: (updatedMessages) => console.log('Messages updated:', updatedMessages),
+ *   updateShowMessagesBadge: (show) => console.log('Show badge:', show)
+ * };
+ * receiveMessageService.receiveMessage(options);
+ */
 export declare class ReceiveMessage {
     /**
      * Receives and processes a message, updating the messages array and handling

package/dist/lib/producers/socket-receive-methods/recording-notice.service.d.ts

@@ -53,6 +53,44 @@ export interface RecordingNoticeOptions {
     parameters: RecordingNoticeParameters;
 }
 export type RecordingNoticeType = (options: RecordingNoticeOptions) => Promise<void>;
+/**
+ * Service for handling recording notices, managing recording states, and updating related parameters.
+ *
+ * @class
+ * @name RecordingNotice
+ * @description Provides methods to handle the recording notice state, manage user recording parameters, and play appropriate sounds for different states.
+ *
+ * @method
+ * RecordingNotice
+ *
+ * @param {RecordingNoticeOptions} options - The options for recording notices:
+ *   - `state` {string}: The current recording state (`pause`, `stop`, etc.).
+ *   - `userRecordingParam` {UserRecordingParams | null}: The user recording parameters (if available).
+ *   - `pauseCount` {number}: The number of pauses in the recording.
+ *   - `timeDone` {number}: The total recording time completed.
+ *   - `parameters` {RecordingNoticeParameters}: Functions and properties to update recording details.
+ *     - `updateRecordElapsedTime` {Function}: Updates elapsed recording time.
+ *     - `updateShowRecordButtons` {Function}: Toggles record button visibility.
+ *     - `updateRecordState` {Function}: Sets the record state (e.g., `red`, `green`, `yellow`).
+ *     - `updatePauseRecordCount` {Function}: Sets the pause record count.
+ *     - `updateRecordStarted`, `updateRecordPaused`, `updateCanLaunchRecord`, etc.: Other update functions to control recording settings and states.
+ *
+ * @returns {Promise<void>} Resolves when the recording state and parameters have been updated.
+ *
+ * @example
+ * const options = {
+ *   state: 'pause',
+ *   userRecordingParam: { mainSpecs: { mediaOptions: 'audio', ... } },
+ *   pauseCount: 3,
+ *   timeDone: 3600,
+ *   parameters: {
+ *     updateRecordStarted: (started) => console.log(`Recording started: ${started}`),
+ *     updateRecordPaused: (paused) => console.log(`Recording paused: ${paused}`),
+ *     // Define other update functions similarly
+ *   }
+ * };
+ * await recordingNoticeService.RecordingNotice(options);
+ */
 export declare class RecordingNotice {
     private SoundPlayerService;
     constructor(SoundPlayerService: SoundPlayer);

package/dist/lib/producers/socket-receive-methods/room-record-params.service.d.ts

@@ -43,6 +43,68 @@ export interface RoomRecordParamsOptions {
     parameters: RoomRecordParamsParameters;
 }
 export type RoomRecordParamsType = ({ recordParams, parameters, }: RoomRecordParamsOptions) => Promise<void>;
+/**
+ * Service to update recording parameters for a room.
+ *
+ * @class
+ * @name RoomRecordParams
+ * @description Updates multiple recording parameters at once, using provided functions for each specific setting.
+ *
+ * @method
+ * roomRecordParams
+ *
+ * @param {RoomRecordParamsOptions} options - The options for updating recording parameters:
+ *   - `recordParams` {RecordParams}: The new recording parameters to apply.
+ *   - `parameters` {RoomRecordParamsParameters}: The update functions for each recording parameter.
+ *     - `updateRecordingAudioPausesLimit` {Function}: Updates the audio pauses limit.
+ *     - `updateRecordingAudioPausesCount` {Function}: Updates the audio pauses count.
+ *     - `updateRecordingAudioSupport` {Function}: Updates the audio support status.
+ *     - `updateRecordingAudioPeopleLimit` {Function}: Updates the audio people limit.
+ *     - `updateRecordingAudioParticipantsTimeLimit` {Function}: Updates the audio participants time limit.
+ *     - `updateRecordingVideoPausesCount` {Function}: Updates the video pauses count.
+ *     - `updateRecordingVideoPausesLimit` {Function}: Updates the video pauses limit.
+ *     - `updateRecordingVideoSupport` {Function}: Updates the video support status.
+ *     - `updateRecordingVideoPeopleLimit` {Function}: Updates the video people limit.
+ *     - `updateRecordingVideoParticipantsTimeLimit` {Function}: Updates the video participants time limit.
+ *     - `updateRecordingAllParticipantsSupport` {Function}: Updates support for all participants.
+ *     - `updateRecordingVideoParticipantsSupport` {Function}: Updates video participants support.
+ *     - `updateRecordingAllParticipantsFullRoomSupport` {Function}: Updates full room support for all participants.
+ *     - `updateRecordingVideoParticipantsFullRoomSupport` {Function}: Updates full room support for video participants.
+ *     - `updateRecordingPreferredOrientation` {Function}: Updates the preferred recording orientation.
+ *     - `updateRecordingSupportForOtherOrientation` {Function}: Updates support for other orientations.
+ *     - `updateRecordingMultiFormatsSupport` {Function}: Updates support for multiple formats.
+ *
+ * @returns {Promise<void>} A promise that resolves after all parameters are updated.
+ *
+ * @example
+ * const recordParams = {
+ *   recordingAudioPausesLimit: 5,
+ *   recordingAudioPausesCount: 2,
+ *   recordingAudioSupport: true,
+ *   recordingAudioPeopleLimit: 10,
+ *   recordingAudioParticipantsTimeLimit: 60,
+ *   recordingVideoPausesCount: 1,
+ *   recordingVideoPausesLimit: 3,
+ *   recordingVideoSupport: true,
+ *   recordingVideoPeopleLimit: 8,
+ *   recordingVideoParticipantsTimeLimit: 90,
+ *   recordingAllParticipantsSupport: true,
+ *   recordingVideoParticipantsSupport: true,
+ *   recordingAllParticipantsFullRoomSupport: false,
+ *   recordingVideoParticipantsFullRoomSupport: true,
+ *   recordingPreferredOrientation: 'landscape',
+ *   recordingSupportForOtherOrientation: false,
+ *   recordingMultiFormatsSupport: true,
+ * };
+ *
+ * const parameters = {
+ *   updateRecordingAudioPausesLimit: (value) => console.log(`Audio pauses limit: ${value}`),
+ *   updateRecordingAudioPausesCount: (value) => console.log(`Audio pauses count: ${value}`),
+ *   // Define other update functions similarly
+ * };
+ *
+ * roomRecordParamsService.roomRecordParams({ recordParams, parameters });
+ */
 export declare class RoomRecordParams {
     /**
      * Updates various recording parameters based on the provided `recordParams`.