mediasfu-angular 2.2.2 → 2.2.3

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

@@ -1,9 +1,6 @@
+import type { LaunchSettingsOptions } from 'mediasfu-shared';
 import * as i0 from "@angular/core";
-export interface LaunchSettingsOptions {
-    updateIsSettingsModalVisible: (isVisible: boolean) => void;
-    isSettingsModalVisible: boolean;
-}
-export type LaunchSettingsType = (options: LaunchSettingsOptions) => void;
+export type { LaunchSettingsOptions, LaunchSettingsType } from 'mediasfu-shared';
 /**
  * Toggles the visibility state of the settings modal.
  *

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

@@ -80,7 +80,7 @@ export declare class ModifySettings {
      *
      * @throws Will show an alert if any setting is set to "approval" in demo mode (room name starts with "d").
      */
-    modifySettings: ({ showAlert, roomName, audioSet, videoSet, screenshareSet, chatSet, socket, updateAudioSetting, updateVideoSetting, updateScreenshareSetting, updateChatSetting, updateIsSettingsModalVisible, }: ModifySettingsOptions) => Promise<void>;
+    modifySettings: ({ roomName, audioSet, videoSet, screenshareSet, chatSet, socket, updateAudioSetting, updateVideoSetting, updateScreenshareSetting, updateChatSetting, updateIsSettingsModalVisible, }: ModifySettingsOptions) => Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ModifySettings, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ModifySettings>;
 }

package/dist/lib/methods/stream-methods/click-chat.service.d.ts

@@ -52,7 +52,7 @@ export declare class ClickChat {
      *
      * @returns {Promise<void>} A promise that resolves when the operation is complete.
      */
-    clickChat({ isMessagesModalVisible, updateIsMessagesModalVisible, chatSetting, islevel, showAlert, }: ClickChatOptions): Promise<void>;
+    clickChat(options: ClickChatOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClickChat, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ClickChat>;
 }

package/dist/lib/methods/utils/get-modal-position.util.d.ts

@@ -1,6 +1,3 @@
-/**
- * Defines the style object for positioning the modal.
- */
 import { ModalPositionStyle } from '../../@types/types';
 export interface GetModalPositionOptions {
     position: string;

package/dist/lib/methods/utils/initial-values.util.d.ts

@@ -7,6 +7,7 @@ type Device = types.Device;
 import { AParamsType, CoHostResponsibility, EventType, HParamsType, Participant, Poll, ScreenParamsType, Stream, VidCons, VParamsType, ConsumeSocket, MeetingRoomParams, UserRecordingParams, ScreenState, AudioDecibels, CustomMediaComponent, GridSizes, Message, WaitingRoomParticipant, Request, BreakoutParticipant, WhiteboardUser, Shape, ResponseJoinRoom, ComponentSizes, Transport as TransportType } from '../../@types/types';
 import { Socket } from 'socket.io-client';
 import { SelfieSegmentation } from '@mediapipe/selfie_segmentation';
+import { TranslationRoomConfig } from '../../producers/socket-receive-methods/translation-receive-methods.service';
 export interface InitialValuesStateType {
     roomName: string;
     member: string;
@@ -219,6 +220,20 @@ export interface InitialValuesStateType {
     videoSetting: string;
     screenshareSetting: string;
     chatSetting: string;
+    translationSupported: boolean;
+    translationConfig: TranslationRoomConfig | null;
+    mySpokenLanguage: string;
+    mySpokenLanguageEnabled: boolean;
+    myDefaultOutputLanguage: string | null;
+    myDefaultListenLanguage: string | null;
+    listenPreferences: Map<string, string>;
+    translationProducerMap: Record<string, Record<string, string>>;
+    availableTranslationChannels: Map<string, {
+        languages: string[];
+        originalProducerId: string;
+    }>;
+    canUsePersonalTranslation: boolean;
+    personalTranslationUsername?: string;
     displayOption: string;
     autoWave: boolean;
     forceFullDisplay: boolean;
@@ -235,13 +250,15 @@ export interface InitialValuesStateType {
     totalReqWait: number;
     alertVisible: boolean;
     alertMessage: string;
-    alertType: 'success' | 'danger';
+    alertType: 'success' | 'danger' | 'info' | 'warning';
+    alertPosition: 'top' | 'bottom' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'center';
     alertDuration: number;
     progressTimerVisible: boolean;
     progressTimerValue: number;
     isMenuModalVisible: boolean;
     isRecordingModalVisible: boolean;
     isSettingsModalVisible: boolean;
+    isTranslationSettingsModalVisible: boolean;
     isRequestsModalVisible: boolean;
     isWaitingModalVisible: boolean;
     isCoHostModalVisible: boolean;

package/dist/lib/methods/utils/mini-audio-player/mini-audio-player.component.d.ts

@@ -93,11 +93,19 @@ export declare class MiniAudioPlayer implements OnInit, OnDestroy {
     autoWaveCheck: boolean;
     private previousShowWaveModal;
     private previousIsMuted;
+    private previousMiniAudioProps;
+    private audioStateRetryTimer;
     private injectorCache;
     private cachedMiniAudioProps;
     constructor(injector: Injector, injectedStream: MediaStream | null, consumer: Consumer, injectedRemoteProducerId: string, injectedParameters: MiniAudioPlayerParameters, injectedMiniAudioComponent: any, injectedMiniAudioProps: Record<string, any>);
     ngOnInit(): void;
     ngOnDestroy(): void;
+    private clearAudioStateRetryTimer;
+    private getParticipantForProducer;
+    private isTranslationAudio;
+    private isTranslationSuppressingOriginal;
+    private syncAudioElementState;
+    private scheduleAudioStateSync;
     setupAudioProcessing(): void;
     createInjector(inputs: any): Injector;
     getMiniAudioProps(): any;

package/dist/lib/methods/utils/producer/a-params.service.d.ts

@@ -1,11 +1,6 @@
-import { types } from 'mediasoup-client';
+import type { AParamsType as SharedAParamsType } from 'mediasfu-shared';
 import * as i0 from "@angular/core";
-type ProducerCodecOptions = types.ProducerCodecOptions;
-type RtpEncodingParameters = types.RtpEncodingParameters;
-export type AParamsType = {
-    encodings: RtpEncodingParameters[];
-    codecOptions?: ProducerCodecOptions;
-};
+export type AParamsType = SharedAParamsType;
 /**
  * The `AParams` service provides the encoding parameters for audio production in a media session using the Mediasoup library.
  * It includes a default configuration for RTP encoding parameters, which can be used when creating audio producers.
@@ -48,4 +43,3 @@ export declare class AParams {
     static ɵfac: i0.ɵɵFactoryDeclaration<AParams, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AParams>;
 }
-export {};

package/dist/lib/methods/utils/producer/h-params.service.d.ts

@@ -1,11 +1,6 @@
-import { types } from 'mediasoup-client';
+import type { HParamsType as SharedHParamsType } from 'mediasfu-shared';
 import * as i0 from "@angular/core";
-type ProducerCodecOptions = types.ProducerCodecOptions;
-type RtpEncodingParameters = types.RtpEncodingParameters;
-export type HParamsType = {
-    encodings: RtpEncodingParameters[];
-    codecOptions?: ProducerCodecOptions;
-};
+export type HParamsType = SharedHParamsType;
 /**
  * The `HParams` service provides encoding parameters for video production in a media session using the Mediasoup library.
  * It includes a default configuration for RTP encoding parameters designed for handling high-quality video streams.
@@ -61,4 +56,3 @@ export declare class HParams {
     static ɵfac: i0.ɵɵFactoryDeclaration<HParams, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<HParams>;
 }
-export {};

package/dist/lib/methods/utils/producer/screen-params.service.d.ts

@@ -1,11 +1,6 @@
-import { types } from 'mediasoup-client';
+import type { ScreenParamsType as SharedScreenParamsType } from 'mediasfu-shared';
 import * as i0 from "@angular/core";
-type ProducerCodecOptions = types.ProducerCodecOptions;
-type RtpEncodingParameters = types.RtpEncodingParameters;
-export type ScreenParamsType = {
-    encodings: RtpEncodingParameters[];
-    codecOptions?: ProducerCodecOptions;
-};
+export type ScreenParamsType = SharedScreenParamsType;
 /**
  * The `ScreenParams` service provides encoding parameters specifically for screen sharing in a media session using the Mediasoup library.
  * It includes a default configuration for RTP encoding parameters optimized for high-quality screen sharing.
@@ -48,4 +43,3 @@ export declare class ScreenParams {
     static ɵfac: i0.ɵɵFactoryDeclaration<ScreenParams, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ScreenParams>;
 }
-export {};

package/dist/lib/methods/utils/producer/v-params.service.d.ts

@@ -1,11 +1,6 @@
-import { types } from 'mediasoup-client';
+import type { VParamsType as SharedVParamsType } from 'mediasfu-shared';
 import * as i0 from "@angular/core";
-type ProducerCodecOptions = types.ProducerCodecOptions;
-type RtpEncodingParameters = types.RtpEncodingParameters;
-export type VParamsType = {
-    encodings: RtpEncodingParameters[];
-    codecOptions?: ProducerCodecOptions;
-};
+export type VParamsType = SharedVParamsType;
 /**
  * The `VParams` service provides encoding parameters for video in a media session using the Mediasoup library.
  * It includes a default configuration for RTP encoding parameters optimized for video streaming.
@@ -61,4 +56,3 @@ export declare class VParams {
     static ɵfac: i0.ɵɵFactoryDeclaration<VParams, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<VParams>;
 }
-export {};

package/dist/lib/methods/utils/sound-player.service.d.ts

@@ -3,7 +3,7 @@ import * as i0 from "@angular/core";
 export interface SoundPlayerOptions {
     soundUrl: string;
 }
-export type SoundPlayerType = (options: SoundPlayerOptions) => void;
+export type SoundPlayerType = (options: SoundPlayerOptions) => void | Promise<void>;
 /**
  * SoundPlayer service for playing a sound from a provided URL.
  *

package/dist/lib/methods/utils/translation-languages.util.d.ts

@@ -0,0 +1,341 @@
+/**
+ * Central Language Definitions for Translation Pipeline (Frontend)
+ *
+ * This module provides a single source of truth for all supported languages,
+ * language codes, and voice configurations across the frontend application.
+ *
+ * Language Code Standards:
+ * - ISO 639-1: 2-letter codes (e.g., 'en', 'es') - PRIMARY STANDARD
+ * - ISO 639-2: 3-letter codes (e.g., 'eng', 'spa') - for extended languages
+ * - BCP 47: Language tags with regions (e.g., 'en-US', 'pt-BR')
+ */
+export type VoiceGender = 'male' | 'female' | 'neutral';
+export type TTSSupport = 'excellent' | 'good' | 'moderate' | 'limited' | 'unknown' | 'n/a';
+export type LanguageRegion = 'global' | 'europe' | 'asia' | 'south-asia' | 'mena' | 'africa' | 'caucasus' | 'central-asia' | 'constructed' | 'special' | 'other';
+export interface LanguageMetadata {
+    name: string;
+    nativeName: string;
+    region: LanguageRegion;
+    ttsSupport: TTSSupport;
+}
+export interface LanguageOption {
+    code: string;
+    name: string;
+    nativeName: string;
+    ttsSupport: TTSSupport;
+    region: LanguageRegion;
+}
+export interface VoiceOption {
+    id: string;
+    name: string;
+    gender: VoiceGender;
+    provider: string;
+    language: string;
+    style?: string;
+}
+export interface VoiceSelectionPreference {
+    gender: VoiceGender;
+    voiceId?: string;
+    style?: string;
+}
+/**
+ * Voice configuration for translation
+ * Used in translation:subscribe and per-language voice settings
+ */
+export interface TranslationVoiceConfig {
+    voiceGender?: VoiceGender;
+    voiceId?: string;
+    voiceClone?: {
+        provider: 'elevenlabs' | 'playht' | 'coqui';
+        voiceId: string;
+        stability?: number;
+        similarity?: number;
+    };
+    sttNickName?: string;
+    llmNickName?: string;
+    ttsNickName?: string;
+    sttParams?: Record<string, string | number | boolean>;
+    llmParams?: Record<string, string | number | boolean>;
+    ttsParams?: Record<string, string | number | boolean>;
+}
+/**
+ * Language entry with voice config override
+ */
+export interface TranslationLanguageEntry {
+    code: string;
+    nickname?: string;
+    voiceConfig?: TranslationVoiceConfig;
+}
+/**
+ * Complete list of supported language codes (ISO 639-1 primarily)
+ */
+export declare const SUPPORTED_LANGUAGE_CODES: string[];
+/**
+ * Language metadata with display names and additional info
+ */
+export declare const LANGUAGE_METADATA: Record<string, LanguageMetadata>;
+export declare const VOICE_GENDERS: Record<string, VoiceGender>;
+/**
+ * Default voice gender per language
+ */
+export declare const DEFAULT_VOICE_GENDERS: Record<string, VoiceGender>;
+/**
+ * Azure Neural Voice mappings by language and gender
+ */
+export declare const AZURE_NEURAL_VOICES: Record<string, {
+    male: string[];
+    female: string[];
+}>;
+/**
+ * Google Cloud TTS voice mappings
+ */
+export declare const GOOGLE_VOICES: Record<string, {
+    male: string[];
+    female: string[];
+}>;
+/**
+ * AWS Polly voice mappings
+ */
+export declare const AWS_POLLY_VOICES: Record<string, {
+    male: string[];
+    female: string[];
+    neural?: {
+        male: string[];
+        female: string[];
+    };
+}>;
+/**
+ * Deepgram Aura voice mappings (multilingual)
+ */
+export interface DeepgramVoice {
+    id: string;
+    name: string;
+}
+export declare const DEEPGRAM_VOICES: {
+    premade: {
+        male: DeepgramVoice[];
+        female: DeepgramVoice[];
+    };
+};
+/**
+ * OpenAI TTS voice mappings (multilingual)
+ */
+export interface OpenAIVoice {
+    id: string;
+    name: string;
+}
+export declare const OPENAI_VOICES: {
+    premade: {
+        male: OpenAIVoice[];
+        female: OpenAIVoice[];
+    };
+};
+/**
+ * ElevenLabs pre-made voices (multilingual)
+ */
+export interface ElevenLabsVoice {
+    id: string;
+    name: string;
+}
+export declare const ELEVENLABS_VOICES: {
+    premade: {
+        male: ElevenLabsVoice[];
+        female: ElevenLabsVoice[];
+    };
+};
+/**
+ * Cartesia Sonic voice mappings
+ */
+export interface CartesiaVoice {
+    id: string;
+    name: string;
+}
+export declare const CARTESIA_VOICES: {
+    premade: {
+        male: CartesiaVoice[];
+        female: CartesiaVoice[];
+    };
+};
+/**
+ * Rime AI TTS voice mappings
+ * Documentation: https://rime.ai/docs/voices
+ */
+export interface RimeVoice {
+    id: string;
+    name: string;
+}
+export declare const RIME_VOICES: {
+    premade: {
+        male: RimeVoice[];
+        female: RimeVoice[];
+    };
+};
+/**
+ * Kokoro TTS voice mappings (via Hugging Face)
+ * Open-source multilingual TTS
+ */
+export interface KokoroVoice {
+    id: string;
+    name: string;
+}
+export declare const KOKORO_VOICES: {
+    premade: {
+        male: KokoroVoice[];
+        female: KokoroVoice[];
+    };
+};
+/**
+ * Google Gemini TTS voice mappings
+ */
+export interface GeminiVoice {
+    id: string;
+    name: string;
+}
+export declare const GEMINI_VOICES: {
+    premade: {
+        male: GeminiVoice[];
+        female: GeminiVoice[];
+    };
+};
+/**
+ * Supported TTS providers
+ */
+export type TTSProvider = 'deepgram' | 'openai' | 'azure' | 'google' | 'aws' | 'elevenlabs' | 'playht' | 'cartesia' | 'rime' | 'kokoro' | 'gemini' | 'assemblyai';
+export declare const TTS_PROVIDERS: Record<TTSProvider, {
+    name: string;
+    supportsSSML: boolean;
+    multilingual?: boolean;
+    isDefault?: boolean;
+}>;
+/**
+ * Check if a language code is supported
+ */
+export declare function isLanguageSupported(code: string): boolean;
+/**
+ * Validate a language code format
+ */
+export declare function isValidLanguageCode(code: string): boolean;
+/**
+ * Normalize a language code to ISO 639-1 (2-letter) format
+ */
+export declare function normalizeLanguageCode(code: string): string;
+/**
+ * Get language display name
+ */
+export declare function getLanguageName(code: string, displayLocale?: string): string;
+/**
+ * Get native language name
+ */
+export declare function getLanguageNativeName(code: string): string;
+/**
+ * Quality levels for TTS support (ordered from best to worst)
+ */
+export declare const QUALITY_LEVELS: TTSSupport[];
+/**
+ * Minimum quality level for languages to be shown in UI
+ * Languages with ttsSupport below this level will be filtered out
+ * 'good' = only show 'excellent' and 'good' languages
+ */
+export declare const MIN_QUALITY_LEVEL: TTSSupport;
+/**
+ * Check if a quality level meets the minimum threshold
+ */
+export declare function meetsQualityThreshold(quality: TTSSupport, minQuality?: TTSSupport): boolean;
+/**
+ * Get all supported languages as array of objects
+ * @param displayLocale - Locale for display names
+ * @param filterByQuality - Whether to filter by MIN_QUALITY_LEVEL (default: true)
+ */
+export declare function getSupportedLanguages(displayLocale?: string, filterByQuality?: boolean): LanguageOption[];
+/**
+ * Get all languages without quality filtering (for admin/debug purposes)
+ */
+export declare function getAllLanguages(displayLocale?: string): LanguageOption[];
+/**
+ * Get languages by region (quality-filtered)
+ */
+export declare function getLanguagesByRegion(region: LanguageRegion): LanguageOption[];
+/**
+ * Get languages with good TTS support
+ * Note: getSupportedLanguages() already filters by quality, this is for explicit filtering
+ */
+export declare function getLanguagesWithGoodTTS(): LanguageOption[];
+/**
+ * Get default voice for a language and gender
+ * Supports multiple TTS providers - defaults to Deepgram
+ */
+export declare function getDefaultVoice(langCode: string, gender?: VoiceGender, provider?: TTSProvider | string): string | null;
+/**
+ * Get all available voices for a language
+ * Supports multiple TTS providers - defaults to Deepgram
+ */
+export declare function getAvailableVoices(langCode: string, provider?: TTSProvider | string): {
+    male: (string | ElevenLabsVoice | DeepgramVoice | OpenAIVoice | CartesiaVoice | RimeVoice | KokoroVoice | GeminiVoice)[];
+    female: (string | ElevenLabsVoice | DeepgramVoice | OpenAIVoice | CartesiaVoice | RimeVoice | KokoroVoice | GeminiVoice)[];
+};
+/**
+ * Get the default voice gender for a language
+ */
+export declare function getDefaultVoiceGender(langCode: string): VoiceGender;
+/**
+ * Format voice option for display in dropdown
+ */
+export declare function formatVoiceOption(voiceId: string): VoiceOption;
+/**
+ * Clear voice cache (clears local static cache)
+ */
+export declare function clearVoiceCache(provider?: string | null): void;
+/**
+ * Set cache TTL
+ */
+export declare function setVoiceCacheTTL(ttlMs: number): void;
+/**
+ * Result from socket voice fetch
+ */
+export interface SocketVoiceResponse {
+    provider: string;
+    language: string;
+    voices: {
+        male: VoiceOption[];
+        female: VoiceOption[];
+    };
+    providers?: Record<string, unknown>;
+    error?: string;
+}
+/**
+ * Fetch voices via socket connection (keeps API keys server-side)
+ *
+ * This is the ONLY method for frontend voice fetching as it:
+ * - Keeps TTS API keys on the server (security)
+ * - Uses cached results from server
+ * - Falls back to static lists if fetch fails
+ *
+ * The backend will use the room's/user's configured TTS credentials to fetch voices.
+ *
+ * @example
+ * ```typescript
+ * // In your React component
+ * const voices = await fetchVoicesViaSocket(socket, 'elevenlabs', 'en');
+ * console.log(voices.voices.male, voices.voices.female);
+ * ```
+ *
+ * @param socket - Socket.io socket instance
+ * @param provider - TTS provider name (e.g., 'deepgram', 'elevenlabs', 'openai')
+ * @param language - Language code (optional, default 'en')
+ * @returns Promise with voices
+ */
+export declare function fetchVoicesViaSocket(socket: {
+    emit: (event: string, data: unknown, callback?: (response: SocketVoiceResponse) => void) => void;
+}, provider?: TTSProvider | string, language?: string): Promise<SocketVoiceResponse>;
+/**
+ * Fetch supported languages via socket
+ *
+ * @param socket - Socket.io socket instance
+ * @param displayLocale - Locale for display names (default 'en')
+ * @returns Promise with language options
+ */
+export declare function fetchLanguagesViaSocket(socket: {
+    emit: (event: string, data: unknown, callback?: (response: {
+        languages: LanguageOption[];
+    }) => void) => void;
+}, displayLocale?: string): Promise<LanguageOption[]>;

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

@@ -1,9 +1,6 @@
+import type { LaunchWaitingOptions } from 'mediasfu-shared';
 import * as i0 from "@angular/core";
-export interface LaunchWaitingOptions {
-    updateIsWaitingModalVisible: (visible: boolean) => void;
-    isWaitingModalVisible: boolean;
-}
-export type LaunchWaitingType = (options: LaunchWaitingOptions) => void;
+export type { LaunchWaitingOptions, LaunchWaitingType } from 'mediasfu-shared';
 /**
  * Service to toggle the visibility of a waiting modal.
  *

package/dist/lib/modern/display-components/modern-alert.component.d.ts

@@ -0,0 +1,40 @@
+import { OnChanges, OnDestroy, SimpleChanges, TemplateRef } from '@angular/core';
+import { type AlertPosition, type AlertTone } from '../../components/display-components/alert-component/alert.component.component';
+import * as i0 from "@angular/core";
+export interface ModernAlertComponentOptions {
+    visible: boolean;
+    message: string;
+    type: AlertTone;
+    duration?: number;
+    onHide?: () => void;
+    textColor?: string;
+    position?: AlertPosition;
+    isDarkMode?: boolean;
+    alertStyle?: Partial<CSSStyleDeclaration>;
+    customTemplate?: TemplateRef<any>;
+}
+export declare class ModernAlertComponent implements OnChanges, OnDestroy {
+    visible: boolean;
+    message: string;
+    type: AlertTone;
+    duration: number;
+    textColor: string;
+    position: AlertPosition;
+    isDarkMode?: boolean;
+    onHide?: () => void;
+    alertStyle?: Partial<CSSStyleDeclaration>;
+    customTemplate?: TemplateRef<any>;
+    alertType: AlertTone;
+    private hideTimeout?;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    handlePress(): void;
+    get alertLabel(): string;
+    get alertMeta(): string;
+    get alertIcon(): string;
+    get alertRole(): 'alert' | 'status';
+    get shellStyle(): Record<string, string>;
+    get resolvedIsDarkMode(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModernAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModernAlertComponent, "app-modern-alert-component", never, { "visible": { "alias": "visible"; "required": false; }; "message": { "alias": "message"; "required": false; }; "type": { "alias": "type"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "position": { "alias": "position"; "required": false; }; "isDarkMode": { "alias": "isDarkMode"; "required": false; }; "onHide": { "alias": "onHide"; "required": false; }; "alertStyle": { "alias": "alertStyle"; "required": false; }; "customTemplate": { "alias": "customTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}

package/dist/lib/modern/display-components/modern-loading-modal.component.d.ts

@@ -0,0 +1,37 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface ModernLoadingModalOptions {
+    isVisible: boolean;
+    backgroundColor?: string;
+    displayColor?: string;
+    isDarkMode?: boolean;
+    loadingText?: string;
+    showSpinner?: boolean;
+    overlayStyle?: Partial<CSSStyleDeclaration>;
+    contentStyle?: Partial<CSSStyleDeclaration>;
+    spinnerStyle?: Partial<CSSStyleDeclaration>;
+    textStyle?: Partial<CSSStyleDeclaration>;
+    customTemplate?: TemplateRef<any>;
+}
+type StyleMap = Record<string, string | number | null | undefined>;
+export declare class ModernLoadingModalComponent {
+    isVisible: boolean;
+    backgroundColor?: string;
+    displayColor?: string;
+    isDarkMode?: boolean;
+    loadingText: string;
+    showSpinner: boolean;
+    overlayStyle?: Partial<CSSStyleDeclaration>;
+    contentStyle?: Partial<CSSStyleDeclaration>;
+    spinnerStyle?: Partial<CSSStyleDeclaration>;
+    textStyle?: Partial<CSSStyleDeclaration>;
+    customTemplate?: TemplateRef<any>;
+    get modalContainerStyle(): StyleMap;
+    get modalContentStyle(): StyleMap;
+    get spinnerContainerStyle(): StyleMap;
+    get loadingTextStyle(): StyleMap;
+    get resolvedIsDarkMode(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModernLoadingModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModernLoadingModalComponent, "app-modern-loading-modal", never, { "isVisible": { "alias": "isVisible"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "displayColor": { "alias": "displayColor"; "required": false; }; "isDarkMode": { "alias": "isDarkMode"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "showSpinner": { "alias": "showSpinner"; "required": false; }; "overlayStyle": { "alias": "overlayStyle"; "required": false; }; "contentStyle": { "alias": "contentStyle"; "required": false; }; "spinnerStyle": { "alias": "spinnerStyle"; "required": false; }; "textStyle": { "alias": "textStyle"; "required": false; }; "customTemplate": { "alias": "customTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/dist/lib/modern/display-components/modern-meeting-progress-timer.component.d.ts

@@ -0,0 +1,40 @@
+import * as i0 from "@angular/core";
+export interface ModernMeetingProgressTimerOptions {
+    meetingProgressTime: string;
+    initialBackgroundColor?: string;
+    position?: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+    textStyle?: {
+        [key: string]: string | number;
+    };
+    showTimer?: boolean;
+}
+export type ModernMeetingProgressTimerType = (options: ModernMeetingProgressTimerOptions) => HTMLElement;
+export declare class ModernMeetingProgressTimerComponent {
+    meetingProgressTime: string;
+    initialBackgroundColor: string;
+    position: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+    textStyle: {
+        [key: string]: string | number;
+    };
+    showTimer: boolean;
+    readonly faClock: import("@fortawesome/fontawesome-common-types").IconDefinition;
+    get positionStyle(): {
+        [key: string]: string;
+    };
+    get badgeStyle(): {
+        [key: string]: string;
+    };
+    get iconToneClass(): string;
+    get badgeTitle(): string;
+    get ariaLabel(): string;
+    isRecordingState(): boolean;
+    private get resolvedTone();
+    private getAccentColor;
+    private getResolvedBackground;
+    private isCustomBackground;
+    private parseTimeInSeconds;
+    private normalizeColor;
+    private withAlpha;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModernMeetingProgressTimerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModernMeetingProgressTimerComponent, "app-modern-meeting-progress-timer", never, { "meetingProgressTime": { "alias": "meetingProgressTime"; "required": false; }; "initialBackgroundColor": { "alias": "initialBackgroundColor"; "required": false; }; "position": { "alias": "position"; "required": false; }; "textStyle": { "alias": "textStyle"; "required": false; }; "showTimer": { "alias": "showTimer"; "required": false; }; }, {}, never, never, true, never>;
+}