mediasfu-angular 1.0.1 → 2.0.0

package/dist/lib/producers/socket-receive-methods/update-media-settings.service.d.ts

@@ -8,6 +8,36 @@ export interface UpdateMediaSettingsOptions {
     updateChatSetting: (value: string) => void;
 }
 export type UpdateMediaSettingsType = (options: UpdateMediaSettingsOptions) => void;
+/**
+ * Service for updating media settings including audio, video, screenshare, and chat.
+ *
+ * @class
+ * @name UpdateMediaSettings
+ * @description Provides a method to update multiple media settings at once using specified update functions.
+ *
+ * @method
+ * updateMediaSettings
+ *
+ * @param {UpdateMediaSettingsOptions} options - Options for updating media settings:
+ *   - `settings` {Settings}: The settings values to apply.
+ *   - `updateAudioSetting` {Function}: Function to update the audio setting.
+ *   - `updateVideoSetting` {Function}: Function to update the video setting.
+ *   - `updateScreenshareSetting` {Function}: Function to update the screenshare setting.
+ *   - `updateChatSetting` {Function}: Function to update the chat setting.
+ *
+ * @returns {void} Updates settings directly through the provided functions.
+ *
+ * @example
+ * const settings = ['mute', 'HD', 'enabled', 'disabled'];
+ * const options = {
+ *   settings,
+ *   updateAudioSetting: (value) => console.log(`Audio setting updated to: ${value}`),
+ *   updateVideoSetting: (value) => console.log(`Video setting updated to: ${value}`),
+ *   updateScreenshareSetting: (value) => console.log(`Screenshare setting updated to: ${value}`),
+ *   updateChatSetting: (value) => console.log(`Chat setting updated to: ${value}`)
+ * };
+ * updateMediaSettingsService.updateMediaSettings(options);
+ */
 export declare class UpdateMediaSettings {
     /**
      * Updates the media settings by invoking the provided update functions for each setting.

package/dist/lib/producers/socket-receive-methods/updated-co-host.service.d.ts

@@ -13,6 +13,46 @@ export interface UpdatedCoHostOptions {
     updateYouAreCoHost: (youAreCoHost: boolean) => void;
 }
 export type UpdatedCoHostType = (options: UpdatedCoHostOptions) => Promise<void>;
+/**
+ * Service for updating co-host information, responsibilities, and the user's co-host status.
+ *
+ * @class
+ * @name UpdatedCoHost
+ * @description Manages co-host updates for different event types, assigning responsibilities and notifying the user if their co-host status changes.
+ *
+ * @method
+ * updatedCoHost
+ * @async
+ *
+ * @param {UpdatedCoHostOptions} options - The options for co-host updates:
+ *   - `coHost` {string}: The name of the co-host.
+ *   - `coHostResponsibility` {CoHostResponsibility[]}: List of responsibilities assigned to the co-host.
+ *   - `showAlert` {ShowAlert}: Optional function to display an alert message.
+ *   - `eventType` {EventType}: Type of the event, determining if co-host can be updated.
+ *   - `islevel` {string}: Current level of the event.
+ *   - `member` {string}: The current user's identifier.
+ *   - `youAreCoHost` {boolean}: Current user's co-host status.
+ *   - `updateCoHost` {Function}: Function to set the new co-host.
+ *   - `updateCoHostResponsibility` {Function}: Function to assign responsibilities to the co-host.
+ *   - `updateYouAreCoHost` {Function}: Function to update the user's co-host status.
+ *
+ * @returns {Promise<void>} Resolves after co-host information is updated.
+ *
+ * @example
+ * const options = {
+ *   coHost: 'Alice',
+ *   coHostResponsibility: ['moderate', 'manageParticipants'],
+ *   showAlert: ({ message, type, duration }) => console.log(message),
+ *   eventType: 'conference',
+ *   islevel: '1',
+ *   member: 'Alice',
+ *   youAreCoHost: false,
+ *   updateCoHost: (newCoHost) => console.log(`Updated co-host: ${newCoHost}`),
+ *   updateCoHostResponsibility: (responsibilities) => console.log(responsibilities),
+ *   updateYouAreCoHost: (status) => console.log(`You are co-host: ${status}`)
+ * };
+ * await updatedCoHostService.updatedCoHost(options);
+ */
 export declare class UpdatedCoHost {
     /**
      * Updates the co-host information, responsibility, and user's co-host status based on the provided options.

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

@@ -8,56 +8,30 @@ export interface UserWaitingOptions {
 }
 export type UserWaitingType = (options: UserWaitingOptions) => Promise<void>;
 /**
- * @fileoverview Service to handle user waiting functionality.
- *
- * @description
- * This service provides methods to handle the logic when a user joins the waiting room.
- * It displays an alert/notification and updates the total number of requests waiting.
- */
-/**
- * Options for the userWaiting method.
- *
- * @interface UserWaitingOptions
- * @property {string} name - The name of the user joining the waiting room.
- * @property {(options: { message: string; type: string; duration: number }) => void} [showAlert] - Optional function to display an alert/notification.
- * @property {number} totalReqWait - The current total number of requests waiting.
- * @property {(total: number) => void} updateTotalReqWait - Function to update the total number of requests waiting.
- */
-/**
- * Service to handle user waiting functionality.
+ * Service for handling user waiting room actions, including notifications and updating request counts.
  *
  * @class
  * @name UserWaiting
- * @description
- * This service provides methods to handle the logic when a user joins the waiting room.
- * It displays an alert/notification and updates the total number of requests waiting.
- *
- * @example
- * const userWaitingService = new UserWaiting();
- * userWaitingService.userWaiting({
- *   name: 'John Doe',
- *   showAlert: (options) => console.log(options.message),
- *   totalReqWait: 5,
- *   updateTotalReqWait: (total) => console.log(`Total requests: ${total}`),
- * });
- */
-/**
- * Handles the logic when a user joins the waiting room.
+ * @description Manages the logic when a user joins the waiting room by displaying alerts and incrementing the total request count.
  *
  * @method
- * @name userWaiting
- * @memberof UserWaiting
+ * userWaiting
  * @async
  *
- * @param {UserWaitingOptions} options - The options for the user waiting method.
- * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ * @param {UserWaitingOptions} options - The options for handling user waiting actions:
+ *   - `name` {string}: Name of the user joining the waiting room.
+ *   - `showAlert` {ShowAlert}: Optional function for showing an alert with a customizable message, type, and duration.
+ *   - `totalReqWait` {number}: Current count of waiting requests.
+ *   - `updateTotalReqWait` {Function}: Updates the total waiting request count.
+ *
+ * @returns {Promise<void>} Resolves after alert is shown and request count is updated.
  *
  * @example
  * const options = {
- *   name: 'John Doe',
- *   showAlert: (options) => console.log(options.message),
- *   totalReqWait: 5,
- *   updateTotalReqWait: (total) => console.log(`Total requests: ${total}`),
+ *   name: 'Alice',
+ *   showAlert: ({ message, type, duration }) => console.log(message),
+ *   totalReqWait: 3,
+ *   updateTotalReqWait: (newTotal) => console.log(`Updated count: ${newTotal}`)
  * };
  * await userWaitingService.userWaiting(options);
  */

package/dist/lib/sockets/socket-manager.service.d.ts

@@ -1,10 +1,27 @@
 import { Socket } from 'socket.io-client';
+import { MeetingRoomParams, RecordingParams } from "../@types/types";
 import * as i0 from "@angular/core";
 /**
  * Validates the provided API key or token.
  * @param {string} value - The API key or token to validate.
  * @returns {Promise<Boolean>} - True if the API key or token is valid, false otherwise.
  */
+export interface ResponseLocalConnection {
+    socket?: Socket;
+    data?: ResponseLocalConnectionData;
+}
+export interface ResponseLocalConnectionData {
+    socketId: string;
+    mode: string;
+    apiUserName?: string;
+    apiKey?: string;
+    allowRecord: boolean;
+    meetingRoomParams_: MeetingRoomParams;
+    recordingParams_: RecordingParams;
+}
+export interface ConnectLocalSocketOptions {
+    link: string;
+}
 export interface ConnectSocketOptions {
     apiUserName: string;
     apiKey?: string;
@@ -16,10 +33,123 @@ export interface DisconnectSocketOptions {
 }
 export type ConnectSocketType = (options: ConnectSocketOptions) => Promise<Socket>;
 export type DisconnectSocketType = (options: DisconnectSocketOptions) => Promise<boolean>;
+export type ConnectLocalSocketType = (options: ConnectLocalSocketOptions) => Promise<ResponseLocalConnection>;
+/**
+ * Manages connections to a media socket, allowing users to connect or disconnect based on API credentials.
+ *
+ * @class
+ * @name SocketManager
+ * @description Provides methods to connect and disconnect from a media socket using a provided API key or token.
+ *
+ * @method
+ * validateApiKeyToken - Validates the API key or token for correct format.
+ * connectSocket - Establishes a connection to the media socket using either the API key or token.
+ * disconnectSocket - Disconnects an active socket connection.
+ *
+ * @example
+ * ```typescript
+ * const socketManager = new SocketManager();
+ *
+ * // Example of connecting to the socket
+ * const socketConnection = await socketManager.connectSocket({
+ *   apiUserName: 'user123',
+ *   apiKey: 'validApiKeyOf64Characters',
+ *   link: 'https://socketserver.example.com'
+ * });
+ *
+ * // Example of disconnecting the socket
+ * const isDisconnected = await socketManager.disconnectSocket({
+ *   socket: socketConnection
+ * });
+ * ```
+ *
+ * @typedef {Object} ConnectSocketOptions
+ * @property {string} apiUserName - Username for the API.
+ * @property {string} [apiKey] - The API key for authentication.
+ * @property {string} [apiToken] - The API token for authentication.
+ * @property {string} link - The socket server link.
+ *
+ * @typedef {Object} DisconnectSocketOptions
+ * @property {Socket} socket - The socket instance to disconnect.
+ *
+ * @returns {Promise<Socket | boolean>} The active socket instance on connection, or a boolean indicating disconnection success.
+ */
 export declare class SocketManager {
     private socket;
     validateApiKeyToken(value: string): Promise<boolean>;
+    /**
+     * Connects to a media socket using the provided connection options.
+     *
+     * @param {ConnectSocketOptions} options - The connection options.
+     * @param {string} options.apiUserName - The API username.
+     * @param {string} [options.apiKey] - The API key for authentication.
+     * @param {string} [options.apiToken] - The API token for authentication.
+     * @param {string} options.link - The socket link.
+     *
+     * @returns {Promise<Socket>} A promise that resolves to the connected socket.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   apiUserName: 'user123',
+     *   apiKey: 'validApiKeyOf64Characters',
+     *   link: 'https://socketserver.example.com'
+     * };
+     *
+     * try {
+     *   const socket = await connectSocket(options);
+     *   console.log('Connected to socket:', socket);
+     * } catch (error) {
+     *   console.error('Failed to connect to socket:', error);
+     * }
+     * ```
+     */
     connectSocket: ({ apiUserName, apiKey, apiToken, link, }: ConnectSocketOptions) => Promise<Socket>;
+    /**
+     * Connects to a local media socket using the provided connection options.
+     *
+     * @param {ConnectLocalSocketOptions} options - The connection options.
+     * @param {string} options.link - The socket link.
+     *
+     * @returns {Promise<ResponseLocalConnection>} A promise that resolves to the connected socket and data.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   link: "http://localhost:3000",
+     * };
+     *
+     * try {
+     *   const { socket, data } = await connectLocalSocket(options);
+     *   console.log("Connected to socket:", socket, data);
+     * } catch (error) {
+     *   console.error("Failed to connect to socket:", error);
+     * }
+     * ```
+     */
+    connectLocalSocket: ({ link }: ConnectLocalSocketOptions) => Promise<ResponseLocalConnection>;
+    /**
+     * Disconnects an active socket connection.
+     *
+     * @param {DisconnectSocketOptions} options - The options for disconnecting the socket.
+     * @param {Socket} options.socket - The socket instance to disconnect.
+     *
+     * @returns {Promise<boolean>} A promise that resolves to true if the socket was disconnected successfully, or false otherwise.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   socket: mySocketInstance,
+     * };
+     *
+     * try {
+     *   const isDisconnected = await disconnectSocket(options);
+     *   console.log("Socket disconnected:", isDisconnected);
+     * } catch (error) {
+     *   console.error("Failed to disconnect socket:", error);
+     * }
+     * ```
+     */
     disconnectSocket: ({ socket }: DisconnectSocketOptions) => Promise<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SocketManager, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SocketManager>;

package/dist/public-api.d.ts

@@ -1,4 +1,8 @@
 import { initialValuesState } from './lib/methods/utils/initial-values.util';
+export * from './lib/methods/utils/join-room-on-media-sfu.service';
+export * from './lib/methods/utils/create-room-on-media-sfu.service';
+export * from './lib/methods/utils/check-limits-and-make-request.service';
+export * from './lib/methods/utils/create-response-join-room.util';
 import { LoadingModal } from './lib/components/display-components/loading-modal/loading-modal.component';
 import { MainAspectComponent } from './lib/components/display-components/main-aspect-component/main-aspect-component.component';
 import { ControlButtonsComponent } from './lib/components/display-components/control-buttons-component/control-buttons-component.component';
@@ -55,6 +59,7 @@ import { LaunchBreakoutRooms } from './lib/methods/breakout-room-methods/launch-
 import { LaunchConfigureWhiteboard } from './lib/methods/whiteboard-methods/launch-configure-whiteboard.service';
 import { SocketManager } from './lib/sockets/socket-manager.service';
 import { JoinRoomClient } from './lib/producer-client/producer-client-emits/join-room-client.service';
+import { JoinLocalRoom } from './lib/producers/producer-emits/join-local-room.service';
 import { UpdateRoomParametersClient } from './lib/producer-client/producer-client-emits/update-room-parameters-client.service';
 import { CreateDeviceClient } from './lib/producer-client/producer-client-emits/create-device-client.service';
 import { ClickVideo } from './lib/methods/stream-methods/click-video.service';
@@ -115,6 +120,7 @@ import { SwitchUserAudio } from './lib/consumers/switch-user-audio.service';
 import { ReceiveRoomMessages } from './lib/consumers/receive-room-messages.service';
 import { FormatNumber } from './lib/methods/utils/format-number.service';
 import { ConnectIps } from './lib/consumers/connect-ips.service';
+import { ConnectLocalIps } from './lib/consumers/connect-local-ips.service';
 import { PollUpdated } from './lib/methods/polls-methods/poll-updated.service';
 import { HandleCreatePoll } from './lib/methods/polls-methods/handle-create-poll.service';
 import { HandleVotePoll } from './lib/methods/polls-methods/handle-vote-poll.service';
@@ -174,4 +180,8 @@ import { CardVideoDisplay } from './lib/components/display-components/card-video
 import { MiniCardAudio } from './lib/components/display-components/mini-card-audio/mini-card-audio.component';
 import { MiniAudioPlayer } from './lib/methods/utils/mini-audio-player/mini-audio-player.component';
 import { SoundPlayer } from './lib/methods/utils/sound-player.service';
-export { initialValuesState, LoadingModal, MainAspectComponent, ControlButtonsComponent, ControlButtonsAltComponent, ControlButtonsComponentTouch, OtherGridComponent, MainScreenComponent, MainGridComponent, SubAspectComponent, MainContainerComponent, AlertComponent, MenuModal, RecordingModal, RequestsModal, WaitingRoomModal, DisplaySettingsModal, EventSettingsModal, CoHostModal, ParticipantsModal, MessagesModal, MediaSettingsModal, ConfirmExitModal, ConfirmHereModal, ShareEventModal, WelcomePage, PreJoinPage, Pagination, FlexibleGrid, FlexibleVideo, AudioGrid, LaunchMenuModal, LaunchRecording, StartRecording, ConfirmRecording, LaunchWaiting, launchCoHost, LaunchMediaSettings, LaunchDisplaySettings, LaunchSettings, LaunchRequests, LaunchParticipants, LaunchMessages, LaunchConfirmExit, JoinRoomClient, UpdateRoomParametersClient, CreateDeviceClient, ClickVideo, ClickAudio, ClickScreenShare, StreamSuccessVideo, StreamSuccessAudio, StreamSuccessScreen, StreamSuccessAudioSwitch, CheckPermission, ProducerClosed, NewPipeProducer, UpdateMiniCardsGrid, MixStreams, DispStreams, StopShareScreen, CheckScreenShare, StartShareScreen, RequestScreenShare, ReorderStreams, PrepopulateUserMedia, GetVideos, RePort, Trigger, ConsumerResume, ConnectSendTransportAudio, ConnectSendTransportVideo, ConnectSendTransportScreen, ProcessConsumerTransports, ResumePauseStreams, Readjust, CheckGrid, GetEstimate, CalculateRowsAndColumns, AddVideosGrid, OnScreenChanges, sleep, ChangeVids, CompareActiveNames, CompareScreenStates, CreateSendTransport, ResumeSendTransportAudio, ReceiveAllPipedTransports, DisconnectSendTransportVideo, DisconnectSendTransportAudio, DisconnectSendTransportScreen, ConnectSendTransport, GetPipedProducersAlt, SignalNewConsumerTransport, ConnectRecvTransport, ReUpdateInter, UpdateParticipantAudioDecibels, CloseAndResize, AutoAdjust, SwitchUserVideoAlt, SwitchUserVideo, SwitchUserAudio, ReceiveRoomMessages, FormatNumber, ConnectIps, StartMeetingProgressTimer, UpdateRecording, StopRecording, UserWaiting, PersonJoined, AllWaitingRoomMembers, RoomRecordParams, BanParticipant, UpdatedCoHost, ParticipantRequested, ScreenProducerId, UpdateMediaSettings, ProducerMediaPaused, ProducerMediaResumed, ProducerMediaClosed, ControlMediaHost, MeetingEnded, DisconnectUserSelf, ReceiveMessage, MeetingTimeRemaining, MeetingStillThere, StartRecords, ReInitiateRecording, GetDomains, UpdateConsumingDomains, RecordingNotice, TimeLeftRecording, StoppedRecording, HostRequestResponse, AllMembers, AllMembersRest, Disconnect, MediasfuGeneric, MediasfuBroadcast, MediasfuWebinar, MediasfuConference, MediasfuChat, GenerateRandomParticipants, GenerateRandomMessages, GenerateRandomRequestList, GenerateRandomWaitingRoomList, GenerateRandomPolls, MeetingProgressTimer, MiniAudio, MiniCard, AudioCard, VideoCard, CardVideoDisplay, MiniCardAudio, MiniAudioPlayer, SoundPlayer, CaptureCanvasStream, ResumePauseAudioStreams, ProcessConsumerTransportsAudio, PollUpdated, HandleCreatePoll, HandleVotePoll, HandleEndPoll, BreakoutRoomUpdated, LaunchPoll, LaunchBackground, LaunchBreakoutRooms, LaunchConfigureWhiteboard, PollModal, BackgroundModal, BreakoutRoomsModal, ConfigureWhiteboardModal, Whiteboard, Screenboard, ScreenboardModal, SocketManager, };
+import { CreateRoomOnMediaSFU } from './lib/methods/utils/create-room-on-media-sfu.service';
+import { JoinRoomOnMediaSFU } from './lib/methods/utils/join-room-on-media-sfu.service';
+import { CheckLimitsAndMakeRequest } from './lib/methods/utils/check-limits-and-make-request.service';
+import { createResponseJoinRoom } from './lib/methods/utils/create-response-join-room.util';
+export { initialValuesState, LoadingModal, MainAspectComponent, ControlButtonsComponent, ControlButtonsAltComponent, ControlButtonsComponentTouch, OtherGridComponent, MainScreenComponent, MainGridComponent, SubAspectComponent, MainContainerComponent, AlertComponent, MenuModal, RecordingModal, RequestsModal, WaitingRoomModal, DisplaySettingsModal, EventSettingsModal, CoHostModal, ParticipantsModal, MessagesModal, MediaSettingsModal, ConfirmExitModal, ConfirmHereModal, ShareEventModal, WelcomePage, PreJoinPage, Pagination, FlexibleGrid, FlexibleVideo, AudioGrid, LaunchMenuModal, LaunchRecording, StartRecording, ConfirmRecording, LaunchWaiting, launchCoHost, LaunchMediaSettings, LaunchDisplaySettings, LaunchSettings, LaunchRequests, LaunchParticipants, LaunchMessages, LaunchConfirmExit, JoinRoomClient, JoinLocalRoom, UpdateRoomParametersClient, CreateDeviceClient, ClickVideo, ClickAudio, ClickScreenShare, StreamSuccessVideo, StreamSuccessAudio, StreamSuccessScreen, StreamSuccessAudioSwitch, CheckPermission, ProducerClosed, NewPipeProducer, UpdateMiniCardsGrid, MixStreams, DispStreams, StopShareScreen, CheckScreenShare, StartShareScreen, RequestScreenShare, ReorderStreams, PrepopulateUserMedia, GetVideos, RePort, Trigger, ConsumerResume, ConnectSendTransportAudio, ConnectSendTransportVideo, ConnectSendTransportScreen, ProcessConsumerTransports, ResumePauseStreams, Readjust, CheckGrid, GetEstimate, CalculateRowsAndColumns, AddVideosGrid, OnScreenChanges, sleep, ChangeVids, CompareActiveNames, CompareScreenStates, CreateSendTransport, ResumeSendTransportAudio, ReceiveAllPipedTransports, DisconnectSendTransportVideo, DisconnectSendTransportAudio, DisconnectSendTransportScreen, ConnectSendTransport, GetPipedProducersAlt, SignalNewConsumerTransport, ConnectRecvTransport, ReUpdateInter, UpdateParticipantAudioDecibels, CloseAndResize, AutoAdjust, SwitchUserVideoAlt, SwitchUserVideo, SwitchUserAudio, ReceiveRoomMessages, FormatNumber, ConnectIps, ConnectLocalIps, StartMeetingProgressTimer, UpdateRecording, StopRecording, UserWaiting, PersonJoined, AllWaitingRoomMembers, RoomRecordParams, BanParticipant, UpdatedCoHost, ParticipantRequested, ScreenProducerId, UpdateMediaSettings, ProducerMediaPaused, ProducerMediaResumed, ProducerMediaClosed, ControlMediaHost, MeetingEnded, DisconnectUserSelf, ReceiveMessage, MeetingTimeRemaining, MeetingStillThere, StartRecords, ReInitiateRecording, GetDomains, UpdateConsumingDomains, RecordingNotice, TimeLeftRecording, StoppedRecording, HostRequestResponse, AllMembers, AllMembersRest, Disconnect, MediasfuGeneric, MediasfuBroadcast, MediasfuWebinar, MediasfuConference, MediasfuChat, GenerateRandomParticipants, GenerateRandomMessages, GenerateRandomRequestList, GenerateRandomWaitingRoomList, GenerateRandomPolls, MeetingProgressTimer, MiniAudio, MiniCard, AudioCard, VideoCard, CardVideoDisplay, MiniCardAudio, MiniAudioPlayer, SoundPlayer, CaptureCanvasStream, ResumePauseAudioStreams, ProcessConsumerTransportsAudio, PollUpdated, HandleCreatePoll, HandleVotePoll, HandleEndPoll, BreakoutRoomUpdated, LaunchPoll, LaunchBackground, LaunchBreakoutRooms, LaunchConfigureWhiteboard, PollModal, BackgroundModal, BreakoutRoomsModal, ConfigureWhiteboardModal, Whiteboard, Screenboard, ScreenboardModal, SocketManager, CreateRoomOnMediaSFU, JoinRoomOnMediaSFU, CheckLimitsAndMakeRequest, createResponseJoinRoom, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasfu-angular",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "author": "MediaSFU",
   "license": "MIT",
   "description": "MediaSFU Prebuilt Angular SDK",
@@ -14,33 +14,32 @@
     "email": "info@mediasfu.com"
   },
   "peerDependencies": {
-    "@angular/animations": "^18.1.0",
-    "@angular/common": "^18.1.0",
-    "@angular/compiler": "^18.1.0",
-    "@angular/core": "^18.1.0",
-    "@angular/forms": "^18.1.0",
-    "@angular/platform-browser": "^18.1.0",
-    "@angular/platform-browser-dynamic": "^18.1.0",
-    "@angular/router": "^18.1.0",
-    "@fortawesome/angular-fontawesome": "^0.15.0",
-    "@fortawesome/fontawesome-svg-core": "^6.6.0",
-    "@fortawesome/free-brands-svg-icons": "^6.6.0",
-    "@fortawesome/free-solid-svg-icons": "^6.6.0",
+    "@angular/animations": "^19.0.1",
+    "@angular/common": "^19.0.1",
+    "@angular/compiler": "^19.0.1",
+    "@angular/core": "^19.0.1",
+    "@angular/forms": "^19.0.1",
+    "@angular/platform-browser": "^19.0.1",
+    "@angular/platform-browser-dynamic": "^19.0.1",
+    "@angular/router": "^19.0.1",
+    "@fortawesome/angular-fontawesome": "^1.0.0",
+    "@fortawesome/fontawesome-svg-core": "^6.7.1",
+    "@fortawesome/free-brands-svg-icons": "^6.7.1",
+    "@fortawesome/free-solid-svg-icons": "^6.7.1",
     "@mediapipe/selfie_segmentation": "^0.1.1675465747",
-    "@zxing/ngx-scanner": "^18.0.1",
+    "@zxing/ngx-scanner": "^19.0.0",
     "bootstrap": "^5.3.3",
-    "ngx-cookie-service": "^18.0.0",
+    "ngx-cookie-service": "^19.0.0",
     "rxjs": "~7.8.0",
-    "zone.js": "~0.14.3",
+    "zone.js": "~0.15.0",
     "mediasoup-client": "3.7.17",
-    "tslib": "^2.3.0",
     "socket.io-client": "^4.3.2"
   },
   "dependencies": {
+    "tslib": "^2.3.0"
   },
   "module": "dist/fesm2022/mediasfu-angular.mjs",
   "es2022": "dist/fesm2022/mediasfu-angular.mjs",
-  "esm2022": "dist/esm2022/mediasfu-angular.mjs",
   "fesm2022": "dist/fesm2022/mediasfu-angular.mjs",
   "typings": "dist/index.d.ts",
   "sideEffects": false,
@@ -54,8 +53,6 @@
     },
     ".": {
       "types": "./dist/index.d.ts",
-      "esm2022": "./dist/esm2022/mediasfu-angular.mjs",
-      "es2022": "./dist/fesm2022/mediasfu-angular.mjs",
       "node": "./dist/fesm2022/mediasfu-angular.mjs",
       "default": "./dist/fesm2022/mediasfu-angular.mjs"
     }

package/dist/esm2022/lib/@types/types.mjs

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/@types/types.ts"],"names":[],"mappings":"","sourcesContent":["// types.ts\nimport { Socket } from 'socket.io-client';\nimport {\n  Consumer,\n  DtlsParameters,\n  IceCandidate,\n  IceParameters,\n  RtpCapabilities,\n} from 'mediasoup-client/lib/types';\nimport { IconDefinition } from '@fortawesome/free-solid-svg-icons';\nimport { CustomComponent } from '../components/display-components/control-buttons-component/control-buttons-component.component';\nimport { CustomButton } from '../components/menu-components/custom-buttons/custom-buttons.component';\nimport { ComponentType } from '@angular/cdk/portal';\n\n// //consumers/socket-receive-methods\nexport type {\n  JoinConsumeRoomOptions,\n  JoinConsumeRoomType,\n  JoinConsumeRoomParameters,\n} from '../consumers/socket-receive-methods/join-consume-room.service';\nexport type {\n  ProducerClosedOptions,\n  ProducerClosedType,\n  ProducerClosedParameters,\n} from '../consumers/socket-receive-methods/producer-closed.service';\nexport type {\n  NewPipeProducerOptions,\n  NewPipeProducerType,\n  NewPipeProducerParameters,\n} from '../consumers/socket-receive-methods/new-pipe-producer.service';\n\n// //consumers\nexport type {\n  AddVideosGridOptions,\n  AddVideosGridType,\n  AddVideosGridParameters,\n} from '../consumers/add-videos-grid.service';\nexport type { AutoAdjustOptions, AutoAdjustType } from '../consumers/auto-adjust.service';\nexport type {\n  CalculateRowsAndColumnsOptions,\n  CalculateRowsAndColumnsType,\n} from '../consumers/calculate-rows-and-columns.service';\nexport type {\n  ChangeVidsOptions,\n  ChangeVidsType,\n  ChangeVidsParameters,\n} from '../consumers/change-vids.service';\nexport type { CheckGridOptions, CheckGridType } from '../consumers/check-grid.service';\nexport type {\n  CheckPermissionOptions,\n  CheckPermissionType,\n} from '../consumers/check-permission.service';\nexport type {\n  CheckScreenShareOptions,\n  CheckScreenShareType,\n  CheckScreenShareParameters,\n} from '../consumers/check-screen-share.service';\nexport type {\n  CloseAndResizeOptions,\n  CloseAndResizeType,\n  CloseAndResizeParameters,\n} from '../consumers/close-and-resize.service';\nexport type {\n  CompareActiveNamesOptions,\n  CompareActiveNamesType,\n  CompareActiveNamesParameters,\n} from '../consumers/compare-active-names.service';\nexport type {\n  CompareScreenStatesOptions,\n  CompareScreenStatesType,\n  CompareScreenStatesParameters,\n} from '../consumers/compare-screen-states.service';\nexport type {\n  ConnectIpsOptions,\n  ConnectIpsType,\n  ConnectIpsParameters,\n} from '../consumers/connect-ips.service';\nexport type {\n  ConnectRecvTransportOptions,\n  ConnectRecvTransportType,\n  ConnectRecvTransportParameters,\n} from '../consumers/connect-recv-transport.service';\nexport type {\n  ConnectSendTransportOptions,\n  ConnectSendTransportType,\n  ConnectSendTransportParameters,\n} from '../consumers/connect-send-transport.service';\nexport type {\n  ConnectSendTransportAudioOptions,\n  ConnectSendTransportAudioType,\n  ConnectSendTransportAudioParameters,\n} from '../consumers/connect-send-transport-audio.service';\nexport type {\n  ConnectSendTransportScreenOptions,\n  ConnectSendTransportScreenType,\n  ConnectSendTransportScreenParameters,\n} from '../consumers/connect-send-transport-screen.service';\nexport type {\n  ConnectSendTransportVideoOptions,\n  ConnectSendTransportVideoType,\n  ConnectSendTransportVideoParameters,\n} from '../consumers/connect-send-transport-video.service';\nexport type {\n  ConsumerResumeOptions,\n  ConsumerResumeType,\n  ConsumerResumeParameters,\n} from '../consumers/consumer-resume.service';\nexport type { ControlMediaOptions, ControlMediaType } from '../consumers/control-media.service';\nexport type {\n  CreateSendTransportOptions,\n  CreateSendTransportType,\n  CreateSendTransportParameters,\n} from '../consumers/create-send-transport.service';\nexport type {\n  DisconnectSendTransportAudioOptions,\n  DisconnectSendTransportAudioType,\n  DisconnectSendTransportAudioParameters,\n} from '../consumers/disconnect-send-transport-audio.service';\nexport type {\n  DisconnectSendTransportVideoOptions,\n  DisconnectSendTransportVideoType,\n  DisconnectSendTransportVideoParameters,\n} from '../consumers/disconnect-send-transport-video.service';\nexport type {\n  DisconnectSendTransportScreenOptions,\n  DisconnectSendTransportScreenType,\n  DisconnectSendTransportScreenParameters,\n} from '../consumers/disconnect-send-transport-screen.service';\nexport type {\n  DispStreamsOptions,\n  DispStreamsType,\n  DispStreamsParameters,\n} from '../consumers/disp-streams.service';\nexport type {\n  GeneratePageContentOptions,\n  GeneratePageContentType,\n} from '../consumers/generate-page-content.service';\nexport type {\n  GetEstimateOptions,\n  GetEstimateType,\n  GetEstimateParameters,\n} from '../consumers/get-estimate.service';\nexport type {\n  GetPipedProducersAltOptions,\n  GetPipedProducersAltType,\n  GetPipedProducersAltParameters,\n} from '../consumers/get-piped-producers-alt.service';\nexport type {\n  GetProducersPipedOptions,\n  GetProducersPipedType,\n  GetProducersPipedParameters,\n} from '../consumers/get-producers-piped.service';\nexport type { GetVideosOptions, GetVideosType } from '../consumers/get-videos.service';\nexport type { MixStreamsOptions, MixStreamsType } from '../consumers/mix-streams.service';\nexport type {\n  OnScreenChangesOptions,\n  OnScreenChangesType,\n  OnScreenChangesParameters,\n} from '../consumers/on-screen-changes.service';\nexport type {\n  PrepopulateUserMediaOptions,\n  PrepopulateUserMediaType,\n  PrepopulateUserMediaParameters,\n} from '../consumers/prepopulate-user-media.service';\nexport type {\n  ProcessConsumerTransportsOptions,\n  ProcessConsumerTransportsType,\n  ProcessConsumerTransportsParameters,\n} from '../consumers/process-consumer-transports.service';\nexport type {\n  ProcessConsumerTransportsAudioOptions,\n  ProcessConsumerTransportsAudioType,\n  ProcessConsumerTransportsAudioParameters,\n} from '../consumers/process-consumer-transports-audio.service';\nexport type {\n  ReadjustOptions,\n  ReadjustType,\n  ReadjustParameters,\n} from '../consumers/readjust.service';\nexport type {\n  ReceiveAllPipedTransportsOptions,\n  ReceiveAllPipedTransportsType,\n  ReceiveAllPipedTransportsParameters,\n} from '../consumers/receive-all-piped-transports.service';\nexport type {\n  ReorderStreamsOptions,\n  ReorderStreamsType,\n  ReorderStreamsParameters,\n} from '../consumers/reorder-streams.service';\nexport type { RePortOptions, RePortType, RePortParameters } from '../consumers/re-port.service';\nexport type {\n  RequestScreenShareOptions,\n  RequestScreenShareType,\n  RequestScreenShareParameters,\n} from '../consumers/request-screen-share.service';\nexport type {\n  ResumePauseAudioStreamsOptions,\n  ResumePauseAudioStreamsType,\n  ResumePauseAudioStreamsParameters,\n} from '../consumers/resume-pause-audio-streams.service';\nexport type {\n  ResumePauseStreamsOptions,\n  ResumePauseStreamsType,\n  ResumePauseStreamsParameters,\n} from '../consumers/resume-pause-streams.service';\nexport type {\n  ResumeSendTransportAudioOptions,\n  ResumeSendTransportAudioType,\n  ResumeSendTransportAudioParameters,\n} from '../consumers/resume-send-transport-audio.service';\nexport type {\n  ReUpdateInterOptions,\n  ReUpdateInterType,\n  ReUpdateInterParameters,\n} from '../consumers/re-update-inter.service';\nexport type {\n  SignalNewConsumerTransportOptions,\n  SignalNewConsumerTransportType,\n  SignalNewConsumerTransportParameters,\n} from '../consumers/signal-new-consumer-transport.service';\nexport type {\n  StartShareScreenOptions,\n  StartShareScreenType,\n  StartShareScreenParameters,\n} from '../consumers/start-share-screen.service';\nexport type {\n  StopShareScreenOptions,\n  StopShareScreenType,\n  StopShareScreenParameters,\n} from '../consumers/stop-share-screen.service';\nexport type {\n  StreamSuccessAudioOptions,\n  StreamSuccessAudioType,\n  StreamSuccessAudioParameters,\n} from '../consumers/stream-success-audio.service';\nexport type {\n  StreamSuccessAudioSwitchOptions,\n  StreamSuccessAudioSwitchType,\n  StreamSuccessAudioSwitchParameters,\n} from '../consumers/stream-success-audio-switch.service';\nexport type {\n  StreamSuccessScreenOptions,\n  StreamSuccessScreenType,\n  StreamSuccessScreenParameters,\n} from '../consumers/stream-success-screen.service';\nexport type {\n  StreamSuccessVideoOptions,\n  StreamSuccessVideoType,\n  StreamSuccessVideoParameters,\n} from '../consumers/stream-success-video.service';\nexport type {\n  SwitchUserAudioOptions,\n  SwitchUserAudioType,\n  SwitchUserAudioParameters,\n} from '../consumers/switch-user-audio.service';\nexport type {\n  SwitchUserVideoOptions,\n  SwitchUserVideoType,\n  SwitchUserVideoParameters,\n} from '../consumers/switch-user-video.service';\nexport type {\n  SwitchUserVideoAltOptions,\n  SwitchUserVideoAltType,\n  SwitchUserVideoAltParameters,\n} from '../consumers/switch-user-video-alt.service';\nexport type { TriggerOptions, TriggerType, TriggerParameters } from '../consumers/trigger.service';\nexport type {\n  UpdateMiniCardsGridOptions,\n  UpdateMiniCardsGridType,\n  UpdateMiniCardsGridParameters,\n} from '../consumers/update-mini-cards-grid.service';\nexport type {\n  UpdateParticipantAudioDecibelsOptions,\n  UpdateParticipantAudioDecibelsType,\n} from '../consumers/update-participant-audio-decibels.service';\n\nexport type { AParamsType } from '../methods/utils/producer/a-params.service';\nexport type { HParamsType } from '../methods/utils/producer/h-params.service';\nexport type { ScreenParamsType } from '../methods/utils/producer/screen-params.service';\nexport type { VParamsType } from '../methods/utils/producer/v-params.service';\n\nexport type {\n  LaunchBackgroundOptions,\n  LaunchBackgroundType,\n} from '../methods/background-methods/launch-background.service';\nexport type {\n  LaunchBreakoutRoomsOptions,\n  LaunchBreakoutRoomsType,\n} from '../methods/breakout-room-methods/launch-breakout-rooms.service';\nexport type {\n  BreakoutRoomUpdatedOptions,\n  BreakoutRoomUpdatedType,\n  BreakoutRoomUpdatedParameters,\n} from '../methods/breakout-room-methods/breakout-room-updated.service';\nexport type {\n  LaunchCoHostOptions,\n  LaunchCoHostType,\n} from '../methods/co-host-methods/launch-co-host.service';\nexport type {\n  ModifyCoHostSettingsOptions,\n  ModifyCoHostSettingsType,\n} from '../methods/co-host-methods/modify-co-host-settings.service';\nexport type {\n  LaunchDisplaySettingsOptions,\n  LaunchDisplaySettingsType,\n} from '../methods/display-settings-methods/launch-display-settings.service';\nexport type {\n  ModifyDisplaySettingsOptions,\n  ModifyDisplaySettingsType,\n  ModifyDisplaySettingsParameters,\n} from '../methods/display-settings-methods/modify-display-settings.service';\nexport type {\n  LaunchConfirmExitOptions,\n  LaunchConfirmExitType,\n} from '../methods/exit-methods/launch-confirm-exit.service';\nexport type {\n  ConfirmExitOptions,\n  ConfirmExitType,\n} from '../methods/exit-methods/confirm-exit.service';\nexport type {\n  LaunchMediaSettingsOptions,\n  LaunchMediaSettingsType,\n} from '../methods/media-settings-methods/launch-media-settings.service';\nexport type {\n  LaunchMenuModalOptions,\n  LaunchMenuModalType,\n} from '../methods/menu-methods/launch-menu-modal.service';\nexport type {\n  LaunchMessagesOptions,\n  LaunchMessagesType,\n} from '../methods/message-methods/launch-messages.service';\nexport type {\n  SendMessageOptions,\n  SendMessageType,\n} from '../methods/message-methods/send-message.service';\nexport type {\n  LaunchParticipantsOptions,\n  LaunchParticipantsType,\n} from '../methods/participants-methods/launch-participants.service';\nexport type {\n  MessageParticipantsOptions,\n  MessageParticipantsType,\n} from '../methods/participants-methods/message-participants.service';\nexport type {\n  MuteParticipantsOptions,\n  MuteParticipantsType,\n} from '../methods/participants-methods/mute-participants.service';\nexport type {\n  RemoveParticipantsOptions,\n  RemoveParticipantsType,\n} from '../methods/participants-methods/remove-participants.service';\nexport type {\n  HandleCreatePollOptions,\n  HandleCreatePollType,\n} from '../methods/polls-methods/handle-create-poll.service';\nexport type {\n  HandleEndPollOptions,\n  HandleEndPollType,\n} from '../methods/polls-methods/handle-end-poll.service';\nexport type {\n  HandleVotePollOptions,\n  HandleVotePollType,\n} from '../methods/polls-methods/handle-vote-poll.service';\nexport type {\n  LaunchPollOptions,\n  LaunchPollType,\n} from '../methods/polls-methods/launch-poll.service';\nexport type {\n  PollUpdatedOptions,\n  PollUpdatedType,\n} from '../methods/polls-methods/poll-updated.service';\nexport type {\n  CheckPauseStateOptions,\n  CheckPauseStateType,\n} from '../methods/recording-methods/check-pause-state.service';\nexport type {\n  CheckResumeStateOptions,\n  CheckResumeStateType,\n} from '../methods/recording-methods/check-resume-state.service';\nexport type {\n  ConfirmRecordingOptions,\n  ConfirmRecordingType,\n  ConfirmRecordingParameters,\n} from '../methods/recording-methods/confirm-recording.service';\nexport type {\n  LaunchRecordingOptions,\n  LaunchRecordingType,\n} from '../methods/recording-methods/launch-recording.service';\nexport type {\n  RecordPauseTimerOptions,\n  RecordPauseTimerType,\n} from '../methods/recording-methods/record-pause-timer.service';\nexport type {\n  RecordResumeTimerOptions,\n  RecordResumeTimerType,\n} from '../methods/recording-methods/record-resume-timer.service';\nexport type {\n  RecordStartTimerOptions,\n  RecordStartTimerType,\n} from '../methods/recording-methods/record-start-timer.service';\nexport type {\n  RecordUpdateTimerOptions,\n  RecordUpdateTimerType,\n} from '../methods/recording-methods/record-update-timer.service';\nexport type {\n  StartRecordingOptions,\n  StartRecordingType,\n  StartRecordingParameters,\n} from '../methods/recording-methods/start-recording.service';\nexport type {\n  StopRecordingOptions,\n  StopRecordingType,\n  StopRecordingParameters,\n} from '../methods/recording-methods/stop-recording.service';\nexport type {\n  UpdateRecordingOptions,\n  UpdateRecordingType,\n  UpdateRecordingParameters,\n} from '../methods/recording-methods/update-recording.service';\nexport type {\n  LaunchRequestsOptions,\n  LaunchRequestsType,\n} from '../methods/requests-methods/launch-requests.service';\nexport type {\n  RespondToRequestsOptions,\n  RespondToRequestsType,\n} from '../methods/requests-methods/respond-to-requests.service';\nexport type {\n  LaunchSettingsOptions,\n  LaunchSettingsType,\n} from '../methods/settings-methods/launch-settings.service';\nexport type {\n  ModifySettingsOptions,\n  ModifySettingsType,\n} from '../methods/settings-methods/modify-settings.service';\nexport type {\n  ClickAudioOptions,\n  ClickAudioType,\n  ClickAudioParameters,\n} from '../methods/stream-methods/click-audio.service';\nexport type { ClickChatOptions, ClickChatType } from '../methods/stream-methods/click-chat.service';\nexport type {\n  ClickScreenShareOptions,\n  ClickScreenShareType,\n  ClickScreenShareParameters,\n} from '../methods/stream-methods/click-screen-share.service';\nexport type {\n  ClickVideoOptions,\n  ClickVideoType,\n  ClickVideoParameters,\n} from '../methods/stream-methods/click-video.service';\nexport type {\n  SwitchAudioOptions,\n  SwitchAudioType,\n  SwitchAudioParameters,\n} from '../methods/stream-methods/switch-audio.service';\nexport type {\n  SwitchVideoOptions,\n  SwitchVideoType,\n  SwitchVideoParameters,\n} from '../methods/stream-methods/switch-video.service';\nexport type {\n  SwitchVideoAltOptions,\n  SwitchVideoAltType,\n} from '../methods/stream-methods/switch-video-alt.service';\n\nexport type {\n  StartMeetingProgressTimerOptions,\n  StartMeetingProgressTimerType,\n  StartMeetingProgressTimerParameters,\n} from '../methods/utils/meeting-timer/start-meeting-progress-timer.service';\nexport type {\n  MiniAudioPlayerOptions,\n  MiniAudioPlayerType,\n  MiniAudioPlayerParameters,\n} from '../methods/utils/mini-audio-player/mini-audio-player.component';\nexport type { FormatNumberOptions, FormatNumberType } from '../methods/utils/format-number.service';\nexport type {\n  GenerateRandomMessagesOptions,\n  GenerateRandomMessagesType,\n} from '../methods/utils/generate-random-messages.service';\nexport type {\n  GenerateRandomParticipantsOptions,\n  GenerateRandomParticipantsType,\n} from '../methods/utils/generate-random-participants.service';\nexport type {\n  GenerateRandomPollsOptions,\n  GenerateRandomPollsType,\n} from '../methods/utils/generate-random-polls.service';\nexport type {\n  GenerateRandomRequestListOptions,\n  GenerateRandomRequestListType,\n} from '../methods/utils/generate-random-request-list.service';\nexport type { GenerateRandomWaitingRoomListType } from '../methods/utils/generate-random-waiting-room-list.service';\nexport type {\n  GetModalPositionOptions,\n  GetModalPositionType,\n} from '../methods/utils/get-modal-position.util';\nexport type {\n  GetOverlayPositionOptions,\n  GetOverlayPositionType,\n} from '../methods/utils/get-overlay-position.util';\nexport type { SleepOptions, SleepType } from '../methods/utils/sleep.util';\nexport type {\n  ValidateAlphanumericOptions,\n  ValidateAlphanumericType,\n} from '../methods/utils/validate-alphanumeric.service';\n\nexport type {\n  LaunchWaitingOptions,\n  LaunchWaitingType,\n} from '../methods/waiting-methods/launch-waiting.service';\nexport type {\n  RespondToWaitingOptions,\n  RespondToWaitingType,\n} from '../methods/waiting-methods/respond-to-waiting.service';\nexport type {\n  LaunchConfigureWhiteboardOptions,\n  LaunchConfigureWhiteboardType,\n} from '../methods/whiteboard-methods/launch-configure-whiteboard.service';\nexport type {\n  CaptureCanvasStreamOptions,\n  CaptureCanvasStreamType,\n  CaptureCanvasStreamParameters,\n} from '../methods/whiteboard-methods/capture-canvas-stream.service';\n\nexport type {\n  CreateDeviceClientOptions,\n  CreateDeviceClientType,\n} from '../producer-client/producer-client-emits/create-device-client.service';\nexport type {\n  JoinRoomClientOptions,\n  JoinRoomClientType,\n} from '../producer-client/producer-client-emits/join-room-client.service';\nexport type {\n  UpdateRoomParametersClientOptions,\n  UpdateRoomParametersClientType,\n  UpdateRoomParametersClientParameters,\n} from '../producer-client/producer-client-emits/update-room-parameters-client.service';\n\nexport type {\n  JoinConRoomOptions,\n  JoinConRoomType,\n} from '../producers/producer-emits/join-con-room.service';\nexport type { JoinRoomOptions, JoinRoomType } from '../producers/producer-emits/join-room.service';\n\nexport type {\n  AllMembersOptions,\n  AllMembersType,\n  AllMembersParameters,\n} from '../producers/socket-receive-methods/all-members.service';\nexport type {\n  AllMembersRestOptions,\n  AllMembersRestType,\n  AllMembersRestParameters,\n} from '../producers/socket-receive-methods/all-members-rest.service';\nexport type {\n  AllWaitingRoomMembersOptions,\n  AllWaitingRoomMembersType,\n} from '../producers/socket-receive-methods/all-waiting-room-members.service';\nexport type {\n  BanParticipantOptions,\n  BanParticipantType,\n  BanParticipantParameters,\n} from '../producers/socket-receive-methods/ban-participant.service';\nexport type {\n  ControlMediaHostOptions,\n  ControlMediaHostType,\n  ControlMediaHostParameters,\n} from '../producers/socket-receive-methods/control-media-host.service';\nexport type {\n  DisconnectOptions,\n  DisconnectType,\n} from '../producers/socket-receive-methods/disconnect.service';\nexport type {\n  DisconnectUserSelfOptions,\n  DisconnectUserSelfType,\n} from '../producers/socket-receive-methods/disconnect-user-self.service';\nexport type {\n  GetDomainsOptions,\n  GetDomainsType,\n  GetDomainsParameters,\n} from '../producers/socket-receive-methods/get-domains.service';\nexport type {\n  HostRequestResponseOptions,\n  HostRequestResponseType,\n} from '../producers/socket-receive-methods/host-request-response.service';\nexport type {\n  MeetingEndedOptions,\n  MeetingEndedType,\n} from '../producers/socket-receive-methods/meeting-ended.service';\nexport type {\n  MeetingStillThereOptions,\n  MeetingStillThereType,\n} from '../producers/socket-receive-methods/meeting-still-there.service';\nexport type {\n  MeetingTimeRemainingOptions,\n  MeetingTimeRemainingType,\n} from '../producers/socket-receive-methods/meeting-time-remaining.service';\nexport type {\n  ParticipantRequestedOptions,\n  ParticipantRequestedType,\n} from '../producers/socket-receive-methods/participant-requested.service';\nexport type {\n  PersonJoinedOptions,\n  PersonJoinedType,\n} from '../producers/socket-receive-methods/person-joined.service';\nexport type {\n  ProducerMediaClosedOptions,\n  ProducerMediaClosedType,\n  ProducerMediaClosedParameters,\n} from '../producers/socket-receive-methods/producer-media-closed.service';\nexport type {\n  ProducerMediaPausedOptions,\n  ProducerMediaPausedType,\n  ProducerMediaPausedParameters,\n} from '../producers/socket-receive-methods/producer-media-paused.service';\nexport type {\n  ProducerMediaResumedOptions,\n  ProducerMediaResumedType,\n  ProducerMediaResumedParameters,\n} from '../producers/socket-receive-methods/producer-media-resumed.service';\nexport type {\n  ReInitiateRecordingOptions,\n  ReInitiateRecordingType,\n} from '../producers/socket-receive-methods/re-initiate-recording.service';\nexport type {\n  ReceiveMessageOptions,\n  ReceiveMessageType,\n} from '../producers/socket-receive-methods/receive-message.service';\nexport type {\n  RecordingNoticeOptions,\n  RecordingNoticeType,\n  RecordingNoticeParameters,\n} from '../producers/socket-receive-methods/recording-notice.service';\nexport type {\n  RoomRecordParamsOptions,\n  RoomRecordParamsType,\n  RoomRecordParamsParameters,\n  RecordParams,\n} from '../producers/socket-receive-methods/room-record-params.service';\nexport type {\n  ScreenProducerIdOptions,\n  ScreenProducerIdType,\n} from '../producers/socket-receive-methods/screen-producer-id.service';\nexport type {\n  StartRecordsOptions,\n  StartRecordsType,\n} from '../producers/socket-receive-methods/start-records.service';\nexport type {\n  StoppedRecordingOptions,\n  StoppedRecordingType,\n} from '../producers/socket-receive-methods/stopped-recording.service';\nexport type {\n  TimeLeftRecordingOptions,\n  TimeLeftRecordingType,\n} from '../producers/socket-receive-methods/time-left-recording.service';\nexport type {\n  UpdateConsumingDomainsOptions,\n  UpdateConsumingDomainsType,\n  UpdateConsumingDomainsParameters,\n} from '../producers/socket-receive-methods/update-consuming-domains.service';\nexport type {\n  UpdateMediaSettingsOptions,\n  UpdateMediaSettingsType,\n} from '../producers/socket-receive-methods/update-media-settings.service';\nexport type {\n  UpdatedCoHostOptions,\n  UpdatedCoHostType,\n} from '../producers/socket-receive-methods/updated-co-host.service';\nexport type {\n  UserWaitingOptions,\n  UserWaitingType,\n} from '../producers/socket-receive-methods/user-waiting.service';\nexport type {\n  ConnectSocketOptions,\n  ConnectSocketType,\n  DisconnectSocketType,\n  DisconnectSocketOptions,\n} from '../sockets/socket-manager.service';\n\nexport type {\n  BackgroundModalOptions,\n  BackgroundModalType,\n  BackgroundModalParameters,\n} from '../components/background-components/background-modal/background-modal.component';\nexport type {\n  BreakoutRoomsModalOptions,\n  BreakoutRoomsModalType,\n  BreakoutRoomsModalParameters,\n} from '../components/breakout-components/breakout-rooms-modal.component';\nexport type {\n  CoHostModalOptions,\n  CoHostModalType,\n} from '../components/co-host-components/co-host-modal/co-host-modal.component';\nexport type {\n  AlertComponentOptions,\n  AlertComponentType,\n} from '../components/display-components/alert-component/alert.component.component';\nexport type {\n  AudioCardOptions,\n  AudioCardType,\n  AudioCardParameters,\n} from '../components/display-components/audio-card/audio-card.component';\nexport type {\n  AudioGridOptions,\n  AudioGridType,\n} from '../components/display-components/audio-grid/audio-grid.component';\nexport type {\n  CardVideoDisplayOptions,\n  CardVideoDisplayType,\n} from '../components/display-components/card-video-display/card-video-display.component';\nexport type {\n  ControlButtonsComponentOptions,\n  ControlButtonsComponentType,\n  Button,\n} from '../components/display-components/control-buttons-component/control-buttons-component.component';\nexport type {\n  ControlButtonsAltComponentOptions,\n  ControlButtonsAltComponentType,\n  AltButton,\n} from '../components/display-components/control-buttons-alt-component/control-buttons-alt-component.component';\nexport type {\n  ControlButtonsComponentTouchOptions,\n  ControlButtonsComponentTouchType,\n  ButtonTouch,\n} from '../components/display-components/control-buttons-component-touch/control-buttons-component-touch.component';\nexport type {\n  FlexibleGridOptions,\n  FlexibleGridType,\n} from '../components/display-components/flexible-grid/flexible-grid.component';\nexport type {\n  FlexibleVideoOptions,\n  FlexibleVideoType,\n} from '../components/display-components/flexible-video/flexible-video.component';\nexport type {\n  LoadingModalOptions,\n  LoadingModalType,\n} from '../components/display-components/loading-modal/loading-modal.component';\nexport type {\n  MainAspectComponentOptions,\n  MainAspectComponentType,\n} from '../components/display-components/main-aspect-component/main-aspect-component.component';\nexport type {\n  MainContainerComponentOptions,\n  MainContainerComponentType,\n} from '../components/display-components/main-container-component/main-container-component.component';\nexport type {\n  MainGridComponentOptions,\n  MainGridComponentType,\n} from '../components/display-components/main-grid-component/main-grid-component.component';\nexport type {\n  MainScreenComponentOptions,\n  MainScreenComponentType,\n} from '../components/display-components/main-screen-component/main-screen-component.component';\nexport type {\n  MeetingProgressTimerOptions,\n  MeetingProgressTimerType,\n} from '../components/display-components/meeting-progress-timer/meeting-progress-timer.component';\nexport type {\n  MiniAudioOptions,\n  MiniAudioType,\n} from '../components/display-components/mini-audio/mini-audio.component';\nexport type {\n  MiniCardOptions,\n  MiniCardType,\n} from '../components/display-components/mini-card/mini-card.component';\nexport type {\n  MiniCardAudioOptions,\n  MiniCardAudioType,\n} from '../components/display-components/mini-card-audio/mini-card-audio.component';\nexport type {\n  OtherGridComponentOptions,\n  OtherGridComponentType,\n} from '../components/display-components/other-grid-component/other-grid-component.component';\nexport type {\n  PaginationOptions,\n  PaginationType,\n} from '../components/display-components/pagination/pagination.component';\nexport type {\n  SubAspectComponentOptions,\n  SubAspectComponentType,\n} from '../components/display-components/sub-aspect-component/sub-aspect-component.component';\nexport type {\n  VideoCardOptions,\n  VideoCardType,\n  VideoCardParameters,\n} from '../components/display-components/video-card/video-card.component';\nexport type {\n  DisplaySettingsModalOptions,\n  DisplaySettingsModalType,\n  DisplaySettingsModalParameters,\n} from '../components/display-settings-components/display-settings-modal.component';\nexport type {\n  EventSettingsModalOptions,\n  EventSettingsModalType,\n} from '../components/event-settings-components/event-settings-modal/event-settings-modal.component';\nexport type {\n  ConfirmExitModalOptions,\n  ConfirmExitModalType,\n} from '../components/exit-components/confirm-exit-modal/confirm-exit-modal.component';\nexport type {\n  MediaSettingsModalOptions,\n  MediaSettingsModalType,\n  MediaSettingsModalParameters,\n} from '../components/media-settings-components/media-settings-modal/media-settings-modal.component';\nexport type {\n  MenuModalOptions,\n  MenuModalType,\n} from '../components/menu-components/menu-modal/menu-modal.component';\nexport type {\n  MessagesModalOptions,\n  MessagesModalType,\n} from '../components/message-components/messages-modal/messages-modal.component';\nexport type {\n  ConfirmHereModalOptions,\n  ConfirmHereModalType,\n} from '../components/misc-components/confirm-here-modal/confirm-here-modal.component';\nexport type {\n  PreJoinPageOptions,\n  PreJoinPageType,\n  PreJoinPageParameters,\n} from '../components/misc-components/pre-join-page/pre-join-page.component';\nexport type {\n  ShareEventModalOptions,\n  ShareEventModalType,\n} from '../components/misc-components/share-event-modal/share-event-modal.component';\nexport type {\n  WelcomePageOptions,\n  WelcomePageType,\n  WelcomePageParameters,\n} from '../components/misc-components/welcome-page/welcome-page.component';\nexport type {\n  ParticipantsModalOptions,\n  ParticipantsModalType,\n  ParticipantsModalParameters,\n} from '../components/participants-components/participants-modal/participants-modal.component';\nexport type {\n  PollModalOptions,\n  PollModalType,\n} from '../components/polls-components/poll-modal/poll-modal.component';\nexport type {\n  RecordingModalOptions,\n  RecordingModalType,\n  RecordingModalParameters,\n} from '../components/recording-components/recording-modal/recording-modal.component';\nexport type {\n  RequestsModalOptions,\n  RequestsModalType,\n} from '../components/requests-components/requests-modal/requests-modal.component';\nexport type {\n  ScreenboardOptions,\n  ScreenboardType,\n  ScreenboardParameters,\n} from '../components/screenboard-components/screenboard/screenboard.component';\nexport type {\n  ScreenboardModalOptions,\n  ScreenboardModalType,\n} from '../components/screenboard-components/screenboard-modal/screenboard-modal.component';\nexport type {\n  WaitingRoomModalOptions,\n  WaitingRoomModalType,\n  WaitingRoomModalParameters,\n} from '../components/waiting-components/waiting-room-modal.component';\nexport type {\n  ConfigureWhiteboardModalOptions,\n  ConfigureWhiteboardModalType,\n} from '../components/whiteboard-components/configure-whiteboard-modal/configure-whiteboard-modal.component';\nexport type {\n  WhiteboardOptions,\n  WhiteboardType,\n  WhiteboardParameters,\n  Shape,\n} from '../components/whiteboard-components/whiteboard/whiteboard.component';\n\nexport type { CustomButton } from '../components/menu-components/custom-buttons/custom-buttons.component';\n\nexport interface Participant {\n  id?: string;\n  audioID: string;\n  videoID: string;\n  ScreenID?: string;\n  ScreenOn?: boolean;\n  islevel?: string;\n  isAdmin?: boolean;\n  name: string;\n  muted?: boolean;\n  isBanned?: boolean;\n  isSuspended?: boolean;\n  useBoard?: boolean;\n  breakRoom?: number | null;\n  [key: string]: any;\n}\n\nexport interface Stream {\n  producerId: string;\n  muted?: boolean;\n  stream?: MediaStream;\n  socket_?: Socket;\n  name?: string;\n  [key: string]: any;\n}\n\nexport interface Request {\n  id: string;\n  icon: string;\n  name?: string;\n  username?: string;\n  [key: string]: any;\n}\n\nexport interface RequestResponse {\n  id: string;\n  icon?: string;\n  name?: string;\n  username?: string;\n  action?: string;\n  type?: string;\n  [key: string]: any;\n}\n\nexport interface Transport {\n  producerId: string;\n  consumer: Consumer;\n  socket_: Socket;\n  serverConsumerTransportId: string;\n  [key: string]: any;\n}\n\nexport interface ScreenState {\n  mainScreenPerson?: string;\n  mainScreenProducerId?: string;\n  mainScreenFilled: boolean;\n  adminOnMainScreen: boolean;\n}\n\nexport interface GridSizes {\n  gridWidth?: number;\n  gridHeight?: number;\n  altGridWidth?: number;\n  altGridHeight?: number;\n}\n\nexport interface ComponentSizes {\n  mainWidth: number;\n  mainHeight: number;\n  otherWidth: number;\n  otherHeight: number;\n}\n\nexport interface AudioDecibels {\n  name: string;\n  averageLoudness: number;\n}\n\nexport type ShowAlert = (options: {\n  message: string;\n  type: 'success' | 'danger';\n  duration?: number;\n}) => void;\n\nexport interface CoHostResponsibility {\n  name: string;\n  value: boolean;\n  dedicated: boolean;\n}\n\nexport interface VidCons {\n  width: number | { ideal?: number; max?: number; min?: number };\n  height: number | { ideal?: number; max?: number; min?: number };\n}\n\nexport type Settings = [string, string, string, string];\n\nexport interface Message {\n  sender: string;\n  receivers: string[];\n  message: string;\n  timestamp: string;\n  group: boolean;\n}\n\nexport type MainSpecs = {\n  mediaOptions: string;\n  audioOptions: string;\n  videoOptions: string;\n  videoType: string;\n  videoOptimized: boolean;\n  recordingDisplayType: 'video' | 'media' | 'all';\n  addHLS: boolean;\n};\n\nexport type DispSpecs = {\n  nameTags: boolean;\n  backgroundColor: string;\n  nameTagsColor: string;\n  orientationVideo: string;\n};\n\nexport type TextSpecs = {\n  addText: boolean;\n  customText?: string;\n  customTextPosition?: string;\n  customTextColor?: string;\n};\n\nexport interface UserRecordingParams {\n  mainSpecs: MainSpecs;\n  dispSpecs: DispSpecs;\n  textSpecs?: TextSpecs;\n}\n\nexport type AltDomains = {\n  [key: string]: string;\n};\n\nexport type RequestPermissionAudioType = () => Promise<string>;\nexport type RequestPermissionCameraType = () => Promise<string>;\n\nexport type ControlsPosition = 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';\nexport type InfoPosition = 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';\n\nexport interface Poll {\n  id: string;\n  question: string;\n  type: string;\n  options: string[];\n  votes: number[];\n  status: string;\n  voters?: Record<string, number>;\n  [key: string]: any;\n}\n\nexport interface WaitingRoomParticipant {\n  name: string;\n  id: string;\n}\n\nexport interface ModalPositionStyle {\n  justifyContent: string;\n  alignItems: string;\n}\n\nexport interface OverlayPositionStyle {\n  top?: number;\n  left?: number;\n  right?: number;\n  bottom?: number;\n}\n\nexport type EventType = 'conference' | 'webinar' | 'chat' | 'broadcast' | 'none';\n\nexport interface PollUpdatedData {\n  polls?: Poll[];\n  poll: Poll;\n  status: string;\n}\n\nexport interface BreakoutParticipant {\n  name: string;\n  breakRoom?: number | null;\n}\n\nexport interface BreakoutRoomUpdatedData {\n  forHost?: boolean;\n  newRoom?: number;\n  members?: Participant[];\n  breakoutRooms?: BreakoutParticipant[][];\n  status?: string;\n}\n\nexport interface ConsumeSocket {\n  [ip: string]: Socket;\n}\n\nexport interface WhiteboardUser {\n  name: string;\n  useBoard: boolean;\n}\n\nexport interface ShapePayload {\n  type: string;\n  x1: number;\n  y1: number;\n  x2: number;\n  y2: number;\n  color: string;\n  thickness: number;\n  lineType: string;\n  [key: string]: any;\n}\n\nexport interface Shapes {\n  action: string;\n  payload: ShapePayload;\n}\nexport interface WhiteboardData {\n  shapes: Shapes[];\n  redoStack: Shapes[];\n  undoStack: Shapes[];\n  useImageBackground: boolean;\n}\n\nexport type SeedData = {\n  member?: string;\n  host?: string;\n  eventType?: EventType;\n  participants?: Participant[];\n  messages?: Message[];\n  polls?: Poll[];\n  breakoutRooms?: BreakoutParticipant[][];\n  requests?: Request[];\n  waitingList?: WaitingRoomParticipant[];\n  whiteboardUsers?: WhiteboardUser[];\n};\n\nexport interface MeetingRoomParams {\n  itemPageLimit: number; // Limit for items per page\n  mediaType: 'audio' | 'video'; // Type of media, could be audio or video\n  addCoHost: boolean; // Whether co-hosts can be added\n  targetOrientation: 'landscape' | 'neutral' | 'portrait'; // Target orientation, landscape, neutral, or portrait\n  targetOrientationHost: 'landscape' | 'neutral' | 'portrait'; // Host's target orientation, landscape, neutral, or portrait\n  targetResolution: 'qhd' | 'fhd' | 'hd' | 'sd' | 'QnHD'; // Target resolution for participants\n  targetResolutionHost: 'qhd' | 'fhd' | 'hd' | 'sd' | 'QnHD'; // Target resolution for host  type: 'chat' | 'conference' | 'webinar' | 'broadcast'; // Room type: chat, conference, webinar, or broadcast\n  type: EventType; // Room type: chat, conference, webinar, or broadcast\n  audioSetting: 'allow' | 'approval' | 'disallow'; // Audio setting: allow, approval, or disallow\n  videoSetting: 'allow' | 'approval' | 'disallow'; // Video setting: allow, approval, or disallow\n  screenshareSetting: 'allow' | 'approval' | 'disallow'; // Screenshare setting: allow, approval, or disallow\n  chatSetting: 'allow' | 'disallow'; // Chat setting: allow or disallow\n}\n\nexport interface RecordingParams {\n  recordingAudioPausesLimit: number; // Limit on audio recording pauses\n  recordingAudioSupport: boolean; // Whether audio recording is supported\n  recordingAudioPeopleLimit: number; // Maximum number of people for audio recording\n  recordingAudioParticipantsTimeLimit: number; // Time limit for audio participants in recording\n\n  recordingVideoPausesLimit: number; // Limit on video recording pauses\n  recordingVideoSupport: boolean; // Whether video recording is supported\n  recordingVideoPeopleLimit: number; // Maximum number of people for video recording\n  recordingVideoParticipantsTimeLimit: number; // Time limit for video participants in recording\n\n  recordingAllParticipantsSupport: boolean; // Whether recording all participants is supported\n  recordingVideoParticipantsSupport: boolean; // Whether video recording for participants is supported\n  recordingAllParticipantsFullRoomSupport: boolean; // Support for recording the entire room for all participants\n  recordingVideoParticipantsFullRoomSupport: boolean; // Support for recording the full room for video participants\n\n  recordingPreferredOrientation: 'landscape' | 'portrait'; // Preferred recording orientation\n  recordingSupportForOtherOrientation: boolean; // Support for orientations other than the preferred one\n  recordingMultiFormatsSupport: boolean; // Support for multiple recording formats\n  recordingHLSSupport: boolean; // Whether HLS recording is supported\n\n  recordingAudioPausesCount?: number; // Number of audio recording pauses\n  recordingVideoPausesCount?: number; // Number of video recording pauses\n}\n\nexport interface CreateRoomOptions {\n  action: 'create' | 'join'; // Either 'create' or 'join' based on the requirement\n  meetingID: string; // The meeting ID, initially an empty string\n  duration: number; // Duration of the meeting in minutes\n  capacity: number; // Max number of participants allowed\n  userName: string; // Username of the room host\n  scheduledDate: number; // Unix timestamp (in milliseconds) for the scheduled date\n  secureCode: string; // Secure code for the room host\n  eventType: 'conference' | 'webinar' | 'chat' | 'broadcast'; // Type of event\n  recordOnly: boolean; // Whether the room is for recording only\n  eventStatus: 'active' | 'inactive'; // Status of the event\n  startIndex: number; // Start index for pagination or data fetch\n  pageSize: number; // Number of items per page\n  safeRoom: boolean; // Whether the room is a safe room\n  autoStartSafeRoom: boolean; // Automatically start the safe room feature\n  safeRoomAction: 'warn' | 'kick' | 'ban'; // Action for the safe room\n  dataBuffer: boolean; // Whether to return data buffer\n  bufferType: 'images' | 'audio' | 'all'; // Type of buffer data\n}\n\nexport interface ResponseJoinRoom {\n  rtpCapabilities?: RtpCapabilities | null; // Object containing the RTP capabilities\n  success: boolean; // Indicates whether the operation (joining the room) was successful.\n  roomRecvIPs: string[]; // Array of strings containing information about the domains that must be connected to in order to receive media.\n  meetingRoomParams: MeetingRoomParams; // Object containing parameters related to the meeting room.\n  recordingParams: RecordingParams; // Object containing parameters related to recording.\n  secureCode: string; // Secure code (host password) associated with the host of the room.\n  recordOnly: boolean; // Indicates whether the room is for recording only.\n  isHost: boolean; // Indicates whether the user joining the room is the host.\n  safeRoom: boolean; // Indicates whether the room is a safe room.\n  autoStartSafeRoom: boolean; // Indicates whether the safe room will automatically start.\n  safeRoomStarted: boolean; // Indicates whether the safe room has started.\n  safeRoomEnded: boolean; // Indicates whether the safe room has ended.\n  reason?: string; // Reason for the success or failure of the operation.\n}\n\nexport interface AllMembersData {\n  members: Participant[]; // Array of objects containing information about all the members in the room.\n  requests: Request[]; // Array of objects containing information about the requests.\n  coHost?: string; // The co-host information.\n  coHostResponsibilities: CoHostResponsibility[]; // Array of objects containing information about the co-host responsibilities.\n}\n\nexport interface AllMembersRestData {\n  members: Participant[]; // Array of objects containing information about all the members in the room.\n  settings: Settings; // Array of strings containing information about the settings.\n  coHost?: string; // The co-host information.\n  coHostResponsibilities: CoHostResponsibility[]; // Array of objects containing information about the co-host responsibilities.\n}\n\nexport interface UserWaitingData {\n  name: string; // Name of the user waiting to join the room.\n}\n\nexport interface AllWaitingRoomMembersData {\n  waitingParticipants?: WaitingRoomParticipant[]; // Array of objects containing information about the participants waiting to join the room.\n  waitingParticipantss?: WaitingRoomParticipant[];\n}\n\nexport interface BanData {\n  name: string; // Name of the user to ban.\n}\n\nexport interface UpdatedCoHostData {\n  coHost: string; // The co-host information.\n  coHostResponsibilities: CoHostResponsibility[]; // Array of objects containing information about the co-host responsibilities.\n}\n\nexport interface ParticipantRequestedData {\n  userRequest: Request; // Object containing information about the user request.\n}\n\nexport interface ScreenProducerIdData {\n  producerId: string; // The producer ID of the screen.\n}\n\nexport interface UpdateMediaSettingsData {\n  settings: Settings; // Array of strings containing information about the settings.\n}\n\nexport interface ProducerMediaPausedData {\n  producerId: string; // The producer ID of the media that was paused.\n  kind: 'audio';\n  name: string; // The name of the media that was paused.\n}\n\nexport interface ProducerMediaResumedData {\n  kind: 'audio';\n  name: string; // The name of the media that was resumed.\n}\n\nexport interface ProducerMediaClosedData {\n  producerId: string; // The producer ID of the media that was stopped.\n  kind: 'audio' | 'video' | 'screenshare';\n  name: string; // The name of the media that was stopped.\n}\n\nexport interface ControlMediaHostData {\n  type: 'all' | 'audio' | 'video' | 'screenshare'; // The type of media to control.\n}\n\nexport interface ReceiveMessageData {\n  message: Message; // Object containing information about the message.\n}\n\nexport interface MeetingTimeRemainingData {\n  timeRemaining: number; // The time remaining for the meeting.\n}\n\nexport interface MeetingStillThereData {\n  timeRemaining: number; // The time remaining for the meeting.\n}\n\nexport interface UpdateConsumingDomainsData {\n  domains: string[]; // Array of strings containing information about the domains to consume media from.\n  alt_domains: AltDomains; // Object containing information about the alternative domains to consume media from.\n}\n\nexport interface RecordingNoticeData {\n  state: string; // The state of the recording.\n  userRecordingParam: UserRecordingParams; // Object containing information about the user recording parameters.\n  pauseCount: number; // The number of times the recording was paused.\n  timeDone: number; // The time the recording was paused.\n}\n\nexport interface TimeLeftRecordingData {\n  timeLeft: number; // The time left for recording.\n}\n\nexport interface StoppedRecordingData {\n  state: string; // The state of the recording.\n  reason?: string; // The reason for stopping the recording.\n}\n\nexport interface HostRequestResponseData {\n  requestResponse: RequestResponse; // Object containing information about the request response.\n}\n\nexport interface SafeRoomNoticeData {\n  state: string; // The state of the safe room.\n}\n\nexport interface UnSafeData {\n  time: number; // The time the room was unsafe.\n  evidence: ImageData; // The evidence for the room being unsafe.\n}\n\nexport interface UnsafeAlertData {\n  name: string; // The name of the user who triggered the unsafe alert.\n}\n\nexport interface DataBufferNotice {\n  state: string; // The state of the data buffer.\n}\n\nexport interface AudioData {\n  audioBuffer: AudioBuffer; // The audio buffer.\n}\n\nexport interface ImageData {\n  jpegBuffer: ImageData; // The JPEG buffer.\n}\n\nexport interface WhiteboardUpdatedData {\n  status: 'started' | 'ended'; // The status of the whiteboard.\n  whiteboardUsers: WhiteboardUser[]; // Array of objects containing information about the whiteboard users.\n  members: Participant[]; // Array of objects containing information about the members.\n  whiteboardData: WhiteboardData; // Object containing information about the whiteboard data.\n}\n\nexport interface WhiteboardActionData {\n  action: string; // The action to be performed on the whiteboard.\n  payload: ShapePayload; // Object containing information about the shape payload.\n}\n\nexport interface CustomMediaComponent {\n  component: ComponentType<any>; // The custom media component.\n  inputs: any;\n}\n\nexport interface GenericButton {\n  name?: string;\n  icon?: IconDefinition;\n  alternateIcon?: IconDefinition;\n  onPress?: () => void;\n  color?: string;\n  backgroundColor?: {\n    default?: string;\n  };\n}\n\nexport interface MainButtonAlt extends GenericButton {\n  active?: boolean | (() => boolean);\n  customComponent?: HTMLElement | CustomComponent | (() => HTMLElement | CustomComponent);\n  iconComponent?: HTMLElement | CustomComponent | (() => HTMLElement | CustomComponent);\n  alternateIconComponent?: HTMLElement | CustomComponent | (() => HTMLElement | CustomComponent);\n  disabled?: boolean | (() => boolean);\n  show?: boolean | (() => boolean);\n  activeColor?: string | (() => string);\n  inActiveColor?: string | (() => string);\n}\n\nexport type MainCustomButton = Pick<\n  CustomButton,\n  Exclude<keyof CustomButton, 'customComponent'>\n> & {\n  customComponent?: HTMLElement | CustomComponent | (() => HTMLElement | CustomComponent);\n};\n\nexport type { CustomComponent } from '../components/menu-components/custom-buttons/custom-buttons.component';\n\nexport type CreateWebRTCTransportResponse = {\n  id: string;\n  dtlsParameters: DtlsParameters;\n  iceCandidates: IceCandidate[];\n  iceParameters: IceParameters;\n  error?: string;\n};\n"]}