mediasfu-angular 1.0.1 → 2.0.0

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

@@ -8,6 +8,37 @@ export interface ParticipantRequestedOptions {
     updateRequestList: (list: Request[]) => void;
 }
 export type ParticipantRequestedType = (options: ParticipantRequestedOptions) => Promise<void>;
+/**
+ * Service to handle participant requests in an event's waiting room.
+ *
+ * @class
+ * @name ParticipantRequested
+ * @description
+ * Manages participant requests by adding new requests to the list and updating the total count of requests and waiting room participants.
+ *
+ * @method
+ * participantRequested
+ *
+ * @param {ParticipantRequestedOptions} options - Contains request information and update functions:
+ *   - `userRequest` {Request}: The new request from a participant.
+ *   - `requestList` {Request[]}: The current list of requests.
+ *   - `waitingRoomList` {WaitingRoomParticipant[]}: The list of participants in the waiting room.
+ *   - `updateTotalReqWait` {Function}: Function to update the total count of requests and waiting room participants.
+ *   - `updateRequestList` {Function}: Function to update the request list.
+ *
+ * @returns {Promise<void>} Updates the request list and total request count.
+ *
+ * @example
+ * const options = {
+ *   userRequest: { id: '123', name: 'John Doe', icon: 'fa-user', username: 'johndoe' },
+ *   requestList: existingRequests,
+ *   waitingRoomList: waitingParticipants,
+ *   updateTotalReqWait: (count) => console.log(`Total requests: ${count}`),
+ *   updateRequestList: (list) => console.log('Updated request list', list)
+ * };
+ * await participantRequestedService.participantRequested(options);
+ * // Adds "John Doe" to request list and updates the total count.
+ */
 export declare class ParticipantRequested {
     /**
      * Handles a participant's request by adding it to the request list and updating the total count of requests and waiting room participants.

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

@@ -5,6 +5,31 @@ export interface PersonJoinedOptions {
     name: string;
 }
 export type PersonJoinedType = (options: PersonJoinedOptions) => Promise<void>;
+/**
+ * Service to handle actions when a person joins an event.
+ *
+ * @class
+ * @name PersonJoined
+ * @description
+ * Displays a notification when a person joins the event, using the `showAlert` function if provided.
+ *
+ * @method
+ * personJoined
+ *
+ * @param {PersonJoinedOptions} options - Contains information about the person and alert display function:
+ *   - `name` {string}: The name of the person who joined.
+ *   - `showAlert` {Function} (optional): Function to display a notification when the person joins.
+ *
+ * @returns {void} Executes alert display through `showAlert` if defined.
+ *
+ * @example
+ * const options = {
+ *   name: 'Alice',
+ *   showAlert: ({ message, type, duration }) => console.log(message)
+ * };
+ * personJoinedService.personJoined(options);
+ * // Logs: "Alice joined the event."
+ */
 export declare class PersonJoined {
     /**
      * Handles the event when a person joins.

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

@@ -21,6 +21,67 @@ export interface ProducerMediaClosedOptions {
     parameters: ProducerMediaClosedParameters;
 }
 export type ProducerMediaClosedType = (options: ProducerMediaClosedOptions) => Promise<void>;
+/**
+ * Service to handle closing a media producer and associated UI and state updates.
+ *
+ * @class
+ * @name ProducerMediaClosed
+ * @description
+ * Manages the closure of a media producer by identifying associated consumer transports, closing necessary resources,
+ * and updating the user interface to reflect the change. For screen sharing, it resets the shared state and adjusts the main view.
+ *
+ * @method
+ * producerMediaClosed
+ *
+ * @param {ProducerMediaClosedOptions} options - Contains details on the producer and parameters for state updates:
+ *   - `producerId` {string}: ID of the producer to close.
+ *   - `kind` {string}: The type of media to close (e.g., "screenshare" or "audio").
+ *   - `parameters` {ProducerMediaClosedParameters}: Settings and update functions to manage the closure process.
+ *      - `consumerTransports` {Transport[]}: List of active transports for consumers.
+ *      - `updateConsumerTransports` {Function}: Updates the list of active consumer transports.
+ *      - `hostLabel` {string}: Label of the host to revert to if screen sharing ends.
+ *      - `shared` {boolean}: Indicates whether a screen is currently shared.
+ *      - `updateShared` {Function}: Updates the shared screen state.
+ *      - `updateShareScreenStarted` {Function}: Marks the start or end of screen sharing.
+ *      - `updateScreenId` {Function}: Clears the screen ID when screen sharing ends.
+ *      - `updateShareEnded` {Function}: Marks the end of screen sharing.
+ *      - `closeAndResize` {Function}: Adjusts the screen display upon closing the media.
+ *      - `prepopulateUserMedia` {Function}: Loads default media after screen sharing ends.
+ *      - `reorderStreams` {Function}: Reorders streams to optimize layout when media is closed.
+ *
+ * @returns {Promise<void>} Resolves when all updates are complete and the producer closure is handled.
+ *
+ * @example
+ * const options = {
+ *   producerId: '12345',
+ *   kind: 'screenshare',
+ *   parameters: {
+ *     consumerTransports: [...],
+ *     updateConsumerTransports: (transports) => { ... },
+ *     hostLabel: 'Host',
+ *     shared: true,
+ *     updateShared: (shared) => { ... },
+ *     updateShareScreenStarted: (started) => { ... },
+ *     updateScreenId: (id) => { ... },
+ *     updateShareEnded: (ended) => { ... },
+ *     closeAndResize: ({ producerId, kind, parameters }) => { ... },
+ *     prepopulateUserMedia: ({ name, parameters }) => { ... },
+ *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },
+ *   }
+ * };
+ *
+ * producerMediaClosedService.producerMediaClosed(options)
+ *   .then(() => console.log('Producer closed successfully'))
+ *   .catch(error => console.error('Error:', error));
+ *
+ * @remarks
+ * This service performs the following steps:
+ * 1. Retrieves updated parameters.
+ * 2. Finds and closes the transport associated with the producer.
+ * 3. Updates the list of consumer transports.
+ * 4. Adjusts the display layout with `closeAndResize`.
+ * 5. If the producer is a screen share, resets shared state and reloads default media.
+ */
 export declare class ProducerMediaClosed {
     /**
      * Handles the closure of a media producer.

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.