mediasfu-angular 1.0.1 → 1.0.2

package/dist/lib/consumers/check-screen-share.service.d.ts

@@ -16,6 +16,41 @@ export interface CheckScreenShareOptions {
     parameters: CheckScreenShareParameters;
 }
 export type CheckScreenShareType = (options: CheckScreenShareOptions) => Promise<void>;
+/**
+ * Checks the current screen sharing status and either stops or requests screen sharing based on the provided parameters.
+ *
+ * @param {CheckScreenShareOptions} options - The options for checking screen share.
+ * @param {Object} options.parameters - The parameters for screen sharing.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is currently being shared.
+ * @param {Function} [options.parameters.showAlert] - Function to show alerts.
+ * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard session has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard session has ended.
+ * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room session has started.
+ * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room session has ended.
+ * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.
+ * @param {Function} options.parameters.requestScreenShare - Function to request screen sharing.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen sharing status has been checked and the appropriate action has been taken.
+ *
+ * @throws Will log an error message if an error occurs during the process.
+ *
+ * @example
+ * const options = {
+ *   parameters: {
+ *     shared: false,
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: false,
+ *     breakOutRoomStarted: false,
+ *     breakOutRoomEnded: false,
+ *     stopShareScreen: async () => { /* Logic to stop screen sharing *\/ },
+ *     requestScreenShare: async () => { /* Logic to request screen sharing *\/ },
+ *     showAlert: (alert) => { console.log(alert.message); },
+ *   },
+ * };
+ *
+ * await checkScreenShareService.checkScreenShare(options);
+ * // Output: Logic to request screen sharing will be executed.
+ */
 export declare class CheckScreenShare {
     /**
      * Checks the current screen sharing status and either stops or requests screen sharing based on the provided parameters.

package/dist/lib/consumers/close-and-resize.service.d.ts

@@ -49,6 +49,108 @@ export interface CloseAndResizeOptions {
     parameters: CloseAndResizeParameters;
 }
 export type CloseAndResizeType = (options: CloseAndResizeOptions) => Promise<void>;
+/**
+ * Closes and resizes the video and audio elements based on the provided options.
+ *
+ * @param {CloseAndResizeOptions} options - The options for closing and resizing.
+ * @param {string} options.producerId - The ID of the producer.
+ * @param {string} options.kind - The kind of media (audio, video, screenshare, or screen).
+ * @param {object} options.parameters - The parameters for the operation.
+ * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {Array} options.parameters.allAudioStreams - Array of all audio streams.
+ * @param {Array} options.parameters.allVideoStreams - Array of all video streams.
+ * @param {Array} options.parameters.activeNames - Array of active participant names.
+ * @param {Array} options.parameters.participants - Array of participants.
+ * @param {Array} options.parameters.streamNames - Array of stream names.
+ * @param {string} options.parameters.recordingDisplayType - Type of recording display.
+ * @param {boolean} options.parameters.recordingVideoOptimized - Whether recording is video optimized.
+ * @param {string} options.parameters.adminIDStream - ID of the admin stream.
+ * @param {Array} options.parameters.newLimitedStreams - Array of new limited streams.
+ * @param {Array} options.parameters.newLimitedStreamsIDs - Array of new limited stream IDs.
+ * @param {Array} options.parameters.oldAllStreams - Array of old all streams.
+ * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.
+ * @param {boolean} options.parameters.shared - Whether sharing is active.
+ * @param {string} options.parameters.meetingDisplayType - Type of meeting display.
+ * @param {boolean} options.parameters.defer_receive - Whether to defer receiving.
+ * @param {boolean} options.parameters.lock_screen - Whether the screen is locked.
+ * @param {boolean} options.parameters.firstAll - Whether it is the first all.
+ * @param {boolean} options.parameters.first_round - Whether it is the first round.
+ * @param {boolean} options.parameters.gotAllVids - Whether all videos are received.
+ * @param {string} options.parameters.eventType - Type of event.
+ * @param {string} options.parameters.hostLabel - Label of the host.
+ * @param {boolean} options.parameters.shareEnded - Whether sharing has ended.
+ * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.
+ * @param {function} options.parameters.updateActiveNames - Function to update active names.
+ * @param {function} options.parameters.updateAllAudioStreams - Function to update all audio streams.
+ * @param {function} options.parameters.updateAllVideoStreams - Function to update all video streams.
+ * @param {function} options.parameters.updateShareScreenStarted - Function to update share screen started status.
+ * @param {function} options.parameters.updateUpdateMainWindow - Function to update main window status.
+ * @param {function} options.parameters.updateNewLimitedStreams - Function to update new limited streams.
+ * @param {function} options.parameters.updateOldAllStreams - Function to update old all streams.
+ * @param {function} options.parameters.updateDefer_receive - Function to update defer receive status.
+ * @param {function} options.parameters.updateMainHeightWidth - Function to update main height and width.
+ * @param {function} options.parameters.updateShareEnded - Function to update share ended status.
+ * @param {function} options.parameters.updateLock_screen - Function to update lock screen status.
+ * @param {function} options.parameters.updateFirstAll - Function to update first all status.
+ * @param {function} options.parameters.updateFirst_round - Function to update first round status.
+ * @param {function} options.parameters.reorderStreams - Function to reorder streams.
+ * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ * @param {function} options.parameters.getVideos - Function to get videos.
+ * @param {function} options.parameters.rePort - Function to report.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @example
+ * const options = {
+ *   producerId: '12345',
+ *   kind: 'video',
+ *   parameters: {
+ *     getUpdatedAllParams: () => { /* Logic to get updated parameters *\/ },
+ *     allAudioStreams: [],
+ *     allVideoStreams: [],
+ *     activeNames: ['Participant1', 'Participant2'],
+ *     participants: [],
+ *     streamNames: [],
+ *     recordingDisplayType: 'video',
+ *     recordingVideoOptimized: true,
+ *     adminIDStream: 'admin123',
+ *     newLimitedStreams: [],
+ *     newLimitedStreamsIDs: [],
+ *     oldAllStreams: [],
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     meetingDisplayType: 'media',
+ *     defer_receive: false,
+ *     lock_screen: false,
+ *     firstAll: false,
+ *     first_round: false,
+ *     gotAllVids: false,
+ *     eventType: 'conference',
+ *     hostLabel: 'Host',
+ *     shareEnded: false,
+ *     updateMainWindow: false,
+ *     updateActiveNames: (names) => { /* Logic to update active names *\/ },
+ *     updateAllAudioStreams: (streams) => { /* Logic to update audio streams *\/ },
+ *     updateShareScreenStarted: (status) => { /* Logic to update share screen status *\/ },
+ *     updateUpdateMainWindow: (status) => { /* Logic to update main window status *\/ },
+ *     updateNewLimitedStreams: (streams) => { /* Logic to update new limited streams *\/ },
+ *     updateOldAllStreams: (streams) => { /* Logic to update old streams *\/ },
+ *     updateDefer_receive: (status) => { /* Logic to update defer receive status *\/ },
+ *     updateMainHeightWidth: (size) => { /* Logic to update main height and width *\/ },
+ *     updateShareEnded: (status) => { /* Logic to update share ended status *\/ },
+ *     updateLock_screen: (status) => { /* Logic to update lock screen status *\/ },
+ *     updateFirstAll: (status) => { /* Logic to update first all status *\/ },
+ *     updateFirst_round: (status) => { /* Logic to update first round status *\/ },
+ *     reorderStreams: async () => { /* Logic to reorder streams *\/ },
+ *     prepopulateUserMedia: async () => { /* Logic to prepopulate user media *\/ },
+ *     getVideos: async () => { /* Logic to get videos *\/ },
+ *     rePort: async () => { /* Logic to report *\/ },
+ *   },
+ * };
+ *
+ * await closeAndResizeService.closeAndResize(options);
+ * // The operation will adjust the video and audio elements as per the given parameters.
+ */
 export declare class CloseAndResize {
     /**
      * Closes and resizes the video and audio elements based on the provided options.

package/dist/lib/consumers/compare-active-names.service.d.ts

@@ -14,6 +14,37 @@ export interface CompareActiveNamesOptions {
     parameters: CompareActiveNamesParameters;
 }
 export type CompareActiveNamesType = (options: CompareActiveNamesOptions) => Promise<void>;
+/**
+ * Compares the current active names with the previous active names and triggers an action if there are changes.
+ *
+ * @param {CompareActiveNamesOptions} options - The options for comparing active names.
+ * @param {boolean} [options.restart=false] - Whether to restart the comparison.
+ * @param {CompareActiveNamesParameters} options.parameters - The parameters for the comparison.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {string[]} options.parameters.activeNames - The current active names.
+ * @param {string[]} options.parameters.prevActiveNames - The previous active names.
+ * @param {Function} options.parameters.updatePrevActiveNames - Function to update the previous active names.
+ * @param {Function} options.parameters.trigger - Function to trigger an action when names change.
+ *
+ * @returns {Promise<void>} A promise that resolves when the comparison is complete.
+ *
+ * @throws Will log an error message if an error occurs during the comparison.
+ *
+ * @example
+ * const options = {
+ *   restart: false,
+ *   parameters: {
+ *     getUpdatedAllParams: () => { /* Logic to get updated parameters *\/ },
+ *     activeNames: ['Alice', 'Bob'],
+ *     prevActiveNames: ['Alice', 'Charlie'],
+ *     updatePrevActiveNames: (names) => { /* Logic to update previous active names *\/ },
+ *     trigger: async (data) => { /* Logic to handle the trigger *\/ },
+ *   },
+ * };
+ *
+ * await compareActiveNamesService.compareActiveNames(options);
+ * // If 'Bob' is not in the previous active names, it will trigger the action.
+ */
 export declare class CompareActiveNames {
     /**
      * Compares the current active names with the previous active names and triggers an action if there are changes.

package/dist/lib/consumers/compare-screen-states.service.d.ts

@@ -15,6 +15,41 @@ export interface CompareScreenStatesOptions {
     parameters: CompareScreenStatesParameters;
 }
 export type CompareScreenStatesType = (options: CompareScreenStatesOptions) => Promise<void>;
+/**
+   * Compares the current screen states with the previous screen states and triggers actions based on changes.
+   *
+   * @param {CompareScreenStatesOptions} options - The options for comparing screen states.
+   * @param {boolean} [options.restart=false] - Whether to restart the comparison process.
+   * @param {CompareScreenStatesParameters} options.parameters - The parameters for the comparison.
+   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+   * @param {string} options.parameters.recordingDisplayType - The type of display being recorded.
+   * @param {boolean} options.parameters.recordingVideoOptimized - Whether the recording is optimized for video.
+   * @param {ScreenState[]} options.parameters.screenStates - The current screen states.
+   * @param {ScreenState[]} options.parameters.prevScreenStates - The previous screen states.
+   * @param {string[]} options.parameters.activeNames - The active names in the current context.
+   * @param {Function} options.parameters.trigger - Function to trigger actions based on changes.
+   *
+   * @returns {Promise<void>} A promise that resolves when the comparison and any triggered actions are complete.
+   *
+   * @throws Will log an error message if an error occurs during the comparison process.
+   *
+   * @example
+   * const options = {
+   *   restart: false,
+   *   parameters: {
+   *     getUpdatedAllParams: () => { /* Logic to get updated parameters *\/ },
+   *     recordingDisplayType: 'video',
+   *     recordingVideoOptimized: true,
+   *     screenStates: [{ state: 'active' }, { state: 'inactive' }],
+   *     prevScreenStates: [{ state: 'inactive' }, { state: 'active' }],
+   *     activeNames: ['Alice', 'Bob'],
+   *     trigger: async (data) => { /* Logic to handle the trigger *\/ },
+   *   },
+   * };
+   *
+   * await compareScreenStatesService.compareScreenStates(options);
+   * // If any screen state has changed, the trigger function will be called accordingly.
+   */
 export declare class CompareScreenStates {
     /**
      * Compares the current screen states with the previous screen states and triggers actions based on changes.

package/dist/lib/consumers/connect-ips.service.d.ts

@@ -26,6 +26,48 @@ export interface ConnectIpsOptions {
     parameters: ConnectIpsParameters;
 }
 export type ConnectIpsType = (options: ConnectIpsOptions) => Promise<[Record<string, any>[], string[]]>;
+/**
+ * Connects to remote IPs and manages socket connections.
+ *
+ * This method establishes connections to remote IPs for media streaming, handles new pipe producer events,
+ * and manages producer closure events. It updates the necessary state in the application to reflect
+ * the current connections and stream configurations.
+ *
+ * @param {ConnectIpsOptions} options - The options for connecting IPs.
+ * @param {Record<string, any>[]} options.consume_sockets - The array of current socket connections.
+ * @param {string[]} options.remIP - The list of remote IPs to connect to.
+ * @param {string} options.apiUserName - The API username for authentication.
+ * @param {string} [options.apiKey] - The API key for authentication.
+ * @param {string} [options.apiToken] - The API token for authentication.
+ * @param {Function} [options.newProducerMethod] - The method to handle new pipe producer events (default: newPipeProducer).
+ * @param {Function} [options.closedProducerMethod] - The method to handle producer closed events (default: producerClosed).
+ * @param {Function} [options.joinConsumeRoomMethod] - The method to handle joining a consuming room (default: joinConsumeRoom).
+ * @param {ConnectIpsParameters} options.parameters - Additional parameters for the operation.
+ * @param {string[]} options.parameters.roomRecvIPs - The list of IPs that have been received in the room.
+ * @param {Function} options.parameters.updateRoomRecvIPs - Function to update the room received IPs.
+ * @param {Function} options.parameters.updateConsume_sockets - Function to update the consume sockets.
+ *
+ * @returns {Promise<[Record<string, any>[], string[]]>} A promise that resolves to an array containing the updated consume sockets and room received IPs.
+ *
+ * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.
+ *
+ * @example
+ * ```typescript
+ * const result = await connectIps({
+ *   consume_sockets: currentSockets,
+ *   remIP: ['192.168.1.1', '192.168.1.2'],
+ *   apiUserName: 'username',
+ *   apiKey: 'your-api-key',
+ *   apiToken: 'your-api-token',
+ *   parameters: {
+ *     roomRecvIPs: [],
+ *     updateRoomRecvIPs: (ips) => { },
+ *     updateConsume_sockets: (sockets) => { },
+ *     // ...other parameters
+ *   },
+ * });
+ * ```
+ */
 export declare class ConnectIps {
     private socketManagerService;
     private newPipeProducerService;

package/dist/lib/consumers/connect-recv-transport.service.d.ts

@@ -18,6 +18,39 @@ export interface ConnectRecvTransportOptions {
     parameters: ConnectRecvTransportParameters;
 }
 export type ConnectRecvTransportType = (options: ConnectRecvTransportOptions) => Promise<void>;
+/**
+ * Connects the receiving transport to consume media from a remote producer.
+ *
+ * @param {ConnectRecvTransportOptions} options - The options for connecting the receiving transport.
+ * @param {Transport} options.consumerTransport - The transport used for consuming media.
+ * @param {string} options.remoteProducerId - The ID of the remote producer.
+ * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.
+ * @param {Socket} options.nsock - The socket used for communication.
+ * @param {ConnectRecvTransportParameters} options.parameters - The parameters for the connection.
+ *
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ *
+ * @throws Will throw an error if the connection or consumption fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   consumerTransport,
+ *   remoteProducerId: 'producer-id',
+ *   serverConsumerTransportId: 'transport-id',
+ *   nsock: socket,
+ *   parameters: connectRecvTransportOptions,
+ * };
+ *
+ * connectRecvTransport(options)
+ *   .then(() => {
+ *     console.log('Transport connected and consuming media');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting transport:', error);
+ *   });
+ * ```
+ */
 export declare class ConnectRecvTransport {
     /**
      * Connects the receiving transport to consume media from a remote producer.

package/dist/lib/consumers/connect-send-transport-audio.service.d.ts

@@ -11,6 +11,44 @@ export interface ConnectSendTransportAudioOptions {
     parameters: ConnectSendTransportAudioParameters;
 }
 export type ConnectSendTransportAudioType = (options: ConnectSendTransportAudioOptions) => Promise<void>;
+/**
+ * Connects the send transport for audio by producing audio data and updating the audio producer and producer transport objects.
+ *
+ * @param {ConnectSendTransportAudioOptions} options - The parameters for connecting the send transport.
+ * @param {ProducerOptions} options.audioParams - The options for the audio producer.
+ * @param {ConnectSendTransportAudioParameters} options.parameters - The parameters containing the audio producer, producer transport, and update functions.
+ * @param {Producer} options.parameters.audioProducer - The current audio producer.
+ * @param {Transport} options.parameters.producerTransport - The transport used to produce audio data.
+ * @param {Function} options.parameters.updateAudioProducer - Function to update the audio producer.
+ * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the audio transport is successfully connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * ```typescript
+ * const audioParams: ProducerOptions = {
+ *   codec: 'opus',
+ *   // other options
+ * };
+ *
+ * const parameters = {
+ *   audioProducer: null,
+ *   producerTransport: transport,
+ *   updateAudioProducer: (producer) => { console.log(updated) },
+  *   updateProducerTransport: (transport) => { console.log(updated) },
+  * };
+  *
+  * connectSendTransportAudio({ audioParams, parameters })
+  *   .then(() => {
+  *     console.log('Audio transport connected successfully');
+  *   })
+  *   .catch((error) => {
+  *     console.error('Error connecting audio transport:', error);
+  *   });
+  * ```
+  */
 export declare class ConnectSendTransportAudio {
     /**
      * Connects the send transport for audio by producing audio data and updating the audio producer and producer transport objects.

package/dist/lib/consumers/connect-send-transport-screen.service.d.ts

@@ -16,6 +16,46 @@ export interface ConnectSendTransportScreenOptions {
     parameters: ConnectSendTransportScreenParameters;
 }
 export type ConnectSendTransportScreenType = (options: ConnectSendTransportScreenOptions) => Promise<void>;
+/**
+ * Connects and sets up the screen sharing transport for sending video streams.
+ *
+ * @param {ConnectSendTransportScreenOptions} options - The options for connecting the screen transport.
+ * @param {MediaStream} options.stream - The media stream containing the screen video track.
+ * @param {ConnectSendTransportScreenParameters} options.parameters - The parameters required for setting up the transport.
+ * @param {Producer} options.parameters.screenProducer - The screen producer object.
+ * @param {Device} options.parameters.device - The device object containing RTP capabilities.
+ * @param {ProducerOptions} options.parameters.screenParams - The parameters for producing the screen share.
+ * @param {Transport} options.parameters.producerTransport - The transport object used for producing the screen share.
+ * @param {Function} options.parameters.updateScreenProducer - Function to update the screen producer object.
+ * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport object.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to fetch updated device information.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen transport is successfully connected and set up.
+ *
+ * @throws Will throw an error if the connection or setup process fails.
+ *
+ * @example
+ * ```typescript
+ * const stream = await navigator.mediaDevices.getDisplayMedia({ video: true });
+ * const parameters = {
+ *   screenProducer: null,
+ *   device: device, // Assume 'device' is initialized and ready
+ *   screenParams: { codec: 'vp9' },
+ *   producerTransport: transport, // Assume 'transport' is initialized
+ *   updateScreenProducer: (producer) => { console.log(updated) },
+ *   updateProducerTransport: (transport) => { console.log(updated) },
+ *   getUpdatedAllParams: () => {  },
+ * };
+ *
+ * connectSendTransportScreen({ stream, parameters })
+ *   .then(() => {
+ *     console.log('Screen transport connected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting screen transport:', error);
+ *   });
+ * ```
+ */
 export declare class ConnectSendTransportScreen {
     /**
      * Connects and sets up the screen sharing transport for sending video streams.

package/dist/lib/consumers/connect-send-transport-video.service.d.ts

@@ -16,6 +16,50 @@ export interface ConnectSendTransportVideoOptions {
     parameters: ConnectSendTransportVideoParameters;
 }
 export type ConnectSendTransportVideoType = (options: ConnectSendTransportVideoOptions) => Promise<void>;
+/**
+ * Connects the send transport for video by producing video data and updates the relevant states.
+ *
+ * @param {ConnectSendTransportVideoOptions} options - The options for connecting the send transport for video.
+ * @param {ProducerOptions} options.videoParams - The parameters for producing video data.
+ * @param {ConnectSendTransportVideoParameters} options.parameters - The parameters for updating the state.
+ * @param {Producer} options.parameters.videoProducer - The video producer instance.
+ * @param {Transport} options.parameters.producerTransport - The transport instance used for producing video.
+ * @param {string} options.parameters.islevel - The connection level.
+ * @param {boolean} options.parameters.updateMainWindow - The state of the main window update.
+ * @param {Function} options.parameters.updateVideoProducer - Function to update the video producer.
+ * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.
+ *
+ * @returns {Promise<void>} A promise that resolves when the send transport for video is connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * ```typescript
+ * const videoParams = {
+ *   codec: 'vp8',
+ *   // Other producer options...
+ * };
+ *
+ * const parameters = {
+ *   videoProducer: null,
+ *   producerTransport: transport, // Assume 'transport' is initialized and ready
+ *   islevel: '1',
+ *   updateMainWindow: false,
+ *   updateVideoProducer: (producer) => { console.log(updated) },
+ *   updateProducerTransport: (transport) => { console.log(updated) },
+ *   updateUpdateMainWindow: (state) => { console.log(updated) },
+ * };
+ *
+ * connectSendTransportVideo({ videoParams, parameters })
+ *   .then(() => {
+ *     console.log('Video transport connected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting video transport:', error);
+ *   });
+ * ```
+ */
 export declare class ConnectSendTransportVideo {
     /**
      * Connects the send transport for video by producing video data and updates the relevant states.

package/dist/lib/consumers/connect-send-transport.service.d.ts

@@ -20,6 +20,60 @@ export interface ConnectSendTransportOptions {
     parameters: ConnectSendTransportParameters;
 }
 export type ConnectSendTransportType = (options: ConnectSendTransportOptions) => Promise<void>;
+/**
+ * Connects the send transport based on the specified option.
+ *
+ * @param {ConnectSendTransportOptions} options - The options for connecting the send transport.
+ * @param {string} options.option - The type of transport to connect ("audio", "video", "screen", or "all").
+ * @param {ConnectSendTransportParameters} options.parameters - The parameters required for connecting the transport.
+ * @param {ProducerOptions} options.parameters.audioParams - The audio parameters.
+ * @param {ProducerOptions} options.parameters.videoParams - The video parameters.
+ * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.
+ * @param {MediaStream} options.parameters.canvasStream - The canvas stream.
+ * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard has ended.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {string} options.parameters.islevel - The level of the screen sharing.
+ * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the audio send transport.
+ * @param {Function} options.parameters.connectSendTransportVideo - Function to connect the video send transport.
+ * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the screen send transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the transport is connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   option: 'audio', // Can be 'audio', 'video', 'screen', or 'all'
+ *   parameters: {
+ *     audioParams: { codec: 'opus' },
+ *     videoParams: { codec: 'vp8' },
+ *     localStreamScreen: null, // Set to your local screen stream
+ *     canvasStream: null, // Set to your canvas stream if using
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: true,
+ *     shared: false,
+ *     islevel: '1',
+ *     connectSendTransportAudio: connectSendTransportAudioFunction,
+ *     connectSendTransportVideo: connectSendTransportVideoFunction,
+ *     connectSendTransportScreen: connectSendTransportScreenFunction,
+ *     updateVideoProducer: () => {},
+ *     updateProducerTransport: () => {},
+ *     updateScreenProducer: () => {},
+ *     updateMainWindow: false,
+ *   },
+ * };
+ *
+ * connectSendTransport(options)
+ *   .then(() => {
+ *     console.log('Transport connected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting transport:', error);
+ *   });
+ * ```
+ */
 export declare class ConnectSendTransport {
     /**
      * Connects the send transport based on the specified option.

package/dist/lib/consumers/consumer-resume.service.d.ts

@@ -65,6 +65,42 @@ export interface ConsumerResumeOptions {
     nsock: Socket;
 }
 export type ConsumerResumeType = (options: ConsumerResumeOptions) => Promise<void>;
+/**
+ * Resumes a consumer, making it ready for use.
+ *
+ * @param {ConsumerResumeOptions} options - The options for resuming the consumer.
+ * @param {MediaStreamTrack} options.track - The media stream track associated with the resumed consumer.
+ * @param {string} options.kind - The type of media ('audio' or 'video') being resumed.
+ * @param {string} options.remoteProducerId - The ID of the remote producer associated with the resumed consumer.
+ * @param {ResumeParams} options.params - Additional parameters related to the resumed consumer.
+ * @param {ConsumerResumeParameters} options.parameters - The parameters object containing various utility functions and state.
+ * @param {Socket} options.nsock - The socket associated with the consumer.
+ * @throws Will throw an error if an issue occurs during the consumer resumption.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   track: mediaStreamTrack, // MediaStreamTrack to be resumed
+ *   remoteProducerId: 'producer-id', // Remote producer ID
+ *   params: {
+ *     id: 'consumer-id',
+ *     producerId: 'producer-id',
+ *     kind: 'audio',
+ *     rtpParameters: {},
+ *   },
+ *   parameters: consumerResumeParameters, // Parameters for the consumer
+ *   nsock: socket, // Socket for communication
+ * };
+ *
+ * consumerResume(options)
+ *   .then(() => {
+ *     console.log('Consumer resumed successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error resuming consumer:', error);
+ *   });
+ * ```
+ */
 export declare class ConsumerResume {
     /**
      * Resumes a consumer, making it ready for use.

package/dist/lib/consumers/control-media.service.d.ts

@@ -15,6 +15,51 @@ export interface ControlMediaOptions {
     roomName: string;
 }
 export type ControlMediaType = (options: ControlMediaOptions) => Promise<void>;
+/**
+ * Controls the media of a participant in a media session if certain conditions are met.
+ *
+ * @param {ControlMediaOptions} options - The options for controlling media.
+ * @param {string} options.participantId - The ID of the participant to control.
+ * @param {string} options.participantName - The name of the participant to control.
+ * @param {'audio' | 'video' | 'screenshare' | 'all'} options.type - The type of media to control.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - List of co-host responsibilities.
+ * @param {Participant[]} options.participants - List of participants in the session.
+ * @param {string} options.member - The current member attempting to control media.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {Function} [options.showAlert] - Optional function to show alerts.
+ * @param {string} options.coHost - The co-host information.
+ * @param {string} options.roomName - The name of the room.
+ *
+ * @returns {Promise<void>} A promise that resolves when the media control operation is complete.
+ *
+ * @throws Will log an error message if the operation fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   participantId: '12345',
+ *   participantName: 'John Doe',
+ *   type: 'audio',
+ *   socket: socketInstance,
+ *   coHostResponsibility: [{ name: 'media', value: true }],
+ *   participants: participantList,
+ *   member: 'currentMember',
+ *   islevel: '2',
+ *   showAlert: showAlertFunction,
+ *   coHost: 'coHostName',
+ *   roomName: 'Room A',
+ * };
+ *
+ * controlMediaService.controlMedia(options)
+ *   .then(() => {
+ *     console.log('Media control action completed');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error controlling media:', error);
+ *   });
+ * ```
+ */
 export declare class ControlMedia {
     /**
      * Controls the media of a participant in a media session if certain conditions are met.