mediasfu-angular 1.0.0

package/dist/lib/consumers/stream-success-screen.service.d.ts

@@ -0,0 +1,78 @@
+import { Socket } from 'socket.io-client';
+import { SleepType, CreateSendTransportType, ConnectSendTransportScreenType, DisconnectSendTransportScreenType, StopShareScreenType, ReorderStreamsType, PrepopulateUserMediaType, RePortType, ShowAlert, CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface StreamSuccessScreenParameters extends CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters {
+    socket: Socket;
+    transportCreated: boolean;
+    localStreamScreen: MediaStream | null;
+    screenAlreadyOn: boolean;
+    screenAction: boolean;
+    transportCreatedScreen: boolean;
+    hostLabel: string;
+    eventType: EventType;
+    showAlert?: ShowAlert;
+    annotateScreenStream: boolean;
+    shared: boolean;
+    updateTransportCreatedScreen: (transportCreatedScreen: boolean) => void;
+    updateScreenAlreadyOn: (screenAlreadyOn: boolean) => void;
+    updateScreenAction: (screenAction: boolean) => void;
+    updateTransportCreated: (transportCreated: boolean) => void;
+    updateLocalStreamScreen: (localStreamScreen: MediaStream | null) => void;
+    updateShared: (shared: boolean) => void;
+    updateIsScreenboardModalVisible: (isVisible: boolean) => void;
+    sleep: SleepType;
+    createSendTransport: CreateSendTransportType;
+    connectSendTransportScreen: ConnectSendTransportScreenType;
+    disconnectSendTransportScreen: DisconnectSendTransportScreenType;
+    stopShareScreen: StopShareScreenType;
+    reorderStreams: ReorderStreamsType;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    rePort: RePortType;
+    getUpdatedAllParams: () => StreamSuccessScreenParameters;
+    [key: string]: any;
+}
+export interface StreamSuccessScreenOptions {
+    stream: MediaStream;
+    parameters: StreamSuccessScreenParameters;
+}
+export type StreamSuccessScreenType = (options: StreamSuccessScreenOptions) => Promise<void>;
+export declare class StreamSuccessScreen {
+    /**
+     * Handles the successful initiation of screen sharing.
+     *
+     * @param {StreamSuccessScreenOptions} options - The options for the screen sharing success handler.
+     * @param {MediaStream} options.stream - The media stream to be shared.
+     * @param {Object} options.parameters - The parameters required for screen sharing.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {Socket} options.parameters.socket - The socket instance for communication.
+     * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport is already created.
+     * @param {MediaStream} options.parameters.localStreamScreen - The local screen media stream.
+     * @param {boolean} options.parameters.screenAlreadyOn - Flag indicating if the screen is already being shared.
+     * @param {boolean} options.parameters.screenAction - Flag indicating if the screen share action is requested.
+     * @param {boolean} options.parameters.transportCreatedScreen - Flag indicating if the screen transport is created.
+     * @param {string} options.parameters.hostLabel - The label of the host.
+     * @param {string} options.parameters.eventType - The type of the event (e.g., conference).
+     * @param {Function} options.parameters.showAlert - Function to show alerts.
+     * @param {boolean} options.parameters.annotateScreenStream - Flag indicating if screen annotation is enabled.
+     * @param {Function} options.parameters.updateTransportCreatedScreen - Function to update the screen transport creation state.
+     * @param {Function} options.parameters.updateScreenAlreadyOn - Function to update the screen sharing state.
+     * @param {Function} options.parameters.updateScreenAction - Function to update the screen action state.
+     * @param {Function} options.parameters.updateTransportCreated - Function to update the transport creation state.
+     * @param {Function} options.parameters.updateLocalStreamScreen - Function to update the local screen stream.
+     * @param {Function} options.parameters.updateShared - Function to update the shared state.
+     * @param {Function} options.parameters.updateIsScreenboardModalVisible - Function to update the screenboard modal visibility.
+     * @param {Function} options.parameters.sleep - Function to pause execution for a specified duration.
+     * @param {Function} options.parameters.createSendTransport - Function to create a send transport.
+     * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the send transport for screen sharing.
+     * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport for screen sharing.
+     * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.
+     * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
+     * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     * @param {Function} options.parameters.rePort - Function to reinitialize ports.
+     *
+     * @returns {Promise<void>} A promise that resolves when the screen sharing setup is complete.
+     */
+    streamSuccessScreen({ stream, parameters }: StreamSuccessScreenOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StreamSuccessScreen, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StreamSuccessScreen>;
+}

package/dist/lib/consumers/stream-success-video.service.d.ts

@@ -0,0 +1,76 @@
+import { Device, ProducerOptions, Producer } from 'mediasoup-client/lib/types';
+import { Socket } from 'socket.io-client';
+import { ConnectSendTransportVideoParameters, Participant, ShowAlert, CreateSendTransportParameters, ReorderStreamsParameters, SleepType, CreateSendTransportType, ConnectSendTransportVideoType, ReorderStreamsType, VParamsType, HParamsType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface StreamSuccessVideoParameters extends CreateSendTransportParameters, ConnectSendTransportVideoParameters, ReorderStreamsParameters {
+    socket: Socket;
+    participants: Participant[];
+    localStream: MediaStream | null;
+    transportCreated: boolean;
+    transportCreatedVideo: boolean;
+    videoAlreadyOn: boolean;
+    videoAction: boolean;
+    videoParams: ProducerOptions;
+    localStreamVideo: MediaStream | null;
+    defVideoID: string;
+    userDefaultVideoInputDevice: string;
+    params: ProducerOptions;
+    videoParamse?: ProducerOptions;
+    islevel: string;
+    member: string;
+    updateMainWindow: boolean;
+    lock_screen: boolean;
+    shared: boolean;
+    shareScreenStarted: boolean;
+    vParams: VParamsType;
+    hParams: HParamsType;
+    allowed: boolean;
+    currentFacingMode: string;
+    device: Device | null;
+    keepBackground: boolean;
+    appliedBackground: boolean;
+    videoProducer: Producer | null;
+    updateTransportCreatedVideo: (created: boolean) => void;
+    updateVideoAlreadyOn: (videoOn: boolean) => void;
+    updateVideoAction: (videoAction: boolean) => void;
+    updateLocalStream: (stream: MediaStream | null) => void;
+    updateLocalStreamVideo: (stream: MediaStream | null) => void;
+    updateUserDefaultVideoInputDevice: (device: string) => void;
+    updateCurrentFacingMode: (mode: string) => void;
+    updateDefVideoID: (id: string) => void;
+    updateAllowed: (allowed: boolean) => void;
+    updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+    updateParticipants: (participants: Participant[]) => void;
+    updateVideoParams: (params: ProducerOptions) => void;
+    updateIsBackgroundModalVisible: (isVisible: boolean) => void;
+    updateAutoClickBackground: (autoClick: boolean) => void;
+    showAlert?: ShowAlert;
+    createSendTransport: CreateSendTransportType;
+    connectSendTransportVideo: ConnectSendTransportVideoType;
+    reorderStreams: ReorderStreamsType;
+    sleep: SleepType;
+    getUpdatedAllParams: () => StreamSuccessVideoParameters;
+    [key: string]: any;
+}
+export interface StreamSuccessVideoOptions {
+    stream: MediaStream;
+    parameters: StreamSuccessVideoParameters;
+}
+export type StreamSuccessVideoType = (options: StreamSuccessVideoOptions) => Promise<void>;
+export declare class StreamSuccessVideo {
+    /**
+     * Streams a video successfully by managing the local stream, updating parameters, and handling video transport.
+     *
+     * @param {StreamSuccessVideoOptions} options - The options for streaming the video.
+     * @param {MediaStream} options.stream - The media stream to be used for the video.
+     * @param {Object} options.parameters - The parameters required for streaming.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     *
+     * @returns {Promise<void>} A promise that resolves when the video has been successfully streamed.
+     *
+     * @throws Will throw an error if there is an issue with streaming the video.
+     */
+    streamSuccessVideo: ({ stream, parameters }: StreamSuccessVideoOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StreamSuccessVideo, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StreamSuccessVideo>;
+}

package/dist/lib/consumers/switch-user-audio.service.d.ts

@@ -0,0 +1,41 @@
+import { ShowAlert, StreamSuccessAudioSwitchType, RequestPermissionAudioType, StreamSuccessAudioSwitchParameters } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface SwitchUserAudioParameters extends StreamSuccessAudioSwitchParameters {
+    userDefaultAudioInputDevice: string;
+    prevAudioInputDevice: string;
+    showAlert?: ShowAlert;
+    hasAudioPermission: boolean;
+    updateUserDefaultAudioInputDevice: (deviceId: string) => void;
+    streamSuccessAudioSwitch: StreamSuccessAudioSwitchType;
+    requestPermissionAudio: RequestPermissionAudioType;
+    checkMediaPermission: boolean;
+    [key: string]: any;
+}
+export interface SwitchUserAudioOptions {
+    audioPreference: string;
+    parameters: SwitchUserAudioParameters;
+}
+export type SwitchUserAudioType = (options: SwitchUserAudioOptions) => Promise<void>;
+export declare class SwitchUserAudio {
+    /**
+     * Switches the user's audio input device based on the provided audio preference.
+     *
+     * @param {SwitchUserAudioOptions} options - The options for switching the user's audio input device.
+     * @param {string} options.audioPreference - The preferred audio input device ID.
+     * @param {Object} options.parameters - Additional parameters required for switching the audio input device.
+     * @param {string} options.parameters.prevAudioInputDevice - The previous audio input device ID.
+     * @param {Function} options.parameters.showAlert - Function to show alert messages.
+     * @param {boolean} options.parameters.hasAudioPermission - Flag indicating if the user has granted audio permission.
+     * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update the user's default audio input device.
+     * @param {Function} options.parameters.streamSuccessAudioSwitch - Function to handle successful audio stream switch.
+     * @param {Function} options.parameters.requestPermissionAudio - Function to request audio permission from the user.
+     * @param {Function} options.parameters.checkMediaPermission - Function to check if media permission is granted.
+     *
+     * @returns {Promise<void>} A promise that resolves when the audio input device has been successfully switched.
+     *
+     * @throws Will throw an error if the audio input device cannot be accessed or if there is an unexpected error.
+     */
+    switchUserAudio({ audioPreference, parameters }: SwitchUserAudioOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchUserAudio, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchUserAudio>;
+}

package/dist/lib/consumers/switch-user-video-alt.service.d.ts

@@ -0,0 +1,43 @@
+import { ClickVideo, ClickVideoParameters } from '../methods/stream-methods/click-video.service';
+import { ShowAlert, VidCons, RequestPermissionCameraType, StreamSuccessVideoType, SleepType, StreamSuccessVideoParameters } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface SwitchUserVideoAltParameters extends StreamSuccessVideoParameters, ClickVideoParameters {
+    audioOnlyRoom: boolean;
+    frameRate: number;
+    vidCons: VidCons;
+    showAlert?: ShowAlert;
+    hasCameraPermission: boolean;
+    updateVideoSwitching: (state: boolean) => void;
+    updateCurrentFacingMode: (mode: string) => void;
+    requestPermissionCamera: RequestPermissionCameraType;
+    streamSuccessVideo: StreamSuccessVideoType;
+    sleep: SleepType;
+    checkMediaPermission: boolean;
+    getUpdatedAllParams: () => SwitchUserVideoAltParameters;
+    [key: string]: any;
+}
+export interface SwitchUserVideoAltOptions {
+    videoPreference: string;
+    checkoff: boolean;
+    parameters: SwitchUserVideoAltParameters;
+}
+export type SwitchUserVideoAltType = (options: SwitchUserVideoAltOptions) => Promise<void>;
+export declare class SwitchUserVideoAlt {
+    private ClickVideoService;
+    constructor(ClickVideoService: ClickVideo);
+    /**
+     * Switches the user's video stream based on the provided video preference and other parameters.
+     *
+     * @param {Object} options - The options for switching the user's video.
+     * @param {string} options.videoPreference - The preferred video facing mode (e.g., "user" or "environment").
+     * @param {boolean} options.checkoff - A flag indicating whether to turn off the video before switching.
+     * @param {SwitchUserVideoAltOptions} options.parameters - The parameters required for switching the video.
+     *
+     * @returns {Promise<void>} A promise that resolves when the video switching is complete.
+     *
+     * @throws Will throw an error if there is an issue with switching the video.
+     */
+    switchUserVideoAlt({ videoPreference, checkoff, parameters, }: SwitchUserVideoAltOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchUserVideoAlt, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchUserVideoAlt>;
+}

package/dist/lib/consumers/switch-user-video.service.d.ts

@@ -0,0 +1,61 @@
+import { ClickVideo, ClickVideoParameters } from '../methods/stream-methods/click-video.service';
+import { ShowAlert, VidCons, RequestPermissionCameraType, StreamSuccessVideoType, SleepType, StreamSuccessVideoParameters } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface SwitchUserVideoParameters extends StreamSuccessVideoParameters, ClickVideoParameters {
+    audioOnlyRoom: boolean;
+    frameRate: number;
+    vidCons: VidCons;
+    prevVideoInputDevice: string;
+    userDefaultVideoInputDevice: string;
+    showAlert?: ShowAlert;
+    hasCameraPermission: boolean;
+    updateVideoSwitching: (state: boolean) => void;
+    updateUserDefaultVideoInputDevice: (deviceId: string) => void;
+    requestPermissionCamera: RequestPermissionCameraType;
+    streamSuccessVideo: StreamSuccessVideoType;
+    sleep: SleepType;
+    checkMediaPermission: boolean;
+    getUpdatedAllParams: () => SwitchUserVideoParameters;
+    [key: string]: any;
+}
+export interface SwitchUserVideoOptions {
+    videoPreference: string;
+    checkoff: boolean;
+    parameters: SwitchUserVideoParameters;
+}
+export type SwitchUserVideoType = (options: SwitchUserVideoOptions) => Promise<void>;
+export declare class SwitchUserVideo {
+    private ClickVideoService;
+    constructor(ClickVideoService: ClickVideo);
+    /**
+     * Switches the user's video input device based on the provided options.
+     *
+     * @param {SwitchUserVideoOptions} options - The options for switching the user's video.
+     * @param {string} options.videoPreference - The preferred video input device ID.
+     * @param {boolean} options.checkoff - Flag indicating whether to turn off the video.
+     * @param {Object} options.parameters - Additional parameters required for switching the video.
+     * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the room is audio-only.
+     * @param {number} options.parameters.frameRate - The desired frame rate for the video.
+     * @param {Object} options.parameters.vidCons - Video constraints such as width and height.
+     * @param {string} options.parameters.prevVideoInputDevice - The previous video input device ID.
+     * @param {Function} options.parameters.showAlert - Function to show alerts to the user.
+     * @param {boolean} options.parameters.hasCameraPermission - Indicates if the user has camera permission.
+     * @param {Function} options.parameters.updateVideoSwitching - Function to update video switching state.
+     * @param {Function} options.parameters.updateUserDefaultVideoInputDevice - Function to update the default video input device.
+     * @param {Function} options.parameters.requestPermissionCamera - Function to request camera permission.
+     * @param {Function} options.parameters.streamSuccessVideo - Function to handle successful video stream.
+     * @param {Function} options.parameters.sleep - Function to pause execution for a specified duration.
+     * @param {Function} options.parameters.checkMediaPermission - Function to check media permissions.
+     *
+     * @returns {Promise<void>} A promise that resolves when the video input device has been switched.
+     *
+     * @throws Will throw an error if switching the video input device fails.
+     */
+    switchUserVideo: ({ videoPreference, checkoff, parameters, }: {
+        videoPreference: string;
+        checkoff: boolean;
+        parameters: any;
+    }) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchUserVideo, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchUserVideo>;
+}

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

@@ -0,0 +1,72 @@
+import { Socket } from 'socket.io-client';
+import { Participant, AutoAdjustType, ScreenState, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface TriggerParameters {
+    socket: Socket;
+    roomName: string;
+    screenStates: ScreenState[];
+    participants: Participant[];
+    updateDateState?: number | null;
+    lastUpdate: number | null;
+    nForReadjust: number;
+    eventType: EventType;
+    shared: boolean;
+    shareScreenStarted: boolean;
+    whiteboardStarted: boolean;
+    whiteboardEnded: boolean;
+    updateUpdateDateState: (timestamp: number | null) => void;
+    updateLastUpdate: (lastUpdate: number | null) => void;
+    updateNForReadjust: (nForReadjust: number) => void;
+    autoAdjust: AutoAdjustType;
+    getUpdatedAllParams: () => TriggerParameters;
+    [key: string]: any;
+}
+export interface TriggerOptions {
+    ref_ActiveNames: string[];
+    parameters: TriggerParameters;
+}
+export type TriggerType = (options: TriggerOptions) => Promise<void>;
+export declare class Trigger {
+    /**
+     * Triggers an update to the screen client based on the provided parameters.
+     *
+     * @param {TriggerOptions} options - The options for triggering the update.
+     * @param {string[]} options.ref_ActiveNames - Reference to the active names.
+     * @param {Parameters} options.parameters - The parameters for the trigger.
+     * @returns {Promise<void>} A promise that resolves when the trigger is complete.
+     *
+     * @throws Will throw an error if the updateScreenClient operation fails.
+     *
+     * @remarks
+     * This function handles various conditions to determine the main screen person,
+     * adjusts the screen states, and emits an update to the screen client via socket.
+     *
+     * @example
+     * ```typescript
+     * await trigger({
+     *   ref_ActiveNames: ["user1", "user2"],
+     *   parameters: {
+     *     socket: socketInstance,
+     *     roomName: "room1",
+     *     screenStates: [{ mainScreenPerson: "user1", mainScreenFilled: true, adminOnMainScreen: false }],
+     *     participants: [{ name: "admin", islevel: "2" }],
+     *     updateDateState: 0,
+     *     lastUpdate: null,
+     *     nForReadjust: 0,
+     *     eventType: "conference",
+     *     shared: false,
+     *     shareScreenStarted: false,
+     *     whiteboardStarted: false,
+     *     whiteboardEnded: false,
+     *     updateUpdateDateState: (date) => {},
+     *     updateLastUpdate: (date) => {},
+     *     updateNForReadjust: (n) => {},
+     *     autoAdjust: async ({ n, parameters }) => [n, 0],
+     *   },
+     * });
+     * ```
+     */
+    trigger({ ref_ActiveNames, parameters }: TriggerOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Trigger, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Trigger>;
+}

package/dist/lib/consumers/update-mini-cards-grid.service.d.ts

@@ -0,0 +1,54 @@
+import { GridSizes, ComponentSizes, EventType } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface UpdateMiniCardsGridParameters {
+    updateGridRows: (rows: number) => void;
+    updateGridCols: (cols: number) => void;
+    updateAltGridRows: (rows: number) => void;
+    updateAltGridCols: (cols: number) => void;
+    updateGridSizes: (gridSizes: GridSizes) => void;
+    gridSizes: GridSizes;
+    paginationDirection: string;
+    paginationHeightWidth: number;
+    doPaginate: boolean;
+    componentSizes: ComponentSizes;
+    eventType: EventType;
+    getUpdatedAllParams: () => UpdateMiniCardsGridParameters;
+    [key: string]: any;
+}
+export interface UpdateMiniCardsGridOptions {
+    rows: number;
+    cols: number;
+    defal?: boolean;
+    actualRows?: number;
+    parameters: UpdateMiniCardsGridParameters;
+}
+export type UpdateMiniCardsGridType = (options: UpdateMiniCardsGridOptions) => Promise<void>;
+export declare class UpdateMiniCardsGrid {
+    /**
+     * Updates the mini cards grid based on the specified rows and columns.
+     *
+     * @param {object} options - The function parameters.
+     * @param {number} options.rows - The number of rows in the grid.
+     * @param {number} options.cols - The number of columns in the grid.
+     * @param {boolean} options.defal - Flag indicating whether to update the default grid or an alternative grid.
+     * @param {number} options.actualRows - The actual number of rows in the grid.
+     * @param {number} options.ind - The index parameter.
+     * @param {object} options.parameters - Additional parameters needed for the function.
+     * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {function} options.parameters.updateGridRows - Function to update the grid rows.
+     * @param {function} options.parameters.updateGridCols - Function to update the grid columns.
+     * @param {function} options.parameters.updateAltGridRows - Function to update the alternative grid rows.
+     * @param {function} options.parameters.updateAltGridCols - Function to update the alternative grid columns.
+     * @param {function} options.parameters.updateGridSizes - Function to update the grid sizes.
+     * @param {object} options.parameters.gridSizes - Object containing grid width and height.
+     * @param {string} options.parameters.paginationDirection - The direction of pagination ('horizontal' or 'vertical').
+     * @param {number} options.parameters.paginationHeightWidth - The height or width of pagination.
+     * @param {boolean} options.parameters.doPaginate - Flag indicating whether pagination is enabled.
+     * @param {object} options.parameters.componentSizes - Object containing container width and height.
+     * @param {string} options.parameters.eventType - The type of event ('chat', etc.).
+     * @returns {Promise<void>} - A Promise that resolves after updating the mini cards grid.
+     */
+    updateMiniCardsGrid({ rows, cols, defal, actualRows, parameters, }: UpdateMiniCardsGridOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateMiniCardsGrid, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateMiniCardsGrid>;
+}

package/dist/lib/consumers/update-participant-audio-decibels.service.d.ts

@@ -0,0 +1,25 @@
+import { AudioDecibels } from '../@types/types';
+import * as i0 from "@angular/core";
+export interface UpdateParticipantAudioDecibelsOptions {
+    name: string;
+    averageLoudness: number;
+    audioDecibels: AudioDecibels[];
+    updateAudioDecibels: (audioDecibels: AudioDecibels[]) => void;
+}
+export type UpdateParticipantAudioDecibelsType = (options: UpdateParticipantAudioDecibelsOptions) => void;
+export declare class UpdateParticipantAudioDecibels {
+    /**
+     * Updates the audio decibels for a participant.
+     *
+     * @param {Object} options - The options for updating participant audio decibels.
+     * @param {string} options.name - The name of the participant.
+     * @param {number} options.averageLoudness - The average loudness of the participant.
+     * @param {Array<{ name: string, averageLoudness: number }>} options.audioDecibels - The array of audio decibels entries.
+     * @param {Function} options.updateAudioDecibels - The function to update the audio decibels array.
+     *
+     * @returns {void}
+     */
+    updateParticipantAudioDecibels({ name, averageLoudness, audioDecibels, updateAudioDecibels, }: UpdateParticipantAudioDecibelsOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateParticipantAudioDecibels, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateParticipantAudioDecibels>;
+}

package/dist/lib/methods/background-methods/launch-background.service.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+export interface LaunchBackgroundOptions {
+    updateIsBackgroundModalVisible: (isVisible: boolean) => void;
+    isBackgroundModalVisible: boolean;
+}
+export type LaunchBackgroundType = (options: LaunchBackgroundOptions) => void;
+export declare class LaunchBackground {
+    /**
+     * Toggles the visibility of the background modal.
+     * @function
+     * @param {Object} options - The options object containing necessary variables and functions.
+     * @param {Function} options.updateIsBackgroundModalVisible - Function to update the visibility state of the background modal.
+     * @param {boolean} options.isBackgroundModalVisible - Current visibility state of the background modal.
+     */
+    launchBackground({ updateIsBackgroundModalVisible, isBackgroundModalVisible, }: LaunchBackgroundOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchBackground, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchBackground>;
+}

package/dist/lib/methods/breakout-room-methods/breakout-room-updated.service.d.ts

@@ -0,0 +1,63 @@
+import { BreakoutParticipant, BreakoutRoomUpdatedData, OnScreenChangesParameters, OnScreenChangesType, Participant, RePortParameters, RePortType } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface BreakoutRoomUpdatedParameters extends OnScreenChangesParameters, RePortParameters {
+    breakOutRoomStarted: boolean;
+    breakOutRoomEnded: boolean;
+    breakoutRooms: BreakoutParticipant[][];
+    hostNewRoom: number;
+    islevel: string;
+    participantsAll: Participant[];
+    participants: Participant[];
+    meetingDisplayType: string;
+    prevMeetingDisplayType: string;
+    updateBreakoutRooms: (rooms: BreakoutParticipant[][]) => void;
+    updateBreakOutRoomStarted: (started: boolean) => void;
+    updateBreakOutRoomEnded: (ended: boolean) => void;
+    updateHostNewRoom: (room: number) => void;
+    updateMeetingDisplayType: (type: string) => void;
+    updateParticipantsAll: (participants: Participant[]) => void;
+    updateParticipants: (participants: Participant[]) => void;
+    onScreenChanges: OnScreenChangesType;
+    rePort: RePortType;
+    getUpdatedAllParams: () => BreakoutRoomUpdatedParameters;
+    [key: string]: any;
+}
+export interface BreakoutRoomUpdatedOptions {
+    data: BreakoutRoomUpdatedData;
+    parameters: BreakoutRoomUpdatedParameters;
+}
+export type BreakoutRoomUpdatedType = (options: BreakoutRoomUpdatedOptions) => Promise<void>;
+export declare class BreakoutRoomUpdated {
+    /**
+     * Updates the state of breakout rooms based on the provided data and parameters.
+     *
+     * @param {Object} options - The options object.
+     * @param {Object} options.data - The data object containing information about the breakout rooms.
+     * @param {Object} options.parameters - The parameters object containing various state update functions and other parameters.
+     * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room has started.
+     * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room has ended.
+     * @param {Array} options.parameters.breakoutRooms - The list of current breakout rooms.
+     * @param {number} options.parameters.hostNewRoom - The ID of the new room for the host.
+     * @param {string} options.parameters.islevel - The level of the breakout room.
+     * @param {Array} options.parameters.participantsAll - The list of all participants.
+     * @param {Array} options.parameters.participants - The list of participants who are not banned.
+     * @param {string} options.parameters.meetingDisplayType - The current display type of the meeting.
+     * @param {string} options.parameters.prevMeetingDisplayType - The previous display type of the meeting.
+     * @param {Function} options.parameters.updateBreakoutRooms - Function to update the breakout rooms.
+     * @param {Function} options.parameters.updateBreakOutRoomStarted - Function to update the breakout room started state.
+     * @param {Function} options.parameters.updateBreakOutRoomEnded - Function to update the breakout room ended state.
+     * @param {Function} options.parameters.updateHostNewRoom - Function to update the host's new room.
+     * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.
+     * @param {Function} options.parameters.updateParticipantsAll - Function to update the list of all participants.
+     * @param {Function} options.parameters.updateParticipants - Function to update the list of participants who are not banned.
+     * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.
+     * @param {Function} options.parameters.rePort - Function to handle reporting.
+     *
+     * @returns {Promise<void>} A promise that resolves when the breakout room state has been updated.
+     *
+     * @throws Will throw an error if the update process fails.
+     */
+    breakoutRoomUpdated: ({ data, parameters }: BreakoutRoomUpdatedOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreakoutRoomUpdated, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BreakoutRoomUpdated>;
+}

package/dist/lib/methods/breakout-room-methods/launch-breakout-rooms.service.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export interface LaunchBreakoutRoomsOptions {
+    updateIsBreakoutRoomsModalVisible: (isVisible: boolean) => void;
+    isBreakoutRoomsModalVisible: boolean;
+}
+export type LaunchBreakoutRoomsType = (options: LaunchBreakoutRoomsOptions) => void;
+export declare class LaunchBreakoutRooms {
+    /**
+     * Launches the breakout rooms by toggling the visibility of the breakout rooms modal.
+     *
+     * @param updateIsBreakoutRoomsModalVisible - Function to update the visibility state of the breakout rooms modal.
+     * @param isBreakoutRoomsModalVisible - Current visibility state of the breakout rooms modal.
+     */
+    launchBreakoutRooms({ updateIsBreakoutRoomsModalVisible, isBreakoutRoomsModalVisible, }: LaunchBreakoutRoomsOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchBreakoutRooms, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchBreakoutRooms>;
+}

package/dist/lib/methods/co-host-methods/launch-co-host.service.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export interface LaunchCoHostOptions {
+    updateIsCoHostModalVisible: (isVisible: boolean) => void;
+    isCoHostModalVisible: boolean;
+}
+export type LaunchCoHostType = (options: LaunchCoHostOptions) => void;
+export declare class launchCoHost {
+    /**
+     * Toggles the visibility of the co-host modal.
+     *
+     * @param updateIsCoHostModalVisible - Function to update the visibility state of the co-host modal.
+     * @param isCoHostModalVisible - Current visibility state of the co-host modal.
+     */
+    launchCoHost({ updateIsCoHostModalVisible, isCoHostModalVisible }: LaunchCoHostOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<launchCoHost, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<launchCoHost>;
+}

package/dist/lib/methods/co-host-methods/modify-co-host-settings.service.d.ts

@@ -0,0 +1,42 @@
+import { ShowAlert, CoHostResponsibility } from '../../@types/types';
+import { Socket } from 'socket.io-client';
+import * as i0 from "@angular/core";
+export interface ModifyCoHostSettingsOptions {
+    roomName: string;
+    showAlert?: ShowAlert;
+    selectedParticipant: string;
+    coHost: string;
+    coHostResponsibility: CoHostResponsibility[];
+    updateIsCoHostModalVisible: (isVisible: boolean) => void;
+    updateCoHostResponsibility: (coHostResponsibility: CoHostResponsibility[]) => void;
+    updateCoHost: (coHost: string) => void;
+    socket: Socket;
+}
+export type ModifyCoHostSettingsType = (options: ModifyCoHostSettingsOptions) => Promise<void>;
+export declare class ModifyCoHostSettings {
+    /**
+     * Modifies the co-host settings for a given room.
+     *
+     * @param {Object} options - The options for modifying co-host settings.
+     * @param {string} options.roomName - The name of the room.
+     * @param {Function} options.showAlert - Function to show an alert message.
+     * @param {string} options.selectedParticipant - The participant selected to be co-host.
+     * @param {string} options.coHost - The current co-host.
+     * @param {string} options.coHostResponsibility - The responsibility assigned to the co-host.
+     * @param {Function} options.updateIsCoHostModalVisible - Function to update the visibility of the co-host modal.
+     * @param {Function} options.updateCoHostResponsibility - Function to update the co-host responsibility.
+     * @param {Function} options.updateCoHost - Function to update the co-host.
+     * @param {Object} options.socket - The socket instance for emitting events.
+     * @returns {Promise<void>} A promise that resolves when the co-host settings have been modified.
+     *
+     * @remarks
+     * - If the room is in demo mode (room name starts with "d"), co-host cannot be added and an alert is shown.
+     * - If a valid participant is selected, they are set as the new co-host.
+     * - The co-host responsibility is updated.
+     * - A socket event is emitted to update the co-host information.
+     * - The co-host modal is closed after updating the settings.
+     */
+    modifyCoHostSettings({ roomName, showAlert, selectedParticipant, coHost, coHostResponsibility, updateIsCoHostModalVisible, updateCoHostResponsibility, updateCoHost, socket, }: ModifyCoHostSettingsOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModifyCoHostSettings, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModifyCoHostSettings>;
+}

package/dist/lib/methods/display-settings-methods/launch-display-settings.service.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export interface LaunchDisplaySettingsOptions {
+    updateIsDisplaySettingsModalVisible: (isVisible: boolean) => void;
+    isDisplaySettingsModalVisible: boolean;
+}
+export type LaunchDisplaySettingsType = (options: LaunchDisplaySettingsOptions) => void;
+export declare class LaunchDisplaySettings {
+    /**
+     * Toggles the visibility of the display settings modal.
+     *
+     * @param updateIsDisplaySettingsModalVisible - Function to update the visibility state of the display settings modal.
+     * @param isDisplaySettingsModalVisible - Current visibility state of the display settings modal.
+     */
+    launchDisplaySettings({ updateIsDisplaySettingsModalVisible, isDisplaySettingsModalVisible, }: LaunchDisplaySettingsOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchDisplaySettings, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchDisplaySettings>;
+}