mediasfu-angular 1.0.0 → 1.0.2

package/dist/lib/methods/recording-methods/stop-recording.service.d.ts

@@ -28,6 +28,44 @@ export interface StopRecordingOptions {
     parameters: StopRecordingParameters;
 }
 export type StopRecordingType = (options: StopRecordingOptions) => Promise<void>;
+/**
+ * Stops the recording process based on the provided parameters.
+ *
+ * @param {StopRecordingOptions} options - The options for stopping the recording.
+ * @param {Object} options.parameters - The parameters required for stopping the recording.
+ * @param {string} options.parameters.roomName - The name of the room where the recording is being stopped.
+ * @param {Socket} options.parameters.socket - The socket instance for communication.
+ * @param {Function} options.parameters.showAlert - Function to show alerts.
+ * @param {boolean} options.parameters.startReport - Flag indicating if the start report is active.
+ * @param {boolean} options.parameters.endReport - Flag indicating if the end report is active.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if the recording has started.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if the recording is paused.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if the recording is stopped.
+ * @param {Function} options.parameters.updateRecordPaused - Function to update the record paused status.
+ * @param {Function} options.parameters.updateRecordStopped - Function to update the record stopped status.
+ * @param {Function} options.parameters.updateStartReport - Function to update the start report status.
+ * @param {Function} options.parameters.updateEndReport - Function to update the end report status.
+ * @param {Function} options.parameters.updateShowRecordButtons - Function to update the visibility of recording buttons.
+ * @param {boolean} options.parameters.whiteboardStarted - Flag indicating if the whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Flag indicating if the whiteboard has ended.
+ * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+ * @param {Function} options.parameters.captureCanvasStream - Function to capture the canvas stream.
+ *
+ * @returns {Promise<void>} - A promise that resolves when the recording is stopped.
+ *
+ * @remarks
+ * This method checks if the recording has started and is not already stopped.
+ * It pauses the timer and emits a stop recording event via socket communication.
+ * If successful, it updates the recording state and alerts the user.
+ * Additionally, if the whiteboard feature is active, it captures the canvas stream.
+ *
+ * @example
+ * ```typescript
+ * const options: StopRecordingOptions = { parameters: someParameters };
+ * await stopRecording(options);
+ * console.log('Recording stopped successfully.');
+ * ```
+ */
 export declare class StopRecording {
     private RecordPauseTimerService;
     constructor(RecordPauseTimerService: RecordPauseTimer);

package/dist/lib/methods/recording-methods/update-recording.service.d.ts

@@ -41,6 +41,54 @@ export interface UpdateRecordingOptions {
     parameters: UpdateRecordingParameters;
 }
 export type UpdateRecordingType = (options: UpdateRecordingOptions) => Promise<void>;
+/**
+ * Updates the recording state based on the provided parameters.
+ *
+ * @param {UpdateRecordingOptions} options - The options for updating the recording state.
+ * @param {Object} options.parameters - The parameters required for updating the recording state.
+ * @param {string} options.parameters.roomName - The name of the room where the recording is taking place.
+ * @param {UserRecordingParams} options.parameters.userRecordingParams - User-specific recording parameters.
+ * @param {Socket} options.parameters.socket - The socket instance for communication.
+ * @param {Function} options.parameters.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
+ * @param {boolean} options.parameters.confirmedToRecord - Indicates if the user has confirmed to start recording.
+ * @param {Function} options.parameters.showAlert - Function to show alerts.
+ * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already turned on.
+ * @param {boolean} options.parameters.audioAlreadyOn - Indicates if the audio is already turned on.
+ * @param {boolean} options.parameters.recordStarted - Indicates if the recording has started.
+ * @param {boolean} options.parameters.recordPaused - Indicates if the recording is paused.
+ * @param {boolean} options.parameters.recordResumed - Indicates if the recording has resumed.
+ * @param {boolean} options.parameters.recordStopped - Indicates if the recording has stopped.
+ * @param {number} options.parameters.recordChangeSeconds - The interval in seconds for changing the recording state.
+ * @param {number} options.parameters.pauseRecordCount - The count of pauses during the recording.
+ * @param {boolean} options.parameters.startReport - Indicates if the start report is active.
+ * @param {boolean} options.parameters.endReport - Indicates if the end report is active.
+ * @param {boolean} options.parameters.canRecord - Indicates if recording is allowed.
+ * @param {boolean} options.parameters.canPauseResume - Indicates if pausing and resuming the recording is allowed.
+ * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume state.
+ * @param {Function} options.parameters.updatePauseRecordCount - Function to update the pause record count.
+ * @param {Function} options.parameters.updateClearedToRecord - Function to update the cleared-to-record state.
+ * @param {Function} options.parameters.updateRecordPaused - Function to update the record paused state.
+ * @param {Function} options.parameters.updateRecordResumed - Function to update the record resumed state.
+ * @param {Function} options.parameters.updateStartReport - Function to update the start report state.
+ * @param {Function} options.parameters.updateEndReport - Function to update the end report state.
+ * @param {Function} options.parameters.updateCanRecord - Function to update the can record state.
+ * @param {Function} options.parameters.rePort - Function to handle reporting.
+ *
+ * @returns {Promise<void>} A promise that resolves when the recording state has been updated.
+ *
+ * @remarks
+ * This method handles the recording state updates, including starting, pausing, resuming, and stopping the recording.
+ * It also performs necessary checks to ensure that the user can perform the requested actions based on their current state.
+ * Alerts are displayed for any issues encountered during the process.
+ *
+ * @example
+ * ```typescript
+ * const options: UpdateRecordingOptions = { parameters: someParameters };
+ * await updateRecording(options);
+ * console.log('Recording state updated successfully.');
+ * ```
+ */
 export declare class UpdateRecording {
     private CheckPauseStateService;
     private CheckResumeStateService;

package/dist/lib/methods/requests-methods/launch-requests.service.d.ts

@@ -4,6 +4,31 @@ export interface LaunchRequestsOptions {
     isRequestsModalVisible: boolean;
 }
 export type LaunchRequestsType = (options: LaunchRequestsOptions) => void;
+/**
+ * Toggles the visibility state of the requests modal.
+ *
+ * @param {LaunchRequestsOptions} options - The options for launching requests.
+ * @param {Function} options.updateIsRequestsModalVisible - Function to update the visibility state of the requests modal.
+ * @param {boolean} options.isRequestsModalVisible - Current visibility state of the requests modal.
+ * @returns {void}
+ *
+ * @remarks
+ * This method is used to open or close the requests modal by toggling its visibility state.
+ * It takes the current visibility state as input and updates it accordingly.
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchRequestsOptions = {
+ *   updateIsRequestsModalVisible: (isVisible) => {
+ *     console.log('Requests modal visibility:', isVisible);
+ *   },
+ *   isRequestsModalVisible: false,
+ * };
+ *
+ * const launchRequestsService = new LaunchRequests();
+ * launchRequestsService.launchRequests(options);
+ * ```
+ */
 export declare class LaunchRequests {
     /**
      * Toggles the visibility state of the requests modal.

package/dist/lib/methods/requests-methods/respond-to-requests.service.d.ts

@@ -10,6 +10,45 @@ export interface RespondToRequestsOptions {
     roomName: string;
 }
 export type RespondToRequestsType = (options: RespondToRequestsOptions) => Promise<void>;
+/**
+ * Responds to incoming requests by updating the request list and emitting a response to the server.
+ *
+ * @param {RespondToRequestsOptions} options - The options for responding to requests.
+ * @param {Socket} options.socket - The socket instance used to emit the response.
+ * @param {Request} options.request - The request object containing details of the request.
+ * @param {Function} options.updateRequestList - The function to update the request list.
+ * @param {Request[]} options.requestList - The current list of requests.
+ * @param {string} options.action - The action to be taken on the request.
+ * @param {string} options.roomName - The name of the room to which the response should be emitted.
+ *
+ * @returns {Promise<void>} A promise that resolves when the response has been emitted.
+ *
+ * @remarks
+ * This method filters out the request that is being responded to from the current request list,
+ * updates the list, and emits the response to the server using the provided socket.
+ * It ensures that the state of the requests is accurately reflected in the application.
+ *
+ * @example
+ * ```typescript
+ * const options: RespondToRequestsOptions = {
+ *   socket: socketInstance,
+ *   request: {
+ *     id: 'request_id',
+ *     name: 'Request Name',
+ *     icon: 'request_icon'
+ *   },
+ *   updateRequestList: (newRequestList) => {
+ *     console.log('Updated request list:', newRequestList);
+ *   },
+ *   requestList: currentRequestList,
+ *   action: 'accept',
+ *   roomName: 'Room 1',
+ * };
+ *
+ * const respondToRequestsService = new RespondToRequests();
+ * await respondToRequestsService.respondToRequests(options);
+ * ```
+ */
 export declare class RespondToRequests {
     /**
      * Responds to incoming requests by updating the request list and emitting a response to the server.

package/dist/lib/methods/settings-methods/launch-settings.service.d.ts

@@ -4,6 +4,31 @@ export interface LaunchSettingsOptions {
     isSettingsModalVisible: boolean;
 }
 export type LaunchSettingsType = (options: LaunchSettingsOptions) => void;
+/**
+ * Toggles the visibility state of the settings modal.
+ *
+ * @param {LaunchSettingsOptions} options - The options for launching settings.
+ * @param {Function} options.updateIsSettingsModalVisible - Function to update the visibility state of the settings modal.
+ * @param {boolean} options.isSettingsModalVisible - Current visibility state of the settings modal.
+ * @returns {void}
+ *
+ * @remarks
+ * This method toggles the current visibility state of the settings modal.
+ * If the modal is currently visible, it will be hidden, and vice versa.
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchSettingsOptions = {
+ *   updateIsSettingsModalVisible: (isVisible) => {
+ *     console.log('Settings modal visibility:', isVisible);
+ *   },
+ *   isSettingsModalVisible: false,
+ * };
+ *
+ * const launchSettingsService = new LaunchSettings();
+ * launchSettingsService.launchSettings(options);
+ * ```
+ */
 export declare class LaunchSettings {
     /**
      * Toggles the visibility state of the settings modal.

package/dist/lib/methods/settings-methods/modify-settings.service.d.ts

@@ -16,6 +16,48 @@ export interface ModifySettingsOptions {
     updateIsSettingsModalVisible: (isVisible: boolean) => void;
 }
 export type ModifySettingsType = (options: ModifySettingsOptions) => Promise<void>;
+/**
+ * Modifies the settings for a given room and updates the state accordingly.
+ *
+ * @param {ModifySettingsOptions} options - The options for modifying settings.
+ * @param {Function} options.showAlert - Function to show alert messages.
+ * @param {string} options.roomName - The name of the room.
+ * @param {string} options.audioSet - The audio setting to be applied.
+ * @param {string} options.videoSet - The video setting to be applied.
+ * @param {string} options.screenshareSet - The screenshare setting to be applied.
+ * @param {string} options.chatSet - The chat setting to be applied.
+ * @param {Socket} options.socket - The socket instance for emitting events.
+ * @param {Function} options.updateAudioSetting - Function to update the audio setting state.
+ * @param {Function} options.updateVideoSetting - Function to update the video setting state.
+ * @param {Function} options.updateScreenshareSetting - Function to update the screenshare setting state.
+ * @param {Function} options.updateChatSetting - Function to update the chat setting state.
+ * @param {Function} options.updateIsSettingsModalVisible - Function to update the visibility of the settings modal.
+ *
+ * @returns {Promise<void>} A promise that resolves when the settings have been modified.
+ *
+ * @throws Will show an alert if any setting is set to "approval" in demo mode (room name starts with "d").
+ *
+ * @example
+ * ```typescript
+ * const options: ModifySettingsOptions = {
+ *   showAlert: (alert) => console.log(alert),
+ *   roomName: 'exampleRoom',
+ *   audioSet: 'enabled',
+ *   videoSet: 'disabled',
+ *   screenshareSet: 'approval',
+ *   chatSet: 'enabled',
+ *   socket: socketInstance,
+ *   updateAudioSetting: (audio) => console.log('Audio setting updated:', audio),
+ *   updateVideoSetting: (video) => console.log('Video setting updated:', video),
+ *   updateScreenshareSetting: (screenshare) => console.log('Screenshare setting updated:', screenshare),
+ *   updateChatSetting: (chat) => console.log('Chat setting updated:', chat),
+ *   updateIsSettingsModalVisible: (visible) => console.log('Settings modal visibility:', visible),
+ * };
+ *
+ * const modifySettingsService = new ModifySettings();
+ * await modifySettingsService.modifySettings(options);
+ * ```
+ */
 export declare class ModifySettings {
     /**
      * Modifies the settings for a given room and updates the state accordingly.

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.