mediasfu-angular 1.0.0 → 1.0.2

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.

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

@@ -20,6 +20,52 @@ export interface CreateSendTransportOptions {
     parameters: CreateSendTransportParameters;
 }
 export type CreateSendTransportType = (options: CreateSendTransportOptions) => Promise<void>;
+/**
+ * Creates a WebRTC send transport and sets up event handlers for the transport.
+ *
+ * @param {CreateSendTransportOptions} options - The options for creating the send transport.
+ * @param {'audio' | 'video' | 'screen' | 'all'} options.option - The type of transport to create.
+ * @param {CreateSendTransportParameters} options.parameters - The parameters required for creating the transport.
+ * @param {string} options.parameters.islevel - Indicates the level of the transport.
+ * @param {string} options.parameters.member - The member name associated with the transport.
+ * @param {Socket} options.parameters.socket - The socket instance for communication.
+ * @param {Device | null} options.parameters.device - The WebRTC device instance.
+ * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport is created.
+ * @param {Transport | null} options.parameters.producerTransport - The producer transport instance.
+ * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.
+ * @param {Function} options.parameters.updateTransportCreated - Function to update the transport creation state.
+ * @param {Function} options.parameters.connectSendTransport - Function to connect the send transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the send transport is created and configured.
+ *
+ * @throws Will throw an error if there is an issue creating the send transport.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   option: 'audio',
+ *   parameters: {
+ *     islevel: '2',
+ *     member: 'currentMember',
+ *     socket: socketInstance,
+ *     device: deviceInstance,
+ *     transportCreated: false,
+ *     producerTransport: null,
+ *     updateProducerTransport: (transport) => { console.log(updated) },
+ *     updateTransportCreated: (state) => { console.log(updated) },
+ *     connectSendTransport: connectSendTransportFunction,
+ *   },
+ * };
+ *
+ * createSendTransportService.createSendTransport(options)
+ *   .then(() => {
+ *     console.log('Send transport created successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error creating send transport:', error);
+ *   });
+ * ```
+ */
 export declare class CreateSendTransport {
     /**
      * Creates a WebRTC send transport and sets up event handlers for the transport.

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

@@ -21,6 +21,56 @@ export interface DisconnectSendTransportAudioOptions {
     parameters: DisconnectSendTransportAudioParameters;
 }
 export type DisconnectSendTransportAudioType = (options: DisconnectSendTransportAudioOptions) => Promise<void>;
+/**
+ * Disconnects the send transport for audio by pausing the audio producer and updating the UI accordingly.
+ *
+ * @param {DisconnectSendTransportAudioOptions} options - The options required to disconnect the send transport for audio.
+ * @param {Object} options.parameters - The parameters required for the disconnection.
+ * @param {Producer | null} options.parameters.audioProducer - The audio producer to be paused.
+ * @param {Socket} options.parameters.socket - The socket connection to notify the server.
+ * @param {boolean} options.parameters.videoAlreadyOn - Flag indicating if the video is already on.
+ * @param {string} options.parameters.islevel - The level of the user.
+ * @param {boolean} options.parameters.lock_screen - Flag indicating if the screen is locked.
+ * @param {boolean} options.parameters.shared - Flag indicating if the screen is shared.
+ * @param {Function} options.parameters.updateMainWindow - Function to update the main window state.
+ * @param {string} options.parameters.hostLabel - The label of the host.
+ * @param {string} options.parameters.roomName - The name of the room.
+ * @param {Function} options.parameters.updateAudioProducer - Function to update the audio producer state.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window update state.
+ * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ *
+ * @returns {Promise<void>} A promise that resolves when the send transport for audio is disconnected.
+ *
+ * @throws Will throw an error if the operation fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   parameters: {
+ *     audioProducer,
+ *     socket,
+ *     videoAlreadyOn: false,
+ *     islevel: '1',
+ *     lock_screen: false,
+ *     shared: false,
+ *     updateMainWindow: false,
+ *     hostLabel: 'Host',
+ *     roomName: 'Room 101',
+ *     updateAudioProducer: (producer) => { console.log(updated) },
+ *     updateUpdateMainWindow: (state) => { console.log(updated) },
+ *     prepopulateUserMedia: async ({ name, parameters }) => { },
+ *   },
+ * };
+ *
+ * disconnectSendTransportAudioService.disconnectSendTransportAudio(options)
+ *   .then(() => {
+ *     console.log('Audio transport disconnected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error disconnecting audio transport:', error);
+ *   });
+ * ```
+ */
 export declare class DisconnectSendTransportAudio {
     /**
      * Disconnects the send transport for audio by pausing the audio producer and updating the UI accordingly.

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

@@ -13,6 +13,45 @@ export interface DisconnectSendTransportScreenOptions {
     parameters: DisconnectSendTransportScreenParameters;
 }
 export type DisconnectSendTransportScreenType = (options: DisconnectSendTransportScreenOptions) => Promise<void>;
+/**
+ * Disconnects the send transport for screen sharing.
+ *
+ * This function closes the screen producer, updates the state, and notifies the server
+ * about the closure and pausing of screen sharing.
+ *
+ * @param {DisconnectSendTransportScreenOptions} options - The options for disconnecting the send transport.
+ * @param {Object} options.parameters - The parameters required for disconnection.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {Producer | null} options.parameters.screenProducer - The screen producer to be closed.
+ * @param {Socket} options.parameters.socket - The socket connection to notify the server.
+ * @param {string} options.parameters.roomName - The name of the room.
+ * @param {Function} options.parameters.updateScreenProducer - Function to update the screen producer state.
+ *
+ * @returns {Promise<void>} A promise that resolves when the disconnection process is complete.
+ *
+ * @throws {Error} If an error occurs during the disconnection process.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   parameters: {
+ *     screenProducer,
+ *     socket,
+ *     roomName: 'Room 101',
+ *     updateScreenProducer: (producer) => { console.log(updated) },
+ *     getUpdatedAllParams: () => ({}),
+ *   },
+ * };
+ *
+ * disconnectSendTransportScreenService.disconnectSendTransportScreen(options)
+ *   .then(() => {
+ *     console.log('Screen transport disconnected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error disconnecting screen transport:', error);
+ *   });
+ * ```
+ */
 export declare class DisconnectSendTransportScreen {
     /**
      * Disconnects the send transport for screen sharing.

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

@@ -18,6 +18,51 @@ export interface DisconnectSendTransportVideoOptions {
     parameters: DisconnectSendTransportVideoParameters;
 }
 export type DisconnectSendTransportVideoType = (options: DisconnectSendTransportVideoOptions) => Promise<void>;
+/**
+ * Disconnects the send transport for video, closes the video producer, and updates the state.
+ *
+ * @param {DisconnectSendTransportVideoOptions} options - The options required for disconnecting the send transport.
+ * @param {Object} options.parameters - The parameters for the disconnection.
+ * @param {Producer} options.parameters.videoProducer - The video producer to be closed.
+ * @param {Socket} options.parameters.socket - The socket instance for communication.
+ * @param {string} options.parameters.islevel - The participant's level.
+ * @param {string} options.parameters.roomName - The name of the room.
+ * @param {boolean} options.parameters.lock_screen - Flag indicating if the screen is locked.
+ * @param {boolean} options.parameters.updateMainWindow - Flag to update the main window.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.
+ * @param {Function} options.parameters.updateVideoProducer - Function to update the video producer state.
+ * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
+ *
+ * @returns {Promise<void>} A promise that resolves when the disconnection process is complete.
+ *
+ * @throws {Error} Throws an error if the disconnection process fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   parameters: {
+ *     videoProducer,
+ *     socket,
+ *     islevel: '1',
+ *     roomName: 'Room 101',
+ *     lock_screen: false,
+ *     updateMainWindow: false,
+ *     updateUpdateMainWindow: (state) => { console.log(updated) },
+ *     updateVideoProducer: (producer) => { console.log(updated) },
+ *     reorderStreams: (params) => { },
+ *     getUpdatedAllParams: () => ({}),
+ *   },
+ * };
+ *
+ * disconnectSendTransportVideoService.disconnectSendTransportVideo(options)
+ *   .then(() => {
+ *     console.log('Video transport disconnected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error disconnecting video transport:', error);
+ *   });
+ * ```
+ */
 export declare class DisconnectSendTransportVideo {
     /**
      * Disconnects the send transport for video, closes the video producer, and updates the state.

package/dist/lib/consumers/disp-streams.service.d.ts

@@ -68,6 +68,98 @@ export interface DispStreamsOptions {
     inBreakRoom?: boolean;
 }
 export type DispStreamsType = (options: DispStreamsOptions) => Promise<void>;
+/**
+ * Function to display streams based on various parameters and conditions.
+ *
+ * @param {DispStreamsOptions} options - The options object.
+ * @param {Array<(Stream | Participant)>} options.lStreams - List of streams to display.
+ * @param {number} options.ind - Index of the current stream.
+ * @param {boolean} [options.auto=false] - Flag to indicate if the function should run automatically.
+ * @param {boolean} [options.ChatSkip=false] - Flag to indicate if chat should be skipped.
+ * @param {string|null} [options.forChatID=null] - ID for chat reference.
+ * @param {DispStreamsParameters} options.parameters - Parameters object containing various settings and functions.
+ * @param {number} [options.breakRoom=-1] - Break room number.
+ * @param {boolean} [options.inBreakRoom=false] - Flag to indicate if in break room.
+ *
+ * @returns {Promise<void>} A promise that resolves when the function completes.
+ *
+ * @async
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   lStreams: [...], // Your streams data here
+ *   ind: 0,
+ *   auto: true,
+ *   ChatSkip: false,
+ *   parameters: {
+ *     consumerTransports: [],
+ *     streamNames: [],
+ *     audStreamNames: [],
+ *     participants: [],
+ *     ref_participants: [],
+ *     recordingDisplayType: 'video',
+ *     recordingVideoOptimized: false,
+ *     meetingDisplayType: 'video',
+ *     meetingVideoOptimized: false,
+ *     currentUserPage: 1,
+ *     hostLabel: 'Host',
+ *     mainHeightWidth: 100,
+ *     prevMainHeightWidth: 100,
+ *     prevDoPaginate: false,
+ *     doPaginate: false,
+ *     firstAll: false,
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     shareEnded: false,
+ *     oldAllStreams: [],
+ *     updateMainWindow: false,
+ *     remoteProducerId: null,
+ *     activeNames: [],
+ *     dispActiveNames: [],
+ *     p_dispActiveNames: [],
+ *     nForReadjustRecord: 0,
+ *     first_round: false,
+ *     lock_screen: false,
+ *     chatRefStreams: [],
+ *     eventType: 'normal',
+ *     islevel: '1',
+ *     localStreamVideo: null,
+ *     breakOutRoomStarted: false,
+ *     breakOutRoomEnded: false,
+ *     keepBackground: false,
+ *     virtualStream: null,
+ *     updateActiveNames: (names) => {},
+ *     updateDispActiveNames: (names) => {},
+ *     updateLStreams: (streams) => {},
+ *     updateChatRefStreams: (streams) => {},
+ *     updateNForReadjustRecord: (n) => {},
+ *     updateUpdateMainWindow: (value) => {},
+ *     updateShowMiniView: (value) => {},
+ *     prepopulateUserMedia: async () => {},
+ *     rePort: async () => {},
+ *     processConsumerTransports: async () => {},
+ *     resumePauseStreams: async () => {},
+ *     readjust: async () => {},
+ *     addVideosGrid: async () => {},
+ *     getEstimate: async () => {},
+ *     checkGrid: async () => {},
+ *     resumePauseAudioStreams: async () => {},
+ *     getUpdatedAllParams: () => options.parameters,
+ *   },
+ *   breakRoom: -1,
+ *   inBreakRoom: false,
+ * };
+ *
+ * dispStreamsService.dispStreams(options)
+ *   .then(() => {
+ *     console.log('Streams displayed successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error displaying streams:', error);
+ *   });
+ * ```
+ */
 export declare class DispStreams {
     /**
      * Function to display streams based on various parameters and conditions.

package/dist/lib/consumers/generate-page-content.service.d.ts

@@ -17,6 +17,53 @@ export interface GeneratePageContentOptions {
     inBreakRoom?: boolean;
 }
 export type GeneratePageContentType = (options: GeneratePageContentOptions) => Promise<void>;
+/**
+ * Generates the content for a specific page.
+ *
+ * @param {GeneratePageContentOptions} options - The options for generating page content.
+ * @param {number | string} options.page - The page number to generate content for.
+ * @param {GeneratePageContentParameters} options.parameters - The parameters required for generating content.
+ * @param {Array<(Participant | Stream)[]>} options.parameters.paginatedStreams - The streams to be paginated.
+ * @param {number} options.parameters.currentUserPage - The current page of the user.
+ * @param {Function} options.parameters.updateMainWindow - Function to update the main window flag.
+ * @param {Function} options.parameters.updateCurrentUserPage - Function to update the current user page.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window update flag.
+ * @param {Function} options.parameters.dispStreams - Function to display streams for the specified page.
+ * @param {number} [options.breakRoom=-1] - The break room identifier.
+ * @param {boolean} [options.inBreakRoom=false] - Flag indicating if the user is in a break room.
+ *
+ * @returns {Promise<void>} A promise that resolves when the content generation is complete.
+ *
+ * @throws {Error} Throws an error if content generation fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   page: 1,
+ *   parameters: {
+ *     paginatedStreams: [
+ *       // Page 0 streams
+ *       [stream1, stream2],
+ *       // Page 1 streams
+ *       [stream3, stream4],
+ *     ],
+ *     currentUserPage: 0,
+ *     updateMainWindow: false,
+ *     updateCurrentUserPage: (page) => { console.log(`Current page updated to: ${page}`); },
+ *     updateUpdateMainWindow: (flag) => { console.log(`Main window update flag: ${flag}`); },
+ *     dispStreams: async ({ lStreams, ind }) => {
+ *       console.log(`Displaying streams for page ${ind}:`, lStreams);
+ *     },
+ *     getUpdatedAllParams: () => options.parameters,
+ *   },
+ *   breakRoom: -1,
+ *   inBreakRoom: false,
+ * };
+ *
+ * const generatePageContentService = new GeneratePageContent();
+ * await generatePageContentService.generatePageContent(options);
+ * ```
+ */
 export declare class GeneratePageContent {
     /**
      * Generates the content for a specific page.