mediasfu-angular 1.0.1 → 2.0.0

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

@@ -1,6 +1,7 @@
-import { Participant, CoHostResponsibility, OnScreenChangesType, OnScreenChangesParameters, Request, ConnectIpsParameters, ReorderStreamsParameters, ConnectIpsType, SleepType, ReorderStreamsType, Settings, ConsumeSocket } from '../../@types/types';
+import { Participant, CoHostResponsibility, OnScreenChangesType, OnScreenChangesParameters, Request, ConnectIpsParameters, ReorderStreamsParameters, ConnectIpsType, ConnectLocalIpsType, ConnectLocalIpsParameters, SleepType, ReorderStreamsType, Settings, ConsumeSocket } from '../../@types/types';
+import { Socket } from 'socket.io-client';
 import * as i0 from "@angular/core";
-export interface AllMembersRestParameters extends OnScreenChangesParameters, ConnectIpsParameters, ReorderStreamsParameters {
+export interface AllMembersRestParameters extends OnScreenChangesParameters, ConnectIpsParameters, OnScreenChangesParameters, ConnectLocalIpsParameters, ReorderStreamsParameters {
     participantsAll: Participant[];
     participants: Participant[];
     dispActiveNames: string[];
@@ -19,6 +20,7 @@ export interface AllMembersRestParameters extends OnScreenChangesParameters, Con
     videoSetting: string;
     screenshareSetting: string;
     chatSetting: string;
+    socket: Socket;
     updateParticipantsAll: (participantsAll: Participant[]) => void;
     updateParticipants: (participants: Participant[]) => void;
     updateRequestList: (requestList: Request[]) => void;
@@ -37,6 +39,7 @@ export interface AllMembersRestParameters extends OnScreenChangesParameters, Con
     updateIsLoadingModalVisible: (visible: boolean) => void;
     onScreenChanges: OnScreenChangesType;
     connectIps: ConnectIpsType;
+    connectLocalIps?: ConnectLocalIpsType;
     sleep: SleepType;
     reorderStreams: ReorderStreamsType;
     getUpdatedAllParams: () => AllMembersRestParameters;
@@ -54,6 +57,81 @@ export interface AllMembersRestOptions {
     apiToken: string;
 }
 export type AllMembersRestType = (options: AllMembersRestOptions) => Promise<void>;
+/**
+ * Manages participant settings and UI updates, including connecting IPs, reordering streams,
+ * updating settings, and handling participant display based on various session parameters.
+ *
+ * @async
+ * @param {AllMembersRestOptions} options - Parameters for managing members.
+ * @param {Participant[]} options.members - The array of participant objects.
+ * @param {Settings} options.settings - The session settings for audio, video, screenshare, and chat.
+ * @param {string} [options.coHoste] - The current co-host name.
+ * @param {CoHostResponsibility[]} [options.coHostRes] - The responsibilities assigned to the co-host.
+ * @param {AllMembersRestParameters} options.parameters - Additional parameters for managing members 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 updates and changes for members are completed.
+ *
+ * @example
+ * ```typescript
+ * const allMembersRestService = new AllMembersRest();
+ * await allMembersRestService.allMembersRest({
+ *   members: [{ name: 'John', isBanned: false, isSuspended: false, audioID: '123', videoID: '456' }],
+ *   settings: ['enabled', 'HD', 'allowed', 'public'],
+ *   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',
+ *     audioSetting: '',
+ *     videoSetting: '',
+ *     screenshareSetting: '',
+ *     chatSetting: '',
+ *     socket: mySocket,
+ *     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),
+ *     updateAudioSetting: (audioSetting) => console.log(audioSetting),
+ *     updateVideoSetting: (videoSetting) => console.log(videoSetting),
+ *     updateScreenshareSetting: (screenshareSetting) => console.log(screenshareSetting),
+ *     updateChatSetting: (chatSetting) => console.log(chatSetting),
+ *     updateConsume_sockets: (sockets) => console.log(sockets),
+ *     updateRoomRecvIPs: (ips) => console.log(ips),
+ *     updateIsLoadingModalVisible: (visible) => console.log(visible),
+ *     onScreenChanges: (params) => console.log('onScreenChanges called with', params),
+ *     connectIps: async (params) => [['socket1'], ['ip1']],
+ *     connectLocalIps: 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 AllMembersRest {
     /**
      * Handles various tasks related to participant management and UI updates.

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

@@ -1,6 +1,7 @@
-import { Participant, Request, ReorderStreamsType, ReorderStreamsParameters, SleepType, ConnectIpsParameters, OnScreenChangesParameters, OnScreenChangesType, ConnectIpsType, ConsumeSocket, CoHostResponsibility, WaitingRoomParticipant } from '../../@types/types';
+import { Participant, Request, ReorderStreamsType, ReorderStreamsParameters, SleepType, ConnectIpsParameters, OnScreenChangesParameters, OnScreenChangesType, ConnectIpsType, ConnectLocalIpsType, ConnectLocalIpsParameters, ConsumeSocket, CoHostResponsibility, WaitingRoomParticipant } from '../../@types/types';
+import { Socket } from 'socket.io-client';
 import * as i0 from "@angular/core";
-export interface AllMembersParameters extends ReorderStreamsParameters, ConnectIpsParameters, OnScreenChangesParameters {
+export interface AllMembersParameters extends ReorderStreamsParameters, ConnectIpsParameters, OnScreenChangesParameters, ConnectLocalIpsParameters {
     participantsAll: Participant[];
     participants: Participant[];
     dispActiveNames: string[];
@@ -18,6 +19,7 @@ export interface AllMembersParameters extends ReorderStreamsParameters, ConnectI
     hostFirstSwitch: boolean;
     waitingRoomList: WaitingRoomParticipant[];
     islevel: string;
+    socket: Socket;
     updateParticipantsAll: (participantsAll: Participant[]) => void;
     updateParticipants: (participants: Participant[]) => void;
     updateRequestList: (requestList: Request[]) => void;
@@ -34,6 +36,7 @@ export interface AllMembersParameters extends ReorderStreamsParameters, ConnectI
     updateTotalReqWait: (total: number) => void;
     onScreenChanges: OnScreenChangesType;
     connectIps: ConnectIpsType;
+    connectLocalIps?: ConnectLocalIpsType;
     sleep: SleepType;
     reorderStreams: ReorderStreamsType;
     getUpdatedAllParams: () => AllMembersParameters;
@@ -51,6 +54,79 @@ 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',
+ *     socket: socket,
+ *     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']],
+ *     connectLocalIps: 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

@@ -4,8 +4,35 @@ export interface DisconnectUserSelfOptions {
     member: string;
     roomName: string;
     socket: Socket;
+    localSocket?: 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.
+ * @param {Socket} [options.localSocket] - The local socket instance used to emit the disconnection 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
+ *   localSocket: myLocalSocketInstance
+ * };
+ * await disconnectUserSelfService.disconnectUserSelf(disconnectUserSelfOptions);
+ */
 export declare class DisconnectUserSelf {
     /**
      * Disconnects the user from the specified room and bans them.
@@ -14,9 +41,10 @@ export declare class DisconnectUserSelf {
      * @param {Object} options.member - The member object representing the user to disconnect.
      * @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 request.
+     * @param {Socket} [options.localSocket] - The local socket instance used to emit the disconnection request.
      * @returns {Promise<void>} A promise that resolves when the disconnection request has been emitted.
      */
-    disconnectUserSelf: ({ member, roomName, socket, }: DisconnectUserSelfOptions) => Promise<void>;
+    disconnectUserSelf: ({ member, roomName, socket, localSocket, }: DisconnectUserSelfOptions) => Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DisconnectUserSelf, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DisconnectUserSelf>;
 }

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'.