mediasfu-angular 1.0.0 → 1.0.2

package/dist/lib/producers/socket-receive-methods/producer-media-paused.service.d.ts

@@ -26,6 +26,68 @@ export interface ProducerMediaPausedOptions {
     parameters: ProducerMediaPausedParameters;
 }
 export type ProducerMediaPausedType = (options: ProducerMediaPausedOptions) => Promise<void>;
+/**
+ * Service to handle the paused state of media for a producer.
+ *
+ * @class
+ * @name ProducerMediaPaused
+ * @description
+ * Handles the actions required when media is paused for a specified producer, including UI updates, participant state handling, and managing meeting display optimizations.
+ *
+ * @method
+ * producerMediaPaused
+ *
+ * @param {ProducerMediaPausedOptions} options - Options to specify the producer and event details:
+ *   - `producerId` {string}: The ID of the paused producer.
+ *   - `kind` {string}: The type of media paused (e.g., "audio", "video").
+ *   - `name` {string}: Name of the producer whose media is paused.
+ *   - `parameters` {ProducerMediaPausedParameters}: Configuration and state parameters for the meeting.
+ *      - `activeSounds` {string[]}: Active audio streams currently displayed.
+ *      - `meetingDisplayType` {string}: Current meeting layout type (e.g., "media", "video").
+ *      - `meetingVideoOptimized` {boolean}: Indicates if video is optimized.
+ *      - `participants` {Participant[]}: List of all meeting participants.
+ *      - `oldSoundIds` {string[]}: List of previously active audio stream IDs.
+ *      - `shared` {boolean}: Indicates if the screen is currently shared.
+ *      - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.
+ *      - `updateMainWindow` {boolean}: Specifies if the main display window should update.
+ *      - `hostLabel` {string}: The label representing the host participant.
+ *      - `islevel` {string}: The access level of the participant.
+ *      - `updateActiveSounds` {Function}: Updates the list of active audio streams.
+ *      - `updateUpdateMainWindow` {Function}: Updates the status of the main display window.
+ *      - `reorderStreams` {Function}: Reorders media streams for optimized display.
+ *      - `prepopulateUserMedia` {Function}: Preloads user media based on display needs.
+ *      - `reUpdateInter` {Function}: Refreshes participant interactions on the UI.
+ *
+ * @returns {Promise<void>} Resolves when media pause handling is complete.
+ *
+ * @example
+ * const options = {
+ *   producerId: '12345',
+ *   kind: 'audio',
+ *   name: 'Participant A',
+ *   parameters: {
+ *     activeSounds: ['Participant B'],
+ *     meetingDisplayType: 'video',
+ *     meetingVideoOptimized: false,
+ *     participants: [...],
+ *     oldSoundIds: ['Participant A'],
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     updateMainWindow: true,
+ *     hostLabel: 'Host',
+ *     islevel: '1',
+ *     updateActiveSounds: (sounds) => { ... },
+ *     updateUpdateMainWindow: (status) => { ... },
+ *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },
+ *     prepopulateUserMedia: ({ name, parameters }) => { ... },
+ *     reUpdateInter: ({ name, add, force, parameters }) => { ... }
+ *   }
+ * };
+ *
+ * producerMediaPausedService.producerMediaPaused(options)
+ *   .then(() => console.log('Media pause handled'))
+ *   .catch(error => console.error('Error:', error));
+ */
 export declare class ProducerMediaPaused {
     /**
      * Handles the event when media is paused for a producer.

package/dist/lib/producers/socket-receive-methods/producer-media-resumed.service.d.ts

@@ -19,6 +19,51 @@ export interface ProducerMediaResumedOptions {
     parameters: ProducerMediaResumedParameters;
 }
 export type ProducerMediaResumedType = (options: ProducerMediaResumedOptions) => Promise<void>;
+/**
+ * Service to handle resuming media for a specific participant in a meeting.
+ *
+ * @class
+ * @name ProducerMediaResumed
+ * @description Resumes media (audio only) for a participant and updates the meeting display based on the meeting layout and participant status.
+ *
+ * @method
+ * producerMediaResumed
+ *
+ * @param {ProducerMediaResumedOptions} options - Options to control media resumption:
+ *   - `name` {string}: Name of the participant whose media is to be resumed.
+ *   - `parameters` {ProducerMediaResumedParameters}: Meeting and participant-specific configurations.
+ *      - `meetingDisplayType` {string}: Type of meeting display (e.g., "media").
+ *      - `participants` {Participant[]}: List of participants in the meeting.
+ *      - `shared` {boolean}: Indicates if the screen is currently shared.
+ *      - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.
+ *      - `mainScreenFilled` {boolean}: Indicates if the main screen is filled.
+ *      - `hostLabel` {string}: Label or name of the host.
+ *      - `updateUpdateMainWindow` {Function}: Function to update the main window display.
+ *      - `reorderStreams` {Function}: Function to manage stream ordering when display changes.
+ *      - `prepopulateUserMedia` {Function}: Function to preload user media for the main screen.
+ *
+ * @returns {Promise<void>} Resolves when media for the specified participant has resumed.
+ *
+ * @example
+ * const options = {
+ *   name: 'Participant A',
+ *   parameters: {
+ *     meetingDisplayType: 'media',
+ *     participants: [...],
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     mainScreenFilled: false,
+ *     hostLabel: 'Host',
+ *     updateUpdateMainWindow: (updateMainWindow) => { ... },
+ *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },
+ *     prepopulateUserMedia: ({ name, parameters }) => { ... }
+ *   }
+ * };
+ *
+ * producerMediaResumedService.producerMediaResumed(options)
+ *   .then(() => console.log('Media resumed'))
+ *   .catch(error => console.error('Error:', error));
+ */
 export declare class ProducerMediaResumed {
     /**
      * Resumes media for a specific participant in a meeting.

package/dist/lib/producers/socket-receive-methods/re-initiate-recording.service.d.ts

@@ -7,6 +7,35 @@ export interface ReInitiateRecordingOptions {
     adminRestrictSetting: boolean;
 }
 export type ReInitiateRecordingType = (options: ReInitiateRecordingOptions) => Promise<void>;
+/**
+ * Service to re-initiate recording in a specific room, considering administrative restrictions.
+ *
+ * @class
+ * @name ReInitiateRecording
+ * @description Attempts to re-initiate recording if administrative restrictions permit.
+ *
+ * @method
+ * reInitiateRecording
+ *
+ * @param {ReInitiateRecordingOptions} options - Configuration options for re-initiating recording:
+ *   - `roomName` {string}: The name of the room to start recording in.
+ *   - `member` {string}: The name of the member initiating the recording.
+ *   - `socket` {Socket}: The socket instance for server communication.
+ *   - `adminRestrictSetting` {boolean}: Flag indicating if the admin restrict setting is active, preventing re-initiation.
+ *
+ * @returns {Promise<void>} Resolves if recording is successfully re-initiated; otherwise, it throws an error if re-initiation fails.
+ *
+ * @example
+ * const options = {
+ *   roomName: 'Room101',
+ *   member: 'Alice',
+ *   socket: mySocketInstance,
+ *   adminRestrictSetting: false
+ * };
+ * reInitiateRecordingService.reInitiateRecording(options)
+ *   .then(() => console.log('Recording re-initiated'))
+ *   .catch(error => console.error(error.message));
+ */
 export declare class ReInitiateRecording {
     /**
      * Re-initiates recording based on specific conditions.

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

@@ -12,6 +12,44 @@ export interface ReceiveMessageOptions {
     updateShowMessagesBadge: (showBadge: boolean) => void;
 }
 export type ReceiveMessageType = (options: ReceiveMessageOptions) => Promise<void>;
+/**
+ * Service for receiving and processing messages, including handling group and direct messages, filtering banned senders, and updating message states.
+ *
+ * @class
+ * @name ReceiveMessage
+ * @description Manages incoming messages, appends them to the existing messages array, filters out banned senders, and updates message badge visibility as needed.
+ *
+ * @method
+ * receiveMessage
+ *
+ * @param {ReceiveMessageOptions} options - Options for handling a received message:
+ *   - `message` {Message}: The new message object to process.
+ *   - `messages` {Message[]}: The current list of messages.
+ *   - `participantsAll` {Participant[]}: All participants in the chat.
+ *   - `member` {string}: The current member's name.
+ *   - `eventType` {EventType}: The type of event (e.g., "broadcast" or "chat").
+ *   - `islevel` {string}: The level of the current user.
+ *   - `coHost` {string}: The name of the co-host.
+ *   - `updateMessages` {Function}: A function to update the messages list.
+ *   - `updateShowMessagesBadge` {Function}: A function to toggle the visibility of the message badge.
+ *
+ * @returns {Promise<void>} Resolves when the message processing and updates are complete.
+ *
+ * @example
+ * const message = { sender: 'Alice', receivers: ['Bob'], message: 'Hello!', timestamp: Date.now(), group: false };
+ * const options = {
+ *   message,
+ *   messages: [],
+ *   participantsAll: [{ name: 'Alice' }, { name: 'Bob' }],
+ *   member: 'Bob',
+ *   eventType: 'chat',
+ *   islevel: '1',
+ *   coHost: 'Charlie',
+ *   updateMessages: (updatedMessages) => console.log('Messages updated:', updatedMessages),
+ *   updateShowMessagesBadge: (show) => console.log('Show badge:', show)
+ * };
+ * receiveMessageService.receiveMessage(options);
+ */
 export declare class ReceiveMessage {
     /**
      * Receives and processes a message, updating the messages array and handling

package/dist/lib/producers/socket-receive-methods/recording-notice.service.d.ts

@@ -53,6 +53,44 @@ export interface RecordingNoticeOptions {
     parameters: RecordingNoticeParameters;
 }
 export type RecordingNoticeType = (options: RecordingNoticeOptions) => Promise<void>;
+/**
+ * Service for handling recording notices, managing recording states, and updating related parameters.
+ *
+ * @class
+ * @name RecordingNotice
+ * @description Provides methods to handle the recording notice state, manage user recording parameters, and play appropriate sounds for different states.
+ *
+ * @method
+ * RecordingNotice
+ *
+ * @param {RecordingNoticeOptions} options - The options for recording notices:
+ *   - `state` {string}: The current recording state (`pause`, `stop`, etc.).
+ *   - `userRecordingParam` {UserRecordingParams | null}: The user recording parameters (if available).
+ *   - `pauseCount` {number}: The number of pauses in the recording.
+ *   - `timeDone` {number}: The total recording time completed.
+ *   - `parameters` {RecordingNoticeParameters}: Functions and properties to update recording details.
+ *     - `updateRecordElapsedTime` {Function}: Updates elapsed recording time.
+ *     - `updateShowRecordButtons` {Function}: Toggles record button visibility.
+ *     - `updateRecordState` {Function}: Sets the record state (e.g., `red`, `green`, `yellow`).
+ *     - `updatePauseRecordCount` {Function}: Sets the pause record count.
+ *     - `updateRecordStarted`, `updateRecordPaused`, `updateCanLaunchRecord`, etc.: Other update functions to control recording settings and states.
+ *
+ * @returns {Promise<void>} Resolves when the recording state and parameters have been updated.
+ *
+ * @example
+ * const options = {
+ *   state: 'pause',
+ *   userRecordingParam: { mainSpecs: { mediaOptions: 'audio', ... } },
+ *   pauseCount: 3,
+ *   timeDone: 3600,
+ *   parameters: {
+ *     updateRecordStarted: (started) => console.log(`Recording started: ${started}`),
+ *     updateRecordPaused: (paused) => console.log(`Recording paused: ${paused}`),
+ *     // Define other update functions similarly
+ *   }
+ * };
+ * await recordingNoticeService.RecordingNotice(options);
+ */
 export declare class RecordingNotice {
     private SoundPlayerService;
     constructor(SoundPlayerService: SoundPlayer);

package/dist/lib/producers/socket-receive-methods/room-record-params.service.d.ts

@@ -43,6 +43,68 @@ export interface RoomRecordParamsOptions {
     parameters: RoomRecordParamsParameters;
 }
 export type RoomRecordParamsType = ({ recordParams, parameters, }: RoomRecordParamsOptions) => Promise<void>;
+/**
+ * Service to update recording parameters for a room.
+ *
+ * @class
+ * @name RoomRecordParams
+ * @description Updates multiple recording parameters at once, using provided functions for each specific setting.
+ *
+ * @method
+ * roomRecordParams
+ *
+ * @param {RoomRecordParamsOptions} options - The options for updating recording parameters:
+ *   - `recordParams` {RecordParams}: The new recording parameters to apply.
+ *   - `parameters` {RoomRecordParamsParameters}: The update functions for each recording parameter.
+ *     - `updateRecordingAudioPausesLimit` {Function}: Updates the audio pauses limit.
+ *     - `updateRecordingAudioPausesCount` {Function}: Updates the audio pauses count.
+ *     - `updateRecordingAudioSupport` {Function}: Updates the audio support status.
+ *     - `updateRecordingAudioPeopleLimit` {Function}: Updates the audio people limit.
+ *     - `updateRecordingAudioParticipantsTimeLimit` {Function}: Updates the audio participants time limit.
+ *     - `updateRecordingVideoPausesCount` {Function}: Updates the video pauses count.
+ *     - `updateRecordingVideoPausesLimit` {Function}: Updates the video pauses limit.
+ *     - `updateRecordingVideoSupport` {Function}: Updates the video support status.
+ *     - `updateRecordingVideoPeopleLimit` {Function}: Updates the video people limit.
+ *     - `updateRecordingVideoParticipantsTimeLimit` {Function}: Updates the video participants time limit.
+ *     - `updateRecordingAllParticipantsSupport` {Function}: Updates support for all participants.
+ *     - `updateRecordingVideoParticipantsSupport` {Function}: Updates video participants support.
+ *     - `updateRecordingAllParticipantsFullRoomSupport` {Function}: Updates full room support for all participants.
+ *     - `updateRecordingVideoParticipantsFullRoomSupport` {Function}: Updates full room support for video participants.
+ *     - `updateRecordingPreferredOrientation` {Function}: Updates the preferred recording orientation.
+ *     - `updateRecordingSupportForOtherOrientation` {Function}: Updates support for other orientations.
+ *     - `updateRecordingMultiFormatsSupport` {Function}: Updates support for multiple formats.
+ *
+ * @returns {Promise<void>} A promise that resolves after all parameters are updated.
+ *
+ * @example
+ * const recordParams = {
+ *   recordingAudioPausesLimit: 5,
+ *   recordingAudioPausesCount: 2,
+ *   recordingAudioSupport: true,
+ *   recordingAudioPeopleLimit: 10,
+ *   recordingAudioParticipantsTimeLimit: 60,
+ *   recordingVideoPausesCount: 1,
+ *   recordingVideoPausesLimit: 3,
+ *   recordingVideoSupport: true,
+ *   recordingVideoPeopleLimit: 8,
+ *   recordingVideoParticipantsTimeLimit: 90,
+ *   recordingAllParticipantsSupport: true,
+ *   recordingVideoParticipantsSupport: true,
+ *   recordingAllParticipantsFullRoomSupport: false,
+ *   recordingVideoParticipantsFullRoomSupport: true,
+ *   recordingPreferredOrientation: 'landscape',
+ *   recordingSupportForOtherOrientation: false,
+ *   recordingMultiFormatsSupport: true,
+ * };
+ *
+ * const parameters = {
+ *   updateRecordingAudioPausesLimit: (value) => console.log(`Audio pauses limit: ${value}`),
+ *   updateRecordingAudioPausesCount: (value) => console.log(`Audio pauses count: ${value}`),
+ *   // Define other update functions similarly
+ * };
+ *
+ * roomRecordParamsService.roomRecordParams({ recordParams, parameters });
+ */
 export declare class RoomRecordParams {
     /**
      * Updates various recording parameters based on the provided `recordParams`.

package/dist/lib/producers/socket-receive-methods/screen-producer-id.service.d.ts

@@ -12,6 +12,47 @@ export interface ScreenProducerIdOptions {
     updateDeferScreenReceived: (received: boolean) => void;
 }
 export type ScreenProducerIdType = (options: ScreenProducerIdOptions) => void;
+/**
+ * Service to manage screen producer ID and screen sharing status for participants.
+ *
+ * @class
+ * @name ScreenProducerId
+ * @description This service processes and updates the screen producer ID, manages screen sharing states, and defers screen updates as needed based on participant data.
+ *
+ * @method
+ * screenProducerId
+ *
+ * @param {ScreenProducerIdOptions} options - Options for handling screen producer ID:
+ *   - `producerId` {string}: The ID of the screen producer.
+ *   - `screenId` {string}: The current screen ID.
+ *   - `membersReceived` {boolean}: Indicates if members data has been received.
+ *   - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.
+ *   - `deferScreenReceived` {boolean}: Indicates if screen sharing should be deferred.
+ *   - `participants` {Participant[]}: The list of current participants.
+ *   - `updateScreenId` {Function}: Function to update the screen ID.
+ *   - `updateShareScreenStarted` {Function}: Function to update the screen sharing status.
+ *   - `updateDeferScreenReceived` {Function}: Function to update the deferred screen status.
+ *
+ * @returns {void} Updates states directly through provided functions.
+ *
+ * @example
+ * const options = {
+ *   producerId: 'abc123',
+ *   screenId: 'screen45',
+ *   membersReceived: true,
+ *   shareScreenStarted: false,
+ *   deferScreenReceived: false,
+ *   participants: [
+ *     { id: 'p1', ScreenID: 'screen45', ScreenOn: true },
+ *     // Additional participants
+ *   ],
+ *   updateScreenId: (id) => console.log(`Screen ID updated to: ${id}`),
+ *   updateShareScreenStarted: (started) => console.log(`Screen sharing started: ${started}`),
+ *   updateDeferScreenReceived: (received) => console.log(`Screen sharing deferred: ${received}`)
+ * };
+ *
+ * screenProducerIdService.screenProducerId(options);
+ */
 export declare class ScreenProducerId {
     /**
      * Handles the screen producer id.

package/dist/lib/producers/socket-receive-methods/start-records.service.d.ts

@@ -6,6 +6,31 @@ export interface StartRecordsOptions {
     socket: Socket;
 }
 export type StartRecordsType = (options: StartRecordsOptions) => Promise<void>;
+/**
+ * Service to initiate recording for a specified room.
+ *
+ * @class
+ * @name StartRecords
+ * @description Sends a request to the server to begin recording a room, using socket communication.
+ *
+ * @method
+ * startRecords
+ *
+ * @param {StartRecordsOptions} options - Options required to start the recording:
+ *   - `roomName` {string}: The name of the room to record.
+ *   - `member` {string}: The identifier of the member initiating the recording.
+ *   - `socket` {Socket}: The socket instance for server communication.
+ *
+ * @returns {Promise<void>} Resolves when the server confirms the recording start request.
+ *
+ * @example
+ * const options = {
+ *   roomName: 'Room101',
+ *   member: 'user123',
+ *   socket: io('http://localhost:3000')
+ * };
+ * startRecordsService.startRecords(options);
+ */
 export declare class StartRecords {
     /**
      * Starts recording the room.

package/dist/lib/producers/socket-receive-methods/stopped-recording.service.d.ts

@@ -6,6 +6,31 @@ export interface StoppedRecordingOptions {
     showAlert?: ShowAlert;
 }
 export type StoppedRecordingType = (options: StoppedRecordingOptions) => Promise<void>;
+/**
+ * Service to display an alert message when recording has stopped.
+ *
+ * @class
+ * @name StoppedRecording
+ * @description Provides a method to show an alert indicating that the recording has stopped.
+ *
+ * @method
+ * stoppedRecording
+ *
+ * @param {StoppedRecordingOptions} options - Options for displaying the alert:
+ *   - `state` {string}: The state of the recording, typically 'stop'.
+ *   - `reason` {string}: The reason for stopping the recording.
+ *   - `showAlert` {Function}: Optional function to show alert messages.
+ *
+ * @returns {Promise<void>} Resolves when the alert message has been displayed.
+ *
+ * @example
+ * const options = {
+ *   state: 'stop',
+ *   reason: 'User ended recording',
+ *   showAlert: ({ message, duration, type }) => console.log(message)
+ * };
+ * stoppedRecordingService.stoppedRecording(options);
+ */
 export declare class StoppedRecording {
     /**
      * Displays an alert message when the recording has stopped.

package/dist/lib/producers/socket-receive-methods/time-left-recording.service.d.ts

@@ -5,6 +5,27 @@ export interface TimeLeftRecordingOptions {
     showAlert?: ShowAlert;
 }
 export type TimeLeftRecordingType = (options: TimeLeftRecordingOptions) => void;
+/**
+ * Service to display an alert indicating the remaining recording time.
+ *
+ * @class
+ * @name TimeLeftRecording
+ * @description Provides a method to show an alert when the recording is close to its end.
+ *
+ * @method
+ * timeLeftRecording
+ *
+ * @param {TimeLeftRecordingOptions} options - Options for the remaining time alert:
+ *   - `timeLeft` {number}: The time left in seconds before the recording stops.
+ *   - `showAlert` {Function}: Optional function to display the alert message.
+ *
+ * @example
+ * const options = {
+ *   timeLeft: 30,
+ *   showAlert: ({ message, duration, type }) => console.log(message)
+ * };
+ * timeLeftRecordingService.timeLeftRecording(options);
+ */
 export declare class TimeLeftRecording {
     /**
      * Displays an alert message indicating the remaining time left for recording.

package/dist/lib/producers/socket-receive-methods/update-consuming-domains.service.d.ts

@@ -17,6 +17,48 @@ export interface UpdateConsumingDomainsOptions {
     parameters: UpdateConsumingDomainsParameters;
 }
 export type UpdateConsumingDomainsType = (options: UpdateConsumingDomainsOptions) => Promise<void>;
+/**
+ * Service to update consuming domains based on specified options and parameters.
+ *
+ * @class
+ * @name UpdateConsumingDomains
+ * @description Provides a method to update consuming domains and optionally connect IPs based on the domains provided.
+ *
+ * @method
+ * updateConsumingDomains
+ *
+ * @param {UpdateConsumingDomainsOptions} options - Options for updating consuming domains:
+ *   - `domains` {Array<string>}: The list of domains to be updated.
+ *   - `alt_domains` {AltDomains}: Alternative domains for fallback scenarios.
+ *   - `apiUserName` {string}: API username for authentication.
+ *   - `apiKey` {string}: API key for access.
+ *   - `apiToken` {string}: API token for additional security.
+ *   - `parameters` {UpdateConsumingDomainsParameters}: The parameters needed for updating, including:
+ *     - `participants` {Array<Participant>}: List of participants.
+ *     - `consume_sockets` {Array<ConsumeSocket>}: Sockets to use for consuming domains.
+ *     - `getDomains` {Function}: Function to retrieve current domain configurations.
+ *     - `connectIps` {Function}: Function to initiate IP connections.
+ *     - `getUpdatedAllParams` {Function}: Refreshes and returns the latest parameters.
+ *
+ * @returns {Promise<void>} Resolves when the consuming domains have been successfully updated.
+ *
+ * @example
+ * const options = {
+ *   domains: ['example.com', 'sample.org'],
+ *   alt_domains: { primary: 'primary.com', backup: 'backup.com' },
+ *   apiUserName: 'user123',
+ *   apiKey: 'apikey123',
+ *   apiToken: 'token123',
+ *   parameters: {
+ *     participants: [{ id: '1', name: 'John Doe' }],
+ *     consume_sockets: [socket1, socket2],
+ *     getDomains: (opts) => fetchDomains(opts),
+ *     connectIps: (opts) => connectToIPs(opts),
+ *     getUpdatedAllParams: () => refreshParams(),
+ *   },
+ * };
+ * await updateConsumingDomainsService.updateConsumingDomains(options);
+ */
 export declare class UpdateConsumingDomains {
     /**
      * Updates the consuming domains based on the provided options.

package/dist/lib/producers/socket-receive-methods/update-media-settings.service.d.ts

@@ -8,6 +8,36 @@ export interface UpdateMediaSettingsOptions {
     updateChatSetting: (value: string) => void;
 }
 export type UpdateMediaSettingsType = (options: UpdateMediaSettingsOptions) => void;
+/**
+ * Service for updating media settings including audio, video, screenshare, and chat.
+ *
+ * @class
+ * @name UpdateMediaSettings
+ * @description Provides a method to update multiple media settings at once using specified update functions.
+ *
+ * @method
+ * updateMediaSettings
+ *
+ * @param {UpdateMediaSettingsOptions} options - Options for updating media settings:
+ *   - `settings` {Settings}: The settings values to apply.
+ *   - `updateAudioSetting` {Function}: Function to update the audio setting.
+ *   - `updateVideoSetting` {Function}: Function to update the video setting.
+ *   - `updateScreenshareSetting` {Function}: Function to update the screenshare setting.
+ *   - `updateChatSetting` {Function}: Function to update the chat setting.
+ *
+ * @returns {void} Updates settings directly through the provided functions.
+ *
+ * @example
+ * const settings = ['mute', 'HD', 'enabled', 'disabled'];
+ * const options = {
+ *   settings,
+ *   updateAudioSetting: (value) => console.log(`Audio setting updated to: ${value}`),
+ *   updateVideoSetting: (value) => console.log(`Video setting updated to: ${value}`),
+ *   updateScreenshareSetting: (value) => console.log(`Screenshare setting updated to: ${value}`),
+ *   updateChatSetting: (value) => console.log(`Chat setting updated to: ${value}`)
+ * };
+ * updateMediaSettingsService.updateMediaSettings(options);
+ */
 export declare class UpdateMediaSettings {
     /**
      * Updates the media settings by invoking the provided update functions for each setting.

package/dist/lib/producers/socket-receive-methods/updated-co-host.service.d.ts

@@ -13,6 +13,46 @@ export interface UpdatedCoHostOptions {
     updateYouAreCoHost: (youAreCoHost: boolean) => void;
 }
 export type UpdatedCoHostType = (options: UpdatedCoHostOptions) => Promise<void>;
+/**
+ * Service for updating co-host information, responsibilities, and the user's co-host status.
+ *
+ * @class
+ * @name UpdatedCoHost
+ * @description Manages co-host updates for different event types, assigning responsibilities and notifying the user if their co-host status changes.
+ *
+ * @method
+ * updatedCoHost
+ * @async
+ *
+ * @param {UpdatedCoHostOptions} options - The options for co-host updates:
+ *   - `coHost` {string}: The name of the co-host.
+ *   - `coHostResponsibility` {CoHostResponsibility[]}: List of responsibilities assigned to the co-host.
+ *   - `showAlert` {ShowAlert}: Optional function to display an alert message.
+ *   - `eventType` {EventType}: Type of the event, determining if co-host can be updated.
+ *   - `islevel` {string}: Current level of the event.
+ *   - `member` {string}: The current user's identifier.
+ *   - `youAreCoHost` {boolean}: Current user's co-host status.
+ *   - `updateCoHost` {Function}: Function to set the new co-host.
+ *   - `updateCoHostResponsibility` {Function}: Function to assign responsibilities to the co-host.
+ *   - `updateYouAreCoHost` {Function}: Function to update the user's co-host status.
+ *
+ * @returns {Promise<void>} Resolves after co-host information is updated.
+ *
+ * @example
+ * const options = {
+ *   coHost: 'Alice',
+ *   coHostResponsibility: ['moderate', 'manageParticipants'],
+ *   showAlert: ({ message, type, duration }) => console.log(message),
+ *   eventType: 'conference',
+ *   islevel: '1',
+ *   member: 'Alice',
+ *   youAreCoHost: false,
+ *   updateCoHost: (newCoHost) => console.log(`Updated co-host: ${newCoHost}`),
+ *   updateCoHostResponsibility: (responsibilities) => console.log(responsibilities),
+ *   updateYouAreCoHost: (status) => console.log(`You are co-host: ${status}`)
+ * };
+ * await updatedCoHostService.updatedCoHost(options);
+ */
 export declare class UpdatedCoHost {
     /**
      * Updates the co-host information, responsibility, and user's co-host status based on the provided options.

package/dist/lib/producers/socket-receive-methods/user-waiting.service.d.ts

@@ -8,56 +8,30 @@ export interface UserWaitingOptions {
 }
 export type UserWaitingType = (options: UserWaitingOptions) => Promise<void>;
 /**
- * @fileoverview Service to handle user waiting functionality.
- *
- * @description
- * This service provides methods to handle the logic when a user joins the waiting room.
- * It displays an alert/notification and updates the total number of requests waiting.
- */
-/**
- * Options for the userWaiting method.
- *
- * @interface UserWaitingOptions
- * @property {string} name - The name of the user joining the waiting room.
- * @property {(options: { message: string; type: string; duration: number }) => void} [showAlert] - Optional function to display an alert/notification.
- * @property {number} totalReqWait - The current total number of requests waiting.
- * @property {(total: number) => void} updateTotalReqWait - Function to update the total number of requests waiting.
- */
-/**
- * Service to handle user waiting functionality.
+ * Service for handling user waiting room actions, including notifications and updating request counts.
  *
  * @class
  * @name UserWaiting
- * @description
- * This service provides methods to handle the logic when a user joins the waiting room.
- * It displays an alert/notification and updates the total number of requests waiting.
- *
- * @example
- * const userWaitingService = new UserWaiting();
- * userWaitingService.userWaiting({
- *   name: 'John Doe',
- *   showAlert: (options) => console.log(options.message),
- *   totalReqWait: 5,
- *   updateTotalReqWait: (total) => console.log(`Total requests: ${total}`),
- * });
- */
-/**
- * Handles the logic when a user joins the waiting room.
+ * @description Manages the logic when a user joins the waiting room by displaying alerts and incrementing the total request count.
  *
  * @method
- * @name userWaiting
- * @memberof UserWaiting
+ * userWaiting
  * @async
  *
- * @param {UserWaitingOptions} options - The options for the user waiting method.
- * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ * @param {UserWaitingOptions} options - The options for handling user waiting actions:
+ *   - `name` {string}: Name of the user joining the waiting room.
+ *   - `showAlert` {ShowAlert}: Optional function for showing an alert with a customizable message, type, and duration.
+ *   - `totalReqWait` {number}: Current count of waiting requests.
+ *   - `updateTotalReqWait` {Function}: Updates the total waiting request count.
+ *
+ * @returns {Promise<void>} Resolves after alert is shown and request count is updated.
  *
  * @example
  * const options = {
- *   name: 'John Doe',
- *   showAlert: (options) => console.log(options.message),
- *   totalReqWait: 5,
- *   updateTotalReqWait: (total) => console.log(`Total requests: ${total}`),
+ *   name: 'Alice',
+ *   showAlert: ({ message, type, duration }) => console.log(message),
+ *   totalReqWait: 3,
+ *   updateTotalReqWait: (newTotal) => console.log(`Updated count: ${newTotal}`)
  * };
  * await userWaitingService.userWaiting(options);
  */