mediasfu-angular 1.0.1 → 2.0.0

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

@@ -19,6 +19,7 @@ export interface ClickAudioParameters extends DisconnectSendTransportAudioParame
     audioRequestTime: number;
     member: string;
     socket: Socket;
+    localSocket?: Socket;
     roomName: string;
     userDefaultAudioInputDevice: string;
     micAction: boolean;
@@ -52,6 +53,105 @@ 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 {Socket} options.parameters.localSocket - The local 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,
+ *     localSocket: 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/check-limits-and-make-request.service.d.ts

@@ -0,0 +1,23 @@
+import { PreJoinPageParameters } from '../../@types/types';
+import { CookieService } from 'ngx-cookie-service';
+import * as i0 from "@angular/core";
+export declare class CheckLimitsAndMakeRequest {
+    private cookieService;
+    constructor(cookieService: CookieService);
+    /**
+     * Checks rate limits and attempts to make a socket connection.
+     *
+     * @param params - The parameters required for making the request.
+     */
+    checkLimitsAndMakeRequest({ apiUserName, apiToken, link, apiKey, userName, parameters, validate, }: {
+        apiUserName: string;
+        apiToken: string;
+        link: string;
+        apiKey?: string;
+        userName: string;
+        parameters: PreJoinPageParameters;
+        validate?: boolean;
+    }): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckLimitsAndMakeRequest, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckLimitsAndMakeRequest>;
+}

package/dist/lib/methods/utils/create-response-join-room.util.d.ts

@@ -0,0 +1,33 @@
+import { ResponseJoinLocalRoom, ResponseJoinRoom } from "../../@types/types";
+export interface CreateResponseJoinRoomOptions {
+    localRoom: ResponseJoinLocalRoom;
+}
+export type CreateResponseJoinRoomType = (options: CreateResponseJoinRoomOptions) => Promise<ResponseJoinRoom>;
+/**
+ * Creates a ResponseJoinRoom object from a ResponseJoinLocalRoom object.
+ *
+ * @param {CreateResponseJoinRoomOptions} options - The options containing the ResponseJoinLocalRoom object.
+ * @returns {Promise<ResponseJoinRoom>} - A promise that resolves to a ResponseJoinRoom object.
+ *
+ * @example
+ * ```typescript
+ * const localRoom: ResponseJoinLocalRoom = {
+ *   rtpCapabilities: null,
+ *   isHost: true,
+ *   eventStarted: false,
+ *   isBanned: false,
+ *   hostNotJoined: false,
+ *   eventRoomParams: { /* MeetingRoomParams * / },
+ *   recordingParams: { /* RecordingParams * / },
+ *   secureCode: "12345",
+ *   mediasfuURL: "https://example.com",
+ *   apiKey: "api-key",
+ *   apiUserName: "user-name",
+ *   allowRecord: true,
+ * };
+ *
+ * const joinRoom = await createResponseJoinRoom({ localRoom });
+ * console.log(joinRoom);
+ * ```
+ */
+export declare const createResponseJoinRoom: CreateResponseJoinRoomType;

package/dist/lib/methods/utils/create-room-on-media-sfu.service.d.ts

@@ -0,0 +1,25 @@
+import { CreateJoinRoomResponse, CreateJoinRoomError } from '../../@types/types';
+import * as i0 from "@angular/core";
+/**
+ * Async function to create a room on MediaSFU.
+ *
+ * @param {object} options - The options for creating a room.
+ * @param {any} options.payload - The payload for the API request.
+ * @param {string} options.apiUserName - The API username.
+ * @param {string} options.apiKey - The API key.
+ * @returns {Promise<{ data: CreateJoinRoomResponse | CreateJoinRoomError | null; success: boolean; }>} The response from the API.
+ */
+export declare class CreateRoomOnMediaSFU {
+    private readonly API_URL;
+    constructor();
+    createRoomOnMediaSFU({ payload, apiUserName, apiKey, }: {
+        payload: any;
+        apiUserName: string;
+        apiKey: string;
+    }): Promise<{
+        data: CreateJoinRoomResponse | CreateJoinRoomError | null;
+        success: boolean;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateRoomOnMediaSFU, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateRoomOnMediaSFU>;
+}