mediasfu-angular 1.0.0

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

@@ -0,0 +1,41 @@
+import { Device, Producer, ProducerOptions, Transport } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface ConnectSendTransportVideoParameters {
+    videoProducer: Producer | null;
+    device: Device | null;
+    producerTransport: Transport | null;
+    islevel: string;
+    updateMainWindow: boolean;
+    updateVideoProducer: (producer: Producer | null) => void;
+    updateProducerTransport: (transport: Transport | null) => void;
+    updateUpdateMainWindow: (state: boolean) => void;
+    [key: string]: any;
+}
+export interface ConnectSendTransportVideoOptions {
+    videoParams: ProducerOptions;
+    parameters: ConnectSendTransportVideoParameters;
+}
+export type ConnectSendTransportVideoType = (options: ConnectSendTransportVideoOptions) => Promise<void>;
+export declare class ConnectSendTransportVideo {
+    /**
+     * Connects the send transport for video by producing video data and updates the relevant states.
+     *
+     * @param {ConnectSendTransportVideoOptions} options - The options for connecting the send transport for video.
+     * @param {Object} options.videoParams - The parameters for producing video data.
+     * @param {Object} options.parameters - The parameters for updating the state.
+     * @param {Producer} options.parameters.videoProducer - The video producer instance.
+     * @param {Transport} options.parameters.producerTransport - The transport instance used for producing video.
+     * @param {string} options.parameters.islevel - The connection level.
+     * @param {boolean} options.parameters.updateMainWindow - The state of the main window update.
+     * @param {Function} options.parameters.updateVideoProducer - Function to update the video producer.
+     * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.
+     * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.
+     *
+     * @returns {Promise<void>} A promise that resolves when the send transport for video is connected.
+     *
+     * @throws Will throw an error if the connection fails.
+     */
+    connectSendTransportVideo: ({ videoParams, parameters, }: ConnectSendTransportVideoOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectSendTransportVideo, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectSendTransportVideo>;
+}

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

@@ -0,0 +1,49 @@
+import { ProducerOptions } from 'mediasoup-client/lib/types';
+import { ConnectSendTransportAudioType, ConnectSendTransportVideoType, ConnectSendTransportScreenType, ConnectSendTransportAudioParameters, ConnectSendTransportVideoParameters, ConnectSendTransportScreenParameters } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ConnectSendTransportParameters extends ConnectSendTransportAudioParameters, ConnectSendTransportVideoParameters, ConnectSendTransportScreenParameters {
+    audioParams: ProducerOptions;
+    videoParams: ProducerOptions;
+    localStreamScreen: MediaStream | null;
+    canvasStream: MediaStream | null;
+    whiteboardStarted: boolean;
+    whiteboardEnded: boolean;
+    shared: boolean;
+    islevel: string;
+    connectSendTransportAudio: ConnectSendTransportAudioType;
+    connectSendTransportVideo: ConnectSendTransportVideoType;
+    connectSendTransportScreen: ConnectSendTransportScreenType;
+    [key: string]: any;
+}
+export interface ConnectSendTransportOptions {
+    option: 'audio' | 'video' | 'screen' | 'all';
+    parameters: ConnectSendTransportParameters;
+}
+export type ConnectSendTransportType = (options: ConnectSendTransportOptions) => Promise<void>;
+export declare class ConnectSendTransport {
+    /**
+     * Connects the send transport based on the specified option.
+     *
+     * @param {ConnectSendTransportOptions} options - The options for connecting the send transport.
+     * @param {string} options.option - The type of transport to connect ("audio", "video", "screen", or both).
+     * @param {Object} options.parameters - The parameters required for connecting the transport.
+     * @param {Object} options.parameters.audioParams - The audio parameters.
+     * @param {Object} options.parameters.videoParams - The video parameters.
+     * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.
+     * @param {MediaStream} options.parameters.canvasStream - The canvas stream.
+     * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard has started.
+     * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard has ended.
+     * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+     * @param {string} options.parameters.islevel - The level of the screen sharing.
+     * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the audio send transport.
+     * @param {Function} options.parameters.connectSendTransportVideo - Function to connect the video send transport.
+     * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the screen send transport.
+     *
+     * @returns {Promise<void>} A promise that resolves when the transport is connected.
+     *
+     * @throws Will throw an error if the connection fails.
+     */
+    connectSendTransport({ option, parameters }: ConnectSendTransportOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectSendTransport, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectSendTransport>;
+}

package/dist/lib/consumers/consumer-resume.service.d.ts

@@ -0,0 +1,85 @@
+import { Socket } from 'socket.io-client';
+import { ReorderStreamsType, ReorderStreamsParameters, Participant, PrepopulateUserMediaType, PrepopulateUserMediaParameters, Stream, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ConsumerResumeParameters extends ReorderStreamsParameters, PrepopulateUserMediaParameters {
+    nStream: MediaStream | null;
+    allAudioStreams: (Stream | Participant)[];
+    allVideoStreams: (Stream | Participant)[];
+    streamNames: Stream[];
+    audStreamNames: Stream[];
+    updateMainWindow: boolean;
+    shared: boolean;
+    shareScreenStarted: boolean;
+    screenId?: string;
+    participants: Array<Participant>;
+    eventType: EventType;
+    meetingDisplayType: string;
+    mainScreenFilled: boolean;
+    first_round: boolean;
+    lock_screen: boolean;
+    oldAllStreams: (Stream | Participant)[];
+    adminVidID?: string;
+    mainHeightWidth: number;
+    member: string;
+    audioOnlyStreams: Array<any>;
+    gotAllVids: boolean;
+    defer_receive: boolean;
+    firstAll: boolean;
+    remoteScreenStream: Stream[];
+    hostLabel: string;
+    whiteboardStarted: boolean;
+    whiteboardEnded: boolean;
+    updateUpdateMainWindow: (value: boolean) => void;
+    updateAllAudioStreams: (value: (Stream | Participant)[]) => void;
+    updateAllVideoStreams: (value: (Stream | Participant)[]) => void;
+    updateStreamNames: (value: Stream[]) => void;
+    updateAudStreamNames: (value: Stream[]) => void;
+    updateNStream: (value: MediaStream | null) => void;
+    updateMainHeightWidth: (value: number) => void;
+    updateLock_screen: (value: boolean) => void;
+    updateFirstAll: (value: boolean) => void;
+    updateRemoteScreenStream: (value: Stream[]) => void;
+    updateOldAllStreams: (value: (Stream | Participant)[]) => void;
+    updateAudioOnlyStreams: (value: Array<any>) => void;
+    updateShareScreenStarted: (value: boolean) => void;
+    updateGotAllVids: (value: boolean) => void;
+    updateScreenId: (value: string) => void;
+    updateDefer_receive: (value: boolean) => void;
+    reorderStreams: ReorderStreamsType;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    getUpdatedAllParams: () => ConsumerResumeParameters;
+    [key: string]: any;
+}
+interface ResumeParams {
+    id: string;
+    producerId: string;
+    kind: string;
+    rtpParameters: any;
+}
+export interface ConsumerResumeOptions {
+    track: MediaStreamTrack;
+    kind: string;
+    remoteProducerId: string;
+    params: ResumeParams;
+    parameters: ConsumerResumeParameters;
+    nsock: Socket;
+}
+export type ConsumerResumeType = (options: ConsumerResumeOptions) => Promise<void>;
+export declare class ConsumerResume {
+    /**
+     * Resumes a consumer, making it ready for use.
+     *
+     * @param {Object} options - The options object.
+     * @param {MediaStreamTrack} options.track - The media stream track associated with the resumed consumer.
+     * @param {string} options.kind - The type of media ('audio' or 'video') being resumed.
+     * @param {string} options.remoteProducerId - The ID of the remote producer associated with the resumed consumer.
+     * @param {Object} options.params - Additional parameters related to the resumed consumer.
+     * @param {Object} options.parameters - The parameters object containing various utility functions and state.
+     * @param {Object} options.nsock - The socket associated with the consumer.
+     * @throws Throws an error if an issue occurs during the consumer resumption.
+     */
+    consumerResume: ({ track, remoteProducerId, params, parameters, nsock, }: ConsumerResumeOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConsumerResume, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConsumerResume>;
+}
+export {};

package/dist/lib/consumers/control-media.service.d.ts

@@ -0,0 +1,40 @@
+import { Socket } from 'socket.io-client';
+import { CoHostResponsibility, Participant, ShowAlert } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface ControlMediaOptions {
+    participantId: string;
+    participantName: string;
+    type: 'audio' | 'video' | 'screenshare' | 'all';
+    socket: Socket;
+    coHostResponsibility: CoHostResponsibility[];
+    participants: Participant[];
+    member: string;
+    islevel: string;
+    showAlert?: ShowAlert;
+    coHost: string;
+    roomName: string;
+}
+export type ControlMediaType = (options: ControlMediaOptions) => Promise<void>;
+export declare class ControlMedia {
+    /**
+     * Controls the media of a participant in a media session if certain conditions are met.
+     *
+     * @param {Object} options - The options for controlling media.
+     * @param {string} options.participantId - The ID of the participant to control.
+     * @param {string} options.participantName - The name of the participant to control.
+     * @param {string} options.type - The type of media to control.
+     * @param {Socket} options.socket - The socket instance for communication.
+     * @param {Array} options.coHostResponsibility - List of co-host responsibilities.
+     * @param {Array} options.participants - List of participants in the session.
+     * @param {string} options.member - The current member attempting to control media.
+     * @param {string} options.islevel - The level of the current member.
+     * @param {Function} [options.showAlert] - Optional function to show alerts.
+     * @param {string} options.coHost - The co-host information.
+     * @param {string} options.roomName - The name of the room.
+     *
+     * @returns {Promise<void>} A promise that resolves when the media control operation is complete.
+     */
+    controlMedia({ participantId, participantName, type, socket, coHostResponsibility, participants, member, islevel, showAlert, coHost, roomName, }: ControlMediaOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlMedia, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ControlMedia>;
+}

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

@@ -0,0 +1,46 @@
+import { Socket } from 'socket.io-client';
+import { Device, Transport } from 'mediasoup-client/lib/types';
+import { ConnectSendTransportParameters, ConnectSendTransportType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface CreateSendTransportParameters extends ConnectSendTransportParameters {
+    islevel: string;
+    member: string;
+    socket: Socket;
+    device: Device | null;
+    transportCreated: boolean;
+    producerTransport: Transport | null;
+    updateProducerTransport: (producerTransport: Transport | null) => void;
+    updateTransportCreated: (transportCreated: boolean) => void;
+    connectSendTransport: ConnectSendTransportType;
+    getUpdatedAllParams: () => CreateSendTransportParameters;
+    [key: string]: any;
+}
+export interface CreateSendTransportOptions {
+    option: 'audio' | 'video' | 'screen' | 'all';
+    parameters: CreateSendTransportParameters;
+}
+export type CreateSendTransportType = (options: CreateSendTransportOptions) => Promise<void>;
+export declare class CreateSendTransport {
+    /**
+     * Creates a WebRTC send transport and sets up event handlers for the transport.
+     *
+     * @param {CreateSendTransportOptions} options - The options for creating the send transport.
+     * @param {Object} options.option - Additional options for the transport creation.
+     * @param {Object} options.parameters - The parameters required for creating the transport.
+     * @param {boolean} options.parameters.islevel - Indicates the level of the transport.
+     * @param {string} options.parameters.member - The member name associated with the transport.
+     * @param {Socket} options.parameters.socket - The socket instance for communication.
+     * @param {Device} options.parameters.device - The WebRTC device instance.
+     * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport is created.
+     * @param {Transport} options.parameters.producerTransport - The producer transport instance.
+     * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.
+     * @param {Function} options.parameters.updateTransportCreated - Function to update the transport creation state.
+     * @param {Function} options.parameters.connectSendTransport - Function to connect the send transport.
+     * @returns {Promise<void>} A promise that resolves when the send transport is created and configured.
+     *
+     * @throws Will throw an error if there is an issue creating the send transport.
+     */
+    createSendTransport({ option, parameters }: CreateSendTransportOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateSendTransport, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateSendTransport>;
+}

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

@@ -0,0 +1,49 @@
+import { Socket } from 'socket.io-client';
+import { PrepopulateUserMediaType, PrepopulateUserMediaParameters } from '../@types/types';
+import { Producer } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface DisconnectSendTransportAudioParameters extends PrepopulateUserMediaParameters {
+    audioProducer: Producer | null;
+    socket: Socket;
+    videoAlreadyOn: boolean;
+    islevel: string;
+    lock_screen: boolean;
+    shared: boolean;
+    updateMainWindow: boolean;
+    hostLabel: string;
+    roomName: string;
+    updateAudioProducer: (audioProducer: Producer | null) => void;
+    updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    [key: string]: any;
+}
+export interface DisconnectSendTransportAudioOptions {
+    parameters: DisconnectSendTransportAudioParameters;
+}
+export type DisconnectSendTransportAudioType = (options: DisconnectSendTransportAudioOptions) => Promise<void>;
+export declare class DisconnectSendTransportAudio {
+    /**
+     * Disconnects the send transport for audio by pausing the audio producer and updating the UI accordingly.
+     *
+     * @param {DisconnectSendTransportAudioOptions} parameters - The parameters required to disconnect the send transport for audio.
+     * @param {Object} parameters.audioProducer - The audio producer to be paused.
+     * @param {Object} parameters.socket - The socket connection to notify the server.
+     * @param {boolean} parameters.videoAlreadyOn - Flag indicating if the video is already on.
+     * @param {string} parameters.islevel - The level of the user.
+     * @param {boolean} parameters.lock_screen - Flag indicating if the screen is locked.
+     * @param {boolean} parameters.shared - Flag indicating if the screen is shared.
+     * @param {Function} parameters.updateMainWindow - Function to update the main window state.
+     * @param {string} parameters.hostLabel - The label of the host.
+     * @param {string} parameters.roomName - The name of the room.
+     * @param {Function} parameters.updateAudioProducer - Function to update the audio producer state.
+     * @param {Function} parameters.updateUpdateMainWindow - Function to update the main window update state.
+     * @param {Function} parameters.prepopulateUserMedia - Function to prepopulate user media.
+     *
+     * @returns {Promise<void>} A promise that resolves when the send transport for audio is disconnected.
+     *
+     * @throws Will throw an error if the operation fails.
+     */
+    disconnectSendTransportAudio({ parameters, }: DisconnectSendTransportAudioOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisconnectSendTransportAudio, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DisconnectSendTransportAudio>;
+}

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

@@ -0,0 +1,36 @@
+import { Producer } from 'mediasoup-client/lib/types';
+import { Socket } from 'socket.io-client';
+import * as i0 from "@angular/core";
+export interface DisconnectSendTransportScreenParameters {
+    screenProducer: Producer | null;
+    socket: Socket;
+    roomName: string;
+    updateScreenProducer: (screenProducer: Producer | null) => void;
+    getUpdatedAllParams: () => DisconnectSendTransportScreenParameters;
+    [key: string]: any;
+}
+export interface DisconnectSendTransportScreenOptions {
+    parameters: DisconnectSendTransportScreenParameters;
+}
+export type DisconnectSendTransportScreenType = (options: DisconnectSendTransportScreenOptions) => Promise<void>;
+export declare class DisconnectSendTransportScreen {
+    /**
+     * Disconnects the send transport for screen sharing.
+     *
+     * This function closes the screen producer, updates the state, and notifies the server
+     * about the closure and pausing of screen sharing.
+     *
+     * @param {DisconnectSendTransportScreenOptions} options - The options for disconnecting the send transport.
+     * @param {Object} options.parameters - The parameters required for disconnection.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {Object} options.parameters.screenProducer - The screen producer to be closed.
+     * @param {Object} options.parameters.socket - The socket connection to notify the server.
+     * @param {string} options.parameters.roomName - The name of the room.
+     * @param {Function} options.parameters.updateScreenProducer - Function to update the screen producer state.
+     * @returns {Promise<void>} A promise that resolves when the disconnection process is complete.
+     * @throws {Error} If an error occurs during the disconnection process.
+     */
+    disconnectSendTransportScreen({ parameters, }: DisconnectSendTransportScreenOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisconnectSendTransportScreen, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DisconnectSendTransportScreen>;
+}

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

@@ -0,0 +1,43 @@
+import { Producer } from 'mediasoup-client/lib/types';
+import { Socket } from 'socket.io-client';
+import { ReorderStreamsType, ReorderStreamsParameters } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface DisconnectSendTransportVideoParameters extends ReorderStreamsParameters {
+    videoProducer: Producer | null;
+    socket: Socket;
+    islevel: string;
+    roomName: string;
+    lock_screen: boolean;
+    updateMainWindow: boolean;
+    updateUpdateMainWindow: (state: boolean) => void;
+    updateVideoProducer: (producer: Producer | null) => void;
+    reorderStreams: ReorderStreamsType;
+    [key: string]: any;
+}
+export interface DisconnectSendTransportVideoOptions {
+    parameters: DisconnectSendTransportVideoParameters;
+}
+export type DisconnectSendTransportVideoType = (options: DisconnectSendTransportVideoOptions) => Promise<void>;
+export declare class DisconnectSendTransportVideo {
+    /**
+     * Disconnects the send transport for video, closes the video producer, and updates the state.
+     *
+     * @param {DisconnectSendTransportVideoOptions} parameters - The parameters required for disconnecting the send transport.
+     * @param {Producer} parameters.videoProducer - The video producer to be closed.
+     * @param {Socket} parameters.socket - The socket instance for communication.
+     * @param {string} parameters.islevel - The participant's level.
+     * @param {string} parameters.roomName - The name of the room.
+     * @param {boolean} parameters.updateMainWindow - Flag to update the main window.
+     * @param {boolean} parameters.lock_screen - Flag indicating if the screen is locked.
+     * @param {Function} parameters.updateUpdateMainWindow - Function to update the main window state.
+     * @param {Function} parameters.updateVideoProducer - Function to update the video producer state.
+     * @param {Function} parameters.reorderStreams - Function to reorder streams.
+     *
+     * @returns {Promise<void>} - A promise that resolves when the disconnection process is complete.
+     *
+     * @throws {Error} - Throws an error if the disconnection process fails.
+     */
+    disconnectSendTransportVideo({ parameters, }: DisconnectSendTransportVideoOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisconnectSendTransportVideo, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DisconnectSendTransportVideo>;
+}

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

@@ -0,0 +1,92 @@
+import { Stream, Participant, Transport, PrepopulateUserMediaParameters, PrepopulateUserMediaType, RePortParameters, RePortType, ProcessConsumerTransportsParameters, ProcessConsumerTransportsType, ResumePauseStreamsParameters, ResumePauseStreamsType, ReadjustParameters, ReadjustType, AddVideosGridType, AddVideosGridParameters, GetEstimateType, CheckGridType, ResumePauseAudioStreamsParameters, ResumePauseAudioStreamsType, GetEstimateParameters, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface DispStreamsParameters extends PrepopulateUserMediaParameters, RePortParameters, ProcessConsumerTransportsParameters, ResumePauseStreamsParameters, ReadjustParameters, ResumePauseAudioStreamsParameters, GetEstimateParameters, AddVideosGridParameters {
+    consumerTransports: Transport[];
+    streamNames: Stream[];
+    audStreamNames: Stream[];
+    participants: Participant[];
+    ref_participants: Participant[];
+    recordingDisplayType: 'video' | 'media' | 'all';
+    recordingVideoOptimized: boolean;
+    meetingDisplayType: string;
+    meetingVideoOptimized: boolean;
+    currentUserPage: number;
+    hostLabel: string;
+    mainHeightWidth: number;
+    prevMainHeightWidth: number;
+    prevDoPaginate: boolean;
+    doPaginate: boolean;
+    firstAll: boolean;
+    shared: boolean;
+    shareScreenStarted: boolean;
+    shareEnded: boolean;
+    oldAllStreams: (Stream | Participant)[];
+    updateMainWindow: boolean;
+    remoteProducerId?: string;
+    activeNames: string[];
+    dispActiveNames: string[];
+    p_dispActiveNames: string[];
+    nForReadjustRecord: number;
+    first_round: boolean;
+    lock_screen: boolean;
+    chatRefStreams: (Stream | Participant)[];
+    eventType: EventType;
+    islevel: string;
+    localStreamVideo: MediaStream | null;
+    breakOutRoomStarted: boolean;
+    breakOutRoomEnded: boolean;
+    keepBackground: boolean;
+    virtualStream: MediaStream | null;
+    updateActiveNames: (names: string[]) => void;
+    updateDispActiveNames: (names: string[]) => void;
+    updateLStreams: (streams: (Stream | Participant)[]) => void;
+    updateChatRefStreams: (streams: (Stream | Participant)[]) => void;
+    updateNForReadjustRecord: (n: number) => void;
+    updateUpdateMainWindow: (value: boolean) => void;
+    updateShowMiniView: (value: boolean) => void;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    rePort: RePortType;
+    processConsumerTransports: ProcessConsumerTransportsType;
+    resumePauseStreams: ResumePauseStreamsType;
+    readjust: ReadjustType;
+    addVideosGrid: AddVideosGridType;
+    getEstimate: GetEstimateType;
+    checkGrid: CheckGridType;
+    resumePauseAudioStreams: ResumePauseAudioStreamsType;
+    getUpdatedAllParams: () => DispStreamsParameters;
+    [key: string]: any;
+}
+export interface DispStreamsOptions {
+    lStreams: (Stream | Participant)[];
+    ind: number;
+    auto?: boolean;
+    ChatSkip?: boolean;
+    forChatCard?: any;
+    forChatID?: any;
+    parameters: DispStreamsParameters;
+    breakRoom?: number;
+    inBreakRoom?: boolean;
+}
+export type DispStreamsType = (options: DispStreamsOptions) => Promise<void>;
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DispStreams, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DispStreams>;
+}

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

@@ -0,0 +1,41 @@
+import { Participant, Stream, DispStreamsType, DispStreamsParameters } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface GeneratePageContentParameters extends DispStreamsParameters {
+    paginatedStreams: (Participant | Stream)[][];
+    currentUserPage: number;
+    updateMainWindow: boolean;
+    updateCurrentUserPage: (page: number) => void;
+    updateUpdateMainWindow: (flag: boolean) => void;
+    dispStreams: DispStreamsType;
+    getUpdatedAllParams: () => GeneratePageContentParameters;
+    [key: string]: any;
+}
+export interface GeneratePageContentOptions {
+    page: number | string;
+    parameters: GeneratePageContentParameters;
+    breakRoom?: number;
+    inBreakRoom?: boolean;
+}
+export type GeneratePageContentType = (options: GeneratePageContentOptions) => Promise<void>;
+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

@@ -0,0 +1,46 @@
+import { CalculateRowsAndColumnsType, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface GetEstimateParameters {
+    fixedPageLimit: number;
+    screenPageLimit: number;
+    shareScreenStarted: boolean;
+    shared?: boolean;
+    eventType: EventType;
+    removeAltGrid: boolean;
+    isWideScreen: boolean;
+    isMediumScreen: boolean;
+    updateRemoveAltGrid: (value: boolean) => void;
+    calculateRowsAndColumns: CalculateRowsAndColumnsType;
+    [key: string]: any;
+}
+export interface GetEstimateOptions {
+    n: number;
+    parameters: GetEstimateParameters;
+}
+export type GetEstimateType = (options: GetEstimateOptions) => [number, 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/get-piped-producers-alt.service.d.ts

@@ -0,0 +1,33 @@
+import { Socket } from 'socket.io-client';
+import { SignalNewConsumerTransportParameters, SignalNewConsumerTransportType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface GetPipedProducersAltParameters extends SignalNewConsumerTransportParameters {
+    member: string;
+    signalNewConsumerTransport: SignalNewConsumerTransportType;
+    [key: string]: any;
+}
+export interface GetPipedProducersAltOptions {
+    nsock: Socket;
+    islevel: string;
+    parameters: GetPipedProducersAltParameters;
+}
+export type GetPipedProducersAltType = (options: GetPipedProducersAltOptions) => Promise<void>;
+export declare class GetPipedProducersAlt {
+    /**
+     * Retrieves piped producers and signals new consumer transport for each retrieved producer.
+     *
+     * @param {Object} options - The options for retrieving piped producers.
+     * @param {WebSocket} options.nsock - The WebSocket instance used for communication.
+     * @param {boolean} options.islevel - A flag indicating the level of the request.
+     * @param {Object} options.parameters - Additional parameters for the request.
+     * @param {string} options.parameters.member - The member identifier.
+     * @param {Function} options.parameters.signalNewConsumerTransport - A function to signal new consumer transport.
+     *
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     *
+     * @throws {Error} If an error occurs during the process of retrieving producers.
+     */
+    getPipedProducersAlt({ nsock, islevel, parameters, }: GetPipedProducersAltOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetPipedProducersAlt, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetPipedProducersAlt>;
+}

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

@@ -0,0 +1,33 @@
+import { Socket } from 'socket.io-client';
+import { SignalNewConsumerTransportParameters, SignalNewConsumerTransportType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface GetProducersPipedParameters extends SignalNewConsumerTransportParameters {
+    member: string;
+    signalNewConsumerTransport: SignalNewConsumerTransportType;
+    [key: string]: any;
+}
+export interface GetProducersPipedOptions {
+    nsock: Socket;
+    islevel: string;
+    parameters: GetProducersPipedParameters;
+}
+export type GetProducersPipedType = (options: GetProducersPipedOptions) => Promise<void>;
+export declare class GetProducersPiped {
+    /**
+     * Retrieves piped producers and signals new consumer transport for each retrieved producer.
+     *
+     * @param {Object} options - The options for getting piped producers.
+     * @param {WebSocket} options.nsock - The WebSocket instance used for communication.
+     * @param {boolean} options.islevel - A flag indicating the level of the operation.
+     * @param {Object} options.parameters - Additional parameters for the operation.
+     * @param {string} options.parameters.member - The member identifier.
+     * @param {Function} options.parameters.signalNewConsumerTransport - The function to signal new consumer transport.
+     *
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     *
+     * @throws {Error} If an error occurs during the process of retrieving producers.
+     */
+    getProducersPiped({ nsock, islevel, parameters }: GetProducersPipedOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetProducersPiped, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetProducersPiped>;
+}