mediasfu-angular 1.0.0

package/dist/lib/producers/socket-receive-methods/get-domains.service.d.ts

@@ -0,0 +1,48 @@
+import { ConnectIpsType, ConnectIpsParameters, AltDomains, ConsumeSocket } from '../../@types/types';
+import { RtpCapabilities } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface GetDomainsParameters extends ConnectIpsParameters {
+    roomRecvIPs: string[];
+    rtpCapabilities: RtpCapabilities | null;
+    consume_sockets: ConsumeSocket[];
+    connectIps: ConnectIpsType;
+    getUpdatedAllParams: () => GetDomainsParameters;
+    [key: string]: any;
+}
+export interface GetDomainsOptions {
+    domains: string[];
+    alt_domains: AltDomains;
+    apiUserName: string;
+    apiKey: string;
+    apiToken: string;
+    parameters: GetDomainsParameters;
+}
+export type GetDomainsType = (options: GetDomainsOptions) => Promise<void>;
+/**
+ * Service to handle domain-related operations.
+ *
+ * @class
+ * @name GetDomains
+ * @description This service provides a method to retrieve and process domains.
+ *
+ * @method
+ * @name getDomains
+ * @async
+ * @param {Object} options - The options for retrieving domains.
+ * @param {string[]} options.domains - The list of domains to process.
+ * @param {Object} options.alt_domains - An object mapping domains to alternative domains.
+ * @param {string} options.apiUserName - The API username for authentication.
+ * @param {string} options.apiKey - The API key for authentication.
+ * @param {string} options.apiToken - The API token for authentication.
+ * @param {Object} options.parameters - Additional parameters for the operation.
+ * @param {string[]} options.parameters.roomRecvIPs - The list of IPs currently in the room.
+ * @param {Function} options.parameters.getUpdatedAllParams - A function to get updated parameters.
+ * @param {Function} options.parameters.connectIps - A function to connect IPs.
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ * @throws {Error} Throws an error if the domain retrieval fails.
+ */
+export declare class GetDomains {
+    getDomains: ({ domains, alt_domains, apiUserName, apiKey, apiToken, parameters, }: GetDomainsOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetDomains, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetDomains>;
+}

package/dist/lib/producers/socket-receive-methods/host-request-response.service.d.ts

@@ -0,0 +1,81 @@
+import { ShowAlert, Request, RequestResponse } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface HostRequestResponseOptions {
+    requestResponse: RequestResponse;
+    showAlert?: ShowAlert;
+    requestList: Request[];
+    updateRequestList: (requestList: Request[]) => void;
+    updateMicAction: (action: boolean) => void;
+    updateVideoAction: (action: boolean) => void;
+    updateScreenAction: (action: boolean) => void;
+    updateChatAction: (action: boolean) => void;
+    updateAudioRequestState: (state: string | null) => void;
+    updateVideoRequestState: (state: string | null) => void;
+    updateScreenRequestState: (state: string | null) => void;
+    updateChatRequestState: (state: string | null) => void;
+    updateAudioRequestTime: (time: number) => void;
+    updateVideoRequestTime: (time: number) => void;
+    updateScreenRequestTime: (time: number) => void;
+    updateChatRequestTime: (time: number) => void;
+    updateRequestIntervalSeconds: number;
+}
+export type HostRequestResponseType = (options: HostRequestResponseOptions) => Promise<void>;
+/**
+ * Service to handle host request responses.
+ *
+ * @example
+ * ```typescript
+ * const hostRequestResponseService = new HostRequestResponse();
+ * await hostRequestResponseService.hostRequestResponse({
+ *   requestResponse: { id: '1', type: 'fa-microphone', name: 'John Doe', username: 'johndoe', action: 'accepted' },
+ *   showAlert: (alert) => console.log(alert),
+ *   requestList: [],
+ *   updateRequestList: (list) => console.log(list),
+ *   updateMicAction: (state) => console.log(state),
+ *   updateVideoAction: (state) => console.log(state),
+ *   updateScreenAction: (state) => console.log(state),
+ *   updateChatAction: (state) => console.log(state),
+ *   updateAudioRequestState: (state) => console.log(state),
+ *   updateVideoRequestState: (state) => console.log(state),
+ *   updateScreenRequestState: (state) => console.log(state),
+ *   updateChatRequestState: (state) => console.log(state),
+ *   updateAudioRequestTime: (time) => console.log(time),
+ *   updateVideoRequestTime: (time) => console.log(time),
+ *   updateScreenRequestTime: (time) => console.log(time),
+ *   updateChatRequestTime: (time) => console.log(time),
+ *   updateRequestIntervalSeconds: 30,
+ * });
+ * ```
+ *
+ * @typedef {Object} HostRequestResponseOptions
+ * @property {Object} requestResponse - The request response object.
+ * @property {Function} showAlert - Function to show alert messages.
+ * @property {Array} requestList - List of current requests.
+ * @property {Function} updateRequestList - Function to update the request list.
+ * @property {Function} updateMicAction - Function to update microphone action state.
+ * @property {Function} updateVideoAction - Function to update video action state.
+ * @property {Function} updateScreenAction - Function to update screen action state.
+ * @property {Function} updateChatAction - Function to update chat action state.
+ * @property {Function} updateAudioRequestState - Function to update audio request state.
+ * @property {Function} updateVideoRequestState - Function to update video request state.
+ * @property {Function} updateScreenRequestState - Function to update screen request state.
+ * @property {Function} updateChatRequestState - Function to update chat request state.
+ * @property {Function} updateAudioRequestTime - Function to update audio request time.
+ * @property {Function} updateVideoRequestTime - Function to update video request time.
+ * @property {Function} updateScreenRequestTime - Function to update screen request time.
+ * @property {Function} updateChatRequestTime - Function to update chat request time.
+ * @property {number} updateRequestIntervalSeconds - Interval in seconds to update request time.
+ *
+ * @class
+ * @classdesc This service handles the responses to host requests, updating the state and showing alerts based on the response.
+ *
+ * @method hostRequestResponse
+ * @async
+ * @param {HostRequestResponseOptions} options - The options for handling the host request response.
+ * @returns {Promise<void>} A promise that resolves when the request response has been handled.
+ */
+export declare class HostRequestResponse {
+    hostRequestResponse: ({ requestResponse, showAlert, requestList, updateRequestList, updateMicAction, updateVideoAction, updateScreenAction, updateChatAction, updateAudioRequestState, updateVideoRequestState, updateScreenRequestState, updateChatRequestState, updateAudioRequestTime, updateVideoRequestTime, updateScreenRequestTime, updateChatRequestTime, updateRequestIntervalSeconds, }: HostRequestResponseOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HostRequestResponse, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HostRequestResponse>;
+}

package/dist/lib/producers/socket-receive-methods/meeting-ended.service.d.ts

@@ -0,0 +1,26 @@
+import { EventType, ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface MeetingEndedOptions {
+    showAlert?: ShowAlert;
+    redirectURL?: string;
+    onWeb: boolean;
+    eventType: EventType;
+    updateValidated?: (isValid: boolean) => void;
+}
+export type MeetingEndedType = (options: MeetingEndedOptions) => Promise<void>;
+export declare class MeetingEnded {
+    /**
+     * Handles the end of a meeting by showing an alert and redirecting the user.
+     *
+     * @param {MeetingEndedOptions} options - The options for handling the meeting end.
+     * @param {Function} options.showAlert - Function to show an alert message.
+     * @param {string} options.redirectURL - URL to redirect to after the meeting ends.
+     * @param {boolean} options.onWeb - Flag indicating if the application is running on the web.
+     * @param {string} options.eventType - Type of the event that triggered the meeting end.
+     *
+     * @returns {Promise<void>} A promise that resolves when the meeting end handling is complete.
+     */
+    meetingEnded: ({ showAlert, redirectURL, onWeb, eventType, }: MeetingEndedOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MeetingEnded, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MeetingEnded>;
+}

package/dist/lib/producers/socket-receive-methods/meeting-still-there.service.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export interface MeetingStillThereOptions {
+    updateIsConfirmHereModalVisible: (isVisible: boolean) => void;
+}
+export type MeetingStillThereType = (options: MeetingStillThereOptions) => Promise<void>;
+export declare class MeetingStillThere {
+    /**
+     * Handles the "still there?" meeting check by updating the visibility of the confirmation modal.
+     *
+     * @param {Object} options - The options for the meeting still there check.
+     * @param {Function} options.updateIsConfirmHereModalVisible - Function to update the visibility of the "still there?" modal.
+     * @returns {Promise<void>} A promise that resolves when the modal visibility is updated.
+     */
+    meetingStillThere: ({ updateIsConfirmHereModalVisible }: MeetingStillThereOptions) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MeetingStillThere, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MeetingStillThere>;
+}

package/dist/lib/producers/socket-receive-methods/meeting-time-remaining.service.d.ts

@@ -0,0 +1,22 @@
+import { EventType, ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface MeetingTimeRemainingOptions {
+    timeRemaining: number;
+    showAlert?: ShowAlert;
+    eventType: EventType;
+}
+export type MeetingTimeRemainingType = (options: MeetingTimeRemainingOptions) => Promise<void>;
+export declare class MeetingTimeRemaining {
+    /**
+     * Handles the remaining time for a meeting and shows an alert if the event type is not 'chat'.
+     *
+     * @param {Object} options - The options for the meeting time remaining.
+     * @param {number} options.timeRemaining - The remaining time in milliseconds.
+     * @param {Function} options.showAlert - The function to show an alert message.
+     * @param {string} options.eventType - The type of the event.
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     */
+    meetingTimeRemaining: ({ timeRemaining, showAlert, eventType, }: MeetingTimeRemainingOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MeetingTimeRemaining, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MeetingTimeRemaining>;
+}

package/dist/lib/producers/socket-receive-methods/participant-requested.service.d.ts

@@ -0,0 +1,26 @@
+import { Request, WaitingRoomParticipant } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ParticipantRequestedOptions {
+    userRequest: Request;
+    requestList: Request[];
+    waitingRoomList: WaitingRoomParticipant[];
+    updateTotalReqWait: (count: number) => void;
+    updateRequestList: (list: Request[]) => void;
+}
+export type ParticipantRequestedType = (options: ParticipantRequestedOptions) => Promise<void>;
+export declare class ParticipantRequested {
+    /**
+     * Handles a participant's request by adding it to the request list and updating the total count of requests and waiting room participants.
+     *
+     * @param {ParticipantRequestedOptions} options - The options for handling the participant's request.
+     * @param {UserRequest} options.userRequest - The user request to be added to the request list.
+     * @param {UserRequest[]} options.requestList - The current list of user requests.
+     * @param {UserRequest[]} options.waitingRoomList - The current list of participants in the waiting room.
+     * @param {Function} options.updateTotalReqWait - Function to update the total count of requests and waiting room participants.
+     * @param {Function} options.updateRequestList - Function to update the request list.
+     * @returns {Promise<void>} A promise that resolves when the participant's request has been handled.
+     */
+    participantRequested: ({ userRequest, requestList, waitingRoomList, updateTotalReqWait, updateRequestList, }: ParticipantRequestedOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantRequested, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ParticipantRequested>;
+}

package/dist/lib/producers/socket-receive-methods/person-joined.service.d.ts

@@ -0,0 +1,20 @@
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface PersonJoinedOptions {
+    showAlert?: ShowAlert;
+    name: string;
+}
+export type PersonJoinedType = (options: PersonJoinedOptions) => Promise<void>;
+export declare class PersonJoined {
+    /**
+     * Handles the event when a person joins.
+     *
+     * @param {PersonJoinedOptions} options - The options for the person joined event.
+     * @param {string} options.name - The name of the person who joined.
+     * @param {Function} options.showAlert - A function to display an alert/notification.
+     * @returns {Promise<void>} A promise that resolves when the alert has been shown.
+     */
+    personJoined: ({ name, showAlert }: PersonJoinedOptions) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PersonJoined, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PersonJoined>;
+}

package/dist/lib/producers/socket-receive-methods/producer-media-closed.service.d.ts

@@ -0,0 +1,47 @@
+import { CloseAndResizeParameters, CloseAndResizeType, PrepopulateUserMediaParameters, PrepopulateUserMediaType, ReorderStreamsParameters, ReorderStreamsType, Transport } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ProducerMediaClosedParameters extends CloseAndResizeParameters, PrepopulateUserMediaParameters, ReorderStreamsParameters {
+    consumerTransports: Transport[];
+    updateConsumerTransports: (transports: Transport[]) => void;
+    hostLabel: string;
+    shared: boolean;
+    updateShared: (shared: boolean) => void;
+    updateShareScreenStarted: (started: boolean) => void;
+    updateScreenId: (screenId: string) => void;
+    updateShareEnded: (ended: boolean) => void;
+    closeAndResize: CloseAndResizeType;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    reorderStreams: ReorderStreamsType;
+    getUpdatedAllParams: () => ProducerMediaClosedParameters;
+    [key: string]: any;
+}
+export interface ProducerMediaClosedOptions {
+    producerId: string;
+    kind: 'video' | 'screen' | 'audio' | 'screenshare';
+    parameters: ProducerMediaClosedParameters;
+}
+export type ProducerMediaClosedType = (options: ProducerMediaClosedOptions) => Promise<void>;
+export declare class ProducerMediaClosed {
+    /**
+     * Handles the closure of a media producer.
+     *
+     * @param {ProducerMediaClosedOptions} options - The options for closing the media producer.
+     * @param {string} options.producerId - The ID of the producer to close.
+     * @param {string} options.kind - The kind of media (e.g., "screenshare" or "screen").
+     * @param {Parameters} options.parameters - The parameters object containing various methods and properties.
+     *
+     * @returns {Promise<void>} - A promise that resolves when the producer has been closed and necessary updates are made.
+     *
+     * @remarks
+     * This function performs the following steps:
+     * 1. Retrieves updated parameters.
+     * 2. Finds the transport associated with the producer to close.
+     * 3. Closes the consumer transport and consumer if found.
+     * 4. Updates the consumer transports list.
+     * 5. Calls `closeAndResize` with the necessary parameters.
+     * 6. If the producer kind is "screenshare" or "screen", updates shared state and calls various update methods.
+     */
+    producerMediaClosed: ({ producerId, kind, parameters, }: ProducerMediaClosedOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProducerMediaClosed, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProducerMediaClosed>;
+}

package/dist/lib/producers/socket-receive-methods/producer-media-paused.service.d.ts

@@ -0,0 +1,51 @@
+import { Participant, PrepopulateUserMediaType, ReorderStreamsType, ReUpdateInterParameters, ReUpdateInterType, ReorderStreamsParameters, PrepopulateUserMediaParameters } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ProducerMediaPausedParameters extends PrepopulateUserMediaParameters, ReorderStreamsParameters, ReUpdateInterParameters {
+    activeSounds: string[];
+    meetingDisplayType: string;
+    meetingVideoOptimized: boolean;
+    participants: Participant[];
+    oldSoundIds: string[];
+    shared: boolean;
+    shareScreenStarted: boolean;
+    updateMainWindow: boolean;
+    hostLabel: string;
+    islevel: string;
+    updateActiveSounds: (activeSounds: string[]) => void;
+    updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+    reorderStreams: ReorderStreamsType;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    reUpdateInter: ReUpdateInterType;
+    getUpdatedAllParams: () => ProducerMediaPausedParameters;
+    [key: string]: any;
+}
+export interface ProducerMediaPausedOptions {
+    producerId: string;
+    kind: 'audio' | 'video' | 'screenshare' | 'screen';
+    name: string;
+    parameters: ProducerMediaPausedParameters;
+}
+export type ProducerMediaPausedType = (options: ProducerMediaPausedOptions) => Promise<void>;
+export declare class ProducerMediaPaused {
+    /**
+     * Handles the event when media is paused for a producer.
+     *
+     * @param {ProducerMediaPausedOptions} options - The options for the producer media paused event.
+     * @param {string} options.producerId - The ID of the producer.
+     * @param {string} options.kind - The kind of media (e.g., "audio", "video").
+     * @param {string} options.name - The name of the producer.
+     * @param {Parameters} options.parameters - The parameters for the event.
+     *
+     * @returns {Promise<void>} A promise that resolves when the media paused handling is complete.
+     *
+     * @description
+     * This function handles the event when media is paused for a producer. It performs the following tasks:
+     * - Updates the parameters.
+     * - Iterates through participants and updates the UI based on their muted status and other conditions.
+     * - Handles meeting display type and optimizes the UI accordingly.
+     * - Manages audio media by updating the relevant participant's state.
+     */
+    producerMediaPaused: ({ producerId, kind, name, parameters, }: ProducerMediaPausedOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProducerMediaPaused, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProducerMediaPaused>;
+}

package/dist/lib/producers/socket-receive-methods/producer-media-resumed.service.d.ts

@@ -0,0 +1,44 @@
+import { Participant, PrepopulateUserMediaParameters, PrepopulateUserMediaType, ReorderStreamsParameters, ReorderStreamsType } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ProducerMediaResumedParameters extends PrepopulateUserMediaParameters, ReorderStreamsParameters {
+    meetingDisplayType: string;
+    participants: Participant[];
+    shared: boolean;
+    shareScreenStarted: boolean;
+    mainScreenFilled: boolean;
+    hostLabel: string;
+    updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+    reorderStreams: ReorderStreamsType;
+    prepopulateUserMedia: PrepopulateUserMediaType;
+    getUpdatedAllParams: () => ProducerMediaResumedParameters;
+    [key: string]: any;
+}
+export interface ProducerMediaResumedOptions {
+    name: string;
+    kind: 'audio';
+    parameters: ProducerMediaResumedParameters;
+}
+export type ProducerMediaResumedType = (options: ProducerMediaResumedOptions) => Promise<void>;
+export declare class ProducerMediaResumed {
+    /**
+     * Resumes media for a specific participant in a meeting.
+     *
+     * @param {ProducerMediaResumedOptions} options - The options for resuming media.
+     * @param {string} options.name - The name of the participant whose media is to be resumed.
+     * @param {Object} options.parameters - The parameters related to the meeting and participants.
+     * @param {string} options.parameters.meetingDisplayType - The type of meeting display.
+     * @param {Array} options.parameters.participants - The list of participants in the meeting.
+     * @param {boolean} options.parameters.shared - Indicates if the screen is being shared.
+     * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+     * @param {boolean} options.parameters.mainScreenFilled - Indicates if the main screen is filled.
+     * @param {string} options.parameters.hostLabel - The label of the host.
+     * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+     * @param {Function} options.parameters.reorderStreams - Function to reorder the streams.
+     * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     *
+     * @returns {Promise<void>} A promise that resolves when the media has been resumed.
+     */
+    producerMediaResumed: ({ name, parameters, }: ProducerMediaResumedOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProducerMediaResumed, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProducerMediaResumed>;
+}

package/dist/lib/producers/socket-receive-methods/re-initiate-recording.service.d.ts

@@ -0,0 +1,25 @@
+import { Socket } from 'socket.io-client';
+import * as i0 from "@angular/core";
+export interface ReInitiateRecordingOptions {
+    roomName: string;
+    member: string;
+    socket: Socket;
+    adminRestrictSetting: boolean;
+}
+export type ReInitiateRecordingType = (options: ReInitiateRecordingOptions) => Promise<void>;
+export declare class ReInitiateRecording {
+    /**
+     * Re-initiates recording based on specific conditions.
+     * @async
+     * @function
+     * @param {ReInitiateRecordingOptions} options - The options for re-initiating recording.
+     * @param {string} options.roomName - The name of the room to re-initiate recording.
+     * @param {string} options.member - The member re-initiating the recording.
+     * @param {Socket} options.socket - The socket instance for communication.
+     * @param {boolean} options.adminRestrictSetting - Indicates whether the admin restrict setting is enabled.
+     * @returns {Promise<void>} A promise that resolves when the recording is re-initiated.
+     */
+    reInitiateRecording: ({ roomName, member, socket, adminRestrictSetting, }: ReInitiateRecordingOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReInitiateRecording, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReInitiateRecording>;
+}

package/dist/lib/producers/socket-receive-methods/receive-message.service.d.ts

@@ -0,0 +1,37 @@
+import { EventType, Message, Participant } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ReceiveMessageOptions {
+    message: Message;
+    messages: Message[];
+    participantsAll: Participant[];
+    member: string;
+    eventType: EventType;
+    islevel: string;
+    coHost: string;
+    updateMessages: (messages: Message[]) => void;
+    updateShowMessagesBadge: (showBadge: boolean) => void;
+}
+export type ReceiveMessageType = (options: ReceiveMessageOptions) => Promise<void>;
+export declare class ReceiveMessage {
+    /**
+     * Receives and processes a message, updating the messages array and handling
+     * various message types and events.
+     *
+     * @param {ReceiveMessageOptions} options - The options for receiving the message.
+     * @param {Object} options.message - The message object containing sender, receivers, content, timestamp, and group.
+     * @param {Function} options.getUpdatedAllParams - Function to get updated parameters.
+     * @param {Array} options.messages - Array of current messages.
+     * @param {Array} options.participantsAll - Array of all participants.
+     * @param {string} options.member - The current member.
+     * @param {string} options.eventType - The type of event (e.g., "broadcast", "chat").
+     * @param {string} options.islevel - The level of the current member.
+     * @param {string} options.coHost - The co-host of the event.
+     * @param {Function} options.updateMessages - Function to update the messages array.
+     * @param {Function} options.updateShowMessagesBadge - Function to update the visibility of the messages badge.
+     *
+     * @returns {Promise<void>} A promise that resolves when the message has been processed.
+     */
+    receiveMessage: ({ message, messages, participantsAll, member, eventType, islevel, coHost, updateMessages, updateShowMessagesBadge, }: ReceiveMessageOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReceiveMessage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReceiveMessage>;
+}

package/dist/lib/producers/socket-receive-methods/recording-notice.service.d.ts

@@ -0,0 +1,120 @@
+import { SoundPlayer } from '../../methods/utils/sound-player.service';
+import { EventType, UserRecordingParams } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface RecordingNoticeParameters {
+    islevel: string;
+    userRecordingParams: UserRecordingParams;
+    recordElapsedTime: number;
+    recordStartTime: number;
+    recordStarted: boolean;
+    recordPaused: boolean;
+    canLaunchRecord: boolean;
+    stopLaunchRecord: boolean;
+    recordStopped: boolean;
+    isTimerRunning: boolean;
+    canPauseResume: boolean;
+    eventType: EventType;
+    updateRecordingProgressTime: (time: string) => void;
+    updateShowRecordButtons: (show: boolean) => void;
+    updateUserRecordingParams: (params: UserRecordingParams) => void;
+    updateRecordingMediaOptions: (options: string) => void;
+    updateRecordingAudioOptions: (options: string) => void;
+    updateRecordingVideoOptions: (options: string) => void;
+    updateRecordingVideoType: (type: string) => void;
+    updateRecordingVideoOptimized: (optimized: boolean) => void;
+    updateRecordingDisplayType: (type: 'video' | 'media' | 'all') => void;
+    updateRecordingAddHLS: (addHLS: boolean) => void;
+    updateRecordingNameTags: (nameTags: boolean) => void;
+    updateRecordingBackgroundColor: (color: string) => void;
+    updateRecordingNameTagsColor: (color: string) => void;
+    updateRecordingOrientationVideo: (orientation: string) => void;
+    updateRecordingAddText: (addText: boolean) => void;
+    updateRecordingCustomText: (text: string) => void;
+    updateRecordingCustomTextPosition: (position: string) => void;
+    updateRecordingCustomTextColor: (color: string) => void;
+    updatePauseRecordCount: (count: number) => void;
+    updateRecordElapsedTime: (time: number) => void;
+    updateRecordStarted: (started: boolean) => void;
+    updateRecordPaused: (paused: boolean) => void;
+    updateCanLaunchRecord: (canLaunch: boolean) => void;
+    updateStopLaunchRecord: (stop: boolean) => void;
+    updateRecordStopped: (stopped: boolean) => void;
+    updateIsTimerRunning: (running: boolean) => void;
+    updateCanPauseResume: (canPause: boolean) => void;
+    updateRecordStartTime: (startTime: number) => void;
+    updateRecordState: (state: string) => void;
+    [key: string]: any;
+}
+export interface RecordingNoticeOptions {
+    state: string;
+    userRecordingParam: UserRecordingParams | null;
+    pauseCount: number;
+    timeDone: number;
+    parameters: RecordingNoticeParameters;
+}
+export type RecordingNoticeType = (options: RecordingNoticeOptions) => Promise<void>;
+export declare class RecordingNotice {
+    private SoundPlayerService;
+    constructor(SoundPlayerService: SoundPlayer);
+    /**
+     * Handles the recording notice state and updates various recording parameters accordingly.
+     *
+     * @param {Object} options - The options object.
+     * @param {string} options.state - The current state of the recording (e.g., "pause", "stop").
+     * @param {Object} options.userRecordingParam - The user recording parameters.
+     * @param {number} options.pauseCount - The count of pauses during the recording.
+     * @param {number} options.timeDone - The elapsed time of the recording.
+     * @param {Object} options.parameters - The parameters object containing various update functions and state variables.
+     * @param {string} options.parameters.islevel - The level of the recording.
+     * @param {Object} options.parameters.userRecordingParams - The user recording parameters.
+     * @param {number} options.parameters.pauseRecordCount - The count of pauses during the recording.
+     * @param {number} options.parameters.recordElapsedTime - The elapsed time of the recording.
+     * @param {number} options.parameters.recordStartTime - The start time of the recording.
+     * @param {boolean} options.parameters.recordStarted - Indicates if the recording has started.
+     * @param {boolean} options.parameters.recordPaused - Indicates if the recording is paused.
+     * @param {boolean} options.parameters.canLaunchRecord - Indicates if the recording can be launched.
+     * @param {boolean} options.parameters.stopLaunchRecord - Indicates if the recording launch should be stopped.
+     * @param {boolean} options.parameters.recordStopped - Indicates if the recording is stopped.
+     * @param {boolean} options.parameters.isTimerRunning - Indicates if the timer is running.
+     * @param {boolean} options.parameters.canPauseResume - Indicates if the recording can be paused or resumed.
+     * @param {string} options.parameters.eventType - The type of event triggering the recording notice.
+     * @param {Function} options.parameters.updateRecordingProgressTime - Function to update the recording progress time.
+     * @param {Function} options.parameters.updateShowRecordButtons - Function to update the visibility of record buttons.
+     * @param {Function} options.parameters.updateUserRecordingParams - Function to update user recording parameters.
+     * @param {Function} options.parameters.updateRecordingMediaOptions - Function to update recording media options.
+     * @param {Function} options.parameters.updateRecordingAudioOptions - Function to update recording audio options.
+     * @param {Function} options.parameters.updateRecordingVideoOptions - Function to update recording video options.
+     * @param {Function} options.parameters.updateRecordingVideoType - Function to update recording video type.
+     * @param {Function} options.parameters.updateRecordingVideoOptimized - Function to update recording video optimization.
+     * @param {Function} options.parameters.updateRecordingDisplayType - Function to update recording display type.
+     * @param {Function} options.parameters.updateRecordingAddHLS - Function to update HLS addition in recording.
+     * @param {Function} options.parameters.updateRecordingNameTags - Function to update recording name tags.
+     * @param {Function} options.parameters.updateRecordingBackgroundColor - Function to update recording background color.
+     * @param {Function} options.parameters.updateRecordingNameTagsColor - Function to update recording name tags color.
+     * @param {Function} options.parameters.updateRecordingOrientationVideo - Function to update recording orientation video.
+     * @param {Function} options.parameters.updateRecordingAddText - Function to update recording text addition.
+     * @param {Function} options.parameters.updateRecordingCustomText - Function to update custom text in recording.
+     * @param {Function} options.parameters.updateRecordingCustomTextPosition - Function to update custom text position.
+     * @param {Function} options.parameters.updateRecordingCustomTextColor - Function to update custom text color.
+     * @param {Function} options.parameters.updatePauseRecordCount - Function to update pause record count.
+     * @param {Function} options.parameters.updateRecordElapsedTime - Function to update record elapsed time.
+     * @param {Function} options.parameters.updateRecordStartTime - Function to update record start time.
+     * @param {Function} options.parameters.updateRecordStarted - Function to update record started status.
+     * @param {Function} options.parameters.updateRecordPaused - Function to update record paused status.
+     * @param {Function} options.parameters.updateCanLaunchRecord - Function to update can launch record status.
+     * @param {Function} options.parameters.updateStopLaunchRecord - Function to update stop launch record status.
+     * @param {Function} options.parameters.updateRecordStopped - Function to update record stopped status.
+     * @param {Function} options.parameters.updateIsTimerRunning - Function to update timer running status.
+     * @param {Function} options.parameters.updateCanPauseResume - Function to update can pause/resume status.
+     * @param {Function} options.parameters.updateRecordState - Function to update the record state.
+     *
+     * @returns {Promise<void>} A promise that resolves when the recording notice handling is complete.
+     *
+     * @throws {Error} Throws an error if handling the recording state and status fails.
+     */
+    RecordingNotice: ({ state, userRecordingParam, pauseCount, timeDone, parameters, }: RecordingNoticeOptions) => Promise<void>;
+    private formatElapsedTime;
+    private padNumber;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecordingNotice, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RecordingNotice>;
+}