mediasfu-angular 1.0.0

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

@@ -0,0 +1,74 @@
+import { OnScreenChangesParameters, OnScreenChangesType, ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ModifyDisplaySettingsParameters extends OnScreenChangesParameters {
+    showAlert?: ShowAlert;
+    meetingDisplayType: string;
+    autoWave: boolean;
+    forceFullDisplay: boolean;
+    meetingVideoOptimized: boolean;
+    islevel: string;
+    recordStarted: boolean;
+    recordResumed: boolean;
+    recordStopped: boolean;
+    recordPaused: boolean;
+    recordingDisplayType: 'video' | 'media' | 'all';
+    recordingVideoOptimized: boolean;
+    prevForceFullDisplay: boolean;
+    prevMeetingDisplayType: string;
+    updateMeetingDisplayType: (displayType: string) => void;
+    updateAutoWave: (autoWave: boolean) => void;
+    updateForceFullDisplay: (forceFullDisplay: boolean) => void;
+    updateMeetingVideoOptimized: (optimized: boolean) => void;
+    updatePrevForceFullDisplay: (forceFullDisplay: boolean) => void;
+    updatePrevMeetingDisplayType: (displayType: string) => void;
+    updateIsDisplaySettingsModalVisible: (isVisible: boolean) => void;
+    updateFirstAll: (firstAll: boolean) => void;
+    updateUpdateMainWindow: (update: boolean) => void;
+    breakOutRoomStarted: boolean;
+    breakOutRoomEnded: boolean;
+    onScreenChanges: OnScreenChangesType;
+    [key: string]: any;
+}
+export interface ModifyDisplaySettingsOptions {
+    parameters: ModifyDisplaySettingsParameters;
+}
+export type ModifyDisplaySettingsType = (options: ModifyDisplaySettingsOptions) => Promise<void>;
+export declare class ModifyDisplaySettings {
+    /**
+     * Modifies the display settings based on the provided parameters.
+     *
+     * @param {ModifyDisplaySettingsOptions} options - The options containing the parameters to modify the display settings.
+     * @param {Object} options.parameters - The parameters for modifying the display settings.
+     * @param {Function} options.parameters.showAlert - Function to show alert messages.
+     * @param {string} options.parameters.meetingDisplayType - The current meeting display type.
+     * @param {boolean} options.parameters.autoWave - Flag indicating if auto wave is enabled.
+     * @param {boolean} options.parameters.forceFullDisplay - Flag indicating if full display is forced.
+     * @param {boolean} options.parameters.meetingVideoOptimized - Flag indicating if the meeting video is optimized.
+     * @param {string} options.parameters.islevel - The current level of the meeting.
+     * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.
+     * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.
+     * @param {boolean} options.parameters.recordStopped - Flag indicating if recording has stopped.
+     * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.
+     * @param {string} options.parameters.recordingDisplayType - The current recording display type.
+     * @param {boolean} options.parameters.recordingVideoOptimized - Flag indicating if the recording video is optimized.
+     * @param {string} options.parameters.prevForceFullDisplay - The previous force full display value.
+     * @param {string} options.parameters.prevMeetingDisplayType - The previous meeting display type.
+     * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.
+     * @param {Function} options.parameters.updateAutoWave - Function to update the auto wave setting.
+     * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display setting.
+     * @param {Function} options.parameters.updateMeetingVideoOptimized - Function to update the meeting video optimization setting.
+     * @param {Function} options.parameters.updatePrevForceFullDisplay - Function to update the previous force full display setting.
+     * @param {Function} options.parameters.updatePrevMeetingDisplayType - Function to update the previous meeting display type.
+     * @param {Function} options.parameters.updateIsDisplaySettingsModalVisible - Function to update the visibility of the display settings modal.
+     * @param {Function} options.parameters.updateFirstAll - Function to update the first all setting.
+     * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+     * @param {boolean} options.parameters.breakOutRoomStarted - Flag indicating if a breakout room has started.
+     * @param {boolean} options.parameters.breakOutRoomEnded - Flag indicating if a breakout room has ended.
+     * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.
+     *
+     * @returns {Promise<void>} A promise that resolves when the display settings have been modified.
+     */
+    modifyDisplaySettings: ({ parameters }: ModifyDisplaySettingsOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModifyDisplaySettings, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModifyDisplaySettings>;
+}

package/dist/lib/methods/exit-methods/confirm-exit.service.d.ts

@@ -0,0 +1,24 @@
+import { Socket } from 'socket.io-client';
+import * as i0 from "@angular/core";
+export interface ConfirmExitOptions {
+    socket: Socket;
+    member: string;
+    roomName: string;
+    ban?: boolean;
+}
+export type ConfirmExitType = (options: ConfirmExitOptions) => Promise<void>;
+export declare class ConfirmExit {
+    /**
+     * Confirms the exit of a member from a room and optionally bans them.
+     *
+     * @param {Object} options - The options for confirming the exit.
+     * @param {Socket} options.socket - The socket instance to emit the event.
+     * @param {string} options.member - The member who is exiting.
+     * @param {string} options.roomName - The name of the room the member is exiting from.
+     * @param {boolean} [options.ban=false] - Whether to ban the member from the room.
+     * @returns {Promise<void>} A promise that resolves when the exit is confirmed.
+     */
+    confirmExit({ socket, member, roomName, ban }: ConfirmExitOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmExit, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmExit>;
+}

package/dist/lib/methods/exit-methods/launch-confirm-exit.service.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export interface LaunchConfirmExitOptions {
+    updateIsConfirmExitModalVisible: (isVisible: boolean) => void;
+    isConfirmExitModalVisible: boolean;
+}
+export type LaunchConfirmExitType = (options: LaunchConfirmExitOptions) => void;
+export declare class LaunchConfirmExit {
+    /**
+     * Toggles the visibility of the confirmation exit modal.
+     *
+     * @param updateIsConfirmExitModalVisible - Function to update the visibility state of the confirmation exit modal.
+     * @param isConfirmExitModalVisible - Current visibility state of the confirmation exit modal.
+     */
+    launchConfirmExit({ updateIsConfirmExitModalVisible, isConfirmExitModalVisible, }: LaunchConfirmExitOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchConfirmExit, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchConfirmExit>;
+}

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

@@ -0,0 +1,27 @@
+import * as i0 from "@angular/core";
+export interface LaunchMediaSettingsOptions {
+    updateIsMediaSettingsModalVisible: (isVisible: boolean) => void;
+    isMediaSettingsModalVisible: boolean;
+    audioInputs: MediaDeviceInfo[];
+    videoInputs: MediaDeviceInfo[];
+    updateAudioInputs: (inputs: MediaDeviceInfo[]) => void;
+    updateVideoInputs: (inputs: MediaDeviceInfo[]) => void;
+}
+export type LaunchMediaSettingsType = (options: LaunchMediaSettingsOptions) => Promise<void>;
+export declare class LaunchMediaSettings {
+    /**
+     * Launches the media settings modal and updates the available audio and video input devices.
+     *
+     * @param {Object} options - The options for launching media settings.
+     * @param {Function} options.updateIsMediaSettingsModalVisible - Function to update the visibility state of the media settings modal.
+     * @param {boolean} options.isMediaSettingsModalVisible - Current visibility state of the media settings modal.
+     * @param {MediaDeviceInfo[]} options.audioInputs - Array to store available audio input devices.
+     * @param {MediaDeviceInfo[]} options.videoInputs - Array to store available video input devices.
+     * @param {Function} options.updateAudioInputs - Function to update the available audio input devices.
+     * @param {Function} options.updateVideoInputs - Function to update the available video input devices.
+     * @returns {Promise<void>} A promise that resolves when the media settings have been updated.
+     */
+    launchMediaSettings({ updateIsMediaSettingsModalVisible, isMediaSettingsModalVisible, audioInputs, videoInputs, updateAudioInputs, updateVideoInputs, }: LaunchMediaSettingsOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchMediaSettings, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchMediaSettings>;
+}

package/dist/lib/methods/menu-methods/launch-menu-modal.service.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export interface LaunchMenuModalOptions {
+    updateIsMenuModalVisible: (isVisible: boolean) => void;
+    isMenuModalVisible: boolean;
+}
+export type LaunchMenuModalType = (options: LaunchMenuModalOptions) => void;
+export declare class LaunchMenuModal {
+    /**
+     * Toggles the visibility of the menu modal.
+     *
+     * @param updateIsMenuModalVisible - Function to update the visibility state of the menu modal.
+     * @param isMenuModalVisible - Current visibility state of the menu modal.
+     */
+    launchMenuModal({ updateIsMenuModalVisible, isMenuModalVisible }: LaunchMenuModalOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchMenuModal, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchMenuModal>;
+}

package/dist/lib/methods/message-methods/launch-messages.service.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+export interface LaunchMessagesOptions {
+    updateIsMessagesModalVisible: (visible: boolean) => void;
+    isMessagesModalVisible: boolean;
+}
+export type LaunchMessagesType = (options: LaunchMessagesOptions) => void;
+export declare class LaunchMessages {
+    /**
+     * Toggles the visibility state of the messages modal.
+     * If the modal is currently visible, it will be closed. If it's hidden, it will be opened.
+     *
+     * @param updateIsMessagesModalVisible - Function to update the visibility state of the messages modal.
+     * @param isMessagesModalVisible - Current visibility state of the messages modal.
+     */
+    launchMessages({ updateIsMessagesModalVisible, isMessagesModalVisible, }: LaunchMessagesOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchMessages, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchMessages>;
+}

package/dist/lib/methods/message-methods/send-message.service.d.ts

@@ -0,0 +1,48 @@
+import { Socket } from 'socket.io-client';
+import { CoHostResponsibility, ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface SendMessageOptions {
+    member: string;
+    islevel: string;
+    showAlert?: ShowAlert;
+    coHostResponsibility: CoHostResponsibility[];
+    coHost: string;
+    chatSetting: string;
+    message: string;
+    roomName: string;
+    messagesLength: number;
+    receivers: string[];
+    group: boolean;
+    sender: string;
+    socket: Socket;
+}
+export type SendMessageType = (options: SendMessageOptions) => Promise<void>;
+export declare class SendMessage {
+    /**
+     * Sends a message to the specified room.
+     *
+     * @param {Object} options - The options for sending the message.
+     * @param {string} options.member - The member sending the message.
+     * @param {string} options.islevel - The level of the member.
+     * @param {Function} options.showAlert - Function to show alert messages.
+     * @param {Array} options.coHostResponsibility - List of co-host responsibilities.
+     * @param {string} options.coHost - The co-host of the room.
+     * @param {boolean} options.chatSetting - Chat setting for the room.
+     * @param {string} options.message - The message to be sent.
+     * @param {string} options.roomName - The name of the room.
+     * @param {number} options.messagesLength - The current number of messages in the room.
+     * @param {Array} options.receivers - List of receivers for the message.
+     * @param {boolean} options.group - Indicates if the message is for a group.
+     * @param {string} options.sender - The sender of the message.
+     * @param {Object} options.socket - The socket instance for communication.
+     *
+     * @returns {Promise<void>} A promise that resolves when the message is sent.
+     *
+     * @throws Will throw an error if the message count limit is exceeded.
+     * @throws Will throw an error if the message, sender, or receivers are not valid.
+     * @throws Will throw an error if the user is not allowed to send a message in the event room.
+     */
+    sendMessage({ member, islevel, showAlert, coHostResponsibility, coHost, chatSetting, message, roomName, messagesLength, receivers, group, sender, socket, }: SendMessageOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SendMessage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SendMessage>;
+}

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

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

package/dist/lib/methods/participants-methods/message-participants.service.d.ts

@@ -0,0 +1,34 @@
+import { Participant, CoHostResponsibility, ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface MessageParticipantsOptions {
+    coHostResponsibility: CoHostResponsibility[];
+    participant: Participant;
+    member: string;
+    islevel: string;
+    showAlert?: ShowAlert;
+    coHost: string;
+    updateIsMessagesModalVisible: (isVisible: boolean) => void;
+    updateDirectMessageDetails: (participant: Participant | null) => void;
+    updateStartDirectMessage: (start: boolean) => void;
+}
+export type MessageParticipantsType = (options: MessageParticipantsOptions) => void;
+export declare class MessageParticipants {
+    /**
+     * Sends a direct message to a participant if certain conditions are met.
+     *s
+     * @param coHostResponsibility - Array of responsibilities assigned to the co-host.
+     * @param participant - The participant to whom the message is to be sent.
+     * @param member - The current member attempting to send the message.
+     * @param islevel - The level of the current member.
+     * @param showAlert - Function to show an alert message.
+     * @param coHost - The co-host member.
+     * @param updateIsMessagesModalVisible - Function to update the visibility of the messages modal.
+     * @param updateDirectMessageDetails - Function to update the details of the direct message.
+     * @param updateStartDirectMessage - Function to start the direct message.
+     *
+     * @returns void
+     */
+    messageParticipants({ coHostResponsibility, participant, member, islevel, showAlert, coHost, updateIsMessagesModalVisible, updateDirectMessageDetails, updateStartDirectMessage, }: MessageParticipantsOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageParticipants, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageParticipants>;
+}

package/dist/lib/methods/participants-methods/mute-participants.service.d.ts

@@ -0,0 +1,36 @@
+import { Socket } from 'socket.io-client';
+import { Participant, CoHostResponsibility, ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface MuteParticipantsOptions {
+    socket: Socket;
+    coHostResponsibility: CoHostResponsibility[];
+    participant: Participant;
+    member: string;
+    islevel: string;
+    showAlert?: ShowAlert;
+    coHost: string;
+    roomName: string;
+}
+export type MuteParticipantsType = (options: MuteParticipantsOptions) => Promise<void>;
+export declare class MuteParticipants {
+    /**
+     * Mutes a participant in a media session if certain conditions are met.
+     *
+     * @param {Object} options - The options for muting participants.
+     * @param {Socket} options.socket - The socket instance for communication.
+     * @param {Array} options.coHostResponsibility - List of co-host responsibilities.
+     * @param {Object} options.participant - The participant to be muted.
+     * @param {Object} options.member - The current member attempting to mute.
+     * @param {string} options.islevel - The level of the current member.
+     * @param {Function} [options.showAlert] - Optional function to show alerts.
+     * @param {Object} options.coHost - The co-host information.
+     * @param {string} options.roomName - The name of the room.
+     *
+     * @returns {Promise<void>} A promise that resolves when the participant is muted.
+     *
+     * @throws Will log an error if there is an issue accessing co-host responsibilities.
+     */
+    muteParticipants({ socket, coHostResponsibility, participant, member, islevel, showAlert, coHost, roomName, }: MuteParticipantsOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MuteParticipants, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MuteParticipants>;
+}

package/dist/lib/methods/participants-methods/remove-participants.service.d.ts

@@ -0,0 +1,38 @@
+import { Socket } from 'socket.io-client';
+import { CoHostResponsibility, Participant, ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface RemoveParticipantsOptions {
+    coHostResponsibility: CoHostResponsibility[];
+    participant: Participant;
+    member: string;
+    islevel: string;
+    showAlert?: ShowAlert;
+    coHost: string;
+    participants: Participant[];
+    socket: Socket;
+    roomName: string;
+    updateParticipants: (participants: Participant[]) => void;
+}
+export type RemoveParticipantsType = (options: RemoveParticipantsOptions) => Promise<void>;
+export declare class RemoveParticipants {
+    /**
+     * Removes a participant from the room if the user has the appropriate permissions.
+     *
+     * @param {RemoveParticipantsOptions} options - The options for removing a participant.
+     * @param {Array} options.coHostResponsibility - The responsibilities of the co-host.
+     * @param {Object} options.participant - The participant to be removed.
+     * @param {Object} options.member - The current member attempting to remove the participant.
+     * @param {string} options.islevel - The level of the current member.
+     * @param {Function} [options.showAlert] - Function to show an alert message.
+     * @param {Object} options.coHost - The co-host information.
+     * @param {Array} options.participants - The list of current participants.
+     * @param {Object} options.socket - The socket instance for emitting events.
+     * @param {string} options.roomName - The name of the room.
+     * @param {Function} options.updateParticipants - Function to update the participants list.
+     *
+     * @returns {Promise<void>} - A promise that resolves when the participant is removed.
+     */
+    removeParticipants({ coHostResponsibility, participant, member, islevel, showAlert, coHost, participants, socket, roomName, updateParticipants, }: RemoveParticipantsOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveParticipants, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveParticipants>;
+}

package/dist/lib/methods/polls-methods/handle-create-poll.service.d.ts

@@ -0,0 +1,24 @@
+import { Poll, ShowAlert } from '../../@types/types';
+import { Socket } from 'socket.io-client';
+import * as i0 from "@angular/core";
+export interface HandleCreatePollOptions {
+    poll: Poll;
+    socket: Socket;
+    roomName: string;
+    showAlert?: ShowAlert;
+    updateIsPollModalVisible: (visible: boolean) => void;
+}
+export type HandleCreatePollType = (options: HandleCreatePollOptions) => Promise<void>;
+export declare class HandleCreatePoll {
+    /**
+     * Handles the creation of a poll.
+     *
+     * @param {Object} options - The options for creating the poll.
+     * @param {Poll} options.poll - The poll object containing the poll details.
+     * @param {Object} options.parameters - Additional parameters for creating the poll.
+     * @returns {Promise<void>} - A promise that resolves when the poll is created successfully.
+     */
+    handleCreatePoll({ poll, socket, roomName, showAlert, updateIsPollModalVisible, }: HandleCreatePollOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HandleCreatePoll, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HandleCreatePoll>;
+}

package/dist/lib/methods/polls-methods/handle-end-poll.service.d.ts

@@ -0,0 +1,27 @@
+import { Socket } from 'socket.io-client';
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface HandleEndPollOptions {
+    pollId: string;
+    socket: Socket;
+    showAlert?: ShowAlert;
+    roomName: string;
+    updateIsPollModalVisible: (visible: boolean) => void;
+}
+export type HandleEndPollType = (options: HandleEndPollOptions) => Promise<void>;
+export declare class HandleEndPoll {
+    /**
+     * Handles the end of a poll by emitting an "endPoll" event through the provided socket.
+     * Displays an alert based on the success or failure of the operation.
+     *
+     * @param {Object} options - The options for ending the poll.
+     * @param {string} options.pollId - The ID of the poll to end.
+     * @param {Socket} options.socket - The socket instance to emit the event.
+     * @param {Function} [options.showAlert] - Optional function to display alerts.
+     * @param {string} options.roomName - The name of the room where the poll is being conducted.
+     * @returns {Promise<void>} A promise that resolves when the poll end operation is complete.
+     */
+    handleEndPoll({ pollId, socket, showAlert, roomName, updateIsPollModalVisible, }: HandleEndPollOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HandleEndPoll, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HandleEndPoll>;
+}

package/dist/lib/methods/polls-methods/handle-vote-poll.service.d.ts

@@ -0,0 +1,33 @@
+import { Socket } from 'socket.io-client';
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface HandleVotePollOptions {
+    pollId: string;
+    optionIndex: number;
+    socket: Socket;
+    showAlert?: ShowAlert;
+    member: string;
+    roomName: string;
+    updateIsPollModalVisible: (isVisible: boolean) => void;
+}
+export type HandleVotePollType = (options: HandleVotePollOptions) => Promise<void>;
+export declare class HandleVotePoll {
+    /**
+     * Handles the voting process for a poll.
+     *
+     * @param {Object} options - The options for handling the vote.
+     * @param {string} options.pollId - The ID of the poll.
+     * @param {number} options.optionIndex - The index of the selected option.
+     * @param {Socket} options.socket - The socket instance for communication.
+     * @param {Function} [options.showAlert] - Optional function to show alerts.
+     * @param {Object} options.member - The member who is voting.
+     * @param {string} options.roomName - The name of the room where the poll is conducted.
+     * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+     * @returns {Promise<void>} A promise that resolves when the vote is handled.
+     *
+     * @throws Will log an error message if there is an issue submitting the vote.
+     */
+    handleVotePoll({ pollId, optionIndex, socket, showAlert, member, roomName, updateIsPollModalVisible, }: HandleVotePollOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HandleVotePoll, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HandleVotePoll>;
+}

package/dist/lib/methods/polls-methods/launch-poll.service.d.ts

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

package/dist/lib/methods/polls-methods/poll-updated.service.d.ts

@@ -0,0 +1,34 @@
+import { Poll, ShowAlert, PollUpdatedData } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface PollUpdatedOptions {
+    data: PollUpdatedData;
+    polls: Poll[];
+    poll: Poll;
+    member: string;
+    islevel: string;
+    showAlert?: ShowAlert;
+    updatePolls: (polls: Poll[]) => void;
+    updatePoll: (poll: Poll) => void;
+    updateIsPollModalVisible: (isVisible: boolean) => void;
+}
+export type PollUpdatedType = (options: PollUpdatedOptions) => Promise<void>;
+export declare class PollUpdated {
+    /**
+     * Updates the poll state based on the provided data.
+     *
+     * @param {Object} options - The options for updating the poll.
+     * @param {any} options.data - The data containing poll information.
+     * @param {any[]} options.polls - The current list of polls.
+     * @param {any} options.poll - The current poll.
+     * @param {string} options.member - The member identifier.
+     * @param {string} options.islevel - The level of the member.
+     * @param {Function} options.showAlert - Function to show alerts.
+     * @param {Function} options.updatePolls - Function to update the list of polls.
+     * @param {Function} options.updatePoll - Function to update the current poll.
+     * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+     * @returns {Promise<void>} A promise that resolves when the poll update is complete.
+     */
+    pollUpdated({ data, polls, poll, member, islevel, showAlert, updatePolls, updatePoll, updateIsPollModalVisible, }: PollUpdatedOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PollUpdated, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PollUpdated>;
+}

package/dist/lib/methods/recording-methods/check-pause-state.service.d.ts

@@ -0,0 +1,26 @@
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface CheckPauseStateOptions {
+    recordingMediaOptions: string;
+    recordingVideoPausesLimit: number;
+    recordingAudioPausesLimit: number;
+    pauseRecordCount: number;
+    showAlert?: ShowAlert;
+}
+export type CheckPauseStateType = (options: CheckPauseStateOptions) => Promise<boolean>;
+export declare class CheckPauseState {
+    /**
+     * Checks if the recording can be paused based on the current pause count and the allowed pause limits.
+     *
+     * @param {Object} options - The options for checking the pause state.
+     * @param {string} options.recordingMediaOptions - The type of media being recorded ("video" or "audio").
+     * @param {number} options.recordingVideoPausesLimit - The maximum number of pauses allowed for video recordings.
+     * @param {number} options.recordingAudioPausesLimit - The maximum number of pauses allowed for audio recordings.
+     * @param {number} options.pauseRecordCount - The current count of pauses that have been made.
+     * @param {Function} options.showAlert - A function to show an alert message if the pause limit is reached.
+     * @returns {Promise<boolean>} - A promise that resolves to `true` if the recording can be paused, otherwise `false`.
+     */
+    checkPauseState: ({ recordingMediaOptions, recordingVideoPausesLimit, recordingAudioPausesLimit, pauseRecordCount, showAlert, }: CheckPauseStateOptions) => Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckPauseState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckPauseState>;
+}

package/dist/lib/methods/recording-methods/check-resume-state.service.d.ts

@@ -0,0 +1,23 @@
+import * as i0 from "@angular/core";
+export interface CheckResumeStateOptions {
+    recordingMediaOptions: string;
+    recordingVideoPausesLimit: number;
+    recordingAudioPausesLimit: number;
+    pauseRecordCount: number;
+}
+export type CheckResumeStateType = (options: CheckResumeStateOptions) => Promise<boolean>;
+export declare class CheckResumeState {
+    /**
+     * Checks if the recording can be resumed based on the media type and pause limits.
+     *
+     * @param {Object} options - The options for checking resume state.
+     * @param {string} options.recordingMediaOptions - The type of media being recorded ("video" or "audio").
+     * @param {number} options.recordingVideoPausesLimit - The maximum number of pauses allowed for video recording.
+     * @param {number} options.recordingAudioPausesLimit - The maximum number of pauses allowed for audio recording.
+     * @param {number} options.pauseRecordCount - The current number of pauses that have occurred.
+     * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether the recording can be resumed.
+     */
+    checkResumeState: ({ recordingMediaOptions, recordingVideoPausesLimit, recordingAudioPausesLimit, pauseRecordCount, }: CheckResumeStateOptions) => Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckResumeState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckResumeState>;
+}

package/dist/lib/methods/recording-methods/confirm-recording.service.d.ts

@@ -0,0 +1,78 @@
+import { ShowAlert, EventType, UserRecordingParams } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ConfirmRecordingParameters {
+    showAlert?: ShowAlert;
+    recordingMediaOptions: string;
+    recordingAudioOptions: string;
+    recordingVideoOptions: string;
+    recordingVideoType: string;
+    recordingDisplayType: 'video' | 'media' | 'all';
+    recordingNameTags: boolean;
+    recordingBackgroundColor: string;
+    recordingNameTagsColor: string;
+    recordingOrientationVideo: string;
+    recordingAddHLS: boolean;
+    recordingAddText: boolean;
+    recordingCustomText: string;
+    recordingCustomTextPosition: string;
+    recordingCustomTextColor: string;
+    meetingDisplayType: string;
+    recordingVideoParticipantsFullRoomSupport: boolean;
+    recordingAllParticipantsSupport: boolean;
+    recordingVideoParticipantsSupport: boolean;
+    recordingSupportForOtherOrientation: boolean;
+    recordingPreferredOrientation: string;
+    recordingMultiFormatsSupport: boolean;
+    recordingVideoOptimized: boolean;
+    recordingAllParticipantsFullRoomSupport: boolean;
+    meetingVideoOptimized: boolean;
+    eventType: EventType;
+    breakOutRoomStarted: boolean;
+    breakOutRoomEnded: boolean;
+    updateRecordingDisplayType: (value: 'video' | 'media' | 'all') => void;
+    updateRecordingVideoOptimized: (value: boolean) => void;
+    updateUserRecordingParams: (params: UserRecordingParams) => void;
+    updateConfirmedToRecord: (value: boolean) => void;
+    getUpdatedAllParams: () => ConfirmRecordingParameters;
+    [key: string]: any;
+}
+export interface ConfirmRecordingOptions {
+    parameters: ConfirmRecordingParameters;
+}
+export type ConfirmRecordingType = (options: ConfirmRecordingOptions) => Promise<void>;
+export declare class ConfirmRecording {
+    /**
+     * Confirms the recording settings based on the provided parameters and updates the recording state.
+     *
+     * @param {ConfirmRecordingOptions} options - The options for confirming the recording.
+     * @param {Parameters} options.parameters - The parameters for the recording.
+     *
+     * @returns {Promise<void>} A promise that resolves when the recording settings have been confirmed.
+     *
+     * @remarks
+     * This function performs several checks to ensure that the recording settings are valid based on the provided parameters.
+     * If any of the checks fail, an alert is shown and the function returns early without updating the recording state.
+     *
+     * The function checks for the following conditions:
+     * - Whether recording videos of all participants is allowed.
+     * - Whether recording all participants is allowed.
+     * - Whether recording other video participants is allowed.
+     * - Whether recording all orientations is allowed.
+     * - Whether recording the preferred orientation is allowed.
+     * - Whether recording all formats is allowed.
+     * - Whether the recording display type is valid based on the meeting display type.
+     * - Whether recording all participants with media is allowed.
+     *
+     * If all checks pass, the function constructs the `mainSpecs`, `dispSpecs`, and `textSpecs` objects based on the state variables,
+     * updates the user recording parameters, and confirms the recording.
+     *
+     * @example
+     * ```typescript
+     * const options: ConfirmRecordingOptions = { parameters: someParameters };
+     * await confirmRecording(options);
+     * ```
+     */
+    confirmRecording: ({ parameters }: ConfirmRecordingOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmRecording, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmRecording>;
+}