mediasfu-angular 1.0.1 → 2.0.0

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.

package/dist/lib/consumers/get-estimate.service.d.ts

@@ -18,6 +18,56 @@ export interface GetEstimateOptions {
     parameters: GetEstimateParameters;
 }
 export type GetEstimateType = (options: GetEstimateOptions) => [number, number, number];
+/**
+ * Estimates the number of rows and columns for a given set of parameters.
+ *
+ * @param {GetEstimateOptions} options - The options for the estimation.
+ * @param {number} options.n - The number of items to estimate for.
+ * @param {GetEstimateParameters} options.parameters - The parameters for the estimation.
+ * @param {number} options.parameters.fixedPageLimit - The fixed page limit.
+ * @param {number} options.parameters.screenPageLimit - The screen page limit.
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {boolean} [options.parameters.shared=false] - Indicates if sharing is active.
+ * @param {EventType} options.parameters.eventType - The type of event (e.g., "chat", "conference").
+ * @param {boolean} options.parameters.removeAltGrid - Indicates if the alternate grid should be removed.
+ * @param {boolean} options.parameters.isWideScreen - Indicates if the screen is wide.
+ * @param {boolean} options.parameters.isMediumScreen - Indicates if the screen is medium-sized.
+ * @param {Function} options.parameters.updateRemoveAltGrid - Function to update the removeAltGrid parameter.
+ * @param {CalculateRowsAndColumnsType} options.parameters.calculateRowsAndColumns - Function to calculate rows and columns.
+ *
+ * @returns {[number, number, number]} An array containing:
+ * - Estimated number of items,
+ * - Estimated number of rows,
+ * - Estimated number of columns.
+ *
+ * @throws Will log an error message if an error occurs during estimation.
+ *
+ * @example
+ * ```typescript
+ * const estimateOptions = {
+ *   n: 20,
+ *   parameters: {
+ *     fixedPageLimit: 10,
+ *     screenPageLimit: 15,
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     eventType: 'conference',
+ *     removeAltGrid: false,
+ *     isWideScreen: true,
+ *     isMediumScreen: false,
+ *     updateRemoveAltGrid: (value) => console.log(`Remove Alt Grid: ${value}`),
+ *     calculateRowsAndColumns: ({ n }) => {
+ *       const sqrt = Math.sqrt(n);
+ *       return [Math.ceil(sqrt), Math.floor(sqrt)];
+ *     },
+ *   },
+ * };
+ *
+ * const estimateService = new GetEstimate();
+ * const [estimatedItems, estimatedRows, estimatedCols] = estimateService.getEstimate(estimateOptions);
+ * console.log(`Estimated Items: ${estimatedItems}, Rows: ${estimatedRows}, Columns: ${estimatedCols}`);
+ * ```
+ */
 export declare class GetEstimate {
     /**
      * Estimates the number of rows and columns for a given set of parameters.

package/dist/lib/consumers/get-piped-producers-alt.service.d.ts

@@ -7,16 +7,53 @@ export interface GetPipedProducersAltParameters extends SignalNewConsumerTranspo
     [key: string]: any;
 }
 export interface GetPipedProducersAltOptions {
+    community?: boolean;
     nsock: Socket;
     islevel: string;
     parameters: GetPipedProducersAltParameters;
 }
 export type GetPipedProducersAltType = (options: GetPipedProducersAltOptions) => Promise<void>;
+/**
+ * Retrieves piped producers and signals new consumer transport for each retrieved producer.
+ *
+ * @param {GetPipedProducersAltOptions} options - The options for retrieving piped producers.
+ * @param {boolean} options.community - Whether the room is a community edition room.
+ * @param {Socket} options.nsock - The WebSocket instance used for communication.
+ * @param {string} options.islevel - A flag indicating the level of the request.
+ * @param {GetPipedProducersAltParameters} options.parameters - Additional parameters for the request.
+ * @param {string} options.parameters.member - The member identifier.
+ * @param {SignalNewConsumerTransportType} options.parameters.signalNewConsumerTransport - A function to signal new consumer transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @throws {Error} If an error occurs during the process of retrieving producers.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   community: true,
+ *   nsock: socketInstance,
+ *   islevel: '2',
+ *   parameters: {
+ *     member: 'user123',
+ *     signalNewConsumerTransport: async ({ nsock, remoteProducerId, islevel, parameters }) => {
+ *       // Implementation to signal new consumer transport
+ *       console.log(`Signaling new consumer transport for producer: ${remoteProducerId}`);
+ *     },
+ *   },
+ * };
+ *
+ * const getPipedProducersService = new GetPipedProducersAlt();
+ * await getPipedProducersService.getPipedProducersAlt(options);
+ * console.log('Piped producers retrieved successfully.');
+ * ```
+ */
 export declare class GetPipedProducersAlt {
     /**
      * Retrieves piped producers and signals new consumer transport for each retrieved producer.
      *
      * @param {Object} options - The options for retrieving piped producers.
+     * @param {boolean} options.community - Whether the room is a community edition room.
      * @param {WebSocket} options.nsock - The WebSocket instance used for communication.
      * @param {boolean} options.islevel - A flag indicating the level of the request.
      * @param {Object} options.parameters - Additional parameters for the request.
@@ -27,7 +64,7 @@ export declare class GetPipedProducersAlt {
      *
      * @throws {Error} If an error occurs during the process of retrieving producers.
      */
-    getPipedProducersAlt({ nsock, islevel, parameters, }: GetPipedProducersAltOptions): Promise<void>;
+    getPipedProducersAlt({ community, nsock, islevel, parameters, }: GetPipedProducersAltOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<GetPipedProducersAlt, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GetPipedProducersAlt>;
 }

package/dist/lib/consumers/get-producers-piped.service.d.ts

@@ -12,6 +12,39 @@ export interface GetProducersPipedOptions {
     parameters: GetProducersPipedParameters;
 }
 export type GetProducersPipedType = (options: GetProducersPipedOptions) => Promise<void>;
+/**
+ * Retrieves piped producers and signals new consumer transport for each retrieved producer.
+ *
+ * @param {GetProducersPipedOptions} options - The options for getting piped producers.
+ * @param {Socket} options.nsock - The WebSocket instance used for communication.
+ * @param {string} options.islevel - A flag indicating the level of the operation.
+ * @param {GetProducersPipedParameters} options.parameters - Additional parameters for the operation.
+ * @param {string} options.parameters.member - The member identifier.
+ * @param {SignalNewConsumerTransportType} options.parameters.signalNewConsumerTransport - The function to signal new consumer transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @throws {Error} If an error occurs during the process of retrieving producers.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   nsock: socketInstance,
+ *   islevel: '2',
+ *   parameters: {
+ *     member: 'user123',
+ *     signalNewConsumerTransport: async ({ remoteProducerId, islevel, nsock, parameters }) => {
+ *       // Implementation to signal new consumer transport
+ *       console.log(`Signaling new consumer transport for producer: ${remoteProducerId}`);
+ *     },
+ *   },
+ * };
+ *
+ * const getProducersPipedService = new GetProducersPiped();
+ * await getProducersPipedService.getProducersPiped(options);
+ * console.log('Piped producers retrieved successfully.');
+ * ```
+ */
 export declare class GetProducersPiped {
     /**
      * Retrieves piped producers and signals new consumer transport for each retrieved producer.

package/dist/lib/consumers/get-videos.service.d.ts

@@ -9,6 +9,39 @@ export interface GetVideosOptions {
     updateOldAllStreams: (streams: (Stream | Participant)[]) => void;
 }
 export type GetVideosType = (options: GetVideosOptions) => Promise<void>;
+/**
+ * Asynchronously processes and updates video streams by filtering out the admin's video stream.
+ *
+ * @param {GetVideosOptions} options - The options for getting videos.
+ * @param {Participant[]} options.participants - The list of participants.
+ * @param {Stream[]} options.allVideoStreams - The list of all video streams.
+ * @param {(Stream | Participant)[]} options.oldAllStreams - The list of old video streams.
+ * @param {string} [options.adminVidID] - The ID of the admin's video stream.
+ * @param {Function} options.updateAllVideoStreams - Function to update the state variable for all video streams.
+ * @param {Function} options.updateOldAllStreams - Function to update the state variable for old video streams.
+ * @returns {Promise<void>} A promise that resolves when the video streams have been processed and updated.
+ *
+ * @throws {Error} If an error occurs during the process of updating video streams.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   participants: participantList,
+ *   allVideoStreams: currentVideoStreams,
+ *   oldAllStreams: previousVideoStreams,
+ *   updateAllVideoStreams: (streams) => {
+ *     console.log('Updated all video streams:', streams);
+ *   },
+ *   updateOldAllStreams: (streams) => {
+ *     console.log('Updated old video streams:', streams);
+ *   },
+ * };
+ *
+ * const getVideosService = new GetVideos();
+ * await getVideosService.getVideos(options);
+ * console.log('Video streams processed successfully.');
+ * ```
+ */
 export declare class GetVideos {
     /**
      * Asynchronously processes and updates video streams by filtering out the admin's video stream.

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

@@ -6,6 +6,28 @@ export interface MixStreamsOptions {
     ref_participants: (Stream | Participant)[];
 }
 export type MixStreamsType = (options: MixStreamsOptions) => Promise<(Stream | Participant)[]>;
+/**
+ * Mixes video and audio streams and participants based on specified parameters.
+ *
+ * @param {MixStreamsOptions} options - The options for mixing streams.
+ * @param {Array<Stream | Participant>} options.alVideoStreams - The list of audio and video streams to mix.
+ * @param {Array<Participant>} options.non_alVideoStreams - The list of non-audio and video streams to mix.
+ * @param {Array<Stream | Participant>} options.ref_participants - The list of reference participants to mix.
+ * @returns {Promise<Array<Stream | Participant>>} A promise that resolves with the mixed streams.
+ *
+ * @throws Will throw an error if there is an issue mixing the streams.
+ *
+ * @example
+ * ```typescript
+ * const mixedStreams = await mixStreams({
+ *   alVideoStreams: [stream1, stream2],
+ *   non_alVideoStreams: [participant1, participant2],
+ *   ref_participants: [participant1, participant2],
+ * });
+ *
+ * console.log('Mixed streams:', mixedStreams);
+ * ```
+ */
 export declare class MixStreams {
     /**
      * Mixes video and audio streams and participants based on specified parameters.

package/dist/lib/consumers/on-screen-changes.service.d.ts

@@ -17,6 +17,46 @@ export interface OnScreenChangesOptions {
     parameters: OnScreenChangesParameters;
 }
 export type OnScreenChangesType = (options: OnScreenChangesOptions) => Promise<void>;
+/**
+ * Handles changes in screen events such as broadcast, chat, and conference.
+ *
+ * @param {OnScreenChangesOptions} options - The options for handling screen changes.
+ * @param {boolean} [options.changed=false] - Indicates if the screen has changed.
+ * @param {OnScreenChangesParameters} options.parameters - The parameters for handling screen changes.
+ * @param {string} options.parameters.eventType - The type of event (e.g., "broadcast", "chat", "conference").
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {boolean} options.parameters.addForBasic - Flag to add basic controls.
+ * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+ * @param {Function} options.parameters.updateAddForBasic - Function to update the addForBasic flag.
+ * @param {number} options.parameters.itemPageLimit - The limit for item pages.
+ * @param {Function} options.parameters.updateItemPageLimit - Function to update the item page limit.
+ * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen changes have been handled.
+ *
+ * @throws {Error} Throws an error if there is an issue handling screen changes.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   changed: true,
+ *   parameters: {
+ *     eventType: 'broadcast',
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     addForBasic: false,
+ *     updateMainHeightWidth: (value) => { console.log(updated) },
+ *     updateAddForBasic: (value) => { console.log(updated) },
+ *     itemPageLimit: 1,
+ *     updateItemPageLimit: (value) => { console.log(updated) },
+ *     reorderStreams: async (params) => { },
+ *   },
+ * };
+ *
+ * await onScreenChanges(options);
+ * ```
+ */
 export declare class OnScreenChanges {
     /**
      * Handles changes in screen events such as broadcast, chat, and conference.

package/dist/lib/consumers/prepopulate-user-media.service.d.ts

@@ -51,6 +51,105 @@ export type PrepopulateUserMediaType = (options: {
     component: any;
     inputs: any;
 }[] | void>;
+/**
+ * Prepopulates the user media based on the provided options.
+ *
+ * This method prepares the UI components for the user's media based on the event type and participant information.
+ * It manages the display of video and audio cards, mini cards, and handles screen sharing scenarios.
+ *
+ * @param {PrepopulateUserMediaOptions} options - The options for prepopulating user media.
+ * @param {string} options.name - The name of the user.
+ * @param {PrepopulateUserMediaParameters} options.parameters - The parameters for prepopulating user media.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {Array<Participant>} options.parameters.participants - List of participants.
+ * @param {Array<Stream>} options.parameters.allVideoStreams - List of all video streams.
+ * @param {string} options.parameters.islevel - The level of the user.
+ * @param {string} options.parameters.member - The member name.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {string} options.parameters.eventType - The type of event (e.g., "broadcast", "chat", "conference").
+ * @param {string} options.parameters.screenId - The ID of the screen.
+ * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.
+ * @param {Function} options.parameters.updateMainWindow - Function to update the main window.
+ * @param {boolean} options.parameters.mainScreenFilled - Indicates if the main screen is filled.
+ * @param {boolean} options.parameters.adminOnMainScreen - Indicates if admin is on the main screen.
+ * @param {string} options.parameters.mainScreenPerson - The person on the main screen.
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.
+ * @param {boolean} options.parameters.audioAlreadyOn - Indicates if the audio is already on.
+ * @param {Array<Stream>} options.parameters.oldAllStreams - List of old all streams.
+ * @param {Function} options.parameters.checkOrientation - Function to check orientation.
+ * @param {boolean} options.parameters.screenForceFullDisplay - Indicates if screen force full display is enabled.
+ * @param {Stream} options.parameters.localStreamScreen - The local screen stream.
+ * @param {Array<Stream>} options.parameters.remoteScreenStream - List of remote screen streams.
+ * @param {Stream} options.parameters.localStreamVideo - The local video stream.
+ * @param {number} options.parameters.mainHeightWidth - The main height and width.
+ * @param {boolean} options.parameters.isWideScreen - Indicates if the screen is wide.
+ * @param {boolean} options.parameters.localUIMode - Indicates if local UI mode is enabled.
+ * @param {boolean} options.parameters.whiteboardStarted - Indicates if whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Indicates if whiteboard has ended.
+ * @param {Stream} options.parameters.virtualStream - The virtual stream.
+ * @param {boolean} options.parameters.keepBackground - Indicates if background should be kept.
+ * @param {Stream} options.parameters.annotateScreenStream - The annotate screen stream.
+ * @param {Function} options.parameters.updateMainScreenPerson - Function to update the main screen person.
+ * @param {Function} options.parameters.updateMainScreenFilled - Function to update if the main screen is filled.
+ * @param {Function} options.parameters.updateAdminOnMainScreen - Function to update if admin is on the main screen.
+ * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+ * @param {Function} options.parameters.updateScreenForceFullDisplay - Function to update screen force full display.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window update status.
+ * @param {Function} options.parameters.updateMainGridStream - Function to update the main grid stream.
+ *
+ * @returns {Promise<{ component: any; inputs: any }[] | void>} A promise that resolves with the components and inputs or void.
+ *
+ * @throws {Error} Throws an error if there is an issue preparing and populating the main screen.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   name: 'John Doe',
+ *   parameters: {
+ *     getUpdatedAllParams: () => { },
+ *     participants: [],
+ *     allVideoStreams: [],
+ *     islevel: '1',
+ *     member: 'John',
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     eventType: 'conference',
+ *     screenId: 'screen123',
+ *     forceFullDisplay: false,
+ *     updateMainWindow: false,
+ *     mainScreenFilled: false,
+ *     adminOnMainScreen: false,
+ *     mainScreenPerson: '',
+ *     videoAlreadyOn: false,
+ *     audioAlreadyOn: false,
+ *     oldAllStreams: [],
+ *     checkOrientation: () => 'landscape',
+ *     screenForceFullDisplay: false,
+ *     localStreamScreen: null,
+ *     remoteScreenStream: [],
+ *     localStreamVideo: null,
+ *     mainHeightWidth: 100,
+ *     isWideScreen: true,
+ *     localUIMode: false,
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: false,
+ *     virtualStream: null,
+ *     keepBackground: false,
+ *     annotateScreenStream: false,
+ *     updateMainScreenPerson: (person) => { console.log(updated) },
+ *     updateMainScreenFilled: (filled) => { console.log(updated) },
+ *     updateAdminOnMainScreen: (admin) => { console.log(updated) },
+ *     updateMainHeightWidth: (heightWidth) => { console.log(updated) },
+ *     updateScreenForceFullDisplay: (force) => { console.log(updated) },
+ *     updateUpdateMainWindow: (update) => { console.log(updated) },
+ *     updateMainGridStream: (components) => { console.log(updated) },
+ *   },
+ * };
+ *
+ * await prepopulateUserMedia(options);
+ * ```
+ */
 export declare class PrepopulateUserMedia {
     /**
      * Prepopulates the user media based on the provided options.

package/dist/lib/consumers/process-consumer-transports-audio.service.d.ts

@@ -10,6 +10,35 @@ export interface ProcessConsumerTransportsAudioOptions {
     parameters: ProcessConsumerTransportsAudioParameters;
 }
 export type ProcessConsumerTransportsAudioType = (options: ProcessConsumerTransportsAudioOptions) => Promise<void>;
+/**
+ * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.
+ *
+ * This method checks the state of each audio consumer transport and either pauses or resumes it depending on the presence of its producer ID in the provided list of streams.
+ * It uses a sleep function to introduce a delay between the pause and resume operations to ensure smooth transitions.
+ *
+ * @param {ProcessConsumerTransportsAudioOptions} options - The options for processing consumer transports.
+ * @param {Array<Transport>} options.consumerTransports - The list of consumer transports to process.
+ * @param {Array<(Stream | Participant)>} options.lStreams - The list of local streams to check against.
+ * @param {ProcessConsumerTransportsAudioParameters} options.parameters - Additional parameters for processing.
+ * @param {Function} options.parameters.sleep - A function to pause execution for a specified duration.
+ *
+ * @returns {Promise<void>} A promise that resolves when the processing is complete.
+ *
+ * @throws {Error} Will throw an error if there is an issue processing the consumer transports.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   consumerTransports: [,
+ *   lStreams: [],
+ *   parameters: {
+ *     sleep: async ({ ms }) => new Promise(resolve => setTimeout(resolve, ms)),
+ *   },
+ * };
+ *
+ * await processConsumerTransportsAudio(options);
+ * ```
+ */
 export declare class ProcessConsumerTransportsAudio {
     /**
      * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.

package/dist/lib/consumers/process-consumer-transports.service.d.ts

@@ -14,6 +14,43 @@ export interface ProcessConsumerTransportsOptions {
     parameters: ProcessConsumerTransportsParameters;
 }
 export type ProcessConsumerTransportsType = (options: ProcessConsumerTransportsOptions) => Promise<void>;
+/**
+ * Processes consumer transports by pausing and resuming them based on certain conditions.
+ *
+ * This method checks the state of each consumer transport and determines whether to pause or resume
+ * based on the validity of the producer ID in relation to the provided streams.
+ * It utilizes a sleep function to introduce a delay before pausing the transports.
+ *
+ * @param {ProcessConsumerTransportsOptions} options - The options for processing consumer transports.
+ * @param {Array<Transport>} options.consumerTransports - The list of consumer transports to process.
+ * @param {Array<Stream | Participant>} options.lStreams_ - The list of local streams.
+ * @param {ProcessConsumerTransportsParameters} options.parameters - The parameters for processing, including:
+ *   - {Array<Stream>} options.parameters.remoteScreenStream - The list of remote screen streams.
+ *   - {Array<Stream | Participant>} options.parameters.oldAllStreams - The list of old streams.
+ *   - {Array<Stream | Participant>} options.parameters.newLimitedStreams - The list of new limited streams.
+ *   - {Function} options.parameters.sleep - A function to pause execution for a specified duration.
+ *   - {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ *
+ * @returns {Promise<void>} A promise that resolves when the processing is complete.
+ *
+ * @throws {Error} Will throw an error if there is an issue processing consumer transports.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   consumerTransports: [],
+ *   lStreams_: [],
+ *   parameters: {
+ *     remoteScreenStream: [],
+ *     oldAllStreams: [],
+ *     newLimitedStreams: [],
+ *     sleep: async ({ ms }) => new Promise(resolve => setTimeout(resolve, ms)),
+ *   },
+ * };
+ *
+ * await processConsumerTransports(options);
+ * ```
+ */
 export declare class ProcessConsumerTransports {
     /**
      * Processes consumer transports by pausing and resuming them based on certain conditions.

package/dist/lib/consumers/re-port.service.d.ts

@@ -23,6 +23,54 @@ export interface RePortOptions {
     parameters: RePortParameters;
 }
 export type RePortType = (options: RePortOptions) => Promise<void>;
+/**
+ * RePort function that handles the reporting logic based on the provided parameters.
+ *
+ * This method checks the current state of the recording process and updates the screen states
+ * accordingly. It also compares active names and screen states based on the provided parameters.
+ *
+ * @param {RePortOptions} options - The options for the rePort function.
+ * @param {boolean} [options.restart=false] - Flag indicating whether to restart the process.
+ * @param {RePortParameters} options.parameters - The parameters object containing various states and functions.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {string} options.parameters.islevel - The current level of the process.
+ * @param {string} options.parameters.mainScreenPerson - The person on the main screen.
+ * @param {boolean} options.parameters.adminOnMainScreen - Flag indicating if admin is on the main screen.
+ * @param {boolean} options.parameters.mainScreenFilled - Flag indicating if the main screen is filled.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if recording has stopped.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.
+ * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.
+ * @param {Array<ScreenState>} options.parameters.screenStates - Array of current screen states.
+ * @param {Function} options.parameters.updateScreenStates - Function to update the current screen states.
+ * @param {Function} options.parameters.updatePrevScreenStates - Function to update the previous screen states.
+ * @param {Function} options.parameters.compareActiveNames - Function to compare active names.
+ * @param {Function} options.parameters.compareScreenStates - Function to compare screen states.
+ *
+ * @returns {Promise<void>} A promise that resolves when the reporting process is complete.
+ *
+ * @throws {Error} Throws an error if there is an issue during the reporting process.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   restart: false,
+ *   parameters: {
+ *     islevel: '1',
+ *     mainScreenPerson: 'John Doe',
+ *     adminOnMainScreen: false,
+ *     mainScreenFilled: true,
+ *     recordStarted: true,
+ *     screenStates: [],
+ *     updateScreenStates: (states) => { console.log(updated) },
+ *     compareActiveNames: async (opts) => {  },
+ *     compareScreenStates: async (opts) => {  },
+ *   },
+ * };
+ *
+ * await rePort(options);
+ * ```
+ */
 export declare class RePort {
     /**
      * RePort function that handles the reporting logic based on the provided parameters.