mediasfu-angular 1.0.0

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

@@ -0,0 +1,28 @@
+import { Stream, Participant } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface GetVideosOptions {
+    participants: Participant[];
+    allVideoStreams: (Stream | Participant)[];
+    oldAllStreams: (Stream | Participant)[];
+    adminVidID?: string;
+    updateAllVideoStreams: (streams: (Stream | Participant)[]) => void;
+    updateOldAllStreams: (streams: (Stream | Participant)[]) => void;
+}
+export type GetVideosType = (options: GetVideosOptions) => Promise<void>;
+export declare class GetVideos {
+    /**
+     * 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.
+     */
+    getVideos({ participants, allVideoStreams, oldAllStreams, adminVidID, updateAllVideoStreams, updateOldAllStreams, }: GetVideosOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetVideos, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetVideos>;
+}

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

@@ -0,0 +1,32 @@
+import { Stream, Participant } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface MixStreamsOptions {
+    alVideoStreams: (Stream | Participant)[];
+    non_alVideoStreams: Participant[];
+    ref_participants: (Stream | Participant)[];
+}
+export type MixStreamsType = (options: MixStreamsOptions) => Promise<(Stream | Participant)[]>;
+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

@@ -0,0 +1,44 @@
+import { ReorderStreamsType, ReorderStreamsParameters, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface OnScreenChangesParameters extends ReorderStreamsParameters {
+    eventType: EventType;
+    shareScreenStarted: boolean;
+    shared: boolean;
+    addForBasic: boolean;
+    updateAddForBasic: (value: boolean) => void;
+    itemPageLimit: number;
+    updateItemPageLimit: (value: number) => void;
+    updateMainHeightWidth: (value: number) => void;
+    reorderStreams: ReorderStreamsType;
+    [key: string]: any;
+}
+export interface OnScreenChangesOptions {
+    changed?: boolean;
+    parameters: OnScreenChangesParameters;
+}
+export type OnScreenChangesType = (options: OnScreenChangesOptions) => Promise<void>;
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OnScreenChanges, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OnScreenChanges>;
+}

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

@@ -0,0 +1,107 @@
+import { Participant, Stream, AudioCardParameters, EventType, CustomMediaComponent } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface PrepopulateUserMediaParameters extends AudioCardParameters {
+    participants: Participant[];
+    allVideoStreams: (Stream | Participant)[];
+    islevel: string;
+    member: string;
+    shared: boolean;
+    shareScreenStarted: boolean;
+    eventType: EventType;
+    screenId?: string;
+    forceFullDisplay: boolean;
+    updateMainWindow: boolean;
+    mainScreenFilled: boolean;
+    adminOnMainScreen: boolean;
+    mainScreenPerson: string;
+    videoAlreadyOn: boolean;
+    audioAlreadyOn: boolean;
+    oldAllStreams: (Stream | Participant)[];
+    checkOrientation: () => string;
+    screenForceFullDisplay: boolean;
+    localStreamScreen: MediaStream | null;
+    remoteScreenStream: Stream[];
+    localStreamVideo: MediaStream | null;
+    mainHeightWidth: number;
+    isWideScreen: boolean;
+    localUIMode: boolean;
+    whiteboardStarted: boolean;
+    whiteboardEnded: boolean;
+    virtualStream: MediaStream | null;
+    keepBackground: boolean;
+    annotateScreenStream: boolean;
+    updateMainScreenPerson: (person: string) => void;
+    updateMainScreenFilled: (filled: boolean) => void;
+    updateAdminOnMainScreen: (admin: boolean) => void;
+    updateMainHeightWidth: (heightWidth: number) => void;
+    updateScreenForceFullDisplay: (force: boolean) => void;
+    updateUpdateMainWindow: (update: boolean) => void;
+    updateMainGridStream: (components: CustomMediaComponent[]) => void;
+    getUpdatedAllParams: () => PrepopulateUserMediaParameters;
+    [key: string]: any;
+}
+export interface PrepopulateUserMediaOptions {
+    name: string;
+    parameters: PrepopulateUserMediaParameters;
+}
+export type PrepopulateUserMediaType = (options: {
+    name: string;
+    parameters: any;
+}) => Promise<{
+    component: any;
+    inputs: any;
+}[] | void>;
+export declare class PrepopulateUserMedia {
+    /**
+     * Prepopulates the user media based on the provided options.
+     *
+     * @param {PrepopulateUserMediaOptions} options - The options for prepopulating user media.
+     * @param {string} options.name - The name of the user.
+     * @param {Parameters} 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.
+     * @param {string} options.parameters.screenId - The screen ID.
+     * @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.
+     */
+    prepopulateUserMedia: ({ name, parameters, }: PrepopulateUserMediaOptions) => Promise<{
+        component: any;
+        inputs: any;
+    }[] | void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrepopulateUserMedia, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PrepopulateUserMedia>;
+}

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

@@ -0,0 +1,30 @@
+import { Stream, Transport, Participant, SleepType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ProcessConsumerTransportsAudioParameters {
+    sleep: SleepType;
+    [key: string]: any;
+}
+export interface ProcessConsumerTransportsAudioOptions {
+    consumerTransports: Transport[];
+    lStreams: (Stream | Participant)[];
+    parameters: ProcessConsumerTransportsAudioParameters;
+}
+export type ProcessConsumerTransportsAudioType = (options: ProcessConsumerTransportsAudioOptions) => Promise<void>;
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProcessConsumerTransportsAudio, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProcessConsumerTransportsAudio>;
+}

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

@@ -0,0 +1,42 @@
+import { Stream, Participant, Transport, SleepType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ProcessConsumerTransportsParameters {
+    remoteScreenStream: Stream[];
+    oldAllStreams: (Stream | Participant)[];
+    newLimitedStreams: (Stream | Participant)[];
+    sleep: SleepType;
+    getUpdatedAllParams: () => ProcessConsumerTransportsParameters;
+    [key: string]: any;
+}
+export interface ProcessConsumerTransportsOptions {
+    consumerTransports: Transport[];
+    lStreams_: (Stream | Participant)[];
+    parameters: ProcessConsumerTransportsParameters;
+}
+export type ProcessConsumerTransportsType = (options: ProcessConsumerTransportsOptions) => Promise<void>;
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProcessConsumerTransports, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProcessConsumerTransports>;
+}

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

@@ -0,0 +1,55 @@
+import { ScreenState, CompareScreenStatesParameters, CompareScreenStatesType, CompareActiveNamesParameters, CompareActiveNamesType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface RePortParameters extends CompareScreenStatesParameters, CompareActiveNamesParameters {
+    islevel: string;
+    mainScreenPerson: string;
+    adminOnMainScreen: boolean;
+    mainScreenFilled: boolean;
+    recordStarted: boolean;
+    recordStopped: boolean;
+    recordPaused: boolean;
+    recordResumed: boolean;
+    screenStates: ScreenState[];
+    prevScreenStates: ScreenState[];
+    updateScreenStates: (states: ScreenState[]) => void;
+    updatePrevScreenStates: (states: ScreenState[]) => void;
+    compareActiveNames: CompareActiveNamesType;
+    compareScreenStates: CompareScreenStatesType;
+    getUpdatedAllParams: () => RePortParameters;
+    [key: string]: any;
+}
+export interface RePortOptions {
+    restart?: boolean;
+    parameters: RePortParameters;
+}
+export type RePortType = (options: RePortOptions) => Promise<void>;
+export declare class RePort {
+    /**
+     * RePort function that handles the reporting logic 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 {Object} 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} 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.
+     */
+    rePort({ restart, parameters }: RePortOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RePort, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RePort>;
+}

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

@@ -0,0 +1,83 @@
+import { Participant, Stream, OnScreenChangesType, ReorderStreamsType, ChangeVidsType, OnScreenChangesParameters, ReorderStreamsParameters, ChangeVidsParameters, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ReUpdateInterParameters extends OnScreenChangesParameters, ReorderStreamsParameters, ChangeVidsParameters {
+    screenPageLimit: number;
+    itemPageLimit: number;
+    reorderInterval: number;
+    fastReorderInterval: number;
+    eventType: EventType;
+    participants: Participant[];
+    allVideoStreams: (Participant | Stream)[];
+    shared: boolean;
+    shareScreenStarted: boolean;
+    adminNameStream?: string;
+    screenShareNameStream?: string;
+    updateMainWindow: boolean;
+    sortAudioLoudness: boolean;
+    lastReorderTime: number;
+    newLimitedStreams: (Participant | Stream)[];
+    newLimitedStreamsIDs: string[];
+    oldSoundIds: string[];
+    updateUpdateMainWindow: (value: boolean) => void;
+    updateSortAudioLoudness: (value: boolean) => void;
+    updateLastReorderTime: (value: number) => void;
+    updateNewLimitedStreams: (streams: (Participant | Stream)[]) => void;
+    updateNewLimitedStreamsIDs: (ids: string[]) => void;
+    updateOldSoundIds: (ids: string[]) => void;
+    onScreenChanges: OnScreenChangesType;
+    reorderStreams: ReorderStreamsType;
+    changeVids: ChangeVidsType;
+    getUpdatedAllParams: () => ReUpdateInterParameters;
+    [key: string]: any;
+}
+export interface ReUpdateInterOptions {
+    name: string;
+    add?: boolean;
+    force?: boolean;
+    average?: number;
+    parameters: ReUpdateInterParameters;
+}
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReUpdateInter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReUpdateInter>;
+}

package/dist/lib/consumers/readjust.service.d.ts

@@ -0,0 +1,48 @@
+import { PrepopulateUserMediaType, PrepopulateUserMediaParameters, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ReadjustParameters extends PrepopulateUserMediaParameters {
+    eventType: EventType;
+    shareScreenStarted: boolean;
+    shared: boolean;
+    mainHeightWidth: number;
+    prevMainHeightWidth: number;
+    hostLabel: string;
+    first_round: boolean;
+    lock_screen: boolean;
+    updateMainHeightWidth: (value: number) => void;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    getUpdatedAllParams: () => ReadjustParameters;
+    [key: string]: any;
+}
+export interface ReadjustOptions {
+    n: number;
+    state: number;
+    parameters: ReadjustParameters;
+}
+export type ReadjustType = (options: ReadjustOptions) => Promise<void>;
+export declare class Readjust {
+    /**
+     * Adjusts the layout parameters based on the provided options.
+     *
+     * @param {ReadjustOptions} options - The options for readjusting the layout.
+     * @param {number} options.n - The number of participants or elements.
+     * @param {number} options.state - The current state of the layout.
+     * @param {object} options.parameters - The parameters for the layout adjustment.
+     * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @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 content is being shared.
+     * @param {number} options.parameters.mainHeightWidth - The main height and width value.
+     * @param {number} options.parameters.prevMainHeightWidth - The previous main height and width value.
+     * @param {string} options.parameters.hostLabel - The label for the host.
+     * @param {boolean} options.parameters.first_round - Indicates if it is the first round.
+     * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.
+     * @param {function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+     * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     * @returns {Promise<void>} A promise that resolves when the layout adjustment is complete.
+     * @throws {Error} Throws an error if there is an issue updating the grid sizes.
+     */
+    readjust: ({ n, state, parameters }: ReadjustOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Readjust, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Readjust>;
+}

package/dist/lib/consumers/receive-all-piped-transports.service.d.ts

@@ -0,0 +1,33 @@
+import { Socket } from 'socket.io-client';
+import { GetPipedProducersAltType, GetPipedProducersAltParameters } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ReceiveAllPipedTransportsParameters extends GetPipedProducersAltParameters {
+    roomName: string;
+    member: string;
+    getPipedProducersAlt: GetPipedProducersAltType;
+    [key: string]: any;
+}
+export interface ReceiveAllPipedTransportsOptions {
+    nsock: Socket;
+    parameters: ReceiveAllPipedTransportsParameters;
+}
+export type ReceiveAllPipedTransportsType = (options: ReceiveAllPipedTransportsOptions) => Promise<void>;
+export declare class ReceiveAllPipedTransports {
+    /**
+     * Receives all piped transports by emitting an event to the server and processing the response.
+     *
+     * @param {ReceiveAllPipedTransportsOptions} options - The options for receiving all piped transports.
+     * @param {any} options.nsock - The socket instance used for communication.
+     * @param {Object} options.parameters - The parameters for the operation.
+     * @param {string} options.parameters.roomName - The name of the room.
+     * @param {string} options.parameters.member - The member identifier.
+     * @param {Function} options.parameters.getPipedProducersAlt - The function to get piped producers for a given level.
+     *
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     *
+     * @throws Will log an error message if the operation fails.
+     */
+    receiveAllPipedTransports: ({ nsock, parameters, }: ReceiveAllPipedTransportsOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReceiveAllPipedTransports, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReceiveAllPipedTransports>;
+}

package/dist/lib/consumers/receive-room-messages.service.d.ts

@@ -0,0 +1,22 @@
+import { Socket } from 'socket.io-client';
+import { Message } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ReceiveRoomMessagesOptions {
+    socket: Socket;
+    roomName: string;
+    updateMessages: (messages: Message[]) => void;
+}
+export type ReceiveRoomMessagesType = (options: ReceiveRoomMessagesOptions) => Promise<void>;
+export declare class ReceiveRoomMessages {
+    /**
+     * Asynchronously retrieves and updates messages for a specified room from the server.
+     *
+     * @param {object} options - The function parameters.
+     * @param {object} options.parameters - Additional parameters needed for the function.
+     * @param {string} options.parameters.roomName - The name of the room to retrieve messages for.
+     * @param {function} options.parameters.updateMessages - Function to update the messages array.
+     */
+    receiveRoomMessages({ socket, roomName, updateMessages, }: ReceiveRoomMessagesOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReceiveRoomMessages, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReceiveRoomMessages>;
+}

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

@@ -0,0 +1,72 @@
+import { Participant, Stream, ChangeVidsParameters, ChangeVidsType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ReorderStreamsParameters extends ChangeVidsParameters {
+    allVideoStreams: (Stream | Participant)[];
+    participants: Participant[];
+    oldAllStreams: (Stream | Participant)[];
+    screenId?: string;
+    adminVidID?: string;
+    newLimitedStreams: (Stream | Participant)[];
+    newLimitedStreamsIDs: string[];
+    activeSounds: string[];
+    screenShareIDStream?: string;
+    screenShareNameStream?: string;
+    adminIDStream?: string;
+    adminNameStream?: string;
+    updateNewLimitedStreams: (streams: (Stream | Participant)[]) => void;
+    updateNewLimitedStreamsIDs: (ids: string[]) => void;
+    updateActiveSounds: (sounds: string[]) => void;
+    updateScreenShareIDStream: (id: string) => void;
+    updateScreenShareNameStream: (name: string) => void;
+    updateAdminIDStream: (id: string) => void;
+    updateAdminNameStream: (name: string) => void;
+    updateYouYouStream: (streams: (Stream | Participant)[]) => void;
+    changeVids: ChangeVidsType;
+    getUpdatedAllParams: () => ReorderStreamsParameters;
+    [key: string]: any;
+}
+export interface ReorderStreamsOptions {
+    add?: boolean;
+    screenChanged?: boolean;
+    parameters: ReorderStreamsParameters;
+}
+export type ReorderStreamsType = (options: ReorderStreamsOptions) => Promise<void>;
+export declare class ReorderStreams {
+    /**
+     * Reorders the video streams based on the provided options and updates the UI accordingly.
+     *
+     * @param {Object} options - The options for reordering streams.
+     * @param {boolean} [options.add=false] - Whether to add new streams or not.
+     * @param {boolean} [options.screenChanged=false] - Whether the screen has changed or not.
+     * @param {ReorderStreamsOptions} options.parameters - The parameters required for reordering streams.
+     *
+     * @returns {Promise<void>} A promise that resolves when the reordering is complete.
+     *
+     * @typedef {Object} ReorderStreamsOptions
+     * @property {Function} getUpdatedAllParams - Function to get updated parameters.
+     * @property {Array} allVideoStreams - Array of all video streams.
+     * @property {Array} participants - Array of participants.
+     * @property {Array} oldAllStreams - Array of old streams.
+     * @property {string} screenId - ID of the screen.
+     * @property {string} adminVidID - ID of the admin video.
+     * @property {Array} newLimitedStreams - Array of new limited streams.
+     * @property {Array} newLimitedStreamsIDs - Array of new limited stream IDs.
+     * @property {Array} activeSounds - Array of active sounds.
+     * @property {string} screenShareIDStream - ID of the screen share stream.
+     * @property {string} screenShareNameStream - Name of the screen share stream.
+     * @property {string} adminIDStream - ID of the admin stream.
+     * @property {string} adminNameStream - Name of the admin stream.
+     * @property {Function} updateNewLimitedStreams - Function to update new limited streams.
+     * @property {Function} updateNewLimitedStreamsIDs - Function to update new limited stream IDs.
+     * @property {Function} updateActiveSounds - Function to update active sounds.
+     * @property {Function} updateScreenShareIDStream - Function to update screen share ID stream.
+     * @property {Function} updateScreenShareNameStream - Function to update screen share name stream.
+     * @property {Function} updateAdminIDStream - Function to update admin ID stream.
+     * @property {Function} updateAdminNameStream - Function to update admin name stream.
+     * @property {Function} updateYouYouStream - Function to update YouYou stream.
+     * @property {Function} changeVids - Function to reflect changes on the UI.
+     */
+    reorderStreams: ({ add, screenChanged, parameters, }: ReorderStreamsOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReorderStreams, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReorderStreams>;
+}

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

@@ -0,0 +1,38 @@
+import { Socket } from 'socket.io-client';
+import { ShowAlert, StartShareScreenType, StartShareScreenParameters } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface RequestScreenShareParameters extends StartShareScreenParameters {
+    socket: Socket;
+    showAlert?: ShowAlert;
+    localUIMode: boolean;
+    targetResolution?: string;
+    targetResolutionHost?: string;
+    startShareScreen: StartShareScreenType;
+    getUpdatedAllParams: () => RequestScreenShareParameters;
+    [key: string]: any;
+}
+export interface RequestScreenShareOptions {
+    parameters: RequestScreenShareParameters;
+}
+export type RequestScreenShareType = (options: RequestScreenShareOptions) => Promise<void>;
+export declare class RequestScreenShare {
+    /**
+     * Requests to start screen sharing.
+     *
+     * @param {RequestScreenShareOptions} options - The options for requesting screen share.
+     * @param {Object} options.parameters - The parameters for the screen share request.
+     * @param {Socket} options.parameters.socket - The socket instance to communicate with the server.
+     * @param {Function} [options.parameters.showAlert] - Optional function to show alerts to the user.
+     * @param {boolean} options.parameters.localUIMode - Indicates if the user is in local UI mode.
+     * @param {string} [options.parameters.targetResolution] - The target resolution for screen sharing.
+     * @param {string} [options.parameters.targetResolutionHost] - The target resolution for the host screen.
+     * @param {Function} options.parameters.startShareScreen - Function to start screen sharing.
+     *
+     * @returns {Promise<void>} A promise that resolves when the screen share request is processed.
+     *
+     * @throws {Error} Throws an error if there is an issue during the screen share request process.
+     */
+    requestScreenShare: ({ parameters }: RequestScreenShareOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestScreenShare, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RequestScreenShare>;
+}