mediasfu-angular 1.0.1 → 1.0.2

package/dist/lib/methods/whiteboard-methods/launch-configure-whiteboard.service.d.ts

@@ -4,6 +4,26 @@ export interface LaunchConfigureWhiteboardOptions {
     isConfigureWhiteboardModalVisible: boolean;
 }
 export type LaunchConfigureWhiteboardType = (options: LaunchConfigureWhiteboardOptions) => void;
+/**
+ * Toggles the visibility of the configure whiteboard modal.
+ *
+ * @param {LaunchConfigureWhiteboardOptions} options - Options to control whiteboard configuration modal.
+ * @param {Function} options.updateIsConfigureWhiteboardModalVisible - Function to update the modal's visibility state.
+ * @param {boolean} options.isConfigureWhiteboardModalVisible - Current visibility state of the configure whiteboard modal.
+ *
+ * This function uses the current visibility state to toggle the whiteboard configuration modal on or off.
+ *
+ * @example
+ * ```typescript
+ * const launchService = new LaunchConfigureWhiteboard();
+ * launchService.launchConfigureWhiteboard({
+ *   updateIsConfigureWhiteboardModalVisible: (visible) => console.log('Modal Visible:', visible),
+ *   isConfigureWhiteboardModalVisible: false
+ * });
+ * ```
+ *
+ * In this example, the modal visibility state is toggled, and the updated visibility state is logged.
+ */
 export declare class LaunchConfigureWhiteboard {
     /**
      * Toggles the visibility of the configure whiteboard modal.

package/dist/lib/producer-client/producer-client-emits/create-device-client.service.d.ts

@@ -4,6 +4,29 @@ export interface CreateDeviceClientOptions {
     rtpCapabilities: RtpCapabilities | null;
 }
 export type CreateDeviceClientType = (options: CreateDeviceClientOptions) => Promise<Device | null>;
+/**
+ * Creates a mediasoup client device using the provided RTP capabilities.
+ *
+ * @param {CreateDeviceClientOptions} options - Options containing the required RTP capabilities.
+ * @param {RtpCapabilities | null} options.rtpCapabilities - The RTP capabilities necessary for initializing the device.
+ * @returns {Promise<Device | null>} - A promise resolving to the created `Device` instance or `null` if creation fails.
+ * @throws {Error} - Throws an error if RTP capabilities or the mediasoup client library are not provided, or if the device is unsupported by the browser.
+ *
+ * This function initializes a mediasoup client `Device` using the specified RTP capabilities, enabling communication capabilities according to provided media configurations. It filters out unsupported video orientation extensions and loads router capabilities, ensuring compatibility with client configurations.
+ *
+ * @example
+ * ```typescript
+ * const client = new CreateDeviceClient();
+ * const device = await client.createDeviceClient({ rtpCapabilities });
+ * if (device) {
+ *   console.log('Device created successfully:', device);
+ * } else {
+ *   console.log('Failed to create device.');
+ * }
+ * ```
+ *
+ * In this example, the function creates a device based on RTP capabilities, handling errors and unsupported devices gracefully.
+ */
 export declare class CreateDeviceClient {
     /**
      * Creates a mediasoup client device with the provided RTP capabilities.

package/dist/lib/producer-client/producer-client-emits/join-room-client.service.d.ts

@@ -12,6 +12,37 @@ export interface JoinRoomClientOptions {
     consume?: boolean;
 }
 export type JoinRoomClientType = (params: JoinRoomClientOptions) => Promise<any>;
+/**
+ * Facilitates joining a room by emitting the `joinRoom` event to the server through a socket connection.
+ *
+ * @param {JoinRoomClientOptions} options - Configuration options for joining the room.
+ * @param {Socket} options.socket - The socket instance for server communication.
+ * @param {string} options.roomName - The name of the room to join.
+ * @param {string} options.islevel - Level identifier for the user in the room.
+ * @param {string} options.member - Member identifier for the joining user.
+ * @param {string} options.sec - Security token or identifier for access.
+ * @param {string} options.apiUserName - API username for server authentication.
+ * @param {boolean} [options.consume=false] - If `true`, joins via `joinConRoom`; otherwise, joins via `joinRoom`.
+ * @returns {Promise<any>} - A promise resolving with the server response data.
+ * @throws {Error} - Throws an error if the room joining attempt fails.
+ *
+ * @example
+ * ```typescript
+ * const joinRoomClient = new JoinRoomClient(joinRoomService, joinConRoomService);
+ * const response = await joinRoomClient.joinRoomClient({
+ *   socket: mySocket,
+ *   roomName: 'myRoom',
+ *   islevel: '1',
+ *   member: 'user123',
+ *   sec: 'secureToken',
+ *   apiUserName: 'apiUser',
+ *   consume: true,
+ * });
+ * console.log('Joined room with response:', response);
+ * ```
+ *
+ * This example demonstrates using `joinRoomClient` to join a room, either as a consumer or a producer, based on the `consume` flag.
+ */
 export declare class JoinRoomClient {
     private JoinRoomService;
     private JoinConRoomService;

package/dist/lib/producer-client/producer-client-emits/update-room-parameters-client.service.d.ts

@@ -87,6 +87,50 @@ export type UpdateRoomParametersClientOptions = {
     parameters: UpdateRoomParametersClientParameters;
 };
 export type UpdateRoomParametersClientType = (options: UpdateRoomParametersClientOptions) => void;
+/**
+ * Updates room parameters for the client after joining a room and receiving server-provided parameters.
+ *
+ * @param {UpdateRoomParametersClientOptions} options - An object containing:
+ *  - various room settings and parameters,
+ *  - functions to update those parameters.
+ *
+ * - **Screen/Page Settings:** Adjusts screen and item page limits, meeting room parameters, and video constraints based on server data.
+ * - **Recording and Media Settings:** Applies bitrate and frame rate adjustments, based on the target resolution and media options.
+ * - **Role-Specific Settings:** Configures admin, host, and co-host settings for permissions, orientations, and resolutions.
+ * - **Alerting**: Uses `showAlert` to notify the client on issues or permissions restrictions.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   parameters: {
+ *     rtpCapabilities: myRtpCapabilities,
+ *     roomRecvIPs: ['192.168.1.1'],
+ *     meetingRoomParams: myMeetingParams,
+ *     itemPageLimit: 3,
+ *     audioOnlyRoom: false,
+ *     addForBasic: true,
+ *     screenPageLimit: 2,
+ *     shareScreenStarted: false,
+ *     shared: true,
+ *     targetOrientation: 'landscape',
+ *     recordingVideoSupport: true,
+ *     frameRate: 15,
+ *     adminPasscode: 'admin123',
+ *     eventType: 'conference',
+ *     youAreCoHost: false,
+ *     updateRtpCapabilities: (rtp) => console.log('Updating RTP:', rtp),
+ *     updateRoomRecvIPs: (ips) => console.log('Updating IPs:', ips),
+ *     updateMeetingRoomParams: (params) => console.log('Updating room params:', params),
+ *     // Additional parameters...
+ *   },
+ * };
+ *
+ * const updateRoomParametersClient = new UpdateRoomParametersClient(videoCaptureConstraints, hParams, vParams, screenParams, aParams);
+ * updateRoomParametersClient.updateRoomParametersClient(options);
+ * ```
+ *
+ * This example demonstrates setting up room parameters for a conference-type room with recording support and custom update functions.
+ */
 export declare class UpdateRoomParametersClient {
     private videoCaptureConstraints;
     private hParams;

package/dist/lib/producers/producer-emits/join-con-room.service.d.ts

@@ -20,6 +20,44 @@ export interface JoinConRoomResponse {
     [key: string]: any;
 }
 export type JoinConRoomType = (options: JoinConRoomOptions) => Promise<JoinConRoomResponse>;
+/**
+ * Joins a conference room with the provided options and performs validation checks.
+ *
+ * @param {JoinConRoomOptions} options - Contains:
+ *   - socket: Socket instance for communication.
+ *   - roomName: Name of the room to join.
+ *   - islevel: User level within the room.
+ *   - member: Member identifier.
+ *   - sec: Security token.
+ *   - apiUserName: API username for authentication.
+ *
+ * - **Validation**:
+ *   - Checks that `roomName`, `apiUserName`, and `member` are alphanumeric.
+ *   - Ensures `roomName` starts with 's' or 'p' and meets length requirements.
+ *   - Verifies `sec`, `islevel`, and `apiUserName` comply with length and format expectations.
+ *
+ * - **Response Handling**:
+ *   - Resolves to the server's response data upon a successful join.
+ *   - Rejects with specific reasons if the user is banned, suspended, or if the room host is not present.
+ *
+ * @returns {Promise<JoinConRoomResponse>} Resolves with the join response data, or rejects with error details.
+ * @throws {Error} Throws validation errors or issues encountered while joining the room.
+ *
+ * @example
+ * ```typescript
+ * const joinOptions = {
+ *   socket: mySocket,
+ *   roomName: 'sMyRoom',
+ *   islevel: '1',
+ *   member: 'participant123',
+ *   sec: '64-character-long-secret-key-here...',
+ *   apiUserName: 'apiUser123',
+ * };
+ * joinConRoom(joinOptions)
+ *   .then(response => console.log('Joined room:', response))
+ *   .catch(error => console.error('Failed to join room:', error));
+ * ```
+ */
 export declare class JoinConRoom {
     private validateAlphanumeric;
     constructor(validateAlphanumeric: ValidateAlphanumeric);

package/dist/lib/producers/producer-emits/join-room.service.d.ts

@@ -10,6 +10,44 @@ export interface JoinRoomOptions {
     apiUserName: string;
 }
 export type JoinRoomType = (socket: Socket, roomName: string, islevel: string, member: string, sec: string, apiUserName: string) => Promise<object>;
+/**
+ * Joins a user to a room using socket communication with validation checks.
+ *
+ * @param {JoinRoomOptions} options - Contains:
+ *   - `socket`: Socket instance for communication.
+ *   - `roomName`: Name of the room to join.
+ *   - `islevel`: User's level indicator.
+ *   - `member`: User identifier.
+ *   - `sec`: Security token.
+ *   - `apiUserName`: API username for authentication.
+ *
+ * - **Validation**:
+ *   - Ensures `roomName`, `apiUserName`, and `member` are alphanumeric.
+ *   - Verifies that `roomName` starts with 's' or 'p' and meets length requirements.
+ *   - Validates `sec`, `islevel`, and `apiUserName` against specified length and format conditions.
+ *
+ * - **Response Handling**:
+ *   - Resolves with the server's response upon a successful join.
+ *   - Rejects with a descriptive error if the user is banned, suspended, or if the host has not yet joined the room.
+ *
+ * @returns {Promise<object>} Resolves with data from the 'joinRoom' event or rejects with validation errors.
+ * @throws {Error} Throws errors encountered during validation or join process.
+ *
+ * @example
+ * ```typescript
+ * const joinOptions = {
+ *   socket: mySocket,
+ *   roomName: 'sMyRoom',
+ *   islevel: '1',
+ *   member: 'participant123',
+ *   sec: '64-character-secure-key...',
+ *   apiUserName: 'apiUser123',
+ * };
+ * joinRoom(joinOptions)
+ *   .then(response => console.log('Room joined:', response))
+ *   .catch(error => console.error('Join failed:', error));
+ * ```
+ */
 export declare class JoinRoom {
     private validateAlphanumeric;
     constructor(validateAlphanumeric: ValidateAlphanumeric);

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

@@ -54,6 +54,79 @@ 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: '',
+ *     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']],
+ *     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

@@ -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>;