mediasfu-angular 1.0.1 → 1.0.2

package/dist/lib/methods/stream-methods/click-audio.service.d.ts

@@ -52,6 +52,103 @@ export interface ClickAudioOptions {
     parameters: ClickAudioParameters;
 }
 export type ClickAudioType = (options: ClickAudioOptions) => Promise<void>;
+/**
+ * Handles the click event for toggling audio in a media session.
+ *
+ * @param {ClickAudioOptions} options - The parameters required for handling the audio click event.
+ * @param {Object} options.parameters - The parameters for toggling audio.
+ * @param {boolean} options.parameters.checkMediaPermission - Flag indicating whether to check media permission.
+ * @param {boolean} options.parameters.hasAudioPermission - Flag indicating if the user has audio permission.
+ * @param {boolean} options.parameters.audioPaused - Flag indicating if audio is paused.
+ * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if audio is already turned on.
+ * @param {boolean} options.parameters.audioOnlyRoom - Flag indicating if the room is audio-only.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if recording is stopped.
+ * @param {string} options.parameters.recordingMediaOptions - Media options for recording (e.g., "video", "audio").
+ * @param {string} options.parameters.islevel - User's level in the application.
+ * @param {boolean} options.parameters.youAreCoHost - Flag indicating if the user is a co-host.
+ * @param {boolean} options.parameters.adminRestrictSetting - Flag indicating if admin restrictions are set.
+ * @param {string | null} options.parameters.audioRequestState - Current state of the audio request.
+ * @param {number} options.parameters.audioRequestTime - Timestamp of the audio request.
+ * @param {string} options.parameters.member - Current member's name.
+ * @param {Socket} options.parameters.socket - The socket instance for communication.
+ * @param {string} options.parameters.roomName - The name of the room.
+ * @param {string} options.parameters.userDefaultAudioInputDevice - The default audio input device for the user.
+ * @param {boolean} options.parameters.micAction - Flag indicating if the microphone action is in progress.
+ * @param {MediaStream | null} options.parameters.localStream - The user's local media stream.
+ * @param {string} options.parameters.audioSetting - Current audio setting.
+ * @param {string} options.parameters.videoSetting - Current video setting.
+ * @param {string} options.parameters.screenshareSetting - Current screenshare setting.
+ * @param {string} options.parameters.chatSetting - Current chat setting.
+ * @param {number} options.parameters.updateRequestIntervalSeconds - Interval for updating request states.
+ * @param {Participant[]} options.parameters.participants - List of participants in the room.
+ * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport has been created.
+ * @param {boolean} options.parameters.transportCreatedAudio - Flag indicating if audio transport has been created.
+ *
+ * @returns {Promise<void>} A promise that resolves when the audio click event has been handled.
+ *
+ * @remarks
+ * This function performs the following actions:
+ * - If the event is audio-only, it shows an alert and exits.
+ * - If the audio is already on, it handles the logic for turning it off, including checking recording states and permissions.
+ * - If the audio is off, it checks for admin restrictions, user permissions, and handles the logic for turning the audio on.
+ * - It updates various states and emits socket events as necessary.
+ *
+ * @example
+ * ```typescript
+ * const options: ClickAudioOptions = {
+ *   parameters: {
+ *     checkMediaPermission: true,
+ *     hasAudioPermission: false,
+ *     audioPaused: false,
+ *     audioAlreadyOn: false,
+ *     audioOnlyRoom: false,
+ *     recordStarted: false,
+ *     recordResumed: false,
+ *     recordPaused: false,
+ *     recordStopped: false,
+ *     recordingMediaOptions: 'audio',
+ *     islevel: '1',
+ *     youAreCoHost: false,
+ *     adminRestrictSetting: false,
+ *     audioRequestState: null,
+ *     audioRequestTime: 0,
+ *     member: 'John Doe',
+ *     socket: socketInstance,
+ *     roomName: 'exampleRoom',
+ *     userDefaultAudioInputDevice: 'default',
+ *     micAction: false,
+ *     localStream: null,
+ *     audioSetting: 'enabled',
+ *     videoSetting: 'disabled',
+ *     screenshareSetting: 'disabled',
+ *     chatSetting: 'enabled',
+ *     updateRequestIntervalSeconds: 30,
+ *     participants: [],
+ *     transportCreated: false,
+ *     transportCreatedAudio: false,
+ *     updateAudioAlreadyOn: (status) => console.log(status),
+ *     updateAudioRequestState: (state) => console.log(state),
+ *     updateAudioPaused: (status) => console.log(status),
+ *     updateLocalStream: (stream) => console.log(stream),
+ *     updateParticipants: (participants) => console.log(participants),
+ *     updateTransportCreated: (status) => console.log(status),
+ *     updateTransportCreatedAudio: (status) => console.log(status),
+ *     updateMicAction: (action) => console.log(action),
+ *     checkPermission: async () => 'granted',
+ *     streamSuccessAudio: async () => console.log('Audio streaming success'),
+ *     disconnectSendTransportAudio: async () => console.log('Audio transport disconnected'),
+ *     requestPermissionAudio: async () => 'granted',
+ *     resumeSendTransportAudio: async () => console.log('Audio transport resumed'),
+ *   },
+ * };
+ *
+ * const clickAudioService = new ClickAudio();
+ * await clickAudioService.clickAudio(options);
+ * ```
+ */
 export declare class ClickAudio {
     /**
      * Handles the click event for toggling audio in a media session.

package/dist/lib/methods/stream-methods/click-chat.service.d.ts

@@ -8,6 +8,37 @@ export interface ClickChatOptions {
     showAlert?: ShowAlert;
 }
 export type ClickChatType = (options: ClickChatOptions) => Promise<void>;
+/**
+ * Toggles the visibility of the chat modal based on the current state and event settings.
+ *
+ * @param {ClickChatOptions} options - The options for the clickChat function.
+ * @param {boolean} options.isMessagesModalVisible - Indicates if the messages modal is currently visible.
+ * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility state of the messages modal.
+ * @param {string} options.chatSetting - The chat setting for the event, which can be "allow" or other values.
+ * @param {string} options.islevel - The participant's level, where "2" indicates a level that allows chat.
+ * @param {Function} [options.showAlert] - Optional function to show an alert message.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @remarks
+ * This function checks the current visibility state of the messages modal. If it is already visible, it will hide the modal.
+ * If it is not visible, it checks the chat settings and the participant's level to determine whether to show an alert
+ * indicating that chat is disabled or to display the chat modal.
+ *
+ * @example
+ * ```typescript
+ * const options: ClickChatOptions = {
+ *   isMessagesModalVisible: false,
+ *   updateIsMessagesModalVisible: (visible) => console.log(`Modal is now ${visible ? 'visible' : 'hidden'}`),
+ *   chatSetting: 'allow',
+ *   islevel: '1',
+ *   showAlert: (alert) => console.log(`Alert: ${alert.message}`),
+ * };
+ *
+ * const clickChatService = new ClickChat();
+ * await clickChatService.clickChat(options);
+ * ```
+ */
 export declare class ClickChat {
     /**
      * Toggles the visibility of the chat modal based on the current state and event settings.

package/dist/lib/methods/stream-methods/click-screen-share.service.d.ts

@@ -31,6 +31,74 @@ export interface ClickScreenShareOptions {
     parameters: ClickScreenShareParameters;
 }
 export type ClickScreenShareType = (options: ClickScreenShareOptions) => Promise<void>;
+/**
+ * Handles the action for the screen button, including starting and stopping screen sharing.
+ *
+ * @param {ClickScreenShareOptions} options - Options for handling the screen button action.
+ * @param {Object} options.parameters - The parameters required for the screen share action.
+ * @param {Function} options.parameters.showAlert - Function to show alert messages.
+ * @param {string} options.parameters.roomName - The name of the room where the screen share is taking place.
+ * @param {string} options.parameters.member - The member initiating the screen share.
+ * @param {Socket} options.parameters.socket - The socket connection used for communication.
+ * @param {string} options.parameters.islevel - The participant's level.
+ * @param {boolean} options.parameters.youAreCoHost - Indicates if the user is a co-host.
+ * @param {boolean} options.parameters.adminRestrictSetting - Indicates if there are restrictions set by the admin.
+ * @param {string} options.parameters.audioSetting - Current audio setting.
+ * @param {string} options.parameters.videoSetting - Current video setting.
+ * @param {string} options.parameters.screenshareSetting - Current screen share setting.
+ * @param {string} options.parameters.chatSetting - Current chat setting.
+ * @param {boolean} options.parameters.screenAction - Indicates if a screen action is currently taking place.
+ * @param {boolean} options.parameters.screenAlreadyOn - Indicates if screen sharing is currently active.
+ * @param {string | null} options.parameters.screenRequestState - State of the screen share request.
+ * @param {number} options.parameters.screenRequestTime - Timestamp of when the screen share request was made.
+ * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the room is audio-only.
+ * @param {number} options.parameters.updateRequestIntervalSeconds - Interval time for updating request state.
+ * @param {Function} options.parameters.updateScreenRequestState - Function to update the screen request state.
+ * @param {Function} options.parameters.updateScreenAlreadyOn - Function to update the screen sharing status.
+ * @param {Function} options.parameters.checkPermission - Function to check permissions for screen sharing.
+ * @param {Function} options.parameters.checkScreenShare - Function to check and initiate screen sharing.
+ * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen share action has been handled.
+ *
+ * @remarks
+ * This function checks the current status of screen sharing and handles the logic for starting or stopping screen sharing.
+ * It validates permissions and room settings before allowing screen sharing to be activated or deactivated.
+ *
+ * @example
+ * ```typescript
+ * const options: ClickScreenShareOptions = {
+ *   parameters: {
+ *     showAlert: (alert) => console.log(alert.message),
+ *     roomName: 'myRoom',
+ *     member: 'John Doe',
+ *     socket: socketInstance,
+ *     islevel: '1',
+ *     youAreCoHost: false,
+ *     adminRestrictSetting: false,
+ *     audioSetting: 'on',
+ *     videoSetting: 'on',
+ *     screenshareSetting: 'off',
+ *     chatSetting: 'allow',
+ *     screenAction: false,
+ *     screenAlreadyOn: false,
+ *     screenRequestState: null,
+ *     screenRequestTime: 0,
+ *     audioOnlyRoom: false,
+ *     updateRequestIntervalSeconds: 30,
+ *     updateScreenRequestState: (state) => console.log(`Screen request state: ${state}`),
+ *     updateScreenAlreadyOn: (status) => console.log(`Screen already on: ${status}`),
+ *     checkPermission: checkPermissionFunction,
+ *     checkScreenShare: checkScreenShareFunction,
+ *     stopShareScreen: stopShareScreenFunction,
+ *     getUpdatedAllParams: () => parameters,
+ *   },
+ * };
+ *
+ * const clickScreenShareService = new ClickScreenShare();
+ * await clickScreenShareService.clickScreenShare(options);
+ * ```
+ */
 export declare class ClickScreenShare {
     /**
      * Handles the action for the screen button, including starting and stopping screen sharing.

package/dist/lib/methods/stream-methods/click-video.service.d.ts

@@ -45,6 +45,94 @@ export interface ClickVideoOptions {
     parameters: ClickVideoParameters;
 }
 export type ClickVideoType = (options: ClickVideoOptions) => Promise<void>;
+/**
+ * Handles the click event to toggle the participant's video on/off and manages video permission requests.
+ *
+ * @param {ClickVideoOptions} options - The options for handling the video click event.
+ * @param {ClickVideoParameters} options.parameters - The parameters required for the video action.
+ * @param {boolean} options.parameters.checkMediaPermission - Indicates if media permission needs to be checked.
+ * @param {boolean} options.parameters.hasCameraPermission - Indicates if camera permission has been granted.
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is currently active.
+ * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the current room is audio-only.
+ * @param {boolean} options.parameters.recordStarted - Indicates if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Indicates if recording has resumed.
+ * @param {boolean} options.parameters.recordPaused - Indicates if recording is paused.
+ * @param {boolean} options.parameters.recordStopped - Indicates if recording is stopped.
+ * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+ * @param {string} options.parameters.islevel - The participant's level.
+ * @param {boolean} options.parameters.youAreCoHost - Indicates if the user is a co-host.
+ * @param {boolean} options.parameters.adminRestrictSetting - Indicates if there are admin restrictions on video.
+ * @param {string | null} options.parameters.videoRequestState - State of the video request.
+ * @param {number} options.parameters.videoRequestTime - Timestamp of the video request.
+ * @param {string} options.parameters.member - The participant's name.
+ * @param {Socket} options.parameters.socket - The socket connection used for communication.
+ * @param {string} options.parameters.roomName - The name of the room where the video is being toggled.
+ * @param {string} options.parameters.userDefaultVideoInputDevice - The default video input device.
+ * @param {string} options.parameters.currentFacingMode - The current facing mode of the camera.
+ * @param {VidCons} options.parameters.vidCons - Video constraints for the stream.
+ * @param {number} options.parameters.frameRate - Desired frame rate for the video.
+ * @param {boolean} options.parameters.videoAction - Indicates if a video action is currently taking place.
+ * @param {MediaStream | null} options.parameters.localStream - The local media stream.
+ * @param {string} options.parameters.audioSetting - The current audio setting.
+ * @param {string} options.parameters.videoSetting - The current video setting.
+ * @param {string} options.parameters.screenshareSetting - The current screenshare setting.
+ * @param {string} options.parameters.chatSetting - The current chat setting.
+ * @param {number} options.parameters.updateRequestIntervalSeconds - Interval time for updating request state.
+ *
+ * @returns {Promise<void>} A promise that resolves when the video action has been handled.
+ *
+ * @remarks
+ * This function checks the current status of the video and handles the logic for starting or stopping the video stream.
+ * It validates permissions and room settings before allowing the video to be activated or deactivated.
+ *
+ * @example
+ * ```typescript
+ * const options: ClickVideoOptions = {
+ *   parameters: {
+ *     checkMediaPermission: true,
+ *     hasCameraPermission: false,
+ *     videoAlreadyOn: false,
+ *     audioOnlyRoom: false,
+ *     recordStarted: false,
+ *     recordResumed: false,
+ *     recordPaused: false,
+ *     recordStopped: false,
+ *     recordingMediaOptions: 'video',
+ *     islevel: '1',
+ *     youAreCoHost: false,
+ *     adminRestrictSetting: false,
+ *     videoRequestState: null,
+ *     videoRequestTime: 0,
+ *     member: 'John Doe',
+ *     socket: socketInstance,
+ *     roomName: 'myRoom',
+ *     userDefaultVideoInputDevice: '',
+ *     currentFacingMode: 'user',
+ *     vidCons: { width: 1280, height: 720 },
+ *     frameRate: 30,
+ *     videoAction: false,
+ *     localStream: null,
+ *     audioSetting: 'on',
+ *     videoSetting: 'on',
+ *     screenshareSetting: 'off',
+ *     chatSetting: 'allow',
+ *     updateRequestIntervalSeconds: 30,
+ *     showAlert: (alert) => console.log(alert.message),
+ *     updateVideoAlreadyOn: (status) => console.log(`Video already on: ${status}`),
+ *     updateVideoRequestState: (state) => console.log(`Video request state: ${state}`),
+ *     updateLocalStream: (stream) => console.log('Local stream updated'),
+ *     streamSuccessVideo: streamSuccessFunction,
+ *     disconnectSendTransportVideo: disconnectFunction,
+ *     requestPermissionCamera: requestPermissionFunction,
+ *     checkPermission: checkPermissionFunction,
+ *     getUpdatedAllParams: () => parameters,
+ *   },
+ * };
+ *
+ * const clickVideoService = new ClickVideo();
+ * await clickVideoService.clickVideo(options);
+ * ```
+ */
 export declare class ClickVideo {
     /**
      * Handles the click event to toggle the participant's video on/off and manages video permission requests.

package/dist/lib/methods/stream-methods/switch-audio.service.d.ts

@@ -15,6 +15,53 @@ export interface SwitchAudioOptions {
     parameters: SwitchAudioParameters;
 }
 export type SwitchAudioType = (options: SwitchAudioOptions) => Promise<void>;
+/**
+ * Switches the audio input device based on user preference.
+ *
+ * @param {SwitchAudioOptions} options - The options for switching the audio input.
+ * @param {string} options.audioPreference - The ID of the preferred audio input device.
+ * @param {SwitchAudioParameters} options.parameters - The parameters required for switching the audio.
+ * @param {string} options.parameters.defAudioID - The default audio input device ID.
+ * @param {string} options.parameters.userDefaultAudioInputDevice - The current default audio input device ID.
+ * @param {string} options.parameters.prevAudioInputDevice - The previously used audio input device ID.
+ * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update the user's default audio input device.
+ * @param {Function} options.parameters.updatePrevAudioInputDevice - Function to update the previous audio input device.
+ * @param {Function} options.parameters.switchUserAudio - Function to switch the user's audio.
+ *
+ * @returns {Promise<void>} A promise that resolves when the audio input has been switched.
+ *
+ * @remarks
+ * This function checks if the user's preferred audio device differs from the current default.
+ * If so, it updates the previous audio device and the current default audio device.
+ * It then calls the function to switch the user's audio.
+ *
+ * @example
+ * ```typescript
+ * const options: SwitchAudioOptions = {
+ *   audioPreference: 'newAudioDeviceID',
+ *   parameters: {
+ *     defAudioID: 'defaultAudioDeviceID',
+ *     userDefaultAudioInputDevice: 'currentAudioDeviceID',
+ *     prevAudioInputDevice: '',
+ *     updateUserDefaultAudioInputDevice: (deviceId) => console.log(`Updated to: ${deviceId}`),
+ *     updatePrevAudioInputDevice: (deviceId) => console.log(`Previous device was: ${deviceId}`),
+ *     switchUserAudio: async ({ audioPreference, parameters }) => {
+ *       console.log(`Switching audio to: ${audioPreference}`);
+ *     },
+ *     getUpdatedAllParams: () => {
+ *       return {
+ *         defAudioID: 'defaultAudioDeviceID',
+ *         userDefaultAudioInputDevice: 'currentAudioDeviceID',
+ *         prevAudioInputDevice: '',
+ *       };
+ *     },
+ *   },
+ * };
+ *
+ * const switchAudioService = new SwitchAudio();
+ * await switchAudioService.switchAudio(options);
+ * ```
+ */
 export declare class SwitchAudio {
     /**
      * Switches the audio input device based on user preference.

package/dist/lib/methods/stream-methods/switch-video-alt.service.d.ts

@@ -22,6 +22,56 @@ export interface SwitchVideoAltOptions {
     parameters: SwitchVideoAltParameters;
 }
 export type SwitchVideoAltType = (options: SwitchVideoAltOptions) => Promise<void>;
+/**
+ * Switches the video input based on user preference and current state.
+ *
+ * @param {SwitchVideoAltOptions} options - The options for switching the video input.
+ * @param {SwitchVideoAltParameters} options.parameters - The parameters required for switching the video input.
+ * @param {boolean} options.parameters.recordStarted - Indicates if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Indicates if recording has resumed.
+ * @param {boolean} options.parameters.recordStopped - Indicates if recording has stopped.
+ * @param {boolean} options.parameters.recordPaused - Indicates if recording is paused.
+ * @param {string} options.parameters.recordingMediaOptions - The current media options (e.g., "video").
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is currently on.
+ * @param {string} options.parameters.currentFacingMode - The current facing mode of the camera (e.g., "environment").
+ * @param {boolean} options.parameters.allowed - Indicates if the user is allowed to switch video.
+ * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the current room is audio-only.
+ * @param {Function} options.parameters.updateCurrentFacingMode - Function to update the current facing mode.
+ * @param {Function} options.parameters.updateIsMediaSettingsModalVisible - Function to update the visibility of the media settings modal.
+ * @param {Function} [options.parameters.showAlert] - Optional function to show alert messages.
+ * @param {Function} options.parameters.switchUserVideoAlt - Function to switch the user's video input.
+ *
+ * @returns {Promise<void>} A promise that resolves when the video input has been switched.
+ *
+ * @remarks
+ * This function checks if the user is allowed to switch the video input based on the current state,
+ * and it shows alerts if there are any issues. If the video is already on, it cannot be switched until
+ * it is turned off, and vice versa. The facing mode of the camera is toggled between "user" and "environment".
+ *
+ * @example
+ * ```typescript
+ * const options: SwitchVideoAltOptions = {
+ *   parameters: {
+ *     recordStarted: false,
+ *     recordResumed: false,
+ *     recordStopped: false,
+ *     recordPaused: false,
+ *     recordingMediaOptions: 'video',
+ *     videoAlreadyOn: true,
+ *     currentFacingMode: 'user',
+ *     allowed: true,
+ *     audioOnlyRoom: false,
+ *     updateCurrentFacingMode: (mode) => console.log(`Facing mode updated to: ${mode}`),
+ *     updateIsMediaSettingsModalVisible: (isVisible) => console.log(`Media settings modal is now ${isVisible ? 'visible' : 'hidden'}`),
+ *     switchUserVideoAlt: async ({ videoPreference }) => console.log(`Switched video to: ${videoPreference}`),
+ *     getUpdatedAllParams: () => ({ }),
+ *   },
+ * };
+ *
+ * const switchVideoService = new SwitchVideoAlt();
+ * await switchVideoService.switchVideoAlt(options);
+ * ```
+ */
 export declare class SwitchVideoAlt {
     switchVideoAlt({ parameters }: SwitchVideoAltOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SwitchVideoAlt, never>;

package/dist/lib/methods/stream-methods/switch-video.service.d.ts

@@ -23,6 +23,62 @@ export interface SwitchVideoOptions {
     parameters: SwitchVideoParameters;
 }
 export type SwitchVideoType = (options: SwitchVideoOptions) => Promise<void>;
+/**
+ * Switches the user's video device based on the provided video preference.
+ *
+ * @param {SwitchVideoOptions} options - The options for switching the video input.
+ * @param {string} options.videoPreference - The preferred video device to switch to.
+ * @param {SwitchVideoParameters} options.parameters - The parameters required for switching the video input.
+ * @param {boolean} options.parameters.recordStarted - Indicates if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Indicates if recording has resumed.
+ * @param {boolean} options.parameters.recordStopped - Indicates if recording has stopped.
+ * @param {boolean} options.parameters.recordPaused - Indicates if recording is paused.
+ * @param {string} options.parameters.recordingMediaOptions - The current media options (e.g., "video").
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is currently on.
+ * @param {string} options.parameters.userDefaultVideoInputDevice - The default video input device for the user.
+ * @param {string} options.parameters.defVideoID - The default video ID for the input device.
+ * @param {boolean} options.parameters.allowed - Indicates if the user is allowed to switch video.
+ * @param {Function} options.parameters.updateDefVideoID - Function to update the default video ID.
+ * @param {Function} options.parameters.updatePrevVideoInputDevice - Function to update the previous video input device.
+ * @param {Function} options.parameters.updateUserDefaultVideoInputDevice - Function to update the user’s default video input device.
+ * @param {Function} options.parameters.updateIsMediaSettingsModalVisible - Function to update the visibility of the media settings modal.
+ * @param {Function} [options.parameters.showAlert] - Optional function to show alert messages.
+ * @param {Function} options.parameters.switchUserVideo - Function to switch the user's video input.
+ *
+ * @returns {Promise<void>} A promise that resolves when the video input has been switched.
+ *
+ * @remarks
+ * This function checks if the user is allowed to switch the video input based on the current state,
+ * and it shows alerts if there are any issues. If the video is already on, it cannot be switched until
+ * it is turned off, and vice versa. The default video input device is updated if necessary.
+ *
+ * @example
+ * ```typescript
+ * const options: SwitchVideoOptions = {
+ *   videoPreference: 'newDeviceId',
+ *   parameters: {
+ *     recordStarted: false,
+ *     recordResumed: false,
+ *     recordStopped: false,
+ *     recordPaused: false,
+ *     recordingMediaOptions: 'video',
+ *     videoAlreadyOn: true,
+ *     userDefaultVideoInputDevice: 'currentDeviceId',
+ *     defVideoID: 'defaultDeviceId',
+ *     allowed: true,
+ *     updateDefVideoID: (deviceId) => console.log(`Default video ID updated to: ${deviceId}`),
+ *     updatePrevVideoInputDevice: (deviceId) => console.log(`Previous video input device updated to: ${deviceId}`),
+ *     updateUserDefaultVideoInputDevice: (deviceId) => console.log(`User default video input device updated to: ${deviceId}`),
+ *     updateIsMediaSettingsModalVisible: (isVisible) => console.log(`Media settings modal is now ${isVisible ? 'visible' : 'hidden'}`),
+ *     switchUserVideo: async ({ videoPreference }) => console.log(`Switched video to: ${videoPreference}`),
+ *     getUpdatedAllParams: () => ({ }),
+ *   },
+ * };
+ *
+ * const switchVideoService = new SwitchVideo();
+ * await switchVideoService.switchVideo(options);
+ * ```
+ */
 export declare class SwitchVideo {
     /**
      * Switches the user's video device based on the provided video preference.

package/dist/lib/methods/utils/format-number.service.d.ts

@@ -3,21 +3,33 @@ export interface FormatNumberOptions {
     number: number;
 }
 export type FormatNumberType = (options: FormatNumberOptions) => Promise<string | undefined>;
+/**
+ * The `FormatNumber` service provides functionality to format numeric values
+ * into a more readable string representation, appending appropriate suffixes
+ * like K (thousands), M (millions), and B (billions).
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { FormatNumber } from 'mediasfu-angular';
+ *
+ * constructor(private formatNumber: FormatNumber) {}
+ *
+ * async displayFormattedNumber() {
+ *   const formatted = await this.formatNumber.formatNumber({ number: 1500 });
+ *   console.log(formatted); // Outputs: "1.5K"
+ * }
+ * ```
+ *
+ * @remarks
+ * This service can be useful for displaying large numbers in a more compact form
+ * in user interfaces, especially in dashboards or reports where space is limited.
+ *
+ * @property {FormatNumberOptions} options - Options containing the number to format.
+ *
+ * @returns {FormatNumber} The FormatNumber service for formatting numeric values.
+ */
 export declare class FormatNumber {
-    /**
-     * Formats a number into a string representation with appropriate suffixes (K, M, B).
-     *
-     * @param number - The number to format.
-     * @returns A promise that resolves to a formatted string or undefined if the input is falsy.
-     *
-     * @example
-     * ```typescript
-     * formatNumber(500); // "500"
-     * formatNumber(1500); // "1.5K"
-     * formatNumber(1500000); // "1.5M"
-     * formatNumber(1500000000); // "1.5B"
-     * ```
-     */
     formatNumber({ number }: FormatNumberOptions): Promise<string | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormatNumber, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FormatNumber>;

package/dist/lib/methods/utils/generate-random-messages.service.d.ts

@@ -8,6 +8,39 @@ export interface GenerateRandomMessagesOptions {
     forChatBroadcast?: boolean;
 }
 export type GenerateRandomMessagesType = (options: GenerateRandomMessagesOptions) => Message[];
+/**
+ * GenerateRandomMessages - Service to generate random chat messages from participants.
+ *
+ * This service generates random direct and group messages based on participants and a given host setup,
+ * with options to tailor messages for chat broadcast.
+ *
+ * @class
+ * @name GenerateRandomMessages
+ * @example
+ * ```typescript
+ * const generateRandomMessagesService = new GenerateRandomMessages();
+ * const messages = generateRandomMessagesService.generateRandomMessages({
+ *   participants: [
+ *     { name: 'Alice' },
+ *     { name: 'Bob' },
+ *     { name: 'Charlie' }
+ *   ],
+ *   member: 'Alice',
+ *   coHost: 'Bob',
+ *   host: 'Charlie',
+ *   forChatBroadcast: true
+ * });
+ * console.log(messages);
+ * ```
+ *
+ * @param {Object} options - Options for generating random messages.
+ * @param {Participant[]} options.participants - List of participants for message generation.
+ * @param {string} options.member - The primary member in the chat.
+ * @param {string} [options.coHost] - Optional co-host participant.
+ * @param {string} options.host - The chat host.
+ * @param {boolean} [options.forChatBroadcast=false] - Flag to indicate if messages are for chat broadcast.
+ * @returns {Message[]} Array of randomly generated messages with direct and group messaging.
+ */
 export declare class GenerateRandomMessages {
     /**
      * Generates random messages for a given set of participants.

package/dist/lib/methods/utils/generate-random-participants.service.d.ts

@@ -7,6 +7,33 @@ export interface GenerateRandomParticipantsOptions {
     forChatBroadcast?: boolean;
 }
 export type GenerateRandomParticipantsType = (options: GenerateRandomParticipantsOptions) => Participant[];
+/**
+ * GenerateRandomParticipants - Service to generate a list of random participants.
+ *
+ * This service creates a list of participants based on a set of specified options, with customization for chat broadcasts
+ * and designation of specific roles like member, co-host, and host.
+ *
+ * @class
+ * @name GenerateRandomParticipants
+ * @example
+ * ```typescript
+ * const generateRandomParticipantsService = new GenerateRandomParticipants();
+ * const participants = generateRandomParticipantsService.generateRandomParticipants({
+ *   member: 'Alice',
+ *   coHost: 'Bob',
+ *   host: 'Charlie',
+ *   forChatBroadcast: true
+ * });
+ * console.log(participants);
+ * ```
+ *
+ * @param {Object} options - Options for generating participants.
+ * @param {string} options.member - Primary member to include in the participants list.
+ * @param {string} [options.coHost] - Optional co-host in the participants list.
+ * @param {string} options.host - Host to include in the participants list.
+ * @param {boolean} [options.forChatBroadcast=false] - Indicates if participants are for a chat broadcast.
+ * @returns {Participant[]} Array of generated participants with randomized levels, muted states, and identifiers.
+ */
 export declare class GenerateRandomParticipants {
     /**
      * Generates a list of random participants with specified options.

package/dist/lib/methods/utils/generate-random-polls.service.d.ts

@@ -4,6 +4,32 @@ export interface GenerateRandomPollsOptions {
     numberOfPolls: number;
 }
 export type GenerateRandomPollsType = (options: GenerateRandomPollsOptions) => Poll[];
+/**
+   * Generates an array of random poll objects with varying types and options.
+   *
+   * Each poll includes a question, a type (e.g., "trueFalse", "yesNo", or "custom"), and multiple choice options.
+   * Poll types determine the options generated:
+   * - `"trueFalse"` polls have "True" and "False" options.
+   * - `"yesNo"` polls have "Yes" and "No" options.
+   * - `"custom"` polls generate 2–6 custom options labeled as "Option 1", "Option 2", etc.
+   *
+   * @param {GenerateRandomPollsOptions} options - An object containing the number of polls to generate.
+   * @param {number} options.numberOfPolls - The number of random polls to generate.
+   * @returns {Poll[]} An array of generated polls with unique IDs and randomly selected types and options.
+   *
+   * @example
+   * const pollService = new GenerateRandomPolls();
+   * const options = { numberOfPolls: 3 };
+   * const randomPolls = pollService.generateRandomPolls(options);
+   *
+   * console.log(randomPolls);
+   * // Output:
+   * // [
+   * //   { id: '1', question: 'Random Question 1', type: 'yesNo', options: ['Yes', 'No'], votes: [0, 0], status: 'inactive', voters: {} },
+   * //   { id: '2', question: 'Random Question 2', type: 'trueFalse', options: ['True', 'False'], votes: [0, 0], status: 'inactive', voters: {} },
+   * //   { id: '3', question: 'Random Question 3', type: 'custom', options: ['Option 1', 'Option 2', 'Option 3'], votes: [0, 0, 0], status: 'inactive', voters: {} }
+   * // ]
+   */
 export declare class GenerateRandomPolls {
     /**
      * Generates an array of random poll objects.