mediasfu-angular 2.2.2 → 2.2.4

package/dist/lib/components/whiteboard-components/whiteboard/whiteboard.component.d.ts

@@ -424,22 +424,10 @@ export declare class Whiteboard implements OnInit, OnDestroy, OnChanges {
     undo(): void;
     redo(): void;
     saveState(): void;
-    findShape(x: number, y: number): Shape | undefined;
+    findShape(x: number, y: number): Shape;
     drawSelection(shape: any): void;
-    getResizeHandles(shape: any): ({
-        isCenter: boolean;
-        x: any;
-        y: any;
-    } | {
-        isCenter: boolean;
-        x: any;
-        y: any;
-    })[];
-    getHandleAtPosition(x: number, y: number): {
-        isCenter: boolean;
-        x: any;
-        y: any;
-    } | null | undefined;
+    getResizeHandles(shape: any): any[];
+    getHandleAtPosition(x: number, y: number): any;
     resizeShape(shape: any, handle: any, x: number, y: number): void;
     moveShape(shape: any, dx: number, dy: number): void;
     downloadCanvas(tempCanvas: HTMLCanvasElement): void;

package/dist/lib/consumers/auto-adjust.service.d.ts

@@ -34,17 +34,6 @@ export type AutoAdjustType = (options: AutoAdjustOptions) => Promise<number[]>;
  * ```
  */
 export declare class AutoAdjust {
-    /**
-     * Adjusts values based on the provided options.
-     *
-     * @param {AutoAdjustOptions} options - The options for auto adjustment.
-     * @param {number} options.n - The number of participants.
-     * @param {string} options.eventType - The type of event (e.g., 'broadcast', 'chat', 'conference').
-     * @param {boolean} options.shareScreenStarted - Indicates if screen sharing has started.
-     * @param {boolean} options.shared - Indicates if something is shared.
-     *
-     * @returns {Promise<number[]>} A promise that resolves to an array containing the adjusted values.
-     */
     autoAdjust({ n, eventType, shareScreenStarted, shared, }: AutoAdjustOptions): Promise<number[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AutoAdjust, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AutoAdjust>;

package/dist/lib/consumers/calculate-rows-and-columns.service.d.ts

@@ -22,13 +22,6 @@ export type CalculateRowsAndColumnsType = (options: CalculateRowsAndColumnsOptio
  * ```
  */
 export declare class CalculateRowsAndColumns {
-    /**
-     * Calculates the number of rows and columns needed to display a given number of items in a grid.
-     *
-     * @param {CalculateRowsAndColumnsOptions} options - The options for calculating rows and columns.
-     * @param {number} options.n - The number of items to display.
-     * @returns {[number, number]} A tuple containing the number of rows and columns.
-     */
     calculateRowsAndColumns({ n }: CalculateRowsAndColumnsOptions): [number, number];
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateRowsAndColumns, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CalculateRowsAndColumns>;

package/dist/lib/consumers/change-vids.service.d.ts

@@ -196,7 +196,7 @@ export type ChangeVidsType = (options: ChangeVidsOptions) => Promise<void>;
  * ```
  */
 export declare class ChangeVids {
-    changeVids: ({ screenChanged, parameters }: ChangeVidsOptions) => Promise<void>;
+    changeVids({ screenChanged, parameters }: ChangeVidsOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ChangeVids, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ChangeVids>;
 }

package/dist/lib/consumers/check-permission.service.d.ts

@@ -1,3 +1,4 @@
+import { PermissionConfig } from '../methods/permissions-methods/update-permission-config.service';
 import * as i0 from "@angular/core";
 export interface CheckPermissionOptions {
     audioSetting: string;
@@ -5,6 +6,8 @@ export interface CheckPermissionOptions {
     screenshareSetting: string;
     chatSetting: string;
     permissionType: 'audioSetting' | 'videoSetting' | 'screenshareSetting' | 'chatSetting';
+    permissionConfig?: PermissionConfig | null;
+    participantLevel?: string;
 }
 export type CheckPermissionType = (options: CheckPermissionOptions) => Promise<number>;
 /**
@@ -45,7 +48,7 @@ export declare class CheckPermission {
      * @returns {Promise<number>} - Returns 0 if the setting is "allow", 1 if the setting is "approval", and 2 for other settings or invalid permission types.
      * @throws Will throw an error if an unexpected error occurs during the permission check.
      */
-    checkPermission({ permissionType, audioSetting, videoSetting, screenshareSetting, chatSetting, }: CheckPermissionOptions): Promise<number>;
+    checkPermission({ permissionType, audioSetting, videoSetting, screenshareSetting, chatSetting, permissionConfig, participantLevel, }: CheckPermissionOptions): Promise<number>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CheckPermission, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CheckPermission>;
 }

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

@@ -52,24 +52,6 @@ export type CheckScreenShareType = (options: CheckScreenShareOptions) => Promise
  * // 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.
-     *
-     * @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.
-     */
     checkScreenShare: ({ parameters }: CheckScreenShareOptions) => Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CheckScreenShare, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CheckScreenShare>;

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

@@ -46,22 +46,6 @@ export type CompareActiveNamesType = (options: CompareActiveNamesOptions) => Pro
  * // 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.
-     *
-     * @param {Object} options - The options for comparing active names.
-     * @param {boolean} [options.restart=false] - Whether to restart the comparison.
-     * @param {CompareActiveNamesOptions} 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.
-     */
     compareActiveNames({ restart, parameters, }: CompareActiveNamesOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CompareActiveNames, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CompareActiveNames>;

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

@@ -51,24 +51,6 @@ export type CompareScreenStatesType = (options: CompareScreenStatesOptions) => P
    * // 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.
-     *
-     * @param {Object} options - The options for comparing screen states.
-     * @param {boolean} [options.restart=false] - Whether to restart the comparison process.
-     * @param {CompareScreenStatesOptions} 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 {Array<ScreenState>} options.parameters.screenStates - The current screen states.
-     * @param {Array<ScreenState>} options.parameters.prevScreenStates - The previous screen states.
-     * @param {Array<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.
-     */
     compareScreenStates({ restart, parameters, }: CompareScreenStatesOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CompareScreenStates, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CompareScreenStates>;

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

@@ -1,4 +1,3 @@
-import { SocketManager } from '../sockets/socket-manager.service';
 import { NewPipeProducer } from './socket-receive-methods/new-pipe-producer.service';
 import { ProducerClosed } from './socket-receive-methods/producer-closed.service';
 import { JoinConsumeRoom } from './socket-receive-methods/join-consume-room.service';
@@ -70,33 +69,11 @@ export type ConnectIpsType = (options: ConnectIpsOptions) => Promise<[Record<str
  * ```
  */
 export declare class ConnectIps {
-    private socketManagerService;
     private newPipeProducerService;
     private producerClosedService;
     private joinConsumeRoomService;
-    constructor(socketManagerService: SocketManager, newPipeProducerService: NewPipeProducer, producerClosedService: ProducerClosed, joinConsumeRoomService: JoinConsumeRoom);
-    /**
-     * Connects to remote IPs and manages socket connections.
-     *
-     * @param {Object} 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=newPipeProducer] - The method to handle new pipe producer events.
-     * @param {Function} [options.closedProducerMethod=producerClosed] - The method to handle producer closed events.
-     * @param {Function} [options.joinConsumeRoomMethod=joinConsumeRoom] - The method to handle joining a consuming room.
-     * @param {Object} options.parameters - Additional parameters.
-     * @param {string[]} options.parameters.roomRecvIPs - The list of IPs that have been received in the room.
-     * @param {Function} options.parameters.updateRoomRecvIPs - The function to update the room received IPs.
-     * @param {Function} options.parameters.updateConsume_sockets - The 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.
-     */
-    connectIps: ({ consume_sockets, remIP, apiUserName, apiKey, apiToken, newProducerMethod, closedProducerMethod, joinConsumeRoomMethod, parameters, }: ConnectIpsOptions) => Promise<any>;
+    constructor(newPipeProducerService: NewPipeProducer, producerClosedService: ProducerClosed, joinConsumeRoomService: JoinConsumeRoom);
+    connectIps: ConnectIpsType;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConnectIps, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConnectIps>;
 }

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

@@ -48,34 +48,7 @@ export declare class ConnectLocalIps {
     private newPipeProducerService;
     private producerClosedService;
     constructor(newPipeProducerService: NewPipeProducer, producerClosedService: ProducerClosed);
-    /**
-     * 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 {ConnectLocalIpsOptions} options - The options for connecting IPs.
-     * @param {Socket} options.socket - The socket connection to use for communication.
-     * @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 {ConnectLocalIpsParameters} options.parameters - Additional parameters for the operation.
-     *
-     * @returns {Promise<void>} A promise that resolves when the connection is established.
-     *
-     * @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 connectLocalIps({
-    *     socket,
-    *     newProducerMethod: newPipeProducer,
-    *     closedProducerMethod: producerClosed,
-    *     parameters,
-    *   });
-    * ```
-    */
-    connectLocalIps: ({ socket, newProducerMethod, closedProducerMethod, parameters, }: ConnectLocalIpsOptions) => Promise<void>;
+    connectLocalIps: ConnectLocalIpsType;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConnectLocalIps, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConnectLocalIps>;
 }

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

@@ -68,117 +68,8 @@ 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.
-     *
-     * @param {Object} options - The options object.
-     * @param {Array} options.lStreams - List of streams.
-     * @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 {Object} 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
-     */
-    dispStreams: ({ lStreams, ind, auto, ChatSkip, forChatID, parameters, breakRoom, inBreakRoom, }: DispStreamsOptions) => Promise<void>;
+    dispStreams({ lStreams, ind, auto, ChatSkip, forChatCard, forChatID, parameters, breakRoom, inBreakRoom, }: DispStreamsOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DispStreams, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DispStreams>;
 }

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

@@ -65,23 +65,6 @@ export type GeneratePageContentType = (options: GeneratePageContentOptions) => P
  * ```
  */
 export declare class GeneratePageContent {
-    /**
-     * Generates the content for a specific page.
-     *
-     * @param {Object} options - The options for generating page content.
-     * @param {number | string} options.page - The page number to generate content for.
-     * @param {Object} options.parameters - The parameters required for generating content.
-     * @param {Array} 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.
-     */
     generatePageContent({ page, parameters, breakRoom, inBreakRoom, }: GeneratePageContentOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<GeneratePageContent, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GeneratePageContent>;

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

@@ -69,27 +69,6 @@ export type GetEstimateType = (options: GetEstimateOptions) => [number, number,
  * ```
  */
 export declare class GetEstimate {
-    /**
-     * 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 {Object} 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 - Indicates if sharing is active.
-     * @param {string} 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 {Function} options.parameters.calculateRowsAndColumns - Function to calculate rows and columns.
-     *
-     * @returns {number[]} An array containing the estimated number of items, rows, and columns.
-     *
-     * @throws Will log an error message if an error occurs during estimation.
-     */
     getEstimate({ n, parameters }: GetEstimateOptions): [number, number, number];
     static ɵfac: i0.ɵɵFactoryDeclaration<GetEstimate, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GetEstimate>;

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

@@ -29,25 +29,6 @@ export type MixStreamsType = (options: MixStreamsOptions) => Promise<(Stream | P
  * ```
  */
 export declare class MixStreams {
-    /**
-     * Mixes video and audio streams and participants based on specified parameters.
-     *
-     * @param {Object} options - The options for mixing streams.
-     * @param {Array} options.alVideoStreams - The list of audio and video streams to mix.
-     * @param {Array} options.non_alVideoStreams - The list of non-audio and video streams to mix.
-     * @param {Array} options.ref_participants - The list of reference participants to mix.
-     * @returns {Promise<Array>} A promise that resolves with the mixed streams.
-     * @throws Will throw an error if there is an issue mixing the streams.
-     * @example
-     * ```typescript
-     * mixStreams({
-     *   alVideoStreams: [stream1, stream2],
-     *  non_alVideoStreams: [participant1, participant2],
-     * ref_participants: [participant1, participant2]
-     * });
-     *
-     * ```
-     */
     mixStreams({ alVideoStreams, non_alVideoStreams, ref_participants, }: MixStreamsOptions): Promise<(Stream | Participant)[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<MixStreams, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MixStreams>;

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

@@ -58,27 +58,7 @@ export type OnScreenChangesType = (options: OnScreenChangesOptions) => Promise<v
  * ```
  */
 export declare class OnScreenChanges {
-    /**
-     * Handles changes in screen events such as broadcast, chat, and conference.
-     *
-     * @param {OnScreenChangesOptions} options - The options for handling screen changes.
-     * @param {boolean} options.changed - Indicates if the screen has changed.
-     * @param {object} 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.
-     */
-    onScreenChanges: ({ changed, parameters, }: OnScreenChangesOptions) => Promise<void>;
+    onScreenChanges({ changed, parameters, }: OnScreenChangesOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<OnScreenChanges, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<OnScreenChanges>;
 }

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

@@ -40,20 +40,7 @@ export type ProcessConsumerTransportsAudioType = (options: ProcessConsumerTransp
  * ```
  */
 export declare class ProcessConsumerTransportsAudio {
-    /**
-     * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.
-     *
-     * @param {Object} options - The options for processing consumer transports.
-     * @param {Array} options.consumerTransports - The list of consumer transports to process.
-     * @param {Array} options.lStreams - The list of local streams to check against.
-     * @param {Object} 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 Will throw an error if there is an issue processing the consumer transports.
-     */
-    processConsumerTransportsAudio: ({ consumerTransports, lStreams, parameters, }: ProcessConsumerTransportsAudioOptions) => Promise<void>;
+    processConsumerTransportsAudio({ consumerTransports, lStreams, parameters, }: ProcessConsumerTransportsAudioOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProcessConsumerTransportsAudio, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ProcessConsumerTransportsAudio>;
 }

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

@@ -15,65 +15,11 @@ export interface ProcessConsumerTransportsOptions {
 }
 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);
- * ```
+ * @service ProcessConsumerTransports
+ * @description Service adapter for the shared consumer transport pause/resume orchestration.
  */
 export declare class ProcessConsumerTransports {
-    /**
-     * Processes consumer transports by pausing and resuming them based on certain conditions.
-     *
-     * @param {Object} options - The options for processing consumer transports.
-     * @param {Array} options.consumerTransports - The list of consumer transports to process.
-     * @param {Array} options.lStreams_ - The list of local streams.
-     * @param {Object} options.parameters - The parameters object containing various stream arrays and utility functions.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the processing is complete.
-     *
-     * @throws {Error} - Throws an error if there is an issue processing consumer transports.
-     *
-     * The function performs the following steps:
-     * 1. Destructures and updates the parameters.
-     * 2. Defines a helper function to check if a producerId is valid in given stream arrays.
-     * 3. Filters consumer transports to resume based on certain conditions.
-     * 4. Filters consumer transports to pause based on certain conditions.
-     * 5. Pauses consumer transports after a short delay.
-     * 6. Emits `consumer-pause` event for each filtered transport (not audio).
-     * 7. Emits `consumer-resume` event for each filtered transport (not audio).
-     */
-    processConsumerTransports: ({ consumerTransports, lStreams_, parameters, }: ProcessConsumerTransportsOptions) => Promise<void>;
+    processConsumerTransports({ consumerTransports, lStreams_, parameters, }: ProcessConsumerTransportsOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProcessConsumerTransports, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ProcessConsumerTransports>;
 }

package/dist/lib/consumers/re-update-inter.service.d.ts

@@ -121,45 +121,7 @@ export type ReUpdateInterType = (options: ReUpdateInterOptions) => Promise<void>
  * ```
  */
 export declare class ReUpdateInter {
-    /**
-     * Updates the interaction state based on the provided options and parameters.
-     *
-     * @param {ReUpdateInterOptions} options - The options for updating the interaction.
-     * @param {string} options.name - The name of the participant.
-     * @param {boolean} [options.add=false] - Whether to add the participant to the interaction.
-     * @param {boolean} [options.force=false] - Whether to force the update.
-     * @param {number} [options.average=127] - The average value used for determining reorder intervals.
-     * @param {Object} options.parameters - The parameters for updating the interaction.
-     * @param {number} options.parameters.screenPageLimit - The screen page limit.
-     * @param {number} options.parameters.itemPageLimit - The item page limit.
-     * @param {number} options.parameters.reorderInterval - The reorder interval.
-     * @param {number} options.parameters.fastReorderInterval - The fast reorder interval.
-     * @param {string} options.parameters.eventType - The type of event.
-     * @param {Array} options.parameters.participants - The list of participants.
-     * @param {Array} options.parameters.allVideoStreams - The list of all video streams.
-     * @param {boolean} options.parameters.shared - Whether the screen is shared.
-     * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.
-     * @param {string} options.parameters.adminNameStream - The admin name stream.
-     * @param {string} options.parameters.screenShareNameStream - The screen share name stream.
-     * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.
-     * @param {boolean} options.parameters.sortAudioLoudness - Whether to sort audio by loudness.
-     * @param {number} options.parameters.lastReorderTime - The last reorder time.
-     * @param {Array} options.parameters.newLimitedStreams - The list of new limited streams.
-     * @param {Array} options.parameters.newLimitedStreamsIDs - The list of new limited stream IDs.
-     * @param {Array} options.parameters.oldSoundIds - The list of old sound IDs.
-     * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
-     * @param {Function} options.parameters.updateSortAudioLoudness - Function to update the audio loudness sorting.
-     * @param {Function} options.parameters.updateLastReorderTime - Function to update the last reorder time.
-     * @param {Function} options.parameters.updateNewLimitedStreams - Function to update the new limited streams.
-     * @param {Function} options.parameters.updateNewLimitedStreamsIDs - Function to update the new limited stream IDs.
-     * @param {Function} options.parameters.updateOldSoundIds - Function to update the old sound IDs.
-     * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.
-     * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
-     * @param {Function} options.parameters.changeVids - Function to change videos.
-     *
-     * @returns {Promise<void>} A promise that resolves when the interaction update is complete.
-     */
-    reUpdateInter: ({ name, add, force, average, parameters, }: ReUpdateInterOptions) => Promise<void>;
+    reUpdateInter({ name, add, force, average, parameters, }: ReUpdateInterOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ReUpdateInter, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ReUpdateInter>;
 }