mediasfu-angular 1.0.0

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

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export interface CalculateRowsAndColumnsOptions {
+    n: number;
+}
+export type CalculateRowsAndColumnsType = (options: CalculateRowsAndColumnsOptions) => [number, number];
+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

@@ -0,0 +1,137 @@
+import { Stream, Participant, DispStreamsType, DispStreamsParameters, AudioDecibels, MixStreamsType, BreakoutParticipant, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ChangeVidsParameters extends DispStreamsParameters {
+    allVideoStreams: (Stream | Participant)[];
+    p_activeNames: string[];
+    activeNames: string[];
+    dispActiveNames: string[];
+    shareScreenStarted: boolean;
+    shared: boolean;
+    newLimitedStreams: (Stream | Participant)[];
+    non_alVideoStreams: Participant[];
+    ref_participants: Participant[];
+    participants: Participant[];
+    eventType: EventType;
+    islevel: string;
+    member: string;
+    sortAudioLoudness: boolean;
+    audioDecibels: AudioDecibels[];
+    mixed_alVideoStreams: (Stream | Participant)[];
+    non_alVideoStreams_muted: Participant[];
+    remoteProducerId?: string;
+    localStreamVideo: MediaStream | null;
+    oldAllStreams: (Stream | Participant)[];
+    screenPageLimit: number;
+    meetingDisplayType: string;
+    meetingVideoOptimized: boolean;
+    recordingVideoOptimized: boolean;
+    recordingDisplayType: 'video' | 'media' | 'all';
+    paginatedStreams: (Stream | Participant)[][];
+    itemPageLimit: number;
+    doPaginate: boolean;
+    prevDoPaginate: boolean;
+    currentUserPage: number;
+    breakoutRooms: BreakoutParticipant[][];
+    hostNewRoom: number;
+    breakOutRoomStarted: boolean;
+    breakOutRoomEnded: boolean;
+    virtualStream: MediaStream | null;
+    mainRoomsLength: number;
+    memberRoom: number;
+    updateP_activeNames: (names: string[]) => void;
+    updateActiveNames: (names: string[]) => void;
+    updateDispActiveNames: (names: string[]) => void;
+    updateNewLimitedStreams: (streams: (Stream | Participant)[]) => void;
+    updateNon_alVideoStreams: (participants: Participant[]) => void;
+    updateRef_participants: (participants: Participant[]) => void;
+    updateSortAudioLoudness: (sort: boolean) => void;
+    updateMixed_alVideoStreams: (streams: (Stream | Participant)[]) => void;
+    updateNon_alVideoStreams_muted: (participants: Participant[]) => void;
+    updatePaginatedStreams: (streams: (Stream | Participant)[][]) => void;
+    updateDoPaginate: (paginate: boolean) => void;
+    updatePrevDoPaginate: (paginate: boolean) => void;
+    updateCurrentUserPage: (page: number) => void;
+    updateNumberPages: (pages: number) => void;
+    updateMainRoomsLength: (length: number) => void;
+    updateMemberRoom: (room: number) => void;
+    mixStreams: MixStreamsType;
+    dispStreams: DispStreamsType;
+    getUpdatedAllParams: () => ChangeVidsParameters;
+    [key: string]: any;
+}
+export interface ChangeVidsOptions {
+    screenChanged?: boolean;
+    parameters: ChangeVidsParameters;
+}
+export type ChangeVidsType = (options: ChangeVidsOptions) => Promise<void>;
+export declare class ChangeVids {
+    /**
+     * Asynchronously changes the video streams based on the provided options.
+     *
+     * @param {Object} options - The options for changing video streams.
+     * @param {boolean} [options.screenChanged=false] - Indicates if the screen has changed.
+     * @param {ChangeVidsOptions} options.parameters - The parameters for changing video streams.
+     * @returns {Promise<void>} A promise that resolves when the video streams have been changed.
+     *
+     * @typedef {Object} ChangeVidsOptions
+     * @property {Function} getUpdatedAllParams - Function to get updated parameters.
+     * @property {Array} allVideoStreams - Array of all video streams.
+     * @property {Array} p_activeNames - Array of active participant names.
+     * @property {Array} activeNames - Array of active names.
+     * @property {Array} dispActiveNames - Array of displayed active names.
+     * @property {boolean} shareScreenStarted - Indicates if screen sharing has started.
+     * @property {boolean} shared - Indicates if the screen is shared.
+     * @property {Array} newLimitedStreams - Array of new limited streams.
+     * @property {Array} non_alVideoStreams - Array of non-al video streams.
+     * @property {Array} ref_participants - Array of reference participants.
+     * @property {Array} participants - Array of participants.
+     * @property {string} eventType - Type of the event.
+     * @property {string} islevel - Level of the participant.
+     * @property {string} member - Name of the member.
+     * @property {boolean} sortAudioLoudness - Indicates if audio loudness should be sorted.
+     * @property {Array} audioDecibels - Array of audio decibels.
+     * @property {Array} mixed_alVideoStreams - Array of mixed al video streams.
+     * @property {Array} non_alVideoStreams_muted - Array of muted non-al video streams.
+     * @property {string} remoteProducerId - ID of the remote producer.
+     * @property {Object} localStreamVideo - Local stream video object.
+     * @property {Array} oldAllStreams - Array of old all streams.
+     * @property {number} screenPageLimit - Limit of streams per screen page.
+     * @property {string} meetingDisplayType - Type of meeting display.
+     * @property {boolean} meetingVideoOptimized - Indicates if meeting video is optimized.
+     * @property {boolean} recordingVideoOptimized - Indicates if recording video is optimized.
+     * @property {string} recordingDisplayType - Type of recording display.
+     * @property {Array} paginatedStreams - Array of paginated streams.
+     * @property {number} itemPageLimit - Limit of items per page.
+     * @property {boolean} doPaginate - Indicates if pagination should be done.
+     * @property {boolean} prevDoPaginate - Indicates if pagination was previously done.
+     * @property {number} currentUserPage - Current user page number.
+     * @property {Array} breakoutRooms - Array of breakout rooms.
+     * @property {number} hostNewRoom - Index of the new room for the host.
+     * @property {boolean} breakOutRoomStarted - Indicates if breakout room has started.
+     * @property {boolean} breakOutRoomEnded - Indicates if breakout room has ended.
+     * @property {Object} virtualStream - Virtual stream object.
+     * @property {number} mainRoomsLength - Length of main rooms.
+     * @property {string} memberRoom - Room of the member.
+     * @property {Function} updateP_activeNames - Function to update active participant names.
+     * @property {Function} updateActiveNames - Function to update active names.
+     * @property {Function} updateDispActiveNames - Function to update displayed active names.
+     * @property {Function} updateNewLimitedStreams - Function to update new limited streams.
+     * @property {Function} updateNon_alVideoStreams - Function to update non-al video streams.
+     * @property {Function} updateRef_participants - Function to update reference participants.
+     * @property {Function} updateSortAudioLoudness - Function to update audio loudness sorting.
+     * @property {Function} updateMixed_alVideoStreams - Function to update mixed al video streams.
+     * @property {Function} updateNon_alVideoStreams_muted - Function to update muted non-al video streams.
+     * @property {Function} updatePaginatedStreams - Function to update paginated streams.
+     * @property {Function} updateDoPaginate - Function to update pagination status.
+     * @property {Function} updatePrevDoPaginate - Function to update previous pagination status.
+     * @property {Function} updateCurrentUserPage - Function to update current user page.
+     * @property {Function} updateNumberPages - Function to update number of pages.
+     * @property {Function} updateMainRoomsLength - Function to update main rooms length.
+     * @property {Function} updateMemberRoom - Function to update member room.
+     * @property {Function} mixStreams - Function to mix streams.
+     * @property {Function} dispStreams - Function to display streams.
+     */
+    changeVids: ({ screenChanged, parameters }: ChangeVidsOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChangeVids, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChangeVids>;
+}

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

@@ -0,0 +1,30 @@
+import * as i0 from "@angular/core";
+export interface CheckGridOptions {
+    rows: number;
+    cols: number;
+    actives: number;
+}
+export type CheckGridType = (options: CheckGridOptions) => Promise<[boolean, number, number, number, number, number, number] | void>;
+export declare class CheckGrid {
+    /**
+     * Checks the grid configuration and calculates various parameters based on the number of rows, columns, and active elements.
+     *
+     * @param {CheckGridOptions} options - The options for checking the grid.
+     * @param {number} options.rows - The number of rows in the grid.
+     * @param {number} options.cols - The number of columns in the grid.
+     * @param {number} options.actives - The number of active elements in the grid.
+     * @returns {Promise<[boolean, number, number, number, number, number, number] | void>} A promise that resolves to a tuple containing:
+     * - `removeAltGrid` (boolean): Indicates whether to remove the alternate grid.
+     * - `numtoadd` (number): The number of elements to add.
+     * - `numRows` (number): The number of rows.
+     * - `numCols` (number): The number of columns.
+     * - `remainingVideos` (number): The number of remaining videos.
+     * - `actualRows` (number): The actual number of rows.
+     * - `lastrowcols` (number): The number of columns in the last row.
+     *
+     * If an error occurs, it logs the error to the console.
+     */
+    checkGrid({ rows, cols, actives, }: CheckGridOptions): Promise<[boolean, number, number, number, number, number, number] | void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckGrid, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckGrid>;
+}

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

@@ -0,0 +1,26 @@
+import * as i0 from "@angular/core";
+export interface CheckPermissionOptions {
+    audioSetting: string;
+    videoSetting: string;
+    screenshareSetting: string;
+    chatSetting: string;
+    permissionType: 'audioSetting' | 'videoSetting' | 'screenshareSetting' | 'chatSetting';
+}
+export type CheckPermissionType = (options: CheckPermissionOptions) => Promise<number>;
+export declare class CheckPermission {
+    /**
+     * Checks the permission based on the provided settings.
+     *
+     * @param {CheckPermissionOptions} options - The options for checking permissions.
+     * @param {string} options.permissionType - The type of permission to check. Can be "audioSetting", "videoSetting", "screenshareSetting", or "chatSetting".
+     * @param {string} options.audioSetting - The setting for audio permission. Can be "allow", "approval", or other.
+     * @param {string} options.videoSetting - The setting for video permission. Can be "allow", "approval", or other.
+     * @param {string} options.screenshareSetting - The setting for screenshare permission. Can be "allow", "approval", or other.
+     * @param {string} options.chatSetting - The setting for chat permission. Can be "allow", "approval", or other.
+     * @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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckPermission, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckPermission>;
+}

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

@@ -0,0 +1,41 @@
+import { StopShareScreenType, StopShareScreenParameters, RequestScreenShareType, RequestScreenShareParameters, ShowAlert } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface CheckScreenShareParameters extends StopShareScreenParameters, RequestScreenShareParameters {
+    shared: boolean;
+    whiteboardStarted: boolean;
+    whiteboardEnded: boolean;
+    breakOutRoomStarted: boolean;
+    breakOutRoomEnded: boolean;
+    showAlert?: ShowAlert;
+    stopShareScreen: StopShareScreenType;
+    requestScreenShare: RequestScreenShareType;
+    getUpdatedAllParams: () => CheckScreenShareParameters;
+    [key: string]: any;
+}
+export interface CheckScreenShareOptions {
+    parameters: CheckScreenShareParameters;
+}
+export type CheckScreenShareType = (options: CheckScreenShareOptions) => Promise<void>;
+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/close-and-resize.service.d.ts

@@ -0,0 +1,107 @@
+import { Stream, Participant, ReorderStreamsType, ReorderStreamsParameters, PrepopulateUserMediaParameters, PrepopulateUserMediaType, GetVideosType, RePortType, RePortParameters, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface CloseAndResizeParameters extends ReorderStreamsParameters, PrepopulateUserMediaParameters, RePortParameters {
+    allAudioStreams: (Stream | Participant)[];
+    allVideoStreams: (Stream | Participant)[];
+    activeNames: string[];
+    participants: Participant[];
+    streamNames: Stream[];
+    recordingDisplayType: 'video' | 'media' | 'all';
+    recordingVideoOptimized: boolean;
+    adminIDStream?: string;
+    newLimitedStreams: (Stream | Participant)[];
+    newLimitedStreamsIDs: string[];
+    oldAllStreams: (Stream | Participant)[];
+    shareScreenStarted: boolean;
+    shared: boolean;
+    meetingDisplayType: string;
+    defer_receive: boolean;
+    lock_screen: boolean;
+    firstAll: boolean;
+    first_round: boolean;
+    gotAllVids: boolean;
+    eventType: EventType;
+    hostLabel: string;
+    shareEnded: boolean;
+    updateMainWindow: boolean;
+    updateActiveNames: (activeNames: string[]) => void;
+    updateAllAudioStreams: (allAudioStreams: (Stream | Participant)[]) => void;
+    updateShareScreenStarted: (shareScreenStarted: boolean) => void;
+    updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+    updateNewLimitedStreams: (newLimitedStreams: (Stream | Participant)[]) => void;
+    updateOldAllStreams: (oldAllStreams: (Stream | Participant)[]) => void;
+    updateDefer_receive: (defer_receive: boolean) => void;
+    updateMainHeightWidth: (heightWidth: number) => void;
+    updateShareEnded: (shareEnded: boolean) => void;
+    updateLock_screen: (lock_screen: boolean) => void;
+    updateFirstAll: (firstAll: boolean) => void;
+    updateFirst_round: (first_round: boolean) => void;
+    reorderStreams: ReorderStreamsType;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    getVideos: GetVideosType;
+    rePort: RePortType;
+    getUpdatedAllParams: () => CloseAndResizeParameters;
+    [key: string]: any;
+}
+export interface CloseAndResizeOptions {
+    producerId: string;
+    kind: string;
+    parameters: CloseAndResizeParameters;
+}
+export type CloseAndResizeType = (options: CloseAndResizeOptions) => Promise<void>;
+export declare class CloseAndResize {
+    /**
+     * Closes and resizes the video and audio elements based on the provided options.
+     *
+     * @param {CloseAndResizeOptions} options - The options for closing and resizing.
+     * @param {string} options.producerId - The ID of the producer.
+     * @param {string} options.kind - The kind of media (audio, video, screenshare, or screen).
+     * @param {object} options.parameters - The parameters for the operation.
+     * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {Array} options.parameters.allAudioStreams - Array of all audio streams.
+     * @param {Array} options.parameters.allVideoStreams - Array of all video streams.
+     * @param {Array} options.parameters.activeNames - Array of active participant names.
+     * @param {Array} options.parameters.participants - Array of participants.
+     * @param {Array} options.parameters.streamNames - Array of stream names.
+     * @param {string} options.parameters.recordingDisplayType - Type of recording display.
+     * @param {boolean} options.parameters.recordingVideoOptimized - Whether recording is video optimized.
+     * @param {string} options.parameters.adminIDStream - ID of the admin stream.
+     * @param {Array} options.parameters.newLimitedStreams - Array of new limited streams.
+     * @param {Array} options.parameters.newLimitedStreamsIDs - Array of new limited stream IDs.
+     * @param {Array} options.parameters.oldAllStreams - Array of old all streams.
+     * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.
+     * @param {boolean} options.parameters.shared - Whether sharing is active.
+     * @param {string} options.parameters.meetingDisplayType - Type of meeting display.
+     * @param {boolean} options.parameters.defer_receive - Whether to defer receiving.
+     * @param {boolean} options.parameters.lock_screen - Whether the screen is locked.
+     * @param {boolean} options.parameters.firstAll - Whether it is the first all.
+     * @param {boolean} options.parameters.first_round - Whether it is the first round.
+     * @param {boolean} options.parameters.gotAllVids - Whether all videos are received.
+     * @param {string} options.parameters.eventType - Type of event.
+     * @param {string} options.parameters.hostLabel - Label of the host.
+     * @param {boolean} options.parameters.shareEnded - Whether sharing has ended.
+     * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.
+     * @param {function} options.parameters.updateActiveNames - Function to update active names.
+     * @param {function} options.parameters.updateAllAudioStreams - Function to update all audio streams.
+     * @param {function} options.parameters.updateAllVideoStreams - Function to update all video streams.
+     * @param {function} options.parameters.updateShareScreenStarted - Function to update share screen started status.
+     * @param {function} options.parameters.updateUpdateMainWindow - Function to update main window status.
+     * @param {function} options.parameters.updateNewLimitedStreams - Function to update new limited streams.
+     * @param {function} options.parameters.updateOldAllStreams - Function to update old all streams.
+     * @param {function} options.parameters.updateDefer_receive - Function to update defer receive status.
+     * @param {function} options.parameters.updateMainHeightWidth - Function to update main height and width.
+     * @param {function} options.parameters.updateShareEnded - Function to update share ended status.
+     * @param {function} options.parameters.updateLock_screen - Function to update lock screen status.
+     * @param {function} options.parameters.updateFirstAll - Function to update first all status.
+     * @param {function} options.parameters.updateFirst_round - Function to update first round status.
+     * @param {function} options.parameters.reorderStreams - Function to reorder streams.
+     * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     * @param {function} options.parameters.getVideos - Function to get videos.
+     * @param {function} options.parameters.rePort - Function to report.
+     *
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     */
+    closeAndResize: ({ producerId, kind, parameters, }: CloseAndResizeOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CloseAndResize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CloseAndResize>;
+}

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

@@ -0,0 +1,37 @@
+import { TriggerType, TriggerParameters } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface CompareActiveNamesParameters extends TriggerParameters {
+    activeNames: string[];
+    prevActiveNames: string[];
+    updateActiveNames: (activeNames: string[]) => void;
+    updatePrevActiveNames: (prevActiveNames: string[]) => void;
+    trigger: TriggerType;
+    getUpdatedAllParams: () => CompareActiveNamesParameters;
+    [key: string]: any;
+}
+export interface CompareActiveNamesOptions {
+    restart?: boolean;
+    parameters: CompareActiveNamesParameters;
+}
+export type CompareActiveNamesType = (options: CompareActiveNamesOptions) => Promise<void>;
+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

@@ -0,0 +1,40 @@
+import { ScreenState, TriggerType, TriggerParameters } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface CompareScreenStatesParameters extends TriggerParameters {
+    recordingDisplayType: 'video' | 'media' | 'all';
+    recordingVideoOptimized: boolean;
+    screenStates: ScreenState[];
+    prevScreenStates: ScreenState[];
+    activeNames: string[];
+    trigger: TriggerType;
+    getUpdatedAllParams: () => CompareScreenStatesParameters;
+    [key: string]: any;
+}
+export interface CompareScreenStatesOptions {
+    restart?: boolean;
+    parameters: CompareScreenStatesParameters;
+}
+export type CompareScreenStatesType = (options: CompareScreenStatesOptions) => Promise<void>;
+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

@@ -0,0 +1,59 @@
+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';
+import { Device } from 'mediasoup-client/lib/types';
+import { ReorderStreamsParameters, ReorderStreamsType, NewPipeProducerParameters, NewPipeProducerType, ProducerClosedType, ProducerClosedParameters, JoinConsumeRoomType, JoinConsumeRoomParameters, ConsumeSocket } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ConnectIpsParameters extends ReorderStreamsParameters, JoinConsumeRoomParameters, ProducerClosedParameters, NewPipeProducerParameters {
+    device: Device | null;
+    roomRecvIPs: string[];
+    updateRoomRecvIPs: (roomRecvIPs: string[]) => void;
+    updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;
+    reorderStreams: ReorderStreamsType;
+    getUpdatedAllParams: () => ConnectIpsParameters;
+    [key: string]: any;
+}
+export interface ConnectIpsOptions {
+    consume_sockets: ConsumeSocket[];
+    remIP: string[];
+    apiUserName: string;
+    apiKey?: string;
+    apiToken: string;
+    newProducerMethod?: NewPipeProducerType;
+    closedProducerMethod?: ProducerClosedType;
+    joinConsumeRoomMethod?: JoinConsumeRoomType;
+    parameters: ConnectIpsParameters;
+}
+export type ConnectIpsType = (options: ConnectIpsOptions) => Promise<[Record<string, any>[], string[]]>;
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectIps, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectIps>;
+}

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

@@ -0,0 +1,58 @@
+import { Socket } from 'socket.io-client';
+import { ConsumerResumeType, ConsumerResumeParameters, Transport as TransportType } from '../@types/types';
+import { Device, Transport } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface ConnectRecvTransportParameters extends ConsumerResumeParameters {
+    device: Device | null;
+    consumerTransports: TransportType[];
+    updateConsumerTransports: (transports: TransportType[]) => void;
+    consumerResume: ConsumerResumeType;
+    getUpdatedAllParams: () => ConnectRecvTransportParameters;
+    [key: string]: any;
+}
+export interface ConnectRecvTransportOptions {
+    consumerTransport: Transport;
+    remoteProducerId: string;
+    serverConsumerTransportId: string;
+    nsock: Socket;
+    parameters: ConnectRecvTransportParameters;
+}
+export type ConnectRecvTransportType = (options: ConnectRecvTransportOptions) => Promise<void>;
+export declare class ConnectRecvTransport {
+    /**
+     * Connects the receiving transport to consume media from a remote producer.
+     *
+     * @param {Object} options - The options for connecting the receiving transport.
+     * @param {Transport} options.consumerTransport - The transport used for consuming media.
+     * @param {string} options.remoteProducerId - The ID of the remote producer.
+     * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.
+     * @param {Socket} options.nsock - The socket used for communication.
+     * @param {ConnectRecvTransportOptions} options.parameters - The parameters for the connection.
+     *
+     * @returns {Promise<void>} A promise that resolves when the connection is established.
+     *
+     * @throws Will throw an error if the connection or consumption fails.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   consumerTransport,
+     *   remoteProducerId: 'producer-id',
+     *   serverConsumerTransportId: 'transport-id',
+     *   nsock: socket,
+     *   parameters: connectRecvTransportOptions,
+     * };
+     *
+     * connectRecvTransport(options)
+     *   .then(() => {
+     *     console.log('Transport connected and consuming media');
+     *   })
+     *   .catch((error) => {
+     *     console.error('Error connecting transport:', error);
+     *   });
+     * ```
+     */
+    connectRecvTransport: ({ consumerTransport, remoteProducerId, serverConsumerTransportId, nsock, parameters, }: ConnectRecvTransportOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectRecvTransport, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectRecvTransport>;
+}

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

@@ -0,0 +1,33 @@
+import { Transport, Producer, ProducerOptions } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface ConnectSendTransportAudioParameters {
+    audioProducer: Producer | null;
+    producerTransport: Transport | null;
+    updateAudioProducer: (producer: Producer | null) => void;
+    updateProducerTransport: (transport: Transport | null) => void;
+}
+export interface ConnectSendTransportAudioOptions {
+    audioParams: ProducerOptions;
+    parameters: ConnectSendTransportAudioParameters;
+}
+export type ConnectSendTransportAudioType = (options: ConnectSendTransportAudioOptions) => Promise<void>;
+export declare class ConnectSendTransportAudio {
+    /**
+     * Connects the send transport for audio by producing audio data and updating the audio producer and producer transport objects.
+     *
+     * @param {Object} params - The parameters for connecting the send transport.
+     * @param {ProducerOptions} params.audioParams - The options for the audio producer.
+     * @param {ConnectSendTransportAudioParameters} params.parameters - The parameters containing the audio producer, producer transport, and update functions.
+     * @param {Producer} params.parameters.audioProducer - The current audio producer.
+     * @param {Transport} params.parameters.producerTransport - The transport used to produce audio data.
+     * @param {Function} params.parameters.updateAudioProducer - Function to update the audio producer.
+     * @param {Function} params.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.
+     */
+    connectSendTransportAudio({ audioParams, parameters, }: ConnectSendTransportAudioOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectSendTransportAudio, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectSendTransportAudio>;
+}

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

@@ -0,0 +1,42 @@
+import { Transport, Producer, Device, ProducerOptions } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface ConnectSendTransportScreenParameters {
+    screenProducer: Producer | null;
+    device: Device | null;
+    screenParams: ProducerOptions;
+    producerTransport: Transport | null;
+    params: ProducerOptions;
+    updateScreenProducer: (producer: Producer | null) => void;
+    updateProducerTransport: (transport: Transport | null) => void;
+    getUpdatedAllParams: () => ConnectSendTransportScreenParameters;
+    [key: string]: any;
+}
+export interface ConnectSendTransportScreenOptions {
+    stream: MediaStream | null;
+    parameters: ConnectSendTransportScreenParameters;
+}
+export type ConnectSendTransportScreenType = (options: ConnectSendTransportScreenOptions) => Promise<void>;
+export declare class ConnectSendTransportScreen {
+    /**
+     * Connects and sets up the screen sharing transport for sending video streams.
+     *
+     * @param {Object} options - The options for connecting the screen transport.
+     * @param {MediaStream} options.stream - The media stream containing the screen video track.
+     * @param {ConnectSendTransportScreenOptions} 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 {Promise<ScreenParams>} options.parameters.screenParams - A promise resolving to screen share parameters.
+     * @param {Transport} options.parameters.producerTransport - The transport object used for producing the screen share.
+     * @param {Params} options.parameters.params - The parameters 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.
+     */
+    connectSendTransportScreen({ stream, parameters, }: ConnectSendTransportScreenOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectSendTransportScreen, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectSendTransportScreen>;
+}