mediasfu-angular 1.0.0 → 1.0.2

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

@@ -51,6 +51,77 @@ export interface AllMembersOptions {
     apiToken: string;
 }
 export type AllMembersType = (options: AllMembersOptions) => Promise<void>;
+/**
+ * Manages participant-related operations, including updates for participant lists, requests, co-host settings,
+ * and other session details. This method filters out banned and suspended participants, reorders streams,
+ * connects IPs, and updates the UI.
+ *
+ * @async
+ * @param {AllMembersOptions} options - Parameters for managing all members.
+ * @param {Participant[]} options.members - The array of participant objects.
+ * @param {Request[]} options.requestss - The list of requests from participants.
+ * @param {string} options.coHoste - The current co-host name.
+ * @param {CoHostResponsibility[]} options.coHostRes - The responsibilities assigned to the co-host.
+ * @param {AllMembersParameters} options.parameters - Additional parameters for member management and UI updates.
+ * @param {ConsumeSocket[]} options.consume_sockets - Array of sockets for participant communication.
+ * @param {string} options.apiUserName - API username for authentication.
+ * @param {string} options.apiKey - API key for authentication.
+ * @param {string} options.apiToken - API token for authentication.
+ *
+ * @returns {Promise<void>} A promise that resolves when all members have been processed and updates are complete.
+ *
+ * @example
+ * ```typescript
+ * const allMembersService = new AllMembers();
+ * await allMembersService.allMembers({
+ *   members: [{ name: 'John', isBanned: false, isSuspended: false, audioID: '123', videoID: '456' }],
+ *   requestss: [{ id: '1', name: 'Jane', type: 'fa-microphone' }],
+ *   coHoste: 'Jane',
+ *   coHostRes: ['manage-chat'],
+ *   parameters: {
+ *     participantsAll: [],
+ *     participants: [],
+ *     dispActiveNames: ['John'],
+ *     requestList: [],
+ *     coHost: '',
+ *     coHostResponsibility: [],
+ *     lock_screen: false,
+ *     firstAll: false,
+ *     membersReceived: false,
+ *     roomRecvIPs: [],
+ *     deferScreenReceived: false,
+ *     screenId: null,
+ *     shareScreenStarted: false,
+ *     meetingDisplayType: 'grid',
+ *     hostFirstSwitch: false,
+ *     waitingRoomList: [],
+ *     islevel: '1',
+ *     updateParticipantsAll: (participantsAll) => console.log(participantsAll),
+ *     updateParticipants: (participants) => console.log(participants),
+ *     updateRequestList: (requestList) => console.log(requestList),
+ *     updateCoHost: (coHost) => console.log(coHost),
+ *     updateCoHostResponsibility: (coHostRes) => console.log(coHostRes),
+ *     updateFirstAll: (firstAll) => console.log(firstAll),
+ *     updateMembersReceived: (membersReceived) => console.log(membersReceived),
+ *     updateDeferScreenReceived: (deferScreenReceived) => console.log(deferScreenReceived),
+ *     updateShareScreenStarted: (shareScreenStarted) => console.log(shareScreenStarted),
+ *     updateHostFirstSwitch: (hostFirstSwitch) => console.log(hostFirstSwitch),
+ *     updateConsume_sockets: (sockets) => console.log(sockets),
+ *     updateRoomRecvIPs: (ips) => console.log(ips),
+ *     updateIsLoadingModalVisible: (visible) => console.log(visible),
+ *     updateTotalReqWait: (total) => console.log(total),
+ *     onScreenChanges: (params) => console.log('onScreenChanges called with', params),
+ *     connectIps: async (params) => [['socket1'], ['ip1']],
+ *     sleep: async ({ ms }) => new Promise((resolve) => setTimeout(resolve, ms)),
+ *     reorderStreams: async (params) => console.log('reorderStreams called with', params),
+ *   },
+ *   consume_sockets: [{ socketId: 'abc123' }],
+ *   apiUserName: 'testUser',
+ *   apiKey: 'apiKeyExample',
+ *   apiToken: 'apiTokenExample',
+ * });
+ * ```
+ */
 export declare class AllMembers {
     /**
      * allMembers - A method for handling various tasks related to participant management and UI updates.

package/dist/lib/producers/socket-receive-methods/all-waiting-room-members.service.d.ts

@@ -6,6 +6,33 @@ export interface AllWaitingRoomMembersOptions {
     updateTotalReqWait: (totalReqs: number) => void;
 }
 export type AllWaitingRoomMembersType = (options: AllWaitingRoomMembersOptions) => Promise<void>;
+/**
+ * Service to handle updating the list and count of waiting room participants.
+ *
+ * @class
+ * @name AllWaitingRoomMembers
+ * @description This service updates the waiting room participants list and the total count of participants waiting to join.
+ *
+ * @method
+ * @async
+ * @name allWaitingRoomMembers
+ * @param {AllWaitingRoomMembersOptions} options - The options for updating the waiting room data.
+ * @param {WaitingRoomParticipant[]} options.waitingParticipants - An array of participants currently in the waiting room.
+ * @param {Function} options.updateWaitingRoomList - Function to update the waiting room participants list.
+ * @param {Function} options.updateTotalReqWait - Function to update the total count of waiting room participants.
+ *
+ * @returns {Promise<void>} A promise that resolves when the updates to the waiting room data are complete.
+ *
+ * @example
+ * ```typescript
+ * const allWaitingRoomMembersService = new AllWaitingRoomMembers();
+ * await allWaitingRoomMembersService.allWaitingRoomMembers({
+ *   waitingParticipants: [{ name: 'John Doe', isApproved: false }],
+ *   updateWaitingRoomList: (participants) => console.log(participants),
+ *   updateTotalReqWait: (total) => console.log(`Total requests: ${total}`)
+ * });
+ * ```
+ */
 export declare class AllWaitingRoomMembers {
     /**
      * Updates the waiting room participants list and the total count of waiting room participants.

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

@@ -13,6 +13,42 @@ export interface BanParticipantOptions {
     parameters: BanParticipantParameters;
 }
 export type BanParticipantType = (options: BanParticipantOptions) => Promise<void>;
+/**
+ * Service to handle banning a participant from the session.
+ *
+ * @class
+ * @name BanParticipant
+ * @description This service provides a method to remove a participant from active lists and update the session's participant array, followed by reordering the streams.
+ *
+ * @method
+ * banParticipant
+ * @async
+ * @param {BanParticipantOptions} options - The options for banning a participant.
+ * @param {string} options.name - The name of the participant to be banned.
+ * @param {BanParticipantParameters} options.parameters - Parameters required for the banning operation.
+ * @param {string[]} options.parameters.activeNames - Array of active participant names.
+ * @param {string[]} options.parameters.dispActiveNames - Array of display participant names.
+ * @param {Participant[]} options.parameters.participants - Array of current session participants.
+ * @param {Function} options.parameters.updateParticipants - Function to update the participants array.
+ * @param {Function} options.parameters.reorderStreams - Function to reorder the streams after removing the participant.
+ *
+ * @returns {Promise<void>} A promise that resolves when the participant has been banned and streams reordered.
+ *
+ * @example
+ * ```typescript
+ * const banParticipantService = new BanParticipant();
+ * await banParticipantService.banParticipant({
+ *   name: 'John Doe',
+ *   parameters: {
+ *     activeNames: ['John Doe', 'Jane Smith'],
+ *     dispActiveNames: ['John Doe', 'Jane Smith'],
+ *     participants: [{ name: 'John Doe', isBanned: false }, { name: 'Jane Smith', isBanned: false }],
+ *     updateParticipants: (updated) => console.log(updated),
+ *     reorderStreams: async () => { }
+ *   }
+ * });
+ * ```
+ */
 export declare class BanParticipant {
     /**
      * Bans a participant from the session by removing them from the active and display names arrays,

package/dist/lib/producers/socket-receive-methods/control-media-host.service.d.ts

@@ -25,6 +25,43 @@ export interface ControlMediaHostOptions {
     parameters: ControlMediaHostParameters;
 }
 export type ControlMediaHostType = (options: ControlMediaHostOptions) => Promise<void>;
+/**
+ * Service for controlling participant media in a session, with options to manage audio, video, screenshare, and chat functionalities.
+ *
+ * @class
+ * @name ControlMediaHost
+ * @description This service provides the host with control over a participant's media (audio, video, screenshare, chat), with options to enable or disable these functionalities individually or all at once.
+ *
+ * @method
+ * controlMediaHost
+ * @async
+ * @param {ControlMediaHostOptions} options - Options to specify which media type to control and provide necessary parameters.
+ * @param {string} options.type - The media type to control ('audio', 'video', 'screenshare', 'chat', 'all').
+ * @param {ControlMediaHostParameters} options.parameters - Additional parameters, functions, and media streams necessary to perform the media control operations.
+ *
+ * @returns {Promise<void>} - A promise that resolves when the media control operation is complete.
+ *
+ * @example
+ * ```typescript
+ * const controlMediaHostService = new ControlMediaHost();
+ * await controlMediaHostService.controlMediaHost({
+ *   type: 'audio',
+ *   parameters: {
+ *     updateAdminRestrictSetting: (value) => console.log(value),
+ *     localStream: myLocalStream,
+ *     updateLocalStream: (stream) => console.log(stream),
+ *     updateAudioAlreadyOn: (value) => console.log(value),
+ *     onScreenChanges: async () => { },
+ *     disconnectSendTransportAudio: async () => { },
+ *     getUpdatedAllParams: () => ({ }),
+ *   }
+ * });
+ * ```
+ *
+ * @remarks
+ * - This function handles the control of audio, video, screenshare, or chat for a participant based on the specified type.
+ * - For `all` type, it sequentially controls each media type to ensure all are turned off.
+ */
 export declare class ControlMediaHost {
     /**
      * Controls the media (audio, video, screenshare, chat) of a participant as a host.

package/dist/lib/producers/socket-receive-methods/disconnect-user-self.service.d.ts

@@ -6,6 +6,30 @@ export interface DisconnectUserSelfOptions {
     socket: Socket;
 }
 export type DisconnectUserSelfType = (options: DisconnectUserSelfOptions) => Promise<void>;
+/**
+ * Service to handle self-disconnection and banning of a user from a room.
+ *
+ * @class
+ * @name DisconnectUserSelf
+ * @description This service manages the disconnection of a user from a specified room and initiates a ban on the user.
+ *
+ * @method
+ * disconnectUserSelf
+ * @async
+ * @param {DisconnectUserSelfOptions} options - The options required to disconnect the user.
+ * @param {string} options.member - The identifier of the member to be disconnected.
+ * @param {string} options.roomName - The name of the room from which the user will be disconnected.
+ * @param {Socket} options.socket - The socket instance used to emit the disconnection and ban request.
+ * @returns {Promise<void>} A promise that resolves when the disconnection request is sent to the server.
+ *
+ * @example
+ * const disconnectUserSelfOptions = {
+ *   member: 'user123',
+ *   roomName: 'room456',
+ *   socket: mySocketInstance
+ * };
+ * await disconnectUserSelfService.disconnectUserSelf(disconnectUserSelfOptions);
+ */
 export declare class DisconnectUserSelf {
     /**
      * Disconnects the user from the specified room and bans them.

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

@@ -7,6 +7,32 @@ export interface DisconnectOptions {
     updateValidated?: (isValidated: boolean) => void;
 }
 export type DisconnectType = (options: DisconnectOptions) => Promise<void>;
+/**
+ * Service to handle disconnection logic, providing options to redirect or display an alert message.
+ *
+ * @class
+ * @name Disconnect
+ * @description This service manages user disconnection by either redirecting the user to a specified URL (for web platforms) or showing a custom alert message.
+ *
+ * @method
+ * disconnect
+ * @async
+ * @param {DisconnectOptions} options - The options for handling disconnection.
+ * @param {Function} options.showAlert - Function to display an alert message if a redirect is not needed.
+ * @param {string} options.redirectURL - The URL to redirect to upon disconnection, if applicable.
+ * @param {boolean} options.onWeb - Flag indicating if the application is running on the web.
+ * @param {Function} [options.updateValidated] - Optional function to update validation state, primarily for native applications.
+ * @returns {Promise<void>} A promise that resolves when the disconnection process completes.
+ *
+ * @example
+ * const disconnectOptions = {
+ *   showAlert: (alert) => console.log(alert.message),
+ *   redirectURL: 'https://example.com/home',
+ *   onWeb: true,
+ *   updateValidated: (isValid) => console.log(`Validation updated: ${isValid}`)
+ * };
+ * disconnectService.disconnect(disconnectOptions);
+ */
 export declare class Disconnect {
     /**
      * Handles the disconnection logic by either redirecting to a specified URL or showing an alert.

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

@@ -19,27 +19,42 @@ export interface GetDomainsOptions {
 }
 export type GetDomainsType = (options: GetDomainsOptions) => Promise<void>;
 /**
- * Service to handle domain-related operations.
+ * Service to handle domain-related operations, such as retrieving and processing domains for connection.
  *
  * @class
  * @name GetDomains
- * @description This service provides a method to retrieve and process domains.
+ * @description This service provides a method to retrieve and process domains by connecting IPs that are not currently present in the room.
  *
  * @method
- * @name getDomains
+ * getDomains
  * @async
- * @param {Object} options - The options for retrieving domains.
+ * @param {GetDomainsOptions} options - The options for retrieving and connecting domains.
  * @param {string[]} options.domains - The list of domains to process.
- * @param {Object} options.alt_domains - An object mapping domains to alternative domains.
+ * @param {AltDomains} options.alt_domains - An object mapping primary domains to alternative domains.
  * @param {string} options.apiUserName - The API username for authentication.
  * @param {string} options.apiKey - The API key for authentication.
  * @param {string} options.apiToken - The API token for authentication.
- * @param {Object} options.parameters - Additional parameters for the operation.
- * @param {string[]} options.parameters.roomRecvIPs - The list of IPs currently in the room.
+ * @param {GetDomainsParameters} options.parameters - Additional parameters for the operation.
+ * @param {string[]} options.parameters.roomRecvIPs - The list of IP addresses already connected in the room.
  * @param {Function} options.parameters.getUpdatedAllParams - A function to get updated parameters.
- * @param {Function} options.parameters.connectIps - A function to connect IPs.
+ * @param {Function} options.parameters.connectIps - A function to connect IPs that are not currently present.
  * @returns {Promise<void>} A promise that resolves when the operation is complete.
- * @throws {Error} Throws an error if the domain retrieval fails.
+ * @throws {Error} Throws an error if the domain retrieval or connection fails.
+ *
+ * @example
+ * const options = {
+ *   domains: ['example.com', 'example.org'],
+ *   alt_domains: { 'example.com': 'alt-example.com' },
+ *   apiUserName: 'user123',
+ *   apiKey: 'key123',
+ *   apiToken: 'token123',
+ *   parameters: {
+ *     roomRecvIPs: ['192.168.1.1'],
+ *     getUpdatedAllParams: () => updatedParameters,
+ *     connectIps: connectIpsFunction,
+ *   }
+ * };
+ * getDomainsService.getDomains(options);
  */
 export declare class GetDomains {
     getDomains: ({ domains, alt_domains, apiUserName, apiKey, apiToken, parameters, }: GetDomainsOptions) => Promise<void>;

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.