import * as i0 from '@angular/core';
import { OnDestroy, OnInit, EventEmitter, TemplateRef, ViewContainerRef, Signal, AfterViewInit, ElementRef, ChangeDetectorRef, PipeTransform, WritableSignal, ModuleWithProviders } from '@angular/core';
import * as i7 from '@angular/material/dialog';
import { MatDialog, MatDialogRef } from '@angular/material/dialog';
import * as i16 from '@angular/material/snack-bar';
import { MatSnackBarConfig, MatSnackBar } from '@angular/material/snack-bar';
import { LocalParticipant, RemoteParticipant, Room, TrackPublication, ScreenShareCaptureOptions, LocalTrack, TrackPublishOptions, LocalTrackPublication, VideoCaptureOptions, AudioCaptureOptions, DataPublishOptions, Track, Participant } from 'livekit-client';
export * from 'livekit-client';
import { Observable, BehaviorSubject, Subscription } from 'rxjs';
import * as i38 from '@angular/forms';
import { FormGroup, FormBuilder } from '@angular/forms';
import * as i42 from '@angular/cdk/drag-drop';
import { CdkDrag } from '@angular/cdk/drag-drop';
import { SwitchBackgroundProcessorOptions } from '@livekit/track-processors';
import { Observable as Observable$1 } from 'rxjs/internal/Observable';
import * as i17 from '@angular/material/menu';
import { MatMenuTrigger, MatMenuPanel } from '@angular/material/menu';
import { OverlayContainer } from '@angular/cdk/overlay';
import * as i15 from '@angular/material/sidenav';
import { MatSidenav, MatDrawerContainer } from '@angular/material/sidenav';
import * as i11 from '@angular/material/select';
import { MatSelect } from '@angular/material/select';
import * as i37 from '@angular/common';
import * as i1 from '@angular/material/button';
import * as i2 from '@angular/material/card';
import * as i3 from '@angular/material/toolbar';
import * as i4 from '@angular/material/icon';
import * as i5 from '@angular/material/input';
import * as i6 from '@angular/material/form-field';
import * as i8 from '@angular/material/tooltip';
import * as i9 from '@angular/material/badge';
import * as i10 from '@angular/material/grid-list';
import * as i12 from '@angular/material/core';
import * as i13 from '@angular/material/progress-spinner';
import * as i14 from '@angular/material/slider';
import * as i18 from '@angular/material/divider';
import * as i19 from '@angular/material/list';
import * as i20 from '@angular/material/expansion';
import * as i21 from '@angular/material/slide-toggle';

/**
 * Enum representing the possible status of a recording
 */
declare enum RecordingStatus {
    STARTING = "STARTING",
    STARTED = "STARTED",
    STOPPING = "STOPPING",
    STOPPED = "STOPPED",
    FAILED = "FAILED",
    READY = "READY"
}
declare enum RecordingOutputMode {
    COMPOSED = "COMPOSED",
    INDIVIDUAL = "INDIVIDUAL"
}
/**
 * Interface representing information related to the recording status
 */
interface RecordingStatusInfo {
    status: RecordingStatus;
    recordingList: RecordingInfo[];
    startedAt?: Date;
    error?: string;
}
/**
 * Interface representing a recording
 */
interface RecordingInfo {
    id: string;
    roomName: string;
    roomId: string;
    outputMode: RecordingOutputMode;
    status: RecordingStatus;
    filename?: string;
    startedAt?: number;
    endedAt?: number;
    duration?: number;
    size?: number;
    location?: string;
    markedForDeletion?: boolean;
}
/**
 * Interface representing a recording event
 */
interface RecordingEvent {
    roomName: string;
    recordingId?: string;
}
interface RecordingStartRequestedEvent extends RecordingEvent {
}
interface RecordingStopRequestedEvent extends RecordingEvent {
}
interface RecordingDeleteRequestedEvent extends RecordingEvent {
}
interface RecordingDownloadClickedEvent extends RecordingEvent {
}
interface RecordingPlayClickedEvent extends RecordingEvent {
}

/**
 * @internal
 */
interface INotificationOptions {
    message: string;
    buttonActionText?: string;
    config?: MatSnackBarConfig;
}

/**
 * @internal
 */
interface ILogger {
    d(...args: any[]): void;
    v(...args: any[]): void;
    w(...args: any[]): void;
    e(...args: any[]): void;
}
/**
 * @internal
 */
interface ILogService {
    get(name: string): ILogger;
}

interface ParticipantLeftEvent {
    roomName: string;
    participantName: string;
    identity: string;
    reason: ParticipantLeftReason;
}
declare enum ParticipantLeftReason {
    LEAVE = "LEAVE",// The participant left the room voluntarily
    BROWSER_UNLOAD = "browser_unload",// The participant was disconnected due to a browser unload event
    NETWORK_DISCONNECT = "network_disconnect",// The participant was disconnected due to a network error
    SIGNAL_CLOSE = "websocket_closed",// The participant was disconnected due to a websocket error
    SERVER_SHUTDOWN = "server_shutdown",// The server was shut down
    PARTICIPANT_REMOVED = "participant_removed",// The participant was removed from the room
    ROOM_DELETED = "room_deleted",// The room was deleted
    DUPLICATE_IDENTITY = "duplicate_identity",// The participant was disconnected due to a duplicate identity
    OTHER = "other"
}
/**
 * Interface that defines the properties of the participant track publication.
 */
interface ParticipantTrackPublication extends TrackPublication {
    /**
     * The participant who published the track.
     */
    participant: ParticipantModel;
    /**
     * Indicates whether the HTML element associated with the track is pinned (fixed in place) or not.
     */
    isPinned: boolean;
    /**
     * Indicates whether the HTML element associated with the track is minimized (made smaller) or not.
     */
    isMinimized: boolean;
    /**
     * Indicates whether the track is from a camera source or not.
     */
    isCameraTrack: boolean;
    /**
     * Indicates whether the track is from a screen sharing source or not.
     */
    isScreenTrack: boolean;
    /**
     * Indicates whether the track is from an audio sharing source or not.
     */
    isAudioTrack: boolean;
    /**
     * Indicates whether the participant's audio is forcibly muted or not.
     */
    isMutedForcibly?: boolean;
}
/**
 * Interface defining properties of a participant.
 */
interface ParticipantProperties {
    /**
     * The participant instance, which can be either a local participant or a remote participant.
     */
    participant: LocalParticipant | RemoteParticipant;
    /**
     * The room in which the participant is located, applicable only for local participants.
     */
    room?: Room;
    /**
     * The color profile associated with the participant.
     * It specifies the visual representation of the participant in the user interface.
     */
    colorProfile?: string;
    /**
     * This property allows to know what screen track is the last one published for enlarging it
     * Map <trackSid, publicationDate>
     * @internal
     **/
    screenTrackPublicationDate?: Map<string, number>;
}
/**
 * Class that represents a participant in the room.
 */
declare class ParticipantModel {
    /**
     * This property allows to know what screen track is the last one published for enlarging it
     * Map <trackSid, publicationDate>
     * @internal
     **/
    screenTrackPublicationDate: Map<string, number>;
    /**
     * The color profile associated with the participant.
     * It specifies the visual representation of the participant in the user interface.
     */
    colorProfile: string;
    private participant;
    private room;
    private speaking;
    private customVideoTrack;
    private _hasEncryptionError;
    private _decryptedName;
    constructor(props: ParticipantProperties);
    /**
     * @internal
     */
    get identity(): string;
    /**
     * Returns the server assigned unique identifier for the participant.
     * @returns string
     */
    get sid(): string;
    /**
     * Returns the participant name.
     * @returns string
     */
    get name(): string | undefined;
    /**
     * Returns the room name where the participant is.
     * @return string | undefined
     * @internal
     */
    get roomName(): string | undefined;
    /**
     * Returns if the participant has enabled its camera.
     */
    get isCameraEnabled(): boolean;
    /**
     * Returns if the participant has enabled its microphone.
     */
    get isMicrophoneEnabled(): boolean;
    /**
     * Returns if the participant has enabled its screen share.
     */
    get isScreenShareEnabled(): boolean;
    /**
     * Returns if the participant is speaking.
     */
    get isSpeaking(): boolean;
    /**
     * Returns all the participant tracks.
     * @return ParticipantTrackPublication[]
     */
    get tracks(): ParticipantTrackPublication[];
    /**
     * Returns all the participant video tracks.
     * @return ParticipantTrackPublication[]
     */
    get videoTracks(): ParticipantTrackPublication[];
    /**
     * Returns all the participant audio tracks.
     * @return ParticipantTrackPublication[]
     */
    get audioTracks(): ParticipantTrackPublication[];
    /**
     * Returns all the participant camera tracks.
     * @return ParticipantTrackPublication[]
     */
    get cameraTracks(): ParticipantTrackPublication[];
    /**
     * Returns if the participant is local.
     */
    get isLocal(): boolean;
    /**
     * Returns if the participant has only audio tracks.
     */
    get onlyHasAudioTracks(): boolean;
    /**
     * Returns if the participant has only screen tracks.
     */
    get onlyHasScreenTracks(): boolean;
    /**
     * Returns if the participant has any track forcibly muted.
     * @internal
     */
    get isMutedForcibly(): boolean;
    /**
     * Returns if the participant has any track minimized
     * @internal
     */
    get isMinimized(): boolean;
    /**
     * @returns ParticipantProperties
     * @internal
     */
    getProperties(): ParticipantProperties;
    /**
     *
     * Creates a screen capture tracks with getDisplayMedia(). A LocalVideoTrack is always created and returned.
     * @param options
     * @returns Promise<LocalTrack[]>
     * @internal
     */
    createScreenTracks(options: ScreenShareCaptureOptions): Promise<LocalTrack[]>;
    /**
     *
     * Publishes a track to the room
     * @param track
     * @returns
     */
    publishTrack(track: LocalTrack, options?: TrackPublishOptions): Promise<LocalTrackPublication>;
    /**
     * Enable or disable a participant's camera track.
     * @param enabled
     * @returns Promise<LocalTrackPublication | undefined>
     * @internal
     */
    setCameraEnabled(enabled: boolean, options?: VideoCaptureOptions, publishOptions?: TrackPublishOptions): Promise<LocalTrackPublication | undefined>;
    /**
     * Enable or disable a participant's microphone track.
     * @param enabled
     * @returns Promise<LocalTrackPublication | undefined>
     * @internal
     */
    setMicrophoneEnabled(enabled: boolean, options?: AudioCaptureOptions, publishOptions?: TrackPublishOptions): Promise<LocalTrackPublication | undefined>;
    /**
     * Start or stop sharing a participant's screen
     * @param enabled
     * @returns Promise<LocalTrackPublication | undefined>
     * @internal
     */
    setScreenShareEnabled(enabled: boolean, options: ScreenShareCaptureOptions, publishOptions?: TrackPublishOptions): Promise<LocalTrackPublication | undefined>;
    /**
     * Sets the participant's speaking status.
     * @param speaking
     * @internal
     */
    setSpeaking(speaking: boolean): void;
    /**
     * Switches the active camera track used in this room to the given device id.
     * @param deviceId
     * @returns Promise<void>
     * @internal
     */
    switchCamera(deviceId: string): Promise<void>;
    /**
     * Switches the active microphone track used in this room to the given device id.
     * @param deviceId
     * @returns Promise<void>
     * @internal
     */
    switchMicrophone(deviceId: string): Promise<void>;
    /**
     * Switches the active screen share track showing a native browser dialog to select a screen or window.
     * @param newTrack [LocalTrack](https://docs.livekit.io/client-sdk-js/classes/LocalTrack.html)
     * @returns Promise<void>
     * @internal
     */
    switchScreenshare(newTrack: LocalTrack): Promise<void>;
    /**
     * Publish a new data payload to the room. Data will be forwarded to each participant in the room if the destination field in publishOptions is empty.
     * @param data
     * @param {DataPublishOptions} publishOptions [DataPublishOptions](https://docs.livekit.io/client-sdk-js/types/DataPublishOptions.html)
     * @returns Promise that is resolved if the data was successfully sent, or rejected with an Error object if not.
     * @internal
     */
    publishData(data: Uint8Array, publishOptions: DataPublishOptions): Promise<void>;
    /**
     * @returns The participant active connection types
     * @internal
     */
    getTracksPublishedTypes(): Track.Source[];
    /**
     * Sets the participant's name.
     * @param name
     * @internal
     * As updating name requires that the participant has the `canUpdateOwnMetadata` to true in server side, which is a little bit insecure,
     * we decided to not allow this feature for now.
     */
    /**
     * Sets all video track elements to pinned or unpinned given a boolean value
     * @param pinned
     * @internal
     */
    setAllVideoPinned(pinned: boolean): void;
    /**
     * Toggle the pinned status of a video track element
     * @param trackSid
     * @internal
     */
    toggleVideoPinned(trackSid: string): void;
    /**
     * Gets whether this participant is pinned.
     * This indicates that the participant's video is fixed in place in the UI.
     * @returns boolean
     */
    get isPinned(): boolean;
    /**
     * Sets all video track elements from a specific source to pinned or unpinned given a boolean value
     * @param source The source of the track to be pinned or unpinned (e.g., 'camera', 'screenShare').
     * @param pinned
     * @internal
     */
    setVideoPinnedBySource(source: Track.Source, pinned: boolean): void;
    /**
     * Toggle the minimized status of a video track element
     * @param trackSid
     * @returns
     * @internal
     */
    toggleVideoMinimized(trackSid: string): void;
    /**
     * Sets the publication date of a screen track
     * @param trackSid
     * @param publicationDate
     * @internal
     */
    setScreenTrackPublicationDate(trackSid: string, publicationDate: number): void;
    /**
     * @internal
     */
    /**
     * @internal
     */
    setMutedForcibly(muted: boolean): void;
    /**
     * Gets whether this participant has an encryption error.
     * This indicates that the participant cannot decrypt the video stream due to an incorrect encryption key.
     * @returns boolean
     */
    get hasEncryptionError(): boolean;
    /**
     * Sets the encryption error state for this participant.
     * @param hasError - Whether the participant has an encryption error
     * @internal
     */
    setEncryptionError(hasError: boolean): void;
    /**
     * Sets the decrypted name for this participant.
     * @param decryptedName - The decrypted participant name
     * @internal
     */
    setDecryptedName(decryptedName: string | undefined): void;
}

interface OpenViduComponentsConfig {
    production?: boolean;
    participantFactory?: ParticipantFactoryFunction;
}
type ParticipantFactoryFunction = (props: ParticipantProperties) => any;

/**
 * @internal
 */
declare class GlobalConfigService {
    private document;
    private configuration;
    constructor(config: OpenViduComponentsConfig, document: Document);
    /**
     * Retrieves the base href of the application.
     *
     * @returns The base href of the application as a string.
     */
    getBaseHref(): string;
    hasParticipantFactory(): boolean;
    getParticipantFactory(): ParticipantFactoryFunction;
    getConfig(): OpenViduComponentsConfig;
    isProduction(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalConfigService>;
}

/**
 * @internal
 */
declare class LoggerService implements ILogService {
    private globalService;
    private log;
    private LOG_FNS;
    private MSG_PREFIXES;
    private loggerCache;
    constructor(globalService: GlobalConfigService);
    private initializeLogger;
    private createLoggerFunctions;
    get(prefix: string): ILogger;
    /**
     * Clears the logger cache. Useful for testing or when configuration changes.
     * @internal
     */
    clearCache(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoggerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoggerService>;
}

/**
 * @internal
 */
interface CustomDevice {
    label: string;
    device: string;
    type?: CameraType;
}
/**
 * @internal
 */
declare enum CameraType {
    FRONT = "FRONT",
    BACK = "BACK"
}
/**
 * @internal
 */
declare enum DeviceType {
    AUDIO_INPUT = "audioinput",
    VIDEO_INPUT = "videoinput"
}

/**
 * Represents the possible theme modes for OpenVidu components
 * @internal
 */
declare enum OpenViduThemeMode {
    Light = "light",
    Dark = "dark",
    Classic = "classic"
}
/**
 * Interface representing the complete set of theme variables for OpenVidu components
 * @internal
 */
interface OpenViduThemeVariables {
    '--ov-background-color'?: string;
    '--ov-surface-color'?: string;
    '--ov-surface-container-color'?: string;
    '--ov-primary-action-color'?: string;
    '--ov-secondary-action-color'?: string;
    '--ov-accent-action-color'?: string;
    '--ov-error-color'?: string;
    '--ov-warn-color'?: string;
    '--ov-success-color'?: string;
    '--ov-text-primary-color'?: string;
    '--ov-text-surface-color'?: string;
    '--ov-text-secondary-color'?: string;
    '--ov-text-disabled-color'?: string;
    '--ov-hover-color'?: string;
    '--ov-disabled-background'?: string;
    '--ov-disabled-border-color'?: string;
    '--ov-border-color'?: string;
    '--ov-toolbar-buttons-radius'?: string;
    '--ov-leave-button-radius'?: string;
    '--ov-video-radius'?: string;
    '--ov-surface-radius'?: string;
    '--ov-input-radius'?: string;
    '--ov-recording-color'?: string;
    '--ov-broadcasting-color'?: string;
    '--ov-selection-color'?: string;
    '--ov-selection-color-btn'?: string;
    '--ov-activity-status-color'?: string;
    '--ov-video-background'?: string;
    '--ov-captions-height'?: string;
    [key: string]: string | undefined;
}
/**
 * Predefined theme configurations
 * @internal
 */
declare const OPENVIDU_COMPONENTS_LIGHT_THEME: OpenViduThemeVariables;
/**
 * Predefined dark theme configuration
 * @internal
 */
declare const OPENVIDU_COMPONENTS_DARK_THEME: OpenViduThemeVariables;

/**
 * @internal
 */
declare class StorageService implements OnDestroy {
    protected loggerSrv: LoggerService;
    log: ILogger;
    protected PREFIX_KEY: string;
    private readonly tabId;
    private readonly TAB_CLEANUP_INTERVAL;
    private readonly TAB_TIMEOUT_THRESHOLD;
    private cleanupInterval;
    private broadcastChannel;
    private isStorageAvailable;
    private lastHeartbeat;
    private cache;
    private cacheTimeout;
    private readonly CACHE_TTL;
    constructor(loggerSrv: LoggerService);
    /**
     * Check if localStorage and sessionStorage are available
     */
    private checkStorageAvailability;
    /**
     * Safe access to localStorage
     */
    private get localStorage();
    /**
     * Safe access to sessionStorage
     */
    private get sessionStorage();
    /**
     * Initializes tab management system with improved efficiency
     */
    private initializeTabManagement;
    /**
     * Initialize BroadcastChannel for efficient inter-tab communication
     */
    private initializeBroadcastChannel;
    /**
     * Generates a more unique tab identifier with better collision resistance
     */
    private generateUniqueTabId;
    /**
     * Updates heartbeat for current tab
     */
    private updateHeartbeat;
    /**
     * Registers current tab as active with optimized approach
     */
    private registerActiveTab;
    /**
     * Unregisters current tab from active tabs
     */
    private unregisterActiveTab;
    /**
     * Sets up optimized cleanup with reduced frequency
     */
    private setupTabCleanup;
    /**
     * Optimized cleanup of inactive tabs with better performance
     */
    private cleanupInactiveTabs;
    /**
     * Optimized cleanup of tab-specific data
     */
    private cleanupTabData;
    /**
     * Gets active tabs with caching
     */
    private getActiveTabsFromStorage;
    /**
     * Gets the current tab ID
     */
    getTabId(): string;
    getParticipantName(): string | null;
    setParticipantName(name: string): void;
    getVideoDevice(): CustomDevice | null;
    setVideoDevice(device: CustomDevice): void;
    getAudioDevice(): CustomDevice | null;
    setAudioDevice(device: CustomDevice): void;
    /**
     * @internal
     * Returns true only if the participant has the camera deliberately enabled
     */
    isCameraEnabled(): boolean;
    setCameraEnabled(enabled: boolean): void;
    /**
     * @internal
     * Returns true only if the participant has the microphone deliberately enabled
     */
    isMicrophoneEnabled(): boolean;
    setMicrophoneEnabled(enabled: boolean): void;
    setLang(lang: string): void;
    getLang(): string;
    setCaptionLang(lang: string): void;
    getCaptionsLang(): string;
    setBackground(id: string): void;
    getBackground(): string;
    removeBackground(): void;
    setTheme(theme: OpenViduThemeMode): void;
    getTheme(): OpenViduThemeMode | null;
    removeTheme(): void;
    protected set(key: string, item: any): void;
    protected get(key: string): any;
    protected remove(key: string): void;
    /**
     * Determines if a key should use tab-specific storage in localStorage
     */
    private shouldUseTabSpecificKey;
    /**
     * Sets value in localStorage with optimized serialization and caching
     */
    private setLocalValue;
    /**
     * Gets value from localStorage with caching optimization
     */
    private getLocalValue;
    /**
     * Removes value from localStorage with cache cleanup
     */
    private removeLocalValue;
    /**
     * Sets value in sessionStorage with error handling
     */
    private setSessionValue;
    /**
     * Gets value from sessionStorage with error handling
     */
    private getSessionValue;
    /**
     * Removes value from sessionStorage
     */
    private removeSessionValue;
    /**
     * Optimized clear method that safely iterates and removes items
     */
    clear(): void;
    /**
     * Safely clears storage by collecting keys first, then removing
     */
    private clearStorageByPrefix;
    /**
     * Clears only session data (tab-specific data)
     */
    clearSessionData(): void;
    /**
     * Clears only tab-specific data for current tab
     */
    clearTabSpecificData(): void;
    /**
     * Clears only persistent data
     */
    clearPersistentData(): void;
    /**
     * Cleanup method to be called when service is destroyed
     */
    destroy(): void;
    /**
     * Angular lifecycle hook - called when service is destroyed
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
}

type OpenViduLangs = 'en' | 'es' | 'de' | 'fr' | 'cn' | 'hi' | 'it' | 'ja' | 'nl' | 'pt';
type AvailableLangs = OpenViduLangs | string;
type AdditionalTranslationsType = Record<AvailableLangs, Record<string, any>>;
interface LangOption {
    name: string;
    lang: AvailableLangs;
}

/**
 * Service responsible for managing translations for the application.
 * This service provides methods to add additional translations and to translate keys into the currently selected language.
 *
 * The pipe {@link TranslatePipe} is used to translate keys in the templates.
 */
declare class TranslateService {
    private storageService;
    private translationsByLanguage;
    private additionalTranslations;
    private languageOptions;
    private activeTranslations;
    private selectedLanguageOption;
    private _selectedLanguageSubject;
    selectedLanguageOption$: Observable<LangOption>;
    constructor(storageService: StorageService);
    /**
     * Adds multiple translations to the additional translations storage.
     * @param translations - A record where each key is a language code and the value is an object of translations for that language.
     */
    addTranslations(translations: Partial<AdditionalTranslationsType>): void;
    /**
     * Sets the current language based on the provided language code.
     * Updates the selected language and emits the change.
     * @param lang - The language code to set.
     *
     * @internal
     */
    setCurrentLanguage(lang: AvailableLangs): Promise<void>;
    /**
     * Updates the available language options.
     * @param options - The new language options to set.
     *
     * @internal
     */
    updateLanguageOptions(options?: LangOption[]): void;
    /**
     * Retrieves the currently selected language option.
     * @returns The currently selected language option.
     *
     * @internal
     */
    getSelectedLanguage(): LangOption;
    /**
     * Retrieves the list of all available language options.
     * @returns An array of available language options.
     */
    getAvailableLanguages(): LangOption[];
    /**
     * Translates a given key into the current language.
     *
     * This method first attempts to find the translation in the official translations.
     * If the translation is not found, it then looks for the translation in the additional translations registered by the app.
     *
     * @param key - The key to be translated.
     * @returns The translated string if found, otherwise an empty string.
     */
    translate(key: string): string;
    /**
     * Finds and returns a translation string from a nested translations source object based on a dot-separated key.
     *
     * @param translationsSource - The source object containing nested translation strings.
     * @param key - A dot-separated string representing the path to the desired translation.
     * @returns The translation string if found, otherwise `undefined`.
     */
    private findTranslation;
    /**
     * Updates the currently selected language based on the stored language setting.
     */
    private refreshSelectedLanguage;
    /**
     * Fetches the language data from the source based on the provided language code.
     * @param lang - The language code to fetch data for.
     * @returns The language data associated with the provided language code.
     */
    private fetchLanguageData;
    static ɵfac: i0.ɵɵFactoryDeclaration<TranslateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TranslateService>;
}

/**
 * @internal
 */
declare class ActionService {
    private snackBar;
    dialog: MatDialog;
    private translateService;
    private dialogRef;
    private connectionDialogRef;
    private isConnectionDialogOpen;
    constructor(snackBar: MatSnackBar, dialog: MatDialog, translateService: TranslateService);
    launchNotification(options: INotificationOptions, callback?: () => void): void;
    openDialog(titleMessage: string, descriptionMessage: string, allowClose?: boolean): void;
    openConnectionDialog(titleMessage: string, descriptionMessage: string, allowClose?: boolean): void;
    openDeleteRecordingDialog(successCallback: () => void): void;
    openRecordingPlayerDialog(src: string, allowClose?: boolean): void;
    closeDialog(): void;
    closeConnectionDialog(): void;
    private handleRecordingPlayerError;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActionService>;
}

/**
 * Enum representing the position of additional buttons in a toolbar.
 */
declare enum ToolbarAdditionalButtonsPosition {
    BEFORE_MENU = "beforeMenu",
    AFTER_MENU = "afterMenu"
}

/**
 * Recording activity controls configuration
 */
interface RecordingControls {
    play: boolean;
    download: boolean;
    delete: boolean;
    externalView: boolean;
}
/**
 * Toolbar configuration grouped by domain
 */
interface ToolbarConfig {
    camera: boolean;
    microphone: boolean;
    screenshare: boolean;
    fullscreen: boolean;
    captions: boolean;
    settings: boolean;
    leave: boolean;
    participantsPanel: boolean;
    chatPanel: boolean;
    activitiesPanel: boolean;
    displayRoomName: boolean;
    roomName: string;
    displayLogo: boolean;
    backgroundEffects: boolean;
    recording: boolean;
    viewRecordings: boolean;
    broadcasting: boolean;
    brandingLogo: string;
    additionalButtonsPosition: ToolbarAdditionalButtonsPosition;
}
/**
 * Stream/Video configuration
 */
interface StreamConfig {
    videoEnabled: boolean;
    audioEnabled: boolean;
    displayParticipantName: boolean;
    displayAudioDetection: boolean;
    videoControls: boolean;
    participantItemMuteButton: boolean;
}
/**
 * Recording activity configuration
 */
interface RecordingActivityConfig {
    enabled: boolean;
    readOnly: boolean;
    showControls: RecordingControls;
    startStopButton: boolean;
    viewRecordingsButton: boolean;
    showRecordingsList: boolean;
}
/**
 * Admin dashboard configuration
 */
interface AdminConfig {
    recordingsList: RecordingInfo[];
    loginError: any;
    loginTitle: string;
    dashboardTitle: string;
}
/**
 * General application configuration
 */
interface GeneralConfig {
    token: string;
    livekitUrl: string;
    tokenError: any;
    minimal: boolean;
    participantName: string;
    prejoin: boolean;
    prejoinDisplayParticipantName: boolean;
    showDisconnectionDialog: boolean;
    showThemeSelector: boolean;
    recordingStreamBaseUrl: string;
    e2eeKey?: string;
}
/**
 * @internal
 */
declare class OpenViduComponentsConfigService {
    /**
     * Helper method to create a configuration item with BehaviorSubject and Observable
     */
    private createConfigItem;
    /**
     * Helper method for array configurations with optimized comparison
     */
    private createArrayConfigItem;
    /**
     * Helper method for RecordingControls with specific comparison
     */
    private createRecordingControlsConfigItem;
    /**
     * Helper method for ToolbarConfig with specific comparison
     */
    private createToolbarConfigItem;
    /**
     * Helper method for StreamConfig with specific comparison
     */
    private createStreamConfigItem;
    /**
     * Helper method for RecordingActivityConfig with specific comparison
     */
    private createRecordingActivityConfigItem;
    /**
     * Helper method for AdminConfig with specific comparison
     */
    private createAdminConfigItem;
    /**
     * Helper method for GeneralConfig with specific comparison
     */
    private createGeneralConfigItem;
    /**
     * Optimized deep equality check
     */
    private deepEqual;
    /**
     * Compare ToolbarConfig efficiently
     */
    private compareToolbarConfig;
    /**
     * Compare StreamConfig efficiently
     */
    private compareStreamConfig;
    /**
     * Compare RecordingActivityConfig efficiently
     */
    private compareRecordingActivityConfig;
    /**
     * Compare AdminConfig efficiently
     */
    private compareAdminConfig;
    private generalConfig;
    private toolbarConfig;
    private streamConfig;
    private recordingActivityConfig;
    private adminConfig;
    private broadcastingActivityConfig;
    private layoutRemoteParticipantsConfig;
    token$: Observable<string>;
    livekitUrl$: Observable<string>;
    tokenError$: Observable<any>;
    minimal$: Observable<boolean>;
    participantName$: Observable<string>;
    prejoin$: Observable<boolean>;
    prejoinDisplayParticipantName$: Observable<boolean>;
    showDisconnectionDialog$: Observable<boolean>;
    showThemeSelector$: Observable<boolean>;
    recordingStreamBaseUrl$: Observable<string>;
    e2eeKey$: Observable<string | undefined>;
    videoEnabled$: Observable<boolean>;
    audioEnabled$: Observable<boolean>;
    displayParticipantName$: Observable<boolean>;
    displayAudioDetection$: Observable<boolean>;
    streamVideoControls$: Observable<boolean>;
    participantItemMuteButton$: Observable<boolean>;
    cameraButton$: Observable<boolean>;
    microphoneButton$: Observable<boolean>;
    screenshareButton$: Observable<boolean>;
    fullscreenButton$: Observable<boolean>;
    captionsButton$: Observable<boolean>;
    toolbarSettingsButton$: Observable<boolean>;
    leaveButton$: Observable<boolean>;
    participantsPanelButton$: Observable<boolean>;
    chatPanelButton$: Observable<boolean>;
    activitiesPanelButton$: Observable<boolean>;
    displayRoomName$: Observable<boolean>;
    roomName$: Observable<string>;
    brandingLogo$: Observable<string>;
    displayLogo$: Observable<boolean>;
    toolbarAdditionalButtonsPosition$: Observable<ToolbarAdditionalButtonsPosition>;
    backgroundEffectsButton$: Observable<boolean>;
    recordingButton$: Observable<boolean>;
    toolbarViewRecordingsButton$: Observable<boolean>;
    broadcastingButton$: Observable<boolean>;
    recordingActivity$: Observable<boolean>;
    recordingActivityReadOnly$: Observable<boolean>;
    recordingActivityShowControls$: Observable<RecordingControls>;
    recordingActivityStartStopRecordingButton$: Observable<boolean>;
    recordingActivityViewRecordingsButton$: Observable<boolean>;
    recordingActivityShowRecordingsList$: Observable<boolean>;
    adminRecordingsList$: Observable<RecordingInfo[]>;
    adminLoginError$: Observable<any>;
    adminLoginTitle$: Observable<string>;
    adminDashboardTitle$: Observable<string>;
    broadcastingActivity$: Observable<boolean>;
    layoutRemoteParticipants$: Observable<ParticipantModel[] | undefined>;
    constructor();
    /**
     * Update multiple general configuration properties at once
     */
    updateGeneralConfig(partialConfig: Partial<GeneralConfig>): void;
    /**
     * Update multiple toolbar configuration properties at once
     */
    updateToolbarConfig(partialConfig: Partial<ToolbarConfig>): void;
    /**
     * Update multiple stream configuration properties at once
     */
    updateStreamConfig(partialConfig: Partial<StreamConfig>): void;
    /**
     * Update multiple recording activity configuration properties at once
     */
    updateRecordingActivityConfig(partialConfig: Partial<RecordingActivityConfig>): void;
    /**
     * Update multiple admin configuration properties at once
     */
    updateAdminConfig(partialConfig: Partial<AdminConfig>): void;
    /**
     * Update recording controls specifically with batch support
     */
    updateRecordingControls(partialControls: Partial<RecordingControls>): void;
    /**
     * @internal
     * Get current participant name directly
     */
    getCurrentParticipantName(): string;
    getLivekitUrl(): string;
    showPrejoin(): boolean;
    getShowDisconnectionDialog(): boolean;
    getRecordingStreamBaseUrl(): string;
    getE2EEKey(): string | undefined;
    isVideoEnabled(): boolean;
    isAudioEnabled(): boolean;
    getRoomName(): string;
    setBroadcastingButton(broadcastingButton: boolean): void;
    showBackgroundEffectsButton(): boolean;
    setBroadcastingActivity(broadcastingActivity: boolean): void;
    setLayoutRemoteParticipants(participants: ParticipantModel[] | undefined): void;
    showRecordingActivityRecordingsList(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenViduComponentsConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OpenViduComponentsConfigService>;
}

declare class RecordingService {
    private actionService;
    private libService;
    private loggerService;
    /**
     * Recording status Observable which pushes the recording state in every update.
     */
    recordingStatusObs: Observable<RecordingStatusInfo>;
    private recordingTimeInterval;
    private recordingStartTimestamp;
    private recordingStatus;
    private log;
    /**
     * @internal
     */
    constructor(actionService: ActionService, libService: OpenViduComponentsConfigService, loggerService: LoggerService);
    /**
     * Initializes the recording status with the given parameters and the timer to calculate the elapsed time.
     * @internal
     */
    setRecordingStarted(recordingInfo?: RecordingInfo, startTimestamp?: number): void;
    /**
     * Stops the recording timer and updates the recording status to **stopped**.
     * @internal
     */
    setRecordingStopped(recordingInfo?: RecordingInfo): void;
    /**
     * Set the {@link RecordingStatus} to **starting**.
     * The `started` stastus will be updated automatically when the recording is actually started.
     */
    setRecordingStarting(): void;
    /**
     * @internal
     * @param error
     */
    setRecordingFailed(error: string): void;
    /**
     * Set the {@link RecordingStatus} to **stopping**.
     * The `stopped` stastus will be updated automatically when the recording is actually stopped.
     */
    setRecordingStopping(): void;
    /**
     * @internal
     * Play the recording blob received as parameter. This parameter must be obtained from backend using the OpenVidu REST API
     */
    playRecording(recording: RecordingInfo): void;
    /**
     * @internal
     * Download the the recording file received .
     * @param recording
     */
    downloadRecording(recording: RecordingInfo): void;
    /**
     * Deletes a recording from the recording list.
     *
     * @param recording - The recording to be deleted.
     * @internal
     */
    deleteRecording(recording: RecordingInfo): boolean;
    /**
     *
     * @param recordings
     * @internal
     */
    setRecordingList(recordings: RecordingInfo[]): void;
    /**
     * Updates the recording status.
     * @param status {@link RecordingStatus}
     */
    private updateStatus;
    private startRecordingTimer;
    private stopRecordingTimer;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecordingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RecordingService>;
}

declare class AdminDashboardComponent implements OnInit, OnDestroy {
    private actionService;
    private recordingService;
    private libService;
    /**
     * Provides event notifications that fire when delete recording button has been clicked.
     * The recording should be deleted using the REST API.
     * @param recordingId
     */
    onRecordingDeleteRequested: EventEmitter<RecordingDeleteRequestedEvent>;
    /**
     * Provides event notifications that fire when refresh recordings button has been clicked.
     * The recordings should be updated using the REST API.
     */
    onRefreshRecordingsRequested: EventEmitter<void>;
    /**
     * Provides event notifications that fire when load more button has been clicked.
     * The recordings should be updated using the REST API with the continuation token.
     */
    onLoadMoreRecordingsRequested: EventEmitter<void>;
    /**
     * Provides event notifications that fire when logout button has been clicked.
     */
    onLogoutRequested: EventEmitter<void>;
    /**
     * @internal
     */
    title: string;
    /**
     * @internal
     */
    recordings: RecordingInfo[];
    /**
     * @internal
     */
    sortDescendent: boolean;
    /**
     * @internal
     */
    sortByLegend: string;
    /**
     * @internal
     */
    searchValue: string;
    /**
     * @internal
     */
    recordingStatusEnum: typeof RecordingStatus;
    private recordingsSub;
    private titleSub;
    /**
     * @internal
     */
    constructor(actionService: ActionService, recordingService: RecordingService, libService: OpenViduComponentsConfigService);
    /**
     * @internal
     */
    ngOnInit(): void;
    /**
     * @internal
     */
    ngOnDestroy(): void;
    /**
     * @internal
     */
    logout(): void;
    /**
     * @internal
     */
    refreshRecordings(): void;
    /**
     * @internal
     */
    sortRecordingsByDateStart(): void;
    /**
     * @internal
     */
    sortRecordingsByDateEnd(): void;
    /**
     * @internal
     */
    sortRecordingsByDuration(): void;
    /**
     * @internal
     */
    sortRecordingsBySize(): void;
    /**
     * @internal
     */
    loadMore(event: any): void;
    /**
     * @internal
     */
    deleteRecording(recording: RecordingInfo): void;
    /**
     * @internal
     */
    download(recording: RecordingInfo): void;
    /**
     * @internal
     */
    play(recording: RecordingInfo): Promise<void>;
    /**
     * @internal
     */
    trackByRecordingId(index: number, recording: any): any;
    private filterDeletedRecordings;
    private mergeRecordings;
    private sortRecordings;
    private subscribeToAdminDirectives;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdminDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AdminDashboardComponent, "ov-admin-dashboard", never, {}, { "onRecordingDeleteRequested": "onRecordingDeleteRequested"; "onRefreshRecordingsRequested": "onRefreshRecordingsRequested"; "onLoadMoreRecordingsRequested": "onLoadMoreRecordingsRequested"; "onLogoutRequested": "onLogoutRequested"; }, never, never, false, never>;
}

declare class AdminLoginComponent implements OnInit {
    private libService;
    private actionService;
    private fb;
    /**
     * Provides event notifications that fire when login button has been clicked.
     * The event will contain the credentials value.
     * @returns {EventEmitter<{ username: string; password: string }>}
     */
    onLoginRequested: EventEmitter<{
        username: string;
        password: string;
    }>;
    /**
     * @internal
     */
    title: string;
    /**
     * @internal
     */
    loading: boolean;
    /**
     * @internal
     */
    showSpinner: boolean;
    /**
     * @internal
     */
    loginForm: FormGroup;
    private errorSub;
    private titleSub;
    /**
     * @internal
     */
    constructor(libService: OpenViduComponentsConfigService, actionService: ActionService, fb: FormBuilder);
    /**
     * @internal
     */
    ngOnInit(): void;
    /**
     * @internal
     */
    ngOnDestroy(): void;
    /**
     * @internal
     */
    login(): void;
    private subscribeToAdminLoginDirectives;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdminLoginComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AdminLoginComponent, "ov-admin-login", never, {}, { "onLoginRequested": "onLoginRequested"; }, never, never, false, never>;
}

/**
 * Component to display a landscape orientation warning on mobile devices.
 * @internal
 */
declare class LandscapeWarningComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<LandscapeWarningComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LandscapeWarningComponent, "ov-landscape-warning", never, {}, {}, never, never, false, never>;
}

/**
 * The ***ovPreJoin** directive empowers you to substitute the default pre-join component template with a custom one.
 * This directive allows you to create a completely custom pre-join experience while maintaining the core functionality.
 *
 * In the example below, we demonstrate how to replace the pre-join template with a custom one that includes
 * device selection and a custom join button.
 *
 * <!--ovPreJoin-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 * import { FormsModule } from '@angular/forms';
 *
 * import {
 * 	DeviceService,
 * 	ParticipantService,
 * 	OpenViduComponentsModule,
 * } from 'openvidu-components-angular';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 			(onReadyToJoin)="onReadyToJoin()"
 * 		>
 * 			<!-- Custom Pre-Join Component -->
 * 			<div *ovPreJoin class="custom-prejoin">
 * 				<h2>Join Meeting</h2>
 * 				<div class="prejoin-form">
 * 					<input
 * 						type="text"
 * 						placeholder="Enter your name"
 * 						[(ngModel)]="participantName"
 * 						class="name-input"
 * 					/>
 * 					<button
 * 						(click)="joinMeeting()"
 * 						[disabled]="!participantName"
 * 						class="join-button"
 * 					>
 * 						Join Meeting
 * 					</button>
 * 				</div>
 * 			</div>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: `
 * 		.custom-prejoin {
 * 			display: flex;
 * 			flex-direction: column;
 * 			align-items: center;
 * 			justify-content: center;
 * 			height: 100vh;
 * 			background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
 * 			color: white;
 * 		}
 * 		.prejoin-form {
 * 			display: flex;
 * 			flex-direction: column;
 * 			gap: 20px;
 * 			align-items: center;
 * 		}
 * 		.name-input {
 * 			padding: 12px;
 * 			border: none;
 * 			border-radius: 8px;
 * 			font-size: 16px;
 * 			min-width: 250px;
 * 		}
 * 		.join-button {
 * 			padding: 12px 24px;
 * 			background: #4CAF50;
 * 			color: white;
 * 			border: none;
 * 			border-radius: 8px;
 * 			font-size: 16px;
 * 			cursor: pointer;
 * 			transition: background 0.3s;
 * 		}
 * 		.join-button:hover:not(:disabled) {
 * 			background: #45a049;
 * 		}
 * 		.join-button:disabled {
 * 			background: #cccccc;
 * 			cursor: not-allowed;
 * 		}
 * 	`,
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule, FormsModule],
 * })
 * export class AppComponent {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// Define the name of the room and initialize the token variable
 * 	roomName = 'custom-prejoin';
 * 	token!: string;
 * 	participantName: string = '';
 *
 * 	constructor(
 * 		private httpClient: HttpClient,
 * 		private deviceService: DeviceService,
 * 		private participantService: ParticipantService
 * 	) {
 * 		this.configureUrls();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	// Function to request a token when a participant joins the room
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	// Function called when ready to join
 * 	onReadyToJoin() {
 * 		console.log('Ready to join the meeting');
 * 	}
 *
 * 	// Function to join the meeting
 * 	async joinMeeting() {
 * 		if (this.participantName.trim()) {
 * 			// Request token with the participant name
 * 			await this.onTokenRequested(this.participantName);
 * 		}
 * 	}
 *
 * 	// Function to get a token from the server
 * 	getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			// Send a POST request to the server to obtain a token
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			// Handle errors, e.g., if the server is not reachable
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message:
 * 						'Cannot connect with the backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovPreJoin-end-tutorial-->
 *
 * @internal
 */

declare class PreJoinDirective {
    template: TemplateRef<any>;
    container: ViewContainerRef;
    constructor(template: TemplateRef<any>, container: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<PreJoinDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PreJoinDirective, "[ovPreJoin]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovParticipantPanelAfterLocalParticipant** directive allows you to inject custom HTML or Angular templates
 * immediately after the local participant item in the participant panel.
 * This enables you to extend the participant panel with additional controls, information, or UI elements.
 *
 * Usage example:
 * ```html
 * <ov-participant-panel>
 *   <ng-container *ovParticipantPanelAfterLocalParticipant>
 *     <div class="custom-content">
 *       <!-- Your custom HTML here -->
 *       <span>Custom content after local participant</span>
 *     </div>
 *   </ng-container>
 * </ov-participant-panel>
 * ```
 */
declare class ParticipantPanelAfterLocalParticipantDirective {
    template: TemplateRef<any>;
    container: ViewContainerRef;
    constructor(template: TemplateRef<any>, container: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantPanelAfterLocalParticipantDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ParticipantPanelAfterLocalParticipantDirective, "[ovParticipantPanelAfterLocalParticipant]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovLeaveButton** directive allows you to inject a custom leave button template. You can use the toolbarLeaveButton = false for
 * replacing the default leave button with your custom one.
 *
 * Usage example:
 * ```html
 * <ov-videoconference [toolbarLeaveButton]="false">
 *   <ng-container *ovLeaveButton>
 *     <button class="my-leave-button" (click)="customLeave()">
 *       Leave meeting
 *     </button>
 *   </ng-container>
 * </ov-videoconference>
 * ```
 */
declare class LeaveButtonDirective {
    template: TemplateRef<any>;
    container: ViewContainerRef;
    constructor(template: TemplateRef<any>, container: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<LeaveButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LeaveButtonDirective, "[ovToolbarLeaveButton]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovLayoutAdditionalElements** directive allows you to inject custom HTML or Angular templates
 * as additional layout elements within the videoconference UI.
 * This enables you to extend the layout with extra controls, banners, or any custom UI.
 *
 * You can specify a slot to control where the element is positioned:
 * - 'top': Position at the top of the layout (after local participant, before remote participants)
 * - 'bottom': Position at the bottom of the layout (after all participants)
 * - 'default' or no slot: Position after local participant (default behavior)
 *
 * Usage examples:
 * ```html
 * <ov-videoconference>
 *   <!-- Default position (after local participant) -->
 *   <ng-container *ovLayoutAdditionalElements>
 *     <div class="my-banner">Banner</div>
 *   </ng-container>
 *
 *   <!-- Top position -->
 *   <ng-container *ovLayoutAdditionalElements="'top'">
 *     <div class="top-bar">Top Bar</div>
 *   </ng-container>
 *
 *   <!-- Bottom position -->
 *   <ng-container *ovLayoutAdditionalElements="'bottom'">
 *     <div class="bottom-info">Footer Info</div>
 *   </ng-container>
 * </ov-videoconference>
 * ```
 */
declare class LayoutAdditionalElementsDirective {
    template: TemplateRef<any>;
    container: ViewContainerRef;
    /**
     * Slot position: 'top', 'bottom', or 'default'
     */
    slot: 'top' | 'bottom' | 'default';
    constructor(template: TemplateRef<any>, container: ViewContainerRef);
    /**
     * @ignore
     */
    set ovLayoutAdditionalElements(slot: 'top' | 'bottom' | 'default' | '');
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutAdditionalElementsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LayoutAdditionalElementsDirective, "[ovLayoutAdditionalElements]", never, { "ovLayoutAdditionalElements": { "alias": "ovLayoutAdditionalElements"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The ***ovParticipantPanelParticipantBadge** directive allows you to inject custom badges or indicators
 * in the participant panel.
 * This enables you to add role indicators, status badges, or other visual elements.
 *
 * Usage example:
 * ```html
 * <ov-participants-panel>
 *   <div *ovParticipantPanelItem="let participant">
 *     <ov-participant-panel-item [participant]="participant">
 *       <!-- Custom badge for local participant only -->
 *       <ng-container *ovParticipantPanelParticipantBadge>
 *         <span class="moderator-badge">
 *           <mat-icon>admin_panel_settings</mat-icon>
 *           Moderator
 *         </span>
 *       </ng-container>
 *     </ov-participant-panel-item>
 *   </div>
 * </ov-participants-panel>
 * ```
 */
declare class ParticipantPanelParticipantBadgeDirective {
    template: TemplateRef<any>;
    container: ViewContainerRef;
    constructor(template: TemplateRef<any>, container: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantPanelParticipantBadgeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ParticipantPanelParticipantBadgeDirective, "[ovParticipantPanelParticipantBadge]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovSettingsPanelGeneralAdditionalElements** directive allows you to inject custom HTML or Angular templates
 * into the general section of the settings panel.
 * This enables you to add custom controls, information, or UI elements to extend the settings panel functionality.
 *
 * Usage example:
 * ```html
 * <ov-videoconference>
 *   <ng-container *ovSettingsPanelGeneralAdditionalElements>
 *     <div class="custom-settings-section">
 *       <mat-list>
 *         <mat-list-item>
 *           <mat-icon matListItemIcon>tune</mat-icon>
 *           <div matListItemTitle>Custom Setting</div>
 *           <mat-slide-toggle matListItemMeta [(ngModel)]="customSetting"></mat-slide-toggle>
 *         </mat-list-item>
 *       </mat-list>
 *     </div>
 *   </ng-container>
 * </ov-videoconference>
 * ```
 *
 * @internal
 */
declare class SettingsPanelGeneralAdditionalElementsDirective {
    template: TemplateRef<any>;
    container: ViewContainerRef;
    constructor(template: TemplateRef<any>, container: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsPanelGeneralAdditionalElementsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SettingsPanelGeneralAdditionalElementsDirective, "[ovSettingsPanelGeneralAdditionalElements]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovToolbarMoreOptionsAdditionalMenuItems** directive allows you to inject custom HTML or Angular templates
 * into the "more options" menu (three dots button) of the toolbar.
 * This enables you to add custom menu items to extend the toolbar functionality.
 *
 * Usage example:
 * ```html
 * <ov-videoconference>
 *   <ng-container *ovToolbarMoreOptionsAdditionalMenuItems>
 *     <button mat-menu-item (click)="onCustomAction()">
 *       <mat-icon>star</mat-icon>
 *       <span>Custom Action</span>
 *     </button>
 *     <mat-divider></mat-divider>
 *     <button mat-menu-item (click)="onAnotherAction()">
 *       <mat-icon>info</mat-icon>
 *       <span>Another Action</span>
 *     </button>
 *   </ng-container>
 * </ov-videoconference>
 * ```
 *
 * @internal
 */
declare class ToolbarMoreOptionsAdditionalMenuItemsDirective {
    template: TemplateRef<any>;
    container: ViewContainerRef;
    constructor(template: TemplateRef<any>, container: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarMoreOptionsAdditionalMenuItemsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarMoreOptionsAdditionalMenuItemsDirective, "[ovToolbarMoreOptionsAdditionalMenuItems]", never, {}, {}, never, never, false, never>;
}

/**
 * The ***ovToolbar** directive allows to replace the default toolbar component with a custom one.
 *
 * In the example below we've replaced the default toolbar and added the **toggleAudio** and **toggleVideo** buttons.
 * Here we are using the {@link ParticipantService} for enabling/disabling the audio and video.
 *
 * <!--ovToolbar-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 *
 * import {
 *   ParticipantService,
 *   OpenViduComponentsModule,
 * } from 'openvidu-components-angular';
 *
 * @Component({
 *   selector: 'app-root',
 *   template: `
 *     <ov-videoconference
 *       [token]="token"
 *       [livekitUrl]="LIVEKIT_URL"
 *       (onTokenRequested)="onTokenRequested($event)"
 *     >
 *       <div *ovToolbar style="text-align: center;">
 *         <button (click)="toggleVideo()">Toggle Video</button>
 *         <button (click)="toggleAudio()">Toggle Audio</button>
 *       </div>
 *     </ov-videoconference>
 *   `,
 *   standalone: true,
 *   imports: [OpenViduComponentsModule],
 * })
 * export class AppComponent {
 *   // For local development, leave these variables empty
 *   // For production, configure them with correct URLs depending on your deployment
 *
 *   APPLICATION_SERVER_URL = '';
 *   LIVEKIT_URL = '';
 *   // The name of the room.
 *   roomName = 'custom-toolbar';
 *
 *   // The token used to connect to the videoconference.
 *   token!: string;
 *
 *   constructor(
 *     private httpClient: HttpClient,
 *     private participantService: ParticipantService
 *   ) {
 *     this.configureUrls();
 *   }
 *
 *   private configureUrls() {
 *     // If APPLICATION_SERVER_URL is not configured, use default value from local development
 *     if (!this.APPLICATION_SERVER_URL) {
 *       if (window.location.hostname === 'localhost') {
 *         this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 *       } else {
 *         this.APPLICATION_SERVER_URL =
 *           'https://' + window.location.hostname + ':6443/';
 *       }
 *     }
 *
 *     // If LIVEKIT_URL is not configured, use default value from local development
 *     if (!this.LIVEKIT_URL) {
 *       if (window.location.hostname === 'localhost') {
 *         this.LIVEKIT_URL = 'ws://localhost:7880/';
 *       } else {
 *         this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 *       }
 *     }
 *   }
 *
 *   // Called when a token is requested for a participant.
 *   async onTokenRequested(participantName: string) {
 *     const { token } = await this.getToken(this.roomName, participantName);
 *     this.token = token;
 *   }
 *
 *   // Toggles the camera on and off.
 *   async toggleVideo() {
 *     const isCameraEnabled = this.participantService.isMyCameraEnabled();
 *     await this.participantService.setCameraEnabled(!isCameraEnabled);
 *   }
 *
 *   // Toggles the microphone on and off.
 *   async toggleAudio() {
 *     const isMicrophoneEnabled = this.participantService.isMyMicrophoneEnabled();
 *     await this.participantService.setMicrophoneEnabled(!isMicrophoneEnabled);
 *   }
 *
 *   // Gets a token for a participant.
 *   getToken(roomName: string, participantName: string): Promise<any> {
 *     try {
 *       return lastValueFrom(
 *         this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 *           roomName,
 *           participantName,
 *         })
 *       );
 *     } catch (error: any) {
 *       if (error.status === 404) {
 *         throw {
 *           status: error.status,
 *           message: 'Cannot connect with backend. ' + error.url + ' not found',
 *         };
 *       }
 *       throw error;
 *     }
 *   }
 * }
 *
 * ```
 * <!--ovToolbar-end-tutorial-->
 *
 * You can run the associated tutorial [here](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-custom-toolbar/).
 */
declare class ToolbarDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    /**
     * @ignore
     */
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarDirective, "[ovToolbar]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovToolbarAdditionalButtons** directive enables the addition of extra buttons to the central button group within the toolbar.
 *
 * In the following example, we've included the same buttons as those in the {@link ToolbarDirective}. Additionally, we utilize the {@link ParticipantService} to assess audio and video statuses.
 *
 * <!--ovToolbarAdditionalButtons-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 *
 * import {
 * 	ParticipantService,
 * 	OpenViduComponentsModule,
 * } from 'openvidu-components-angular';
 * import { MatIcon } from '@angular/material/icon';
 * import { MatIconButton } from '@angular/material/button';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 		>
 * 			<div *ovToolbarAdditionalButtons style="text-align: center;">
 * 				<button mat-icon-button (click)="toggleVideo()">
 * 					<mat-icon>videocam</mat-icon>
 * 				</button>
 * 				<button mat-icon-button (click)="toggleAudio()">
 * 					<mat-icon>mic</mat-icon>
 * 				</button>
 * 			</div>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: [],
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule, MatIconButton, MatIcon],
 * })
 * export class AppComponent {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 *
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// The name of the room for the video conference.
 * 	roomName = 'toolbar-additionalbtn';
 *
 * 	// The token used to authenticate the user in the video conference.
 * 	token!: string;
 *
 * 	constructor(
 * 		private httpClient: HttpClient,
 * 		private participantService: ParticipantService
 * 	) {
 * 		this.configureUrls();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	// Called when the token is requested.
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	// Toggles the camera on/off.
 * 	async toggleVideo() {
 * 		const isCameraEnabled = this.participantService.isMyCameraEnabled();
 * 		await this.participantService.setCameraEnabled(!isCameraEnabled);
 * 	}
 *
 * 	// Toggles the microphone on/off.
 * 	async toggleAudio() {
 * 		const isMicrophoneEnabled = this.participantService.isMyMicrophoneEnabled();
 * 		await this.participantService.setMicrophoneEnabled(!isMicrophoneEnabled);
 * 	}
 *
 * 	// Retrieves a token from the server to authenticate the user.
 * 	getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message: 'Cannot connect with backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovToolbarAdditionalButtons-end-tutorial-->
 *
 * To follow a step-by-step tutorial on this feature, please visit [this link](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-toolbar-buttons/).
 */
declare class ToolbarAdditionalButtonsDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    /**
     * @ignore
     */
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarAdditionalButtonsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarAdditionalButtonsDirective, "[ovToolbarAdditionalButtons]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovToolbarAdditionalPanelButtons** directive allows to add additional **panel buttons** to the toolbar.
 * In the example below we've added a simple button without any functionality. To learn how to toggle the panel check the {@link AdditionalPanelsDirective}.
 *
 * <!--ovToolbarAdditionalPanelButtons-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 *
 * import { OpenViduComponentsModule } from 'openvidu-components-angular';
 * import { MatIconButton } from '@angular/material/button';
 * import { MatIcon } from '@angular/material/icon';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			[toolbarDisplayRoomName]="false"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 		>
 * 			<div *ovToolbarAdditionalPanelButtons style="text-align: center;">
 * 				<button mat-icon-button (click)="onButtonClicked()">
 * 					<mat-icon>star</mat-icon>
 * 				</button>
 * 			</div>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: [],
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule, MatIconButton, MatIcon],
 * })
 * export class AppComponent {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 *
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// Set the room name
 * 	roomName = 'toolbar-additional-panel-btn';
 *
 * 	// Initialize the token variable
 * 	token!: string;
 *
 * 	constructor(private httpClient: HttpClient) {
 * 		this.configureUrls();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	// Method to request a token for a participant
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	// Method to handle button click
 * 	onButtonClicked() {
 * 		alert('button clicked');
 * 	}
 *
 * 	// Method to get a token from the backend
 * 	getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message: 'Cannot connect with backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovToolbarAdditionalPanelButtons-end-tutorial-->
 *
 * You can run the associated tutorial [here](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-toolbar-panel-buttons/).
 */
declare class ToolbarAdditionalPanelButtonsDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    /**
     * @ignore
     */
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarAdditionalPanelButtonsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarAdditionalPanelButtonsDirective, "[ovToolbarAdditionalPanelButtons]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovPanel** directive empowers you to seamlessly replace default panels with custom ones.
 * It also provides the flexibility to insert elements tagged with the {@link ChatPanelDirective}, {@link ParticipantsPanelDirective}, and {@link AdditionalPanelsDirective}.
 *
 * In the example below, we showcase how to entirely replace the {@link PanelComponent} using the {@link ChatPanelDirective}.
 * Within it, you can tailor the appearance and behavior of the {@link ParticipantsPanelComponent} and {@link ChatPanelComponent} using their respective directives.
 *
 * <!--ovPanel-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 *
 * import { OpenViduComponentsModule } from 'openvidu-components-angular';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<!-- OpenVidu Video Conference Component -->
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 		>
 * 			<!-- Custom Panels -->
 * 			<ov-panel *ovPanel>
 * 				<!-- Custom Chat Panel -->
 * 				<div *ovChatPanel id="my-chat-panel">This is my custom chat panel</div>
 *
 * 				<!-- Custom Participants Panel -->
 * 				<div *ovParticipantsPanel id="my-participants-panel">
 * 					This is my custom participants panel
 * 				</div>
 *
 * 				<!-- Custom Activities Panel -->
 * 				<div *ovActivitiesPanel id="my-activities-panel">
 * 					This is my custom activities panel
 * 				</div>
 * 			</ov-panel>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: `
 * 		#my-chat-panel,
 * 		#my-participants-panel,
 * 		#my-activities-panel {
 * 			text-align: center;
 * 			height: calc(100% - 40px);
 * 			margin: 20px;
 * 		}
 *
 * 		#my-chat-panel {
 * 			background: #c9ffb2;
 * 		}
 *
 * 		#my-participants-panel {
 * 			background: #ddf2ff;
 * 		}
 *
 * 		#my-activities-panel {
 * 			background: #ffddc9;
 * 		}
 * 	`,
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule],
 * })
 * export class AppComponent {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// Define the name of the room and initialize the token variable
 * 	roomName = 'custom-panels';
 * 	token!: string;
 *
 * 	constructor(private httpClient: HttpClient) {
 * 		this.configureUrls();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	// Function to request a token when a participant joins the room
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	// Function to get a token from the server
 * 	getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			// Send a POST request to the server to obtain a token
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			// Handle errors, e.g., if the server is not reachable
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message:
 * 						'Cannot connect with the backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovPanel-end-tutorial-->
 *
 *
 * For a comprehensive tutorial on implementing custom panels, please refer to the associated guide [here](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-custom-panels/).
 */
declare class PanelDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    /**
     * @ignore
     */
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<PanelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PanelDirective, "[ovPanel]", never, {}, {}, never, never, false, never>;
}
/**
 *
 * The ***ovAdditionalPanels** directive enables you to effortlessly integrate additional panels with the {@link PanelComponent}.
 *
 * In the example below, we showcase how to add a custom panel to the {@link PanelComponent} using the **ovAdditionalPanels** directive.
 *
 * <!--ovAdditionalPanels-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 *
 * import {
 * 	PanelStatusInfo,
 * 	PanelService,
 * 	OpenViduComponentsModule,
 * } from 'openvidu-components-angular';
 *
 * import { MatIcon } from '@angular/material/icon';
 * import { MatIconButton } from '@angular/material/button';
 *
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<!-- OpenVidu Video Conference Component -->
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			[toolbarDisplayRoomName]="false"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 		>
 * 			<!-- Additional Toolbar Buttons -->
 * 			<div *ovToolbarAdditionalPanelButtons style="text-align: center;">
 * 				<button mat-icon-button (click)="toggleMyPanel('my-panel1')">
 * 					<mat-icon>360</mat-icon>
 * 				</button>
 * 				<button mat-icon-button (click)="toggleMyPanel('my-panel2')">
 * 					<mat-icon>star</mat-icon>
 * 				</button>
 * 			</div>
 *
 * 			<!-- Additional Panels -->
 * 			<div *ovAdditionalPanels id="my-panels">
 * 				@if (showExternalPanel) {
 * 				<div id="my-panel1">
 * 					<h2>NEW PANEL 1</h2>
 * 					<p>This is my new additional panel</p>
 * 				</div>
 * 				} @if (showExternalPanel2) {
 * 				<div id="my-panel2">
 * 					<h2>NEW PANEL 2</h2>
 * 					<p>This is another new panel</p>
 * 				</div>
 * 				}
 * 			</div>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: `
 * 		#my-panels {
 * 			height: 100%;
 * 			overflow: hidden;
 * 		}
 * 		#my-panel1,
 * 		#my-panel2 {
 * 			text-align: center;
 * 			height: calc(100% - 40px);
 * 			margin: 20px;
 * 		}
 * 		#my-panel1 {
 * 			background: #c9ffb2;
 * 		}
 * 		#my-panel2 {
 * 			background: #ddf2ff;
 * 		}
 * 	`,
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule, MatIconButton, MatIcon],
 * })
 * export class AppComponent {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// Define the name of the room and initialize the token variable
 * 	roomName = 'additional-panels';
 * 	token!: string;
 *
 * 	// Flags to control the visibility of external panels
 * 	showExternalPanel: boolean = false;
 * 	showExternalPanel2: boolean = false;
 *
 * 	constructor(
 * 		private httpClient: HttpClient,
 * 		private panelService: PanelService
 * 	) {
 * 		this.configureUrls();
 * 	}
 *
 * 	ngOnInit() {
 * 		this.subscribeToPanelToggling();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	// Function to request a token when a participant joins the room
 * 	async onTokenRequested(participantName: any) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	// Subscribe to panel toggling events
 * 	subscribeToPanelToggling() {
 * 		this.panelService.panelStatusObs.subscribe((ev: PanelStatusInfo) => {
 * 			this.showExternalPanel = ev.isOpened && ev.panelType === 'my-panel1';
 * 			this.showExternalPanel2 = ev.isOpened && ev.panelType === 'my-panel2';
 * 		});
 * 	}
 *
 * 	// Toggle the visibility of external panels
 * 	toggleMyPanel(type: string) {
 * 		this.panelService.togglePanel(type);
 * 	}
 *
 * 	// Function to get a token from the server
 * 	async getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			// Send a POST request to the server to obtain a token
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			// Handle errors, e.g., if the server is not reachable
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message:
 * 						'Cannot connect with the backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovAdditionalPanels-end-tutorial-->
 *
 * For detailed instructions, refer to the tutorial available [here](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-additional-panels/).
 */
declare class AdditionalPanelsDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    /**
     * @ignore
     */
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<AdditionalPanelsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AdditionalPanelsDirective, "[ovAdditionalPanels]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovChatPanel** directive empowers you to effortlessly substitute the default chat panel template with a custom one.
 *
 * In the example below, we showcase how to replace the chat template with a custom one.
 *
 * <!--ovChatPanel-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 *
 * import {
 * 	DataPacket_Kind,
 * 	DataPublishOptions,
 * 	DataTopic,
 * 	ParticipantService,
 * 	RemoteParticipant,
 * 	Room,
 * 	RoomEvent,
 * 	OpenViduComponentsModule,
 * } from 'openvidu-components-angular';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<!-- OpenVidu Video Conference Component -->
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			[toolbarDisplayRoomName]="false"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 			(onRoomCreated)="onRoomCreated($event)"
 * 		>
 * 			<!-- Chat Panel -->
 * 			<div *ovChatPanel id="my-panel">
 * 				<h3>Chat</h3>
 * 				<div>
 * 					<ul>
 * 						@for (msg of messages; track msg) {
 * 						<li>{{ msg }}</li>
 * 						}
 * 					</ul>
 * 				</div>
 * 				<input value="Hello" #input />
 * 				<button (click)="send(input.value)">Send</button>
 * 			</div>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: `
 * 		#my-panel {
 * 			background: #aafffc;
 * 			height: 100%;
 * 			overflow: hidden;
 * 			text-align: center;
 * 		}
 * 	`,
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule],
 * })
 * export class AppComponent {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// Define the name of the room and initialize the token variable
 * 	roomName = 'chat-panel-directive-example';
 * 	token!: string;
 * 	messages: string[] = [];
 *
 * 	constructor(
 * 		private httpClient: HttpClient,
 * 		private participantService: ParticipantService
 * 	) {
 * 		this.configureUrls();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	// Function to request a token when a participant joins the room
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	// Event handler for room creation
 * 	onRoomCreated(room: Room) {
 * 		room.on(
 * 			RoomEvent.DataReceived,
 * 			(
 * 				payload: Uint8Array,
 * 				participant?: RemoteParticipant,
 * 				_?: DataPacket_Kind,
 * 				topic?: string
 * 			) => {
 * 				if (topic === DataTopic.CHAT) {
 * 					const { message } = JSON.parse(new TextDecoder().decode(payload));
 * 					const participantName = participant?.name || 'Unknown';
 * 					this.messages.push(message);
 * 					console.log(`Message received from ${participantName}:`, message);
 * 				}
 * 			}
 * 		);
 * 	}
 *
 * 	// Function to send a chat message
 * 	async send(message: string): Promise<void> {
 * 		const strData = JSON.stringify({ message });
 * 		const data: Uint8Array = new TextEncoder().encode(strData);
 * 		const options: DataPublishOptions = { topic: DataTopic.CHAT };
 * 		await this.participantService.publishData(data, options);
 * 		this.messages.push(message);
 * 	}
 *
 * 	// Function to get a token from the server
 * 	getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			// Send a POST request to the server to obtain a token
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			// Handle errors, e.g., if the server is not reachable
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message:
 * 						'Cannot connect with the backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovChatPanel-end-tutorial-->
 *
 *
 * For a step-by-step tutorial on how to replace the chat template with just a few lines of code,
 * check out our comprehensive guide: [Customizing the Chat Panel](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-custom-chat-panel/).
 */
declare class ChatPanelDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ChatPanelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ChatPanelDirective, "[ovChatPanel]", never, {}, {}, never, never, false, never>;
}
/**
 * backgroundEffectsPanel does not provide any customization for now
 * @internal
 */
declare class BackgroundEffectsPanelDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<BackgroundEffectsPanelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BackgroundEffectsPanelDirective, "[ovBackgroundEffectsPanel]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovActivitiesPanel** directive empowers you to effortlessly substitute the default activities panel template with a custom one.
 *
 * In the example below, we showcase how to replace the activities template with a custom one.
 *
 * <!--ovActivitiesPanel-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 * import { OpenViduComponentsModule } from 'openvidu-components-angular';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 		>
 * 			<!-- Custom activities panel -->
 * 			<div *ovActivitiesPanel id="my-panel">
 * 				<h3>ACTIVITIES</h3>
 * 				<div>CUSTOM ACTIVITIES</div>
 * 			</div>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: `
 * 		#my-panel {
 * 			background: #aafffc;
 * 			height: 100%;
 * 			overflow: hidden;
 * 			text-align: center;
 * 		}
 * 	`,
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule],
 * })
 * export class AppComponent {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 * 	roomName = 'custom-activities-panel';
 * 	token!: string;
 *
 * 	constructor(private httpClient: HttpClient) {
 * 		this.configureUrls();
 * 	}
 *
 * 	configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message: 'Cannot connect with backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovActivitiesPanel-end-tutorial-->
 *
 * For a step-by-step tutorial on how to replace the activities template with just a few lines of code,
 * check out our comprehensive guide: [Customizing the Activities Panel](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-custom-activities-panel/).
 */
declare class ActivitiesPanelDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivitiesPanelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ActivitiesPanelDirective, "[ovActivitiesPanel]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovParticipantsPanel** directive empowers you to substitute the default participants panel template with a customized one.
 * In the following example, we demonstrate how to replace the participants template with just a few lines of code.
 *
 * <!--ovParticipantsPanel-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component, OnDestroy, OnInit } from '@angular/core';
 * import { lastValueFrom, Subscription } from 'rxjs';
 *
 * import {
 * 	ParticipantModel,
 * 	ParticipantService,
 * 	OpenViduComponentsModule,
 * } from 'openvidu-components-angular';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<!-- OpenVidu Video Conference Component -->
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 		>
 * 			<!-- Custom Participants Panel -->
 * 			<div *ovParticipantsPanel id="my-panel">
 * 				<ul id="local">
 * 					<li>{{ localParticipant.name }}</li>
 * 				</ul>
 * 				<ul id="remote">
 * 					@for (p of remoteParticipants; track p) {
 * 					<li>{{ p.name }}</li>
 * 					}
 * 				</ul>
 * 			</div>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: `
 * 		#my-panel {
 * 			background: #faff7f;
 * 			height: 100%;
 * 			overflow: hidden;
 * 		}
 * 		#my-panel > #local {
 * 			background: #a184ff;
 * 		}
 * 		#my-panel > #remote {
 * 			background: #7fb8ff;
 * 		}
 * 	`,
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule],
 * })
 * export class AppComponent implements OnInit, OnDestroy {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// Define the name of the room and initialize the token variable
 * 	roomName = 'custom-participants-panel';
 * 	token!: string;
 *
 * 	// Participant-related properties
 * 	localParticipant!: ParticipantModel;
 * 	remoteParticipants!: ParticipantModel[];
 * 	localParticipantSubs!: Subscription;
 * 	remoteParticipantsSubs!: Subscription;
 *
 * 	constructor(
 * 		private httpClient: HttpClient,
 * 		private participantService: ParticipantService
 * 	) {
 * 		this.configureUrls();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	// Subscribes to updates for local and remote participants.
 * 	ngOnInit() {
 * 		this.subscribeToParticipants();
 * 	}
 *
 * 	// Unsubscribes from updates for local and remote participants to prevent memory leaks.
 * 	ngOnDestroy() {
 * 		this.localParticipantSubs.unsubscribe();
 * 		this.remoteParticipantsSubs.unsubscribe();
 * 	}
 *
 * 	// Function called when a participant requests a token to join the room.
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	// Subscribes to updates for local and remote participants.
 * 	subscribeToParticipants() {
 * 		this.localParticipantSubs =
 * 			this.participantService.localParticipant$.subscribe((p) => {
 * 				if (p) this.localParticipant = p;
 * 			});
 *
 * 		this.remoteParticipantsSubs =
 * 			this.participantService.remoteParticipants$.subscribe(
 * 				(participants) => {
 * 					this.remoteParticipants = participants;
 * 				}
 * 			);
 * 	}
 *
 * 	// Sends a request to the server to obtain a token for a participant.
 * 	async getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			// Send a POST request to the server to obtain a token
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			// Handle errors, e.g., if the server is not reachable
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message:
 * 						'Cannot connect with the backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovParticipantsPanel-end-tutorial-->
 *
 * For a comprehensive tutorial on customizing the participants panel, please visit [this link](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-custom-participants-panel/).
 */
declare class ParticipantsPanelDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantsPanelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ParticipantsPanelDirective, "[ovParticipantsPanel]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovParticipantPanelItem** directive allows you to customize the default participant panel item template within the {@link ParticipantsPanelComponent}.
 *
 * With the **ovParticipantPanelItem** directive, you can access the participant object from its context using the `let` keyword and referencing the `participant`
 * variable as follows: `*ovParticipantPanelItem="let participant"`. This allows you to access the {@link ParticipantModel} object.
 *
 * In the example below, we demonstrate how to replace the participant panel item template with just a few lines of code.
 *
 * <!--ovParticipantPanelItem-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 *
 * import { MatIcon } from '@angular/material/icon';
 * import { MatMenuTrigger, MatMenu, MatMenuItem } from '@angular/material/menu';
 * import { MatIconButton } from '@angular/material/button';
 * import { OpenViduComponentsModule } from 'openvidu-components-angular';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<!-- OpenVidu Video Conference Component -->
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 		>
 * 			<!-- Participant Panel Items -->
 * 			<div *ovParticipantPanelItem="let participant" style="display: flex">
 * 				<p>{{ participant.name }}</p>
 *
 * 				<!-- More Options Menu -->
 * 				<button mat-icon-button [matMenuTriggerFor]="menu">
 * 					<mat-icon>more_vert</mat-icon>
 * 				</button>
 *
 * 				<!-- Menu Content -->
 * 				<mat-menu #menu="matMenu">
 * 					<button mat-menu-item>Button 1</button>
 * 					<button mat-menu-item>Button 2</button>
 * 				</mat-menu>
 * 			</div>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: [],
 * 	standalone: true,
 * 	imports: [
 * 		OpenViduComponentsModule,
 * 		MatIconButton,
 * 		MatMenuTrigger,
 * 		MatIcon,
 * 		MatMenu,
 * 		MatMenuItem,
 * 	],
 * })
 * export class AppComponent {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// Define the name of the room and initialize the token variable
 * 	roomName = 'participant-panel-item';
 * 	token!: string;
 *
 * 	constructor(private httpClient: HttpClient) {
 * 		this.configureUrls();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	// Function to request a token when a participant joins the room
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	// Function to get a token from the server
 * 	getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			// Send a POST request to the server to obtain a token
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			// Handle errors, e.g., if the server is not reachable
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message:
 * 						'Cannot connect with the backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovParticipantPanelItem-end-tutorial-->
 *
 * For a detailed tutorial on customizing participant panel items, please visit [this link](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-custom-participant-panel-item/).
 */
declare class ParticipantPanelItemDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantPanelItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ParticipantPanelItemDirective, "[ovParticipantPanelItem]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovParticipantPanelItemElements** directive allows you to incorporate additional elements into the {@link ParticipantPanelItemComponent}.
 * In the example below, we demonstrate how to add a simple button for disconnecting from the session.
 *
 * With the ***ovParticipantPanelItemElements** directive, you can access the participant object within its context using the `let` keyword and referencing the `participant` variable as follows: `*ovParticipantPanelItem="let participant"`.
 * This enables you to access the {@link ParticipantModel} object and activate the button exclusively for the local participant.
 *
 *
 * <!--ovParticipantPanelItemElements-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 *
 * import {
 * 	OpenViduService,
 * 	OpenViduComponentsModule,
 * } from 'openvidu-components-angular';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<!-- OpenVidu Video Conference Component -->
 * 		@if (connected) {
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			[toolbarDisplayRoomName]="false"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 		>
 * 			<!-- Participant Panel Item Elements -->
 * 			<div *ovParticipantPanelItemElements="let participant">
 * 				<!-- Leave Button for Local Participant -->
 * 				@if (participant.isLocal) {
 * 				<button (click)="leaveSession()">Leave</button>
 * 				}
 * 			</div>
 * 		</ov-videoconference>
 * 		}
 *
 * 		<!-- Session Disconnected Message -->
 * 		@if (!connected) {
 * 		<div style="text-align: center;">Session disconnected</div>
 * 		}
 * 	`,
 * 	styles: [],
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule],
 * })
 * export class AppComponent {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// Define the name of the room and initialize the token variable
 * 	roomName = 'participant-panel-item-elements';
 * 	token!: string;
 *
 * 	// Flag to indicate session connection status
 * 	connected = true;
 *
 * 	constructor(
 * 		private httpClient: HttpClient,
 * 		private openviduService: OpenViduService
 * 	) {
 * 		this.configureUrls();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	// Function to request a token when a participant joins the room
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	// Function to leave the session
 * 	async leaveSession() {
 * 		await this.openviduService.disconnectRoom();
 * 		this.connected = false;
 * 	}
 *
 * 	// Function to get a token from the server
 * 	getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			// Send a POST request to the server to obtain a token
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			// Handle errors, e.g., if the server is not reachable
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message:
 * 						'Cannot connect with the backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovParticipantPanelItemElements-end-tutorial-->
 *
 * For a comprehensive tutorial on adding elements to participant panel items, please visit [this link](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-custom-participant-panel-item-element/).
 */
declare class ParticipantPanelItemElementsDirective {
    template: TemplateRef<any>;
    viewContainer: ViewContainerRef;
    constructor(template: TemplateRef<any>, viewContainer: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantPanelItemElementsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ParticipantPanelItemElementsDirective, "[ovParticipantPanelItemElements]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovLayout** directive empowers you to replace the default room layout with a customized one.
 *
 * To ensure that the default {@link StreamComponent} functions correctly with participant tracks, you can access all local tracks using the [tracks](../classes/ParticipantModel.html#tracks) accessor.
 * Extracting streams from remote participants can be more complex, but openvidu-angular simplifies the process with the {@link RemoteParticipantTracksPipe}, which facilitates the extraction of each participant's stream.
 *
 * In the example below, take note of the HTML template's structure. The `*ngFor` statements employ the `| tracks` pipe to handle tracks effectively.
 *
 * <!--ovLayout-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component, OnDestroy, OnInit } from '@angular/core';
 * import { lastValueFrom, Subscription } from 'rxjs';
 * import {
 * 	ParticipantModel,
 * 	ParticipantService,
 * 	OpenViduComponentsModule,
 * } from 'openvidu-components-angular';
 * import { NgClass } from '@angular/common';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<!-- OpenVidu Video Conference Component -->
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 		>
 * 			<!-- Custom Layout for Video Streams -->
 * 			<div *ovLayout>
 * 				<div class="container">
 * 					<!-- Local Participant's Tracks -->
 * 					@for (track of localParticipant.tracks; track track) {
 * 					<div
 * 						class="item"
 * 						[ngClass]="{
 * 							hidden:
 * 								track.isAudioTrack && !track.participant.onlyHasAudioTracks
 * 						}"
 * 					>
 * 						<ov-stream [track]="track"></ov-stream>
 * 					</div>
 * 					}
 *
 * 					<!-- Remote Participants' Tracks -->
 * 					@for (track of remoteParticipants | tracks; track track) {
 * 					<div
 * 						class="item"
 * 						[ngClass]="{
 * 							hidden:
 * 								track.isAudioTrack && !track.participant.onlyHasAudioTracks
 * 						}"
 * 					>
 * 						<ov-stream [track]="track"></ov-stream>
 * 					</div>
 * 					}
 * 				</div>
 * 			</div>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: `
 * 		.container {
 * 			display: flex;
 * 			flex-wrap: wrap;
 * 			justify-content: space-between;
 * 		}
 * 		.item {
 * 			flex: 0 50%;
 * 			height: 250px;
 * 			margin-bottom: 2%;
 * 		}
 * 		.hidden {
 * 			display: none;
 * 		}
 * 	`,
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule, NgClass],
 * })
 * export class AppComponent implements OnInit, OnDestroy {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// Define the name of the room and initialize the token variable
 * 	roomName = 'custom-layout';
 * 	token!: string;
 *
 * 	// Participant-related properties
 * 	localParticipant!: ParticipantModel;
 * 	remoteParticipants!: ParticipantModel[];
 * 	localParticipantSubs!: Subscription;
 * 	remoteParticipantsSubs!: Subscription;
 *
 * 	constructor(
 * 		private httpClient: HttpClient,
 * 		private participantService: ParticipantService
 * 	) {
 * 		this.configureUrls();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	ngOnInit() {
 * 		// Subscribe to participants' updates
 * 		this.subscribeToParticipants();
 * 	}
 *
 * 	// Function to request a token when a participant joins the room
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	ngOnDestroy() {
 * 		// Unsubscribe from participant updates to prevent memory leaks
 * 		this.localParticipantSubs.unsubscribe();
 * 		this.remoteParticipantsSubs.unsubscribe();
 * 	}
 *
 * 	// Subscribe to updates for local and remote participants
 * 	subscribeToParticipants() {
 * 		this.localParticipantSubs =
 * 			this.participantService.localParticipant$.subscribe((p) => {
 * 				if (p) this.localParticipant = p;
 * 			});
 *
 * 		this.remoteParticipantsSubs =
 * 			this.participantService.remoteParticipants$.subscribe(
 * 				(participants) => {
 * 					this.remoteParticipants = participants;
 * 				}
 * 			);
 * 	}
 *
 * 	// Function to get a token from the server
 * 	getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			// Send a POST request to the server to obtain a token
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			// Handle errors, e.g., if the server is not reachable
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message:
 * 						'Cannot connect with the backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovLayout-end-tutorial-->
 *
 *
 * For a comprehensive guide on implementing custom layouts, please refer to the associated tutorial [here](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-custom-layout/).
 */
declare class LayoutDirective {
    template: TemplateRef<any>;
    container: ViewContainerRef;
    constructor(template: TemplateRef<any>, container: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LayoutDirective, "[ovLayout]", never, {}, {}, never, never, false, never>;
}
/**
 * The ***ovStream** directive empowers you to substitute the default {@link StreamComponent} template with a custom one.
 * In the example below, we demonstrate how to customize the position and styles of a participant's nickname by replacing the default stream component.
 *
 * With the **ovStream** directive, you can access the track object within its context using the `let` keyword and referencing the `track` variable as follows: `*ovStream="let track"`. This allows you to access the {@link ParticipantModel} object using `track.participant`.
 *
 * In the example provided below, we illustrate how to achieve this customization with just a few lines of code.
 *
 * <!--ovStream-start-tutorial-->
 * ```typescript
 * import { HttpClient } from '@angular/common/http';
 * import { Component } from '@angular/core';
 * import { lastValueFrom } from 'rxjs';
 *
 * import {
 * 	OpenViduComponentsModule,
 * 	ApiDirectiveModule,
 * 	OpenViduComponentsDirectiveModule,
 * } from 'openvidu-components-angular';
 *
 * @Component({
 * 	selector: 'app-root',
 * 	template: `
 * 		<!-- OpenVidu Video Conference Component -->
 * 		<ov-videoconference
 * 			[token]="token"
 * 			[livekitUrl]="LIVEKIT_URL"
 * 			(onTokenRequested)="onTokenRequested($event)"
 * 		>
 * 			<!-- Display Video Streams -->
 * 			<div *ovStream="let track">
 * 				<!-- Video Stream Component -->
 * 				<ov-stream [track]="track" [displayParticipantName]="false"></ov-stream>
 *
 * 				<!-- Display Participant's Name -->
 * 				<p>{{ track.participant.name }}</p>
 * 			</div>
 * 		</ov-videoconference>
 * 	`,
 * 	styles: `
 * 		p {
 * 			position: absolute;
 * 			bottom: 0;
 * 			border: 2px solid;
 * 			background: #000000;
 * 		}
 * 	`,
 * 	standalone: true,
 * 	imports: [OpenViduComponentsModule],
 * })
 * export class AppComponent {
 * 	// For local development, leave these variables empty
 * 	// For production, configure them with correct URLs depending on your deployment
 * 	APPLICATION_SERVER_URL = '';
 * 	LIVEKIT_URL = '';
 *
 * 	// Define the name of the room and initialize the token variable
 * 	roomName = 'custom-stream';
 * 	token!: string;
 *
 * 	constructor(private httpClient: HttpClient) {
 * 		this.configureUrls();
 * 	}
 *
 * 	private configureUrls() {
 * 		// If APPLICATION_SERVER_URL is not configured, use default value from local development
 * 		if (!this.APPLICATION_SERVER_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.APPLICATION_SERVER_URL = 'http://localhost:6080/';
 * 			} else {
 * 				this.APPLICATION_SERVER_URL =
 * 					'https://' + window.location.hostname + ':6443/';
 * 			}
 * 		}
 *
 * 		// If LIVEKIT_URL is not configured, use default value from local development
 * 		if (!this.LIVEKIT_URL) {
 * 			if (window.location.hostname === 'localhost') {
 * 				this.LIVEKIT_URL = 'ws://localhost:7880/';
 * 			} else {
 * 				this.LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
 * 			}
 * 		}
 * 	}
 *
 * 	// Function to request a token when a participant joins the room
 * 	async onTokenRequested(participantName: string) {
 * 		const { token } = await this.getToken(this.roomName, participantName);
 * 		this.token = token;
 * 	}
 *
 * 	// Function to get a token from the server
 * 	getToken(roomName: string, participantName: string): Promise<any> {
 * 		try {
 * 			// Send a POST request to the server to obtain a token
 * 			return lastValueFrom(
 * 				this.httpClient.post<any>(this.APPLICATION_SERVER_URL + 'token', {
 * 					roomName,
 * 					participantName,
 * 				})
 * 			);
 * 		} catch (error: any) {
 * 			// Handle errors, e.g., if the server is not reachable
 * 			if (error.status === 404) {
 * 				throw {
 * 					status: error.status,
 * 					message:
 * 						'Cannot connect with the backend. ' + error.url + ' not found',
 * 				};
 * 			}
 * 			throw error;
 * 		}
 * 	}
 * }
 *
 * ```
 * <!--ovStream-end-tutorial-->
 *
 * For a detailed tutorial on customizing the stream component, please visit [this link](https://openvidu.io/latest/docs/tutorials/angular-components/openvidu-custom-stream/).
 */
declare class StreamDirective {
    template: TemplateRef<any>;
    container: ViewContainerRef;
    constructor(template: TemplateRef<any>, container: ViewContainerRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<StreamDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StreamDirective, "[ovStream]", never, {}, {}, never, never, false, never>;
}

/**
 * @internal
 */
declare enum LayoutClass {
    ROOT_ELEMENT = "OV_root",
    BIG_ELEMENT = "OV_big",
    SMALL_ELEMENT = "OV_small",
    TOP_BAR_ELEMENT = "OV_top-bar",
    IGNORED_ELEMENT = "OV_ignored",
    MINIMIZED_ELEMENT = "OV_minimized",
    SIDENAV_CONTAINER = "sidenav-container",
    NO_SIZE_ELEMENT = "no-size",
    CLASS_NAME = "layout"
}
/**
 * @internal
 */
declare enum SidenavMode {
    OVER = "over",
    SIDE = "side"
}
/**
 * @internal
 */
declare enum LayoutAlignment {
    START = "start",
    CENTER = "center",
    END = "end"
}
/**
 * Layout position options for big elements
 */
type BigFirstOption = boolean | 'column' | 'row';
/**
 * Element dimensions interface
 */
interface ElementDimensions {
    height: number;
    width: number;
    big?: boolean;
    small?: boolean;
    topBar?: boolean;
}
/**
 * Layout area definition
 */
interface LayoutArea {
    top: number;
    left: number;
    width: number;
    height: number;
}
/**
 * Layout box positioning
 */
interface LayoutBox extends LayoutArea {
}
/**
 * Row structure for layout calculations
 */
interface LayoutRow {
    ratios: number[];
    width: number;
    height: number;
}
/**
 * Best dimensions calculation result
 */
interface BestDimensions {
    maxArea: number;
    targetCols: number;
    targetRows: number;
    targetHeight: number;
    targetWidth: number;
    ratio: number;
}
/**
 * Extended layout options with container dimensions
 */
interface ExtendedLayoutOptions extends OpenViduLayoutOptions {
    containerWidth: number;
    containerHeight: number;
}
/**
 * Layout configuration constants
 */
declare const LAYOUT_CONSTANTS: {
    readonly DEFAULT_VIDEO_WIDTH: 640;
    readonly DEFAULT_VIDEO_HEIGHT: 480;
    readonly DEFAULT_MAX_RATIO: number;
    readonly DEFAULT_MIN_RATIO: number;
    readonly DEFAULT_BIG_PERCENTAGE: 0.8;
    readonly UPDATE_TIMEOUT: 50;
    readonly ANIMATION_DURATION: "0.1s";
    readonly ANIMATION_EASING: "linear";
};
/**
 * @internal
 */
interface OpenViduLayoutOptions {
    /** The narrowest ratio that will be used (2x3 by default) */
    maxRatio: number;
    /** The widest ratio that will be used (16x9 by default) */
    minRatio: number;
    /** If true, aspect ratio is maintained and minRatio/maxRatio are ignored */
    fixedRatio: boolean;
    /** Whether to animate transitions */
    animate: boolean;
    /** Class for elements that should be sized bigger */
    bigClass: string;
    /** Class for elements that should be sized smaller */
    smallClass: string;
    /** Class for elements that should be ignored */
    ignoredClass: string;
    /** Maximum percentage of space big elements should take up */
    bigPercentage: number;
    /** Minimum percentage for big space to scale down whitespace */
    minBigPercentage: number;
    /** Fixed ratio for big elements */
    bigFixedRatio: boolean;
    /** Narrowest ratio for big elements */
    bigMaxRatio: number;
    /** Widest ratio for big elements */
    bigMinRatio: number;
    /** Position preference for big elements */
    bigFirst: BigFirstOption;
    /** Alignment for all elements */
    alignItems: LayoutAlignment;
    /** Alignment for big elements */
    bigAlignItems: LayoutAlignment;
    /** Alignment for small elements */
    smallAlignItems: LayoutAlignment;
    /** Maximum width of elements */
    maxWidth: number;
    /** Maximum height of elements */
    maxHeight: number;
    /** Maximum width for small elements */
    smallMaxWidth: number;
    /** Maximum height for small elements */
    smallMaxHeight: number;
    /** Maximum width for big elements */
    bigMaxWidth: number;
    /** Maximum height for big elements */
    bigMaxHeight: number;
    /** Scale up elements in last row if fewer elements */
    scaleLastRow: boolean;
    /** Scale up big elements in last row */
    bigScaleLastRow: boolean;
}

/**
 * OpenViduLayout orchestrates layout calculation and rendering.
 * Maintains backward compatibility with existing API while delegating to specialized classes.
 *
 * @internal
 */
declare class OpenViduLayout {
    private layoutContainer;
    private opts;
    private dimensionsCache;
    private calculator;
    private renderer;
    constructor();
    /**
     * Update the layout container
     * module export layout
     */
    updateLayout(container: HTMLElement, opts: OpenViduLayoutOptions): void;
    /**
     * Initialize the layout inside of the container with the options required
     * @param container
     * @param opts
     */
    initLayoutContainer(container: HTMLElement, opts: OpenViduLayoutOptions): void;
    getLayoutContainer(): HTMLElement;
    /**
     * Clear dimensions cache to free memory
     */
    clearCache(): void;
    private getCssProperty;
    private height;
    private width;
    /**
     * @hidden
     */
    private getChildDims;
    /**
     * @hidden
     */
    private getCSSNumber;
    /**
     * @hidden
     */
    private cheapUUID;
    /**
     * @hidden
     */
    private getHeight;
    /**
     * @hidden
     */
    private getWidth;
    /**
     * @hidden
     */
    private filterDisplayNone;
}

/**
 * Service to detect platform, device type, and browser features.
 * @internal
 */
declare class PlatformService {
    private readonly userAgent;
    constructor();
    /**
     * Returns true if the device is mobile (iOS or Android)
     */
    isMobile(): boolean;
    /**
     * Returns true if the device is physically a mobile device (iPhone, Android phone)
     * This method is orientation-independent and hardware-based
     */
    isPhysicalMobile(): boolean;
    /**
     * Returns true if the device is physically a tablet (iPad, Android tablet)
     */
    isPhysicalTablet(): boolean;
    /**
     * Detect Android phone specifically (not tablet)
     */
    isAndroidPhone(): boolean;
    /**
     * Detect Android tablet specifically
     */
    isAndroidTablet(): boolean;
    /**
     * Detect Android Mobile (legacy method for compatibility)
     */
    isAndroid(): boolean;
    /**
     * Detect iPhone specifically
     */
    isIPhone(): boolean;
    /**
     * Detect iPad specifically
     */
    isIPad(): boolean;
    /**
     * Detect iOS device (iPhone or iPad)
     */
    isIos(): boolean;
    /**
     * Detect if the device supports touch interactions
     */
    isTouchDevice(): boolean;
    /**
     * Get the maximum screen dimension (useful for detecting device capabilities)
     */
    getMaxScreenDimension(): number;
    /**
     * Get the minimum screen dimension
     */
    getMinScreenDimension(): number;
    /**
     * Enhanced mobile detection that considers physical device characteristics
     * This is orientation-independent and more reliable for landscape warnings
     */
    isPhysicalMobileDevice(): boolean;
    isFirefox(): boolean;
    isSafariIos(): boolean;
    private isIOSWithSafari;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformService>;
}

/**
 * Viewport size categories based on design system breakpoints
 * @internal
 */
type ViewportSize = 'mobile' | 'tablet' | 'desktop' | 'wide';
/**
 * Device orientation type
 * @internal
 */
type DeviceOrientation = 'portrait' | 'landscape';
/**
 * Viewport information interface
 * @internal
 */
interface ViewportInfo {
    width: number;
    height: number;
    size: ViewportSize;
    orientation: DeviceOrientation;
    isMobile: boolean;
    isTablet: boolean;
    isDesktop: boolean;
    isWide: boolean;
    isTouchDevice: boolean;
    isPhysicalMobile: boolean;
    isPhysicalTablet: boolean;
    shouldShowLandscapeWarning: boolean;
}

/**
 * Service for responsive viewport detection and device type identification.
 * Provides reactive signals and utilities for building responsive interfaces.
 * @internal
 */
declare class ViewportService implements OnDestroy {
    protected platform: PlatformService;
    private readonly BREAKPOINTS;
    private readonly _width;
    private readonly _height;
    private readonly destroy$;
    constructor(platform: PlatformService);
    /**
     * Current viewport width
     */
    readonly width: i0.Signal<number>;
    /**
     * Current viewport height
     */
    readonly height: i0.Signal<number>;
    /**
     * Whether device supports touch interactions
     */
    readonly isTouchDevice: i0.Signal<boolean>;
    /**
     * Whether device is physically a mobile device (orientation-independent)
     * This uses hardware detection, not just screen size
     */
    readonly isPhysicalMobile: i0.Signal<boolean>;
    /**
     * Whether device is physically a tablet (orientation-independent)
     */
    readonly isPhysicalTablet: i0.Signal<boolean>;
    /**
     * Current viewport size category
     */
    readonly viewportSize: i0.Signal<ViewportSize>;
    /**
     * Device orientation (computed)
     */
    readonly orientation: i0.Signal<DeviceOrientation>;
    /**
     * Whether current viewport is mobile size (legacy method)
     * For landscape warnings, use isPhysicalMobile instead
     */
    readonly isMobile: i0.Signal<boolean>;
    /**
     * Whether current viewport is tablet size
     */
    readonly isTablet: i0.Signal<boolean>;
    /**
     * Whether device should show mobile landscape warning
     * This is orientation-independent and hardware-based detection
     */
    readonly shouldShowLandscapeWarning: i0.Signal<boolean>;
    /**
     * Whether current viewport is desktop size
     */
    readonly isDesktop: i0.Signal<boolean>;
    /**
     * Whether current viewport is wide desktop size
     */
    readonly isWide: i0.Signal<boolean>;
    /**
     * Whether current viewport is mobile or smaller
     */
    readonly isMobileView: i0.Signal<boolean>;
    /**
     * Whether current viewport is tablet or smaller
     */
    readonly isTabletDown: i0.Signal<boolean>;
    /**
     * Whether current viewport is tablet or larger
     */
    readonly isTabletUp: i0.Signal<boolean>;
    /**
     * Whether current viewport is desktop or larger
     */
    readonly isDesktopUp: i0.Signal<boolean>;
    /**
     * Complete viewport information
     */
    readonly viewportInfo: i0.Signal<ViewportInfo>;
    /**
     * Check if viewport matches specific size
     */
    matchesSize(size: ViewportSize): boolean;
    /**
     * Check if viewport is smaller than specified size
     */
    isSmallerThan(size: ViewportSize): boolean;
    /**
     * Check if viewport is larger than specified size
     */
    isLargerThan(size: ViewportSize): boolean;
    /**
     * Get responsive grid columns based on viewport and content count
     */
    getGridColumns(itemCount?: number): string;
    /**
     * Get appropriate icon size for current viewport
     */
    getIconSize(): 'small' | 'medium' | 'large';
    /**
     * Get appropriate spacing size for current viewport
     */
    getSpacing(): 'compact' | 'comfortable' | 'spacious';
    /**
     * Check if device is in landscape mode (mobile context)
     */
    isLandscape(): boolean;
    /**
     * Check if device is in portrait mode
     */
    isPortrait(): boolean;
    /**
     * Get breakpoint value for specified size
     */
    getBreakpoint(size: keyof typeof this.BREAKPOINTS): number;
    private getCurrentWidth;
    private getCurrentHeight;
    private detectTouchDevice;
    private initializeResizeListener;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ViewportService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ViewportService>;
}

/**
 * @internal
 */
declare class LayoutService {
    protected loggerSrv: LoggerService;
    protected viewportSrv: ViewportService;
    layoutContainer: HTMLElement | undefined;
    layoutWidthObs: Observable<number>;
    captionsTogglingObs: Observable<boolean>;
    protected layoutWidth: BehaviorSubject<number>;
    protected openviduLayout: OpenViduLayout | undefined;
    protected openviduLayoutOptions: OpenViduLayoutOptions;
    protected captionsToggling: BehaviorSubject<boolean>;
    protected log: ILogger;
    constructor(loggerSrv: LoggerService, viewportSrv: ViewportService);
    initialize(container: HTMLElement): void;
    toggleCaptions(): void;
    update(timeout?: number | undefined): void;
    updateResponsive(): void;
    getLayout(): OpenViduLayout;
    clear(): void;
    /**
     * Get layout options adjusted to the current viewport
     * @returns Layout options adjusted to the current viewport
     */
    protected getOptions(): OpenViduLayoutOptions;
    protected getResponsiveRatios(): {
        maxRatio: number;
        minRatio: number;
        bigMaxRatio: number;
        bigMinRatio: number;
    };
    protected getResponsivePercentages(): {
        bigPercentage: number;
        minBigPercentage: number;
    };
    protected setupViewportListener(): void;
    protected updateLayoutOptions(): void;
    protected hasSignificantChanges(oldOptions: OpenViduLayoutOptions, newOptions: OpenViduLayoutOptions): boolean;
    protected sendLayoutWidthEvent(): void;
    protected getHTMLElementByClassName(element: HTMLElement | null, className: string): HTMLElement | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
}

/**
 * Interface representing the different types of panels
 */
declare enum PanelType {
    CHAT = "chat",
    PARTICIPANTS = "participants",
    BACKGROUND_EFFECTS = "background-effects",
    ACTIVITIES = "activities",
    SETTINGS = "settings"
}
/**
 * Interface representing a panel event
 */
interface PanelStatusInfo {
    /**
     * Indicates whether the panel is currently opened.
     */
    isOpened: boolean;
    /**
     * The type of the panel. For example: 'chat', 'participants', 'settings', 'activities', etc.
     */
    panelType?: PanelType | string;
    /**
     * Additional information for the 'activities' and 'settings' panel, specifying the sub-option to be displayed.
     */
    subOptionType?: string;
    /**
     * The previous type of the panel before any changes.
     */
    previousPanelType?: PanelType | string;
}
/**
 * @internal
 */
declare enum PanelSettingsOptions {
    GENERAL = "general",
    AUDIO = "audio",
    VIDEO = "video",
    CAPTIONS = "captions"
}
/**
 * Interface representing a panel status event emmited by the library to the final app
 */
interface PanelStatusEvent {
    isOpened: boolean;
}
interface ChatPanelStatusEvent extends PanelStatusEvent {
}
interface ParticipantsPanelStatusEvent extends PanelStatusEvent {
}
interface ActivitiesPanelStatusEvent extends PanelStatusEvent {
}
interface SettingsPanelStatusEvent extends PanelStatusEvent {
}

declare class PanelService {
    private loggerSrv;
    /**
     * Panel Observable which pushes the panel status in every update.
     */
    panelStatusObs: Observable<PanelStatusInfo>;
    private log;
    private isExternalOpened;
    private externalType;
    private _panelOpened;
    private panelTypes;
    /**
     * @internal
     */
    constructor(loggerSrv: LoggerService);
    /**
     * @internal
     */
    clear(): void;
    /**
     * Open or close the panel type received. Calling this method with the panel opened and the same type panel, will close the panel.
     * If the type is differente, it will switch to the properly panel.
     */
    togglePanel(panelType: PanelType | string, subOptionType?: PanelSettingsOptions | string): void;
    /**
     * @internal
     */
    isPanelOpened(): boolean;
    /**
     * Closes the panel if it is opened.
     */
    closePanel(): void;
    /**
     * Whether the chat panel is opened or not.
     */
    isChatPanelOpened(): boolean;
    /**
     * Whether the participants panel is opened or not.
     */
    isParticipantsPanelOpened(): boolean;
    /**
     * Whether the activities panel is opened or not.
     */
    isActivitiesPanelOpened(): boolean;
    /**
     * Whether the settings panel is opened or not.
     */
    isSettingsPanelOpened(): boolean;
    /**
     * Whether the background effects panel is opened or not.
     */
    isBackgroundEffectsPanelOpened(): boolean;
    /**
     * Returns whether the external panel (a panel adding by the final user) is opened or not.
     */
    isExternalPanelOpened(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PanelService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PanelService>;
}

/**
 * Independent E2EE Service for encrypting and decrypting text-based content
 * (chat messages, participant names, metadata, etc.)
 *
 * This service uses LiveKit's key derivation utilities combined with Web Crypto API:
 * - Uses createKeyMaterialFromString from livekit-client for key material generation (PBKDF2)
 * - Uses deriveKeys from livekit-client for key derivation (HKDF)
 * - Uses Web Crypto API (AES-GCM) for actual encryption/decryption
 * - Generates random IV for each encryption operation
 * @internal
 */
declare class E2eeService {
    protected configService: OpenViduComponentsConfigService;
    private static readonly ENCRYPTION_ALGORITHM;
    private static readonly IV_LENGTH;
    private static readonly SALT;
    private decryptionCache;
    private destroy$;
    private isE2EEEnabled;
    private encryptionKey;
    constructor(configService: OpenViduComponentsConfigService);
    setE2EEKey(key: string | null): Promise<void>;
    /**
     * Derives encryption key from passphrase using LiveKit's key derivation utilities
     * @param passphrase The E2EE passphrase
     * @private
     */
    private deriveEncryptionKey;
    /**
     * Checks if E2EE is currently enabled and encryption key is ready
     */
    get isEnabled(): boolean;
    /**
     * Generates a random initialization vector for encryption
     * @private
     */
    private static generateIV;
    /**
     * Encrypts text content using Web Crypto API with LiveKit-derived keys.
     * Returns base64-encoded string suitable for metadata/names.
     *
     * @param text Plain text to encrypt
     * @returns Encrypted text in base64 format, or original text if E2EE is disabled
     */
    encrypt(text: string): Promise<string>;
    /**
     * Encrypts binary data using Web Crypto API with LiveKit-derived keys.
     * Returns Uint8Array suitable for data channels.
     *
     * @param data Plain data to encrypt
     * @returns Encrypted data as Uint8Array, or original data if E2EE is disabled
     */
    encrypt(data: Uint8Array): Promise<Uint8Array>;
    /**
     * Decrypts text content from base64 format using Web Crypto API.
     * Suitable for decrypting participant names, metadata, etc.
     *
     * @param encryptedText Encrypted text in base64 format
     * @param participantIdentity Identity of the participant who encrypted the content (optional, used for caching)
     * @returns Decrypted plain text, or throws error if decryption fails
     */
    decrypt(encryptedText: string, participantIdentity?: string): Promise<string>;
    /**
     * Decrypts binary data from Uint8Array using Web Crypto API.
     * Suitable for decrypting data channel messages.
     *
     * If E2EE is not enabled, returns the original encryptedData.
     *
     * @param encryptedData Encrypted data as Uint8Array (format: [iv][payload])
     * @param participantIdentity Identity of the participant who encrypted the content (optional)
     * @returns Decrypted data as Uint8Array
     */
    decrypt(encryptedData: Uint8Array, participantIdentity?: string): Promise<Uint8Array>;
    /**
     * Attempts to decrypt text content. If decryption fails or E2EE is not enabled,
     * returns a masked string to indicate unavailable content.
     *
     * @param encryptedText Encrypted text in base64 format
     * @param participantIdentity Identity of the participant (optional, used for caching)
     * @param maskText Custom mask text to show on failure (default: '******')
     * @returns Decrypted text or masked value if decryption fails
     */
    decryptOrMask(encryptedText: string, participantIdentity?: string, maskText?: string): Promise<string>;
    /**
     * Attempts to decrypt binary data. If decryption fails or E2EE is not enabled,
     * returns the maskText encoded as Uint8Array to indicate unavailable content.
     *
     * @param encryptedData Encrypted data as Uint8Array
     * @param participantIdentity Identity of the participant (optional)
     * @param maskText Custom mask text to show on failure (default: '******')
     * @returns Decrypted data or encoded maskText as Uint8Array if decryption fails
     */
    decryptOrMask(encryptedData: Uint8Array, participantIdentity?: string, maskText?: string): Promise<Uint8Array>;
    /**
     * Clears the decryption cache.
     * Should be called when E2EE key changes or when leaving a room.
     */
    clearCache(): void;
    /**
     * Cleanup on service destroy
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<E2eeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<E2eeService>;
}

/**
 * Device service with improved performance and independent audio/video handling.
 *
 * Key improvements:
 * - Smart permission requests (single prompt when possible, fallback to separate)
 * - Angular Signals for reactive state management (cameras, microphones as signals)
 * - Live device detection - automatically updates when devices are connected/disconnected
 * - Better error handling with specific error types per device
 * - Performance optimizations with caching
 * - LiveKit client integration for modern track management
 *
 * @internal
 */
declare class DeviceService implements OnDestroy {
    private loggerSrv;
    private platformSrv;
    private storageSrv;
    readonly cameras: i0.WritableSignal<CustomDevice[]>;
    readonly microphones: i0.WritableSignal<CustomDevice[]>;
    readonly cameraSelected: i0.WritableSignal<CustomDevice>;
    readonly microphoneSelected: i0.WritableSignal<CustomDevice>;
    private readonly videoState;
    private readonly audioState;
    readonly hasVideoDevices: i0.Signal<boolean>;
    readonly hasAudioDevices: i0.Signal<boolean>;
    readonly hasVideoPermission: i0.Signal<boolean>;
    readonly hasAudioPermission: i0.Signal<boolean>;
    readonly allPermissionsGranted: i0.Signal<boolean>;
    private readonly CACHE_DURATION;
    private devicesCache;
    private log;
    private initializationPromise;
    private deviceChangeHandler;
    constructor(loggerSrv: LoggerService, platformSrv: PlatformService, storageSrv: StorageService);
    /**
     * Cleanup when service is destroyed
     */
    ngOnDestroy(): void;
    /**
     * Initialize media devices with parallel audio/video handling
     * Returns a promise that resolves when initialization is complete
     */
    initializeDevices(): Promise<void>;
    private performInitialization;
    /**
     * Optimized device retrieval with independent audio/video handling
     * This solves the critical bug where audio device failure affects video device detection
     */
    private getLocalDevicesOptimized;
    /**
     * Smart permission request strategy:
     * 1. Try both together (single prompt - better UX)
     * 2. If fails, try individually (fallback for granular permissions)
     *
     * This minimizes user friction while maintaining independence
     */
    private requestPermissionsParallel;
    /**
     * Request video permission independently
     */
    private requestVideoPermission;
    /**
     * Request audio permission independently
     */
    private requestAudioPermission;
    /**
     * Enumerate devices using LiveKit's Room API or browser API
     */
    private enumerateDevices;
    /**
     * Firefox-specific device enumeration
     */
    private getDevicesFirefox;
    /**
     * Filter out invalid or default devices
     */
    private filterValidDevices;
    /**
     * Fallback device enumeration without permissions
     */
    private fallbackDeviceEnumeration;
    /**
     * Update device states based on permission results
     */
    private updateDeviceStates;
    /**
     * Process raw devices into typed camera and microphone lists
     */
    private processDevices;
    /**
     * Detect camera types (front/back) based on platform and labels
     */
    private detectCameraTypes;
    /**
     * Update device availability states
     */
    private updateDeviceAvailability;
    /**
     * Create custom device object
     */
    private createCustomDevice;
    /**
     * Update selected devices from storage or use defaults
     */
    private updateSelectedDevices;
    /**
     * Find device by ID or return first available
     */
    private findDeviceOrDefault;
    /**
     * Refresh devices (e.g., when a device is plugged/unplugged)
     */
    refreshDevices(): Promise<void>;
    /**
     * Setup live device change detection
     * Automatically refreshes device list when devices are connected/disconnected
     */
    private setupDeviceChangeDetection;
    /**
     * Check if camera is enabled based on storage and device availability
     */
    isCameraEnabled(): boolean;
    /**
     * Check if microphone is enabled based on storage and device availability
     */
    isMicrophoneEnabled(): boolean;
    /**
     * Get currently selected camera
     */
    getCameraSelected(): CustomDevice | undefined;
    /**
     * Get currently selected microphone
     */
    getMicrophoneSelected(): CustomDevice | undefined;
    /**
     * Set selected camera and persist to storage
     */
    setCameraSelected(deviceId: string): void;
    /**
     * Set selected microphone and persist to storage
     */
    setMicSelected(deviceId: string): void;
    /**
     * Check if video track needs to be updated
     */
    needUpdateVideoTrack(newDevice: CustomDevice): boolean;
    /**
     * Check if audio track needs to be updated
     */
    needUpdateAudioTrack(newDevice: CustomDevice): boolean;
    /**
     * Get list of available cameras
     */
    getCameras(): CustomDevice[];
    /**
     * Get list of available microphones
     */
    getMicrophones(): CustomDevice[];
    /**
     * Check if video devices are available
     */
    hasVideoDeviceAvailable(): boolean;
    /**
     * Check if audio devices are available
     */
    hasAudioDeviceAvailable(): boolean;
    /**
     * Check if video permission was granted
     */
    hasVideoPermissionGranted(): boolean;
    /**
     * Check if audio permission was granted
     */
    hasAudioPermissionGranted(): boolean;
    /**
     * Clear all device data
     */
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceService>;
}

declare class OpenViduService {
    private loggerSrv;
    private deviceService;
    private storageService;
    private configService;
    private room;
    private keyProvider;
    /**
     * @internal
     * Indicates whether the client initiated disconnect event should be handled.
     * This is used to determine if the disconnect event should be emitted when the 'Disconnect' event is triggered
     */
    shouldHandleClientInitiatedDisconnectEvent: boolean;
    private localTracks;
    private livekitToken;
    private livekitUrl;
    private log;
    /**
     * Background processor for video tracks. Initialized in disabled mode.
     * This processor is shared between prejoin and in-room states.
     * Only initialized if browser supports background processing (GPU available).
     */
    private backgroundProcessor?;
    /**
     * Signal to track if background processor is supported (requires GPU).
     * Set to false if browser doesn't support it or processor initialization fails.
     */
    private _isBackgroundProcessorSupported;
    /**
     * Public readonly signal for background processor support status.
     */
    readonly isBackgroundProcessorSupported: Signal<boolean>;
    /**
     * Stores the last applied background options so they can be re-applied after a camera switch.
     */
    private currentBackgroundOptions;
    /**
     * @internal
     */
    constructor(loggerSrv: LoggerService, deviceService: DeviceService, storageService: StorageService, configService: OpenViduComponentsConfigService);
    /**
     * Creates a new Room with audio and video devices selected or default ones.
     * @internal
     */
    initRoom(): void;
    private buildE2EEOptions;
    /**
     * Connects local participant to the room
     */
    connectRoom(): Promise<void>;
    /**
     * Disconnects from the current room.
     *
     * This method will check if there's an active connection to a room before attempting to disconnect.
     * If the room is connected, it will perform the disconnection and call the optional callback function.
     *
     * @param callback - Optional function to be executed after a successful disconnection
     * @returns A Promise that resolves once the disconnection is complete
     */
    disconnectRoom(callback?: () => void, shouldHandleClientInitiatedDisconnectEvent?: boolean): Promise<void>;
    /**
     * @returns Room instance
     */
    getRoom(): Room;
    /**
     * Checks if room is initialized without throwing an error
     * @returns true if room is initialized, false otherwise
     */
    isRoomInitialized(): boolean;
    /**
     * Returns the room name
     */
    getRoomName(): string;
    /**
     * Returns if local participant is connected to the room
     * @returns
     */
    isRoomConnected(): boolean;
    hasRoomTracksPublished(): boolean;
    /**
     * @internal
     */
    initializeAndSetToken(token: string, livekitUrl?: string): void;
    /**
     * Sets the local tracks for the OpenVidu service.
     *
     * @param tracks - An array of LocalTrack objects representing the local tracks to be set.
     * @returns void
     * @internal
     */
    setLocalTracks(tracks: LocalTrack[]): void;
    /**
     * @internal
     * @returns
     */
    getLocalTracks(): LocalTrack[];
    /**
     * Switches the background mode on the local video track.
     * Works both in prejoin and in-room states.
     * For Firefox: applies processor when effect is activated to avoid performance issues
     * For other browsers: processor is pre-attached, so just switch mode
     * @param options - The switch options (mode, blurRadius, imagePath)
     * @returns Promise<void>
     * @internal
     */
    switchBackgroundMode(options: SwitchBackgroundProcessorOptions): Promise<void>;
    /**
     * Handles lazy processor attachment for browsers without modern processor support.
     * Creates and attaches processor on-demand when effect is activated.
     * This is used for browsers like Firefox that don't support modern background processors.
     * @internal
     */
    private handleLazyProcessorAttachment;
    /**
     * @internal
     **/
    removeLocalTracks(): void;
    /**
     * Creates local tracks for video and audio devices.
     *
     * @param videoDeviceId - The ID of the video device to use. If not provided, the default video device will be used.
     * @param audioDeviceId - The ID of the audio device to use. If not provided, the default audio device will be used.
     * @param allowPartialCreation - If true, allows creating tracks even if some devices fail
     * @returns A promise that resolves to an array of LocalTrack objects representing the created tracks.
     * @internal
     */
    createLocalTracks(videoDeviceId?: string | boolean | undefined, audioDeviceId?: string | boolean | undefined, allowPartialCreation?: boolean): Promise<LocalTrack[]>;
    /**
     * Creates tracks with fallback strategy to handle device conflicts
     * @param options - The track creation options
     * @returns Array of successfully created tracks
     * @internal
     */
    private createTracksWithFallback;
    private toDeviceConstraint;
    /**
     * @internal
     * As the Room is not created yet, we need to handle the media tracks with a temporary array of tracks.
     * This method must be only called from the prejoin component.
     **/
    setVideoTrackEnabled(enabled: boolean): Promise<void>;
    /**
     * @internal
     * As the Room is not created yet, we need to handle the media tracks with a temporary array of tracks.
     * This method must be only called from the prejoin component.
     **/
    setAudioTrackEnabled(enabled: boolean): Promise<void>;
    /**
     * @internal
     * As the Room is not created yet, we need to handle the media tracks with a temporary array of tracks.
     * This method must be only called before connect to room.
     **/
    isVideoTrackEnabled(): boolean;
    /**
     * @internal
     * As the Room is not created yet, we need to handle the media tracks with a temporary array of tracks.
     * This method must be only called before connect to room.
     **/
    isAudioTrackEnabled(): boolean;
    /**
     * Switches the camera device in prejoin (room not yet connected).
     *
     * Uses `LocalVideoTrack.restartTrack({ deviceId })` on the existing track when available.
     * This is the correct LiveKit pattern: `restartTrack` internally calls `setMediaStreamTrack`,
     * which automatically calls `processor.restart(newTrack)` if a background processor is
     * attached — preserving any active virtual-background effect without extra work.
     *
     * Falls back to creating a new track (with processor reattachment) when no track exists.
     * @param deviceId - The new video device ID
     * @internal
     */
    switchCamera(deviceId: string): Promise<void>;
    /**
     * Attaches the background processor to a freshly-created video track.
     * Called only for brand-new track objects (createLocalTracks or the no-existing-track fallback).
     *
     * - Modern browsers: pre-attaches the shared processor object; `processor.init()` uses the
     *   transformer's stored options so any previously active mode is automatically restored.
     * - Firefox (non-modern / stream fallback): lazily attaches the processor only when a
     *   background effect was already active, then re-applies the stored options.
     * @internal
     */
    private applyProcessorToVideoTrack;
    /**
     * Switches the microphone device in prejoin (room not yet connected).
     *
     * Uses `LocalAudioTrack.restartTrack({ deviceId })` on the existing track when available,
     * preserving echo-cancellation, noise-suppression and auto-gain-control constraints.
     * Falls back to creating a new audio track when none exists.
     * @param deviceId - The new audio device ID
     * @internal
     */
    switchMicrophone(deviceId: string): Promise<void>;
    /**
     * Gets the current video track from local tracks or room
     * @returns LocalVideoTrack or undefined
     * @internal
     */
    private getVideoTrack;
    /**
     * Extracts Livekit data from the provided token and returns an object containing the Livekit URL and room admin status.
     * @param token - The token to extract Livekit data from.
     * @param livekitUrl - The default Livekit URL to use if no Livekit URL is found in the token metadata.
     * @returns An object containing the Livekit URL and room admin status.
     * @throws Error if there is an error decoding and parsing the token.
     * @internal
     */
    private extractLivekitData;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenViduService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OpenViduService>;
}

declare class ParticipantService {
    private globalService;
    private directiveService;
    private openviduService;
    private storageSrv;
    private loggerSrv;
    private e2eeService;
    /**
     * Local participant Observable which pushes the local participant object in every update.
     * @deprecated Please prefer `localParticipantSignal` for reactive updates and `localParticipant$` when using RxJS.
     */
    localParticipant$: Observable<ParticipantModel | undefined>;
    /**
     * Remote participants Observable which pushes the remote participants array in every update.
     * @deprecated Please prefer `remoteParticipantsSignal` for reactive updates and `remoteParticipants$` when using RxJS.
     */
    remoteParticipants$: Observable<ParticipantModel[]>;
    /**
     * Local participant Signal for reactive programming with Angular signals.
     * This is a modern alternative to localParticipant$ Observable.
     * @since Angular 16+
     */
    localParticipantSignal: Signal<ParticipantModel | undefined>;
    private localParticipantWritableSignal;
    /**
     * Remote participants Signal for reactive programming with Angular signals.
     * This is a modern alternative to remoteParticipants$ Observable.
     * @since Angular 16+
     */
    remoteParticipantsSignal: Signal<ParticipantModel[]>;
    private remoteParticipantsWritableSignal;
    private localParticipant;
    private lastLocalParticipantSnapshot;
    private remoteParticipants;
    private log;
    /**
     * @internal
     */
    constructor(globalService: GlobalConfigService, directiveService: OpenViduComponentsConfigService, openviduService: OpenViduService, storageSrv: StorageService, loggerSrv: LoggerService, e2eeService: E2eeService);
    /**
     * @internal
     */
    clear(): void;
    /**
     * @internal
     * Setting up the local participant object.
     * @param participant
     */
    setLocalParticipant(participant: LocalParticipant): void;
    /**
     * Returns the local participant object.
     *
     * @deprecated Please prefer `localParticipantSignal()` for reactive updates and `localParticipant$` when using RxJS.
     */
    getLocalParticipant(): ParticipantModel | undefined;
    /**
     * Connects to the room and publishes the local tracks.
     * @internal
     */
    connect(): Promise<void>;
    /**
     * Publishes a new data payload to the room. Data will be forwarded to each participant in the room if the destination field in publishOptions is empty.
     * @param data
     * @param {DataPublishOptions} publishOptions [DataPublishOptions](https://docs.livekit.io/client-sdk-js/types/DataPublishOptions.html)
     */
    publishData(data: Uint8Array, publishOptions: DataPublishOptions): Promise<void>;
    /**
     * Switches the active camera track used in this room to the given device id.
     * @param deviceId
     */
    switchCamera(deviceId: string): Promise<void>;
    /**
     * Switches the active microphone track used in this room to the given device id.
     * @param deviceId
     */
    switchMicrophone(deviceId: string): Promise<void>;
    /**
     * Switches the active screen share track showing a native browser dialog to select a screen or window.
     */
    switchScreenShare(): Promise<void>;
    /**
     * Sets the local participant camera enabled or disabled.
     * @param enabled
     */
    setCameraEnabled(enabled: boolean): Promise<void>;
    /**
     * Sets the local participant microphone enabled or disabled.
     * @param enabled
     */
    setMicrophoneEnabled(enabled: boolean): Promise<void>;
    /**
     * Share or unshare the local participant screen.
     * @param enabled: true to share the screen, false to unshare it
     *
     */
    setScreenShareEnabled(enabled: boolean): Promise<void>;
    /**
     * @internal
     * As updating name requires that the participant has the `canUpdateOwnMetadata` to true in server side, which is a little bit insecure,
     * we decided to not allow this feature for now.
     */
    /**
     * Sets as speaking to all participants given in the array.
     * @param speakers
     * @internal
     */
    setSpeaking(speakers: Participant[]): void;
    /**
     * Sets the encryption error state for a participant.
     * This is called when a participant cannot decrypt video streams due to an incorrect encryption key.
     * @param participantSid - The SID of the participant with the encryption error
     * @param hasError - Whether the participant has an encryption error
     * @internal
     */
    setEncryptionError(participantSid: string, hasError: boolean): void;
    /**
     * Returns the local participant name.
     */
    getMyName(): string | undefined;
    /**
     * @internal
     */
    toggleMyVideoPinned(sid: string | undefined): void;
    /**
     * @internal
     */
    toggleMyVideoMinimized(sid: string | undefined): void;
    /**
     * @internal
     */
    resetMyStreamsToNormalSize(): void;
    /**
     * Returns if the local participant camera is enabled.
     */
    isMyCameraEnabled(): boolean;
    /**
     * Returns if the local participant microphone is enabled.
     */
    isMyMicrophoneEnabled(): boolean;
    /**
     * Returns if the local participant screen is enabled.
     */
    isMyScreenShareEnabled(): boolean;
    /**
     * Forces to update the local participant object and fire a new `localParticipant$` Observable event.
     */
    updateLocalParticipant(): void;
    private hasParticipantSnapshotMutations;
    private cloneParticipant;
    /**
     * Sets the last screen element as pinned
     * @internal
     */
    setLastScreenPinned(): void;
    /**
     * Returns the participant with the given identity.
     * @param identity
     * @returns
     */
    getParticipantByIdentity(identity: string): ParticipantModel | undefined;
    /**
     * Returns all remote participants in the room.
     *
     * @deprecated Please prefer `remoteParticipantsSignal()` for automatic reactive updates or `remoteParticipants$` when using Observables.
     */
    getRemoteParticipants(): ParticipantModel[];
    /**
     * Returns the remote participant with the given sid.
     * @param sid
     */
    getRemoteParticipantBySid(sid: string): ParticipantModel | undefined;
    /**
     * Force to update the remote participants object and fire a new `remoteParticipants$` Observable event.
     */
    updateRemoteParticipants(): void;
    /**
     * @internal
     */
    addRemoteParticipant(participant: RemoteParticipant): void;
    /**
     * Removes participant track from the remote participant object.
     * @param participant
     * @param trackSid
     * @internal
     */
    removeRemoteParticipantTrack(participant: RemoteParticipant, trackSid: string): void;
    /**
     * @internal
     */
    removeRemoteParticipant(sid: string): void;
    /**
     * @internal
     */
    resetRemoteStreamsToNormalSize(): void;
    /**
     * Set the screen track publication date of a remote participant with the aim of taking control of the last screen published
     * @param participantSid
     * @param trackSid
     * @param createdAt
     * @internal
     */
    setScreenTrackPublicationDate(participantSid: string, trackSid: string, createdAt: number): void;
    /**
     * @internal
     */
    someRemoteIsSharingScreen(): boolean;
    /**
     * @internal
     */
    toggleRemoteVideoPinned(sid: string | undefined): void;
    /**
     * Sets the remote participant video track element muted or unmuted .
     * @internal
     */
    setRemoteMutedForcibly(sid: string, value: boolean): void;
    private newParticipant;
    /**
     * Decrypts the participant name if E2EE is enabled.
     * Updates the participant model asynchronously.
     * @param participant - The participant model to decrypt the name for
     * @private
     */
    private decryptParticipantName;
    private getScreenCaptureOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ParticipantService>;
}

/**
 * Configuration object for all templates in the videoconference component
 */
interface TemplateConfiguration {
    toolbarTemplate: TemplateRef<any>;
    toolbarAdditionalButtonsTemplate?: TemplateRef<any>;
    toolbarAdditionalPanelButtonsTemplate?: TemplateRef<any>;
    toolbarLeaveButtonTemplate?: TemplateRef<any>;
    panelTemplate: TemplateRef<any>;
    chatPanelTemplate: TemplateRef<any>;
    participantsPanelTemplate: TemplateRef<any>;
    activitiesPanelTemplate: TemplateRef<any>;
    additionalPanelsTemplate?: TemplateRef<any>;
    participantPanelAfterLocalParticipantTemplate?: TemplateRef<any>;
    participantPanelItemTemplate: TemplateRef<any>;
    participantPanelItemElementsTemplate?: TemplateRef<any>;
    layoutTemplate: TemplateRef<any>;
    streamTemplate: TemplateRef<any>;
    layoutAdditionalElementsTemplate?: TemplateRef<any>;
    settingsPanelGeneralAdditionalElementsTemplate?: TemplateRef<any>;
    toolbarMoreOptionsAdditionalMenuItemsTemplate?: TemplateRef<any>;
    preJoinTemplate?: TemplateRef<any>;
}
/**
 * Configuration object for panel component templates
 */
interface PanelTemplateConfiguration {
    participantsPanelTemplate?: TemplateRef<any>;
    chatPanelTemplate?: TemplateRef<any>;
    activitiesPanelTemplate?: TemplateRef<any>;
    additionalPanelsTemplate?: TemplateRef<any>;
    backgroundEffectsPanelTemplate?: TemplateRef<any>;
    settingsPanelTemplate?: TemplateRef<any>;
}
/**
 * Configuration object for toolbar component templates
 */
interface ToolbarTemplateConfiguration {
    toolbarAdditionalButtonsTemplate?: TemplateRef<any>;
    toolbarAdditionalPanelButtonsTemplate?: TemplateRef<any>;
    toolbarLeaveButtonTemplate?: TemplateRef<any>;
    toolbarMoreOptionsAdditionalMenuItemsTemplate?: TemplateRef<any>;
}
/**
 * Configuration object for layout component templates
 */
interface LayoutTemplateConfiguration {
    layoutStreamTemplate?: TemplateRef<any>;
    layoutAdditionalElementsTemplate?: TemplateRef<any>;
    layoutAdditionalElementsSlot?: 'top' | 'bottom' | 'default';
}
/**
 * Configuration object for participants panel component templates
 */
interface ParticipantsPanelTemplateConfiguration {
    participantPanelItemTemplate?: TemplateRef<any>;
    participantPanelAfterLocalParticipantTemplate?: TemplateRef<any>;
}
/**
 * Configuration object for participant panel item component templates
 */
interface ParticipantPanelItemTemplateConfiguration {
    participantPanelItemElementsTemplate?: TemplateRef<any>;
}
/**
 * Configuration object for session component templates
 */
interface SessionTemplateConfiguration {
    toolbarTemplate?: TemplateRef<any>;
    panelTemplate?: TemplateRef<any>;
    layoutTemplate?: TemplateRef<any>;
}
/**
 * External directives provided by the consumer
 */
interface ExternalDirectives {
    toolbar?: ToolbarDirective;
    toolbarAdditionalButtons?: ToolbarAdditionalButtonsDirective;
    toolbarAdditionalPanelButtons?: ToolbarAdditionalPanelButtonsDirective;
    toolbarLeaveButton?: LeaveButtonDirective;
    additionalPanels?: AdditionalPanelsDirective;
    panel?: PanelDirective;
    chatPanel?: ChatPanelDirective;
    activitiesPanel?: ActivitiesPanelDirective;
    participantsPanel?: ParticipantsPanelDirective;
    participantPanelAfterLocalParticipant?: ParticipantPanelAfterLocalParticipantDirective;
    participantPanelItem?: ParticipantPanelItemDirective;
    participantPanelItemElements?: ParticipantPanelItemElementsDirective;
    layout?: LayoutDirective;
    stream?: StreamDirective;
    preJoin?: PreJoinDirective;
    layoutAdditionalElements?: LayoutAdditionalElementsDirective;
    settingsPanelGeneralAdditionalElements?: SettingsPanelGeneralAdditionalElementsDirective;
    toolbarMoreOptionsAdditionalMenuItems?: ToolbarMoreOptionsAdditionalMenuItemsDirective;
}
/**
 * Default templates provided by the component
 */
interface DefaultTemplates {
    toolbar: TemplateRef<any>;
    panel: TemplateRef<any>;
    chatPanel: TemplateRef<any>;
    participantsPanel: TemplateRef<any>;
    activitiesPanel: TemplateRef<any>;
    participantPanelItem: TemplateRef<any>;
    layout: TemplateRef<any>;
    stream: TemplateRef<any>;
}
/**
 * Service responsible for managing and configuring templates for the videoconference component.
 * This service centralizes all template setup logic, making the main component cleaner and more maintainable.
 */
declare class TemplateManagerService {
    private loggerSrv;
    private log;
    constructor(loggerSrv: LoggerService);
    /**
     * Sets up all templates based on external directives and default templates
     */
    setupTemplates(externalDirectives: ExternalDirectives, defaultTemplates: DefaultTemplates): TemplateConfiguration;
    /**
     * Sets up the participantPanelAfterLocalParticipant template
     */
    private setupParticipantPanelAfterLocalParticipantTemplate;
    /**
     * Sets up the toolbar template
     */
    private setupToolbarTemplate;
    /**
     * Sets up the panel template
     */
    private setupPanelTemplate;
    /**
     * Sets up the layout template
     */
    private setupLayoutTemplate;
    /**
     * Sets up the prejoin template
     */
    private setupPreJoinTemplate;
    /**
     * Sets up the chat panel template
     */
    private setupChatPanelTemplate;
    /**
     * Sets up the participants panel template
     */
    private setupParticipantsPanelTemplate;
    /**
     * Sets up the activities panel template
     */
    private setupActivitiesPanelTemplate;
    /**
     * Sets up the participant panel item template
     */
    private setupParticipantPanelItemTemplate;
    /**
     * Sets up the stream template
     */
    private setupStreamTemplate;
    /**
     * Sets up templates for the PanelComponent
     */
    setupPanelTemplates(externalParticipantsPanel?: ParticipantsPanelDirective, externalChatPanel?: ChatPanelDirective, externalActivitiesPanel?: ActivitiesPanelDirective, externalAdditionalPanels?: AdditionalPanelsDirective): PanelTemplateConfiguration;
    /**
     * Sets up templates for the ToolbarComponent
     */
    setupToolbarTemplates(externalAdditionalButtons?: ToolbarAdditionalButtonsDirective, externalAdditionalPanelButtons?: ToolbarAdditionalPanelButtonsDirective, externalLeaveButton?: LeaveButtonDirective, externalMoreOptionsAdditionalMenuItems?: ToolbarMoreOptionsAdditionalMenuItemsDirective): ToolbarTemplateConfiguration;
    /**
     * Sets up templates for the LayoutComponent
     */
    setupLayoutTemplates(externalStream?: StreamDirective, externalLayoutAdditionalElements?: LayoutAdditionalElementsDirective): LayoutTemplateConfiguration;
    /**
     * Sets up templates for the ParticipantsPanelComponent
     */
    setupParticipantsPanelTemplates(externalParticipantPanelItem?: ParticipantPanelItemDirective, defaultParticipantPanelItem?: TemplateRef<any>, externalParticipantPanelAfterLocalParticipant?: TemplateRef<any>): ParticipantsPanelTemplateConfiguration;
    /**
     * Sets up templates for the ParticipantPanelItemComponent
     */
    setupParticipantPanelItemTemplates(externalParticipantPanelItemElements?: ParticipantPanelItemElementsDirective): ParticipantPanelItemTemplateConfiguration;
    /**
     * Sets up templates for the SessionComponent
     */
    setupSessionTemplates(toolbarTemplate?: TemplateRef<any>, panelTemplate?: TemplateRef<any>, layoutTemplate?: TemplateRef<any>): SessionTemplateConfiguration;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TemplateManagerService>;
}

/**
 *
 * The **LayoutComponent** is hosted inside of the {@link VideoconferenceComponent}.
 * It is in charge of displaying the participants streams layout.
 */
declare class LayoutComponent implements OnInit, OnDestroy, AfterViewInit {
    private layoutService;
    private panelService;
    private participantService;
    private globalService;
    private directiveService;
    private cd;
    private templateManagerService;
    /**
     * @ignore
     */
    streamTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    layoutAdditionalElementsTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    layoutContainer: ViewContainerRef;
    /**
     * @ignore
     */
    cdkDrag: CdkDrag;
    /**
     * @ignore
     */
    localLayoutElement: ElementRef;
    /**
     * @ignore
     */
    set externalStream(externalStream: StreamDirective);
    /**
     * @ignore
     */
    set externalAdditionalElements(externalAdditionalElements: LayoutAdditionalElementsDirective);
    /**
     * @ignore
     */
    templateConfig: LayoutTemplateConfiguration;
    localParticipant: ParticipantModel | undefined;
    remoteParticipants: ParticipantModel[];
    /**
     * @ignore
     */
    captionsEnabled: boolean;
    private _externalStream?;
    private _externalLayoutAdditionalElements?;
    private destroy$;
    private resizeObserver;
    private resizeTimeout;
    private videoIsAtRight;
    private lastLayoutWidth;
    private lastLayoutHeight;
    /**
     * @ignore
     */
    constructor(layoutService: LayoutService, panelService: PanelService, participantService: ParticipantService, globalService: GlobalConfigService, directiveService: OpenViduComponentsConfigService, cd: ChangeDetectorRef, templateManagerService: TemplateManagerService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    trackParticipantElement(_: number, track: ParticipantTrackPublication): ParticipantTrackPublication;
    private setupTemplates;
    private applyTemplateConfiguration;
    /**
     * @internal
     * Updates templates and triggers change detection
     */
    private updateTemplatesAndMarkForCheck;
    private subscribeToCaptions;
    private subscribeToParticipants;
    private listenToResizeLayout;
    private moveStreamToRight;
    private listenToCdkDrag;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutComponent, "ov-layout", never, {}, {}, ["streamTemplate", "layoutAdditionalElementsTemplate", "externalStream", "externalAdditionalElements"], never, false, never>;
}

/**
 * Enum representing the possible status of a broadcast
 */
declare enum BroadcastingStatus {
    STARTING = "STARTING",
    STARTED = "STARTED",
    STOPPING = "STOPPING",
    STOPPED = "STOPPED",
    FAILED = "FAILED"
}
/**
 * Interface representing information related to the broadcasting status
 */
interface BroadcastingStatusInfo {
    status: BroadcastingStatus;
    broadcastingId: string | undefined;
    error?: string;
}
/**
 * Interface representing a broadcasting event
 */
interface BroadcastingEvent {
    roomName: string;
}
interface BroadcastingStartRequestedEvent extends BroadcastingEvent {
    broadcastUrl: string;
}
interface BroadcastingStopRequestedEvent extends BroadcastingEvent {
    broadcastingId: string;
}

/**
 * The **ActivitiesPanelComponent** is the component that allows showing the activities panel.
 * This panel shows the recording and broadcasting activities.
 */
declare class ActivitiesPanelComponent implements OnInit {
    private panelService;
    private libService;
    private cd;
    /**
     * This event is fired when the user clicks on the start recording button.
     * It provides the {@link RecordingStartRequestedEvent} payload as event data.
     */
    onRecordingStartRequested: EventEmitter<RecordingStartRequestedEvent>;
    /**
     * Provides event notifications that fire when stop recording button has been clicked.
     * It provides the {@link RecordingStopRequestedEvent} payload as event data.
     */
    onRecordingStopRequested: EventEmitter<RecordingStopRequestedEvent>;
    /**
     * Provides event notifications that fire when delete recording button has been clicked.
     * It provides the {@link RecordingDeleteRequestedEvent} payload as event data.
     */
    onRecordingDeleteRequested: EventEmitter<RecordingDeleteRequestedEvent>;
    /**
     * Provides event notifications that fire when download recording button has been clicked.
     * It provides the {@link RecordingDownloadClickedEvent} payload as event data.
     */
    onRecordingDownloadClicked: EventEmitter<RecordingDownloadClickedEvent>;
    /**
     * Provides event notifications that fire when play recording button has been clicked.
     * It provides the {@link RecordingPlayClickedEvent} payload as event data.
     */
    onRecordingPlayClicked: EventEmitter<RecordingPlayClickedEvent>;
    /**
     * @internal
     * Provides event notifications that fire when view recordings button has been clicked.
     * This event is triggered when the user wants to view all recordings in an external page.
     */
    onViewRecordingsClicked: EventEmitter<void>;
    /**
     * @internal
     * Provides event notifications that fire when view recording button has been clicked.
     * This event is triggered when the user wants to view a specific recording in an external page.
     * It provides the recording ID as event data.
     */
    onViewRecordingClicked: EventEmitter<string>;
    /**
     * Provides event notifications that fire when start broadcasting button is clicked.
     * It provides the {@link BroadcastingStartRequestedEvent} payload as event data.
     */
    onBroadcastingStartRequested: EventEmitter<BroadcastingStartRequestedEvent>;
    /**
     * Provides event notifications that fire when stop broadcasting button is clicked.
     * It provides the {@link BroadcastingStopRequestedEvent} payload as event data.
     */
    onBroadcastingStopRequested: EventEmitter<BroadcastingStopRequestedEvent>;
    /**
     * @internal
     */
    expandedPanel: string;
    /**
     * @internal
     */
    showRecordingActivity: boolean;
    /**
     * @internal
     */
    showBroadcastingActivity: boolean;
    private destroy$;
    /**
     * @internal
     */
    constructor(panelService: PanelService, libService: OpenViduComponentsConfigService, cd: ChangeDetectorRef);
    /**
     * @internal
     */
    ngOnInit(): void;
    /**
     * @internal
     */
    ngOnDestroy(): void;
    /**
     * @internal
     */
    close(): void;
    private subscribeToPanelToggling;
    private subscribeToActivitiesPanelDirective;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivitiesPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivitiesPanelComponent, "ov-activities-panel", never, {}, { "onRecordingStartRequested": "onRecordingStartRequested"; "onRecordingStopRequested": "onRecordingStopRequested"; "onRecordingDeleteRequested": "onRecordingDeleteRequested"; "onRecordingDownloadClicked": "onRecordingDownloadClicked"; "onRecordingPlayClicked": "onRecordingPlayClicked"; "onViewRecordingsClicked": "onViewRecordingsClicked"; "onViewRecordingClicked": "onViewRecordingClicked"; "onBroadcastingStartRequested": "onBroadcastingStartRequested"; "onBroadcastingStopRequested": "onBroadcastingStopRequested"; }, never, never, false, never>;
}

declare class BroadcastingService {
    /**
     * Broadcasting status Observable which pushes the {@link BroadcastingStatusInfo} in every update.
     */
    broadcastingStatusObs: Observable<BroadcastingStatusInfo>;
    private broadcastingStatus;
    /**
     * @internal
     */
    constructor();
    /**
     * @internal
     */
    setBroadcastingStarted(broadcastingId: string): void;
    /**
     * @internal
     */
    setBroadcastingStopped(): void;
    /**
     * @internal
     * @param error
     */
    setBroadcastingFailed(error: string): void;
    /**
     * Set the broadcasting {@link BroadcastingStatus} to **starting**.
     * The `started` status will be updated automatically when the broadcasting is started.
     */
    setBroadcastingStarting(): void;
    /**
     * Set the broadcasting {@link BroadcastingStatus} to **stopping**.
     * The `stopped` status will be updated automatically when the broadcasting is stopped.
     */
    setBroadcastingStopping(): void;
    /**
     * Update the broadcasting status.
     * @param status {@link BroadcastingStatusInfo}
     * @intenal
     */
    private updateStatus;
    static ɵfac: i0.ɵɵFactoryDeclaration<BroadcastingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BroadcastingService>;
}

/**
 * The **BroadcastingActivityComponent** is the component that allows showing the broadcasting activity.
 *
 */
declare class BroadcastingActivityComponent implements OnInit {
    private broadcastingService;
    private participantService;
    private openviduService;
    private cd;
    /**
     * Provides event notifications that fire when start broadcasting button is clicked.
     * It provides the {@link BroadcastingStartRequestedEvent} payload as event data.
     */
    onBroadcastingStartRequested: EventEmitter<BroadcastingStartRequestedEvent>;
    /**
     * Provides event notifications that fire when stop broadcasting button is clicked.
     * It provides the {@link BroadcastingStopRequestedEvent} payload as event data.
     */
    onBroadcastingStopRequested: EventEmitter<BroadcastingStopRequestedEvent>;
    /**
     * @internal
     */
    urlRequiredError: boolean;
    /**
     * @internal
     */
    broadcastUrl: string;
    /**
     * @internal
     */
    expanded: boolean;
    /**
     * @internal
     */
    broadcastingError: string | undefined;
    /**
     * @internal
     */
    broadcastingStatus: BroadcastingStatus;
    /**
     * @internal
     */
    broadcastingId: string | undefined;
    /**
     * @internal
     */
    broadcastingStatusEnum: typeof BroadcastingStatus;
    /**
     * @internal
     */
    isPanelOpened: boolean;
    private destroy$;
    /**
     * @internal
     */
    constructor(broadcastingService: BroadcastingService, participantService: ParticipantService, openviduService: OpenViduService, cd: ChangeDetectorRef);
    /**
     * @internal
     */
    ngOnInit(): void;
    /**
     * @internal
     */
    ngOnDestroy(): void;
    /**
     * @internal
     */
    setPanelOpened(value: boolean): void;
    /**
     * @ignore
     */
    eventKeyPress(event: any): void;
    /**
     * @internal
     */
    startBroadcasting(): void;
    /**
     * @internal
     */
    stopBroadcasting(): void;
    private subscribeToBroadcastingStatus;
    static ɵfac: i0.ɵɵFactoryDeclaration<BroadcastingActivityComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BroadcastingActivityComponent, "ov-broadcasting-activity", never, { "expanded": { "alias": "expanded"; "required": false; }; }, { "onBroadcastingStartRequested": "onBroadcastingStartRequested"; "onBroadcastingStopRequested": "onBroadcastingStopRequested"; }, never, never, false, never>;
}

/**
 * The **RecordingActivityComponent** is the component that allows showing the recording activity.
 */
declare class RecordingActivityComponent implements OnInit, OnDestroy {
    private recordingService;
    private participantService;
    private actionService;
    private openviduService;
    private cd;
    private loggerSrv;
    private libService;
    /**
     * @internal
     */
    expanded: boolean;
    /**
     * This event is fired when the user clicks on the start recording button.
     * It provides the {@link RecordingStartRequestedEvent} payload as event data.
     */
    onRecordingStartRequested: EventEmitter<RecordingStartRequestedEvent>;
    /**
     * Provides event notifications that fire when stop recording button has been clicked.
     * It provides the {@link RecordingStopRequestedEvent} payload as event data.
     */
    onRecordingStopRequested: EventEmitter<RecordingStopRequestedEvent>;
    /**
     * Provides event notifications that fire when delete recording button has been clicked.
     * It provides the {@link RecordingDeleteRequestedEvent} payload as event data.
     */
    onRecordingDeleteRequested: EventEmitter<RecordingDeleteRequestedEvent>;
    /**
     * Provides event notifications that fire when download recording button has been clicked.
     * It provides the {@link RecordingDownloadClickedEvent} payload as event data.
     */
    onRecordingDownloadClicked: EventEmitter<RecordingDownloadClickedEvent>;
    /**
     * Provides event notifications that fire when play recording button has been clicked.
     * It provides the {@link RecordingPlayClickedEvent} payload as event data.
     */
    onRecordingPlayClicked: EventEmitter<RecordingPlayClickedEvent>;
    /**
     * @internal
     * Provides event notifications that fire when view recordings button has been clicked.
     * This event is triggered when the user wants to view all recordings in an external page.
     */
    onViewRecordingsClicked: EventEmitter<void>;
    /**
     * @internal
     * This event is fired when the user clicks on the view recording button.
     * It provides the recording ID as event data.
     */
    onViewRecordingClicked: EventEmitter<string>;
    /**
     * @internal
     */
    recordingStatus: RecordingStatus;
    /**
     * @internal
     */
    oldRecordingStatus: RecordingStatus;
    /**
     * @internal
     */
    isPanelOpened: boolean;
    /**
     * @internal
     */
    recStatusEnum: typeof RecordingStatus;
    /**
     * @internal
     */
    recordingAlive: boolean;
    /**
     * @internal
     */
    recordingList: RecordingInfo[];
    /**
     * @internal
     */
    recordingError: any;
    /**
     * @internal
     */
    hasRoomTracksPublished: boolean;
    /**
     * @internal
     */
    mouseHovering: boolean;
    /**
     * @internal
     */
    isReadOnlyMode: boolean;
    /**
     * @internal
     */
    viewButtonText: string;
    /**
     * @internal
     */
    showStartStopRecordingButton: boolean;
    /**
     * @internal
     */
    showViewRecordingsButton: boolean;
    /**
     * @internal
     */
    showRecordingList: boolean;
    /**
     * @internal
     */
    showControls: {
        play?: boolean;
        download?: boolean;
        delete?: boolean;
        externalView?: boolean;
    };
    private log;
    private destroy$;
    /**
     * @internal
     */
    constructor(recordingService: RecordingService, participantService: ParticipantService, actionService: ActionService, openviduService: OpenViduService, cd: ChangeDetectorRef, loggerSrv: LoggerService, libService: OpenViduComponentsConfigService);
    /**
     * @internal
     */
    ngOnInit(): void;
    /**
     * @internal
     */
    ngOnDestroy(): void;
    /**
     * @internal
     */
    trackByRecordingId(index: number, recording: RecordingInfo): string | undefined;
    /**
     * @internal
     */
    setPanelOpened(value: boolean): void;
    /**
     * @internal
     */
    resetStatus(): void;
    /**
     * @internal
     */
    startRecording(): void;
    /**
     * @internal
     */
    stopRecording(): void;
    /**
     * @internal
     */
    deleteRecording(recording: RecordingInfo): void;
    /**
     * @internal
     */
    download(recording: RecordingInfo): void;
    /**
     * @internal
     */
    play(recording: RecordingInfo): void;
    /**
     * @internal
     */
    viewRecording(recording: RecordingInfo): void;
    /**
     * @internal
     */
    viewAllRecordings(): void;
    /**
     * @internal
     * Format duration in seconds to a readable format (e.g., "2m 30s")
     */
    formatDuration(seconds: number): string;
    /**
     * @internal
     * Format file size in bytes to a readable format (e.g., "2.5 MB")
     */
    formatFileSize(bytes: number): string;
    private subscribeToConfigChanges;
    private subscribeToRecordingStatus;
    private subscribeToTracksChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecordingActivityComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RecordingActivityComponent, "ov-recording-activity", never, { "expanded": { "alias": "expanded"; "required": false; }; }, { "onRecordingStartRequested": "onRecordingStartRequested"; "onRecordingStopRequested": "onRecordingStopRequested"; "onRecordingDeleteRequested": "onRecordingDeleteRequested"; "onRecordingDownloadClicked": "onRecordingDownloadClicked"; "onRecordingPlayClicked": "onRecordingPlayClicked"; "onViewRecordingsClicked": "onViewRecordingsClicked"; "onViewRecordingClicked": "onViewRecordingClicked"; }, never, never, false, never>;
}

/**
 * @internal
 */
interface ChatMessage {
    isLocal: boolean;
    participantName: string;
    message: string;
}

/**
 * @internal
 */
declare class ChatService {
    private loggerSrv;
    private participantService;
    private panelService;
    private actionService;
    private translateService;
    chatMessages$: Observable$1<ChatMessage[]>;
    private messageSound;
    private _messageList;
    private messageList;
    private log;
    constructor(loggerSrv: LoggerService, participantService: ParticipantService, panelService: PanelService, actionService: ActionService, translateService: TranslateService);
    /**
     * Adds a new message to the chat from a remote participant
     * @param message
     * @param participantName
     */
    addRemoteMessage(message: string, participantName: string): Promise<void>;
    /**
     * Sends a chat message through the data channel.
     *
     * @param message The message text to send
     */
    sendMessage(message: string): Promise<void>;
    private addMessage;
    private launchNotification;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChatService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ChatService>;
}

/**
 *
 * The **ChatPanelComponent** is an integral part of the {@link PanelComponent} and serves as the interface for displaying the session chat.
 */
declare class ChatPanelComponent implements OnInit, AfterViewInit {
    private chatService;
    private panelService;
    private cd;
    private e2eeService;
    private participantService;
    /**
     * @ignore
     */
    chatScroll: ElementRef;
    /**
     * @ignore
     */
    chatInput: ElementRef;
    /**
     * @ignore
     */
    message: string;
    /**
     * @ignore
     */
    messageList: ChatMessage[];
    private destroy$;
    /**
     * @ignore
     */
    constructor(chatService: ChatService, panelService: PanelService, cd: ChangeDetectorRef, e2eeService: E2eeService, participantService: ParticipantService);
    /**
     * @ignore
     */
    ngOnInit(): void;
    /**
     * @ignore
     */
    ngAfterViewInit(): void;
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    eventKeyPress(event: KeyboardEvent): void;
    /**
     * @ignore
     */
    sendMessage(): Promise<void>;
    /**
     * @ignore
     */
    scrollToBottom(): void;
    /**
     * @ignore
     */
    close(): void;
    /**
     * @ignore
     */
    hasEncryptionKeyMismatch: i0.Signal<boolean>;
    private subscribeToMessages;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChatPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChatPanelComponent, "ov-chat-panel", never, {}, {}, never, never, false, never>;
}

/**
 *
 * The **PanelComponent** is hosted inside of the {@link VideoconferenceComponent}.
 * It is in charge of displaying the videoconference panels providing functionalities to the videoconference app
 * such as the chat ({@link ChatPanelComponent}) and list of participants ({@link ParticipantsPanelComponent})
 */
declare class PanelComponent implements OnInit {
    private panelService;
    private cd;
    private templateManagerService;
    /**
     * @ignore
     */
    participantsPanelTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    backgroundEffectsPanelTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    settingsPanelTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    activitiesPanelTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    chatPanelTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    additionalPanelsTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    set externalParticipantPanel(externalParticipantsPanel: ParticipantsPanelDirective);
    /**
     * @ignore
     */
    set externalActivitiesPanel(externalActivitiesPanel: ActivitiesPanelDirective);
    /**
     * @ignore
     */
    set externalChatPanel(externalChatPanel: ChatPanelDirective);
    /**
     * @ignore
     */
    set externalAdditionalPanels(externalAdditionalPanels: AdditionalPanelsDirective);
    /**
     * This event is fired when the chat panel status has been changed.
     * It provides the new status of the chat panel represented by the {@link ChatPanelStatusEvent} object.
     */
    onChatPanelStatusChanged: EventEmitter<ChatPanelStatusEvent>;
    /**
     * This event is fired when the participants panel status has been changed.
     * It provides the new status of the participants panel represented by the {@link ParticipantsPanelStatusEvent} object.
     */
    onParticipantsPanelStatusChanged: EventEmitter<ParticipantsPanelStatusEvent>;
    /**
     * This event is fired when the settings panel status has been changed.
     * It provides the new status of the settings panel represented by the {@link SettingsPanelStatusEvent} object.
     */
    onSettingsPanelStatusChanged: EventEmitter<SettingsPanelStatusEvent>;
    /**
     * This event is fired when the activities panel status has been changed.
     * It provides the new status of the activities panel represented by the {@link ActivitiesPanelStatusEvent} object.
     */
    onActivitiesPanelStatusChanged: EventEmitter<ActivitiesPanelStatusEvent>;
    /**
     * This event is fired when the background effects panel status has been changed.
     * It provides the new status of the background effects panel represented by the {@link BackgroundEffectsPanelStatusEvent} object.
     * @internal
     */
    /**
     * @ignore
     */
    isParticipantsPanelOpened: boolean;
    /**
     * @ignore
     */
    isChatPanelOpened: boolean;
    /**
     * @ignore
     */
    isBackgroundEffectsPanelOpened: boolean;
    /**
     * @ignore
     */
    isSettingsPanelOpened: boolean;
    /**
     * @ignore
     */
    isActivitiesPanelOpened: boolean;
    /**
     * @internal
     */
    isExternalPanelOpened: boolean;
    /**
     * @internal
     * Template configuration managed by the service
     */
    templateConfig: PanelTemplateConfiguration;
    private _externalParticipantPanel?;
    private _externalChatPanel?;
    private _externalActivitiesPanel?;
    private _externalAdditionalPanels?;
    private destroy$;
    private panelEmitersHandler;
    /**
     * @ignore
     */
    constructor(panelService: PanelService, cd: ChangeDetectorRef, templateManagerService: TemplateManagerService);
    /**
     * @ignore
     */
    ngOnInit(): void;
    /**
     * @internal
     * Sets up all templates using the template manager service
     */
    private setupTemplates;
    /**
     * @internal
     * Applies the template configuration to component properties
     */
    private applyTemplateConfiguration;
    /**
     * @internal
     * Updates templates and triggers change detection
     */
    private updateTemplatesAndMarkForCheck;
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    private subscribeToPanelToggling;
    private sendPanelStatusChangedEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<PanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PanelComponent, "ov-panel", never, {}, { "onChatPanelStatusChanged": "onChatPanelStatusChanged"; "onParticipantsPanelStatusChanged": "onParticipantsPanelStatusChanged"; "onSettingsPanelStatusChanged": "onSettingsPanelStatusChanged"; "onActivitiesPanelStatusChanged": "onActivitiesPanelStatusChanged"; }, ["participantsPanelTemplate", "backgroundEffectsPanelTemplate", "settingsPanelTemplate", "activitiesPanelTemplate", "chatPanelTemplate", "additionalPanelsTemplate", "externalParticipantPanel", "externalActivitiesPanel", "externalChatPanel", "externalAdditionalPanels"], never, false, never>;
}

/**
 * The **ParticipantPanelItemComponent** is hosted inside of the {@link ParticipantsPanelComponent}.
 * It displays participant information with enhanced UI/UX, including support for custom content
 * injection through structural directives.
 */
declare class ParticipantPanelItemComponent implements OnInit, OnDestroy {
    private libService;
    private participantService;
    private cd;
    private templateManagerService;
    /**
     * @ignore
     */
    participantPanelItemElementsTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    showMuteButton: boolean;
    private muteButtonSub;
    /**
     * @ignore
     */
    set externalItemElements(externalItemElements: ParticipantPanelItemElementsDirective);
    /**
     * @ignore
     */
    set externalParticipantBadge(participantBadge: ParticipantPanelParticipantBadgeDirective);
    /**
     * @internal
     * Template configuration managed by the service
     */
    templateConfig: ParticipantPanelItemTemplateConfiguration;
    private _externalItemElements?;
    private _externalParticipantBadge?;
    /**
     * The participant to be displayed
     */
    set participant(participant: ParticipantModel);
    /**
     * @internal
     * Current participant being displayed
     */
    _participant: ParticipantModel;
    /**
     * Whether to show the mute button for remote participants
     */
    muteButton: boolean;
    /**
     * @ignore
     */
    constructor(libService: OpenViduComponentsConfigService, participantService: ParticipantService, cd: ChangeDetectorRef, templateManagerService: TemplateManagerService);
    /**
     * @ignore
     */
    ngOnInit(): void;
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * Toggles the mute state of a remote participant
     */
    toggleMuteForcibly(): void;
    /**
     * Gets the template for local participant badge
     */
    get participantBadgeTemplate(): TemplateRef<any> | undefined;
    /**
     * Checks if the current participant is the local participant
     */
    get isLocalParticipant(): boolean;
    /**
     * Gets the participant's display name
     */
    get participantDisplayName(): string;
    /**
     * Checks if external elements are available
     */
    get hasExternalElements(): boolean;
    /**
     * @internal
     * Sets up all templates using the template manager service
     */
    private setupTemplates;
    /**
     * @internal
     * Applies the template configuration to component properties
     */
    private applyTemplateConfiguration;
    /**
     * @internal
     * Updates templates and triggers change detection
     */
    private updateTemplatesAndMarkForCheck;
    private subscribeToParticipantPanelItemDirectives;
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantPanelItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ParticipantPanelItemComponent, "ov-participant-panel-item", never, { "participant": { "alias": "participant"; "required": false; }; "muteButton": { "alias": "muteButton"; "required": false; }; }, {}, ["participantPanelItemElementsTemplate", "externalItemElements", "externalParticipantBadge"], never, false, never>;
}

/**
 * The **ParticipantsPanelComponent** is hosted inside of the {@link PanelComponent}.
 * It is in charge of displaying the participants connected to the session.
 * This component is composed by the {@link ParticipantPanelItemComponent}.
 */
declare class ParticipantsPanelComponent implements OnInit, OnDestroy, AfterViewInit {
    private participantService;
    private panelService;
    private cd;
    private templateManagerService;
    private libService;
    /**
     * @ignore
     */
    localParticipant: ParticipantModel | undefined;
    /**
     * @ignore
     */
    remoteParticipants: ParticipantModel[];
    /**
     * @ignore
     */
    defaultParticipantPanelItemTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    participantPanelItemTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    participantPanelAfterLocalParticipantTemplate: TemplateRef<any>;
    /**
     * @ignore
     */
    set externalParticipantPanelItem(externalParticipantPanelItem: ParticipantPanelItemDirective);
    /**
     * @internal
     * Template configuration managed by the service
     */
    templateConfig: ParticipantsPanelTemplateConfiguration;
    private _externalParticipantPanelItem?;
    private destroy$;
    /**
     * @ignore
     */
    constructor(participantService: ParticipantService, panelService: PanelService, cd: ChangeDetectorRef, templateManagerService: TemplateManagerService, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngOnInit(): void;
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    ngAfterViewInit(): void;
    private subscribeToParticipantsChanges;
    /**
     * @internal
     * Sets up all templates using the template manager service
     */
    private setupTemplates;
    /**
     * @internal
     * Applies the template configuration to component properties
     */
    private applyTemplateConfiguration;
    /**
     * @internal
     * Updates templates and triggers change detection
     */
    private updateTemplatesAndMarkForCheck;
    /**
     * @ignore
     */
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantsPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ParticipantsPanelComponent, "ov-participants-panel", never, {}, {}, ["participantPanelItemTemplate", "participantPanelAfterLocalParticipantTemplate", "externalParticipantPanelItem"], never, false, never>;
}

declare class CdkOverlayContainer extends OverlayContainer {
    private readonly cdkContainerClass;
    private defaultSelector;
    private currentSelector;
    setContainerSelector(selector: string): void;
    private getElementWithSelector;
    static ɵfac: i0.ɵɵFactoryDeclaration<CdkOverlayContainer, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CdkOverlayContainer>;
}

/**
 * @internal
 */
declare class CdkOverlayService {
    private cdkOverlayModel;
    constructor(cdkOverlayModel: CdkOverlayContainer);
    setSelector(selector: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CdkOverlayService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CdkOverlayService>;
}

/**
 * The **StreamComponent** is hosted inside of the {@link LayoutComponent}.
 * It is in charge of displaying the participant video stream in the videoconference layout.
 */
declare class StreamComponent implements OnInit, OnDestroy {
    private layoutService;
    private participantService;
    private cdkSrv;
    private libService;
    /**
     * @ignore
     */
    menuTrigger: MatMenuTrigger;
    /**
     * @ignore
     */
    menu: MatMenuPanel;
    /**
     * @ignore
     */
    videoTypeEnum: typeof Track.Source;
    /**
     * @ignore
     */
    _track: ParticipantTrackPublication | undefined;
    /**
     * @ignore
     */
    isMinimal: boolean;
    /**
     * @ignore
     */
    showParticipantName: boolean;
    /**
     * @ignore
     */
    showAudioDetection: boolean;
    /**
     * @ignore
     */
    showVideoControls: boolean;
    /**
     * @ignore
     */
    showVideo: boolean;
    /**
     * @ignore
     */
    mouseHovering: boolean;
    /**
     * @ignore
     */
    hoveringTimeout: ReturnType<typeof setTimeout>;
    /**
     * @ignore
     */
    set streamContainer(streamContainer: ElementRef);
    set track(track: ParticipantTrackPublication);
    private _streamContainer;
    private destroy$;
    private readonly HOVER_TIMEOUT;
    /**
     * @ignore
     */
    constructor(layoutService: LayoutService, participantService: ParticipantService, cdkSrv: CdkOverlayService, libService: OpenViduComponentsConfigService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    toggleVideoPinned(): void;
    /**
     * @ignore
     */
    toggleMinimize(): void;
    /**
     * @ignore
     */
    toggleVideoMenu(event: any): void;
    /**
     * @ignore
     */
    toggleMuteForcibly(): void;
    /**
     * @ignore
     */
    mouseHover(event: MouseEvent): void;
    private subscribeToStreamDirectives;
    static ɵfac: i0.ɵɵFactoryDeclaration<StreamComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StreamComponent, "ov-stream", never, { "track": { "alias": "track"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * @internal
 */
declare class ToolbarMediaButtonsComponent {
    showCameraButton: i0.InputSignal<boolean>;
    isCameraEnabled: i0.InputSignal<boolean>;
    cameraMuteChanging: i0.InputSignal<boolean>;
    showMicrophoneButton: i0.InputSignal<boolean>;
    isMicrophoneEnabled: i0.InputSignal<boolean>;
    microphoneMuteChanging: i0.InputSignal<boolean>;
    showScreenshareButton: i0.InputSignal<boolean>;
    isScreenShareEnabled: i0.InputSignal<boolean>;
    isFirefoxBrowser: i0.InputSignal<boolean>;
    hasVideoDevices: i0.InputSignal<boolean>;
    hasAudioDevices: i0.InputSignal<boolean>;
    isConnectionLost: i0.InputSignal<boolean>;
    isMinimal: i0.InputSignal<boolean>;
    showMoreOptionsButton: i0.InputSignal<boolean>;
    showFullscreenButton: i0.InputSignal<boolean>;
    showRecordingButton: i0.InputSignal<boolean>;
    showViewRecordingsButton: i0.InputSignal<boolean>;
    showBroadcastingButton: i0.InputSignal<boolean>;
    showBackgroundEffectsButton: i0.InputSignal<boolean>;
    showCaptionsButton: i0.InputSignal<boolean>;
    showSettingsButton: i0.InputSignal<boolean>;
    isFullscreenActive: i0.InputSignal<boolean>;
    recordingStatus: i0.InputSignal<RecordingStatus>;
    hasRoomTracksPublished: i0.InputSignal<boolean>;
    broadcastingStatus: i0.InputSignal<BroadcastingStatus>;
    captionsEnabled: i0.InputSignal<boolean>;
    showLeaveButton: i0.InputSignal<boolean>;
    toolbarAdditionalButtonsTemplate: i0.InputSignal<TemplateRef<any>>;
    additionalButtonsPosition: i0.InputSignal<ToolbarAdditionalButtonsPosition>;
    toolbarLeaveButtonTemplate: i0.InputSignal<TemplateRef<any>>;
    /**
     * @internal
     * ContentChild for custom menu items in more options menu
     */
    externalMoreOptionsAdditionalMenuItems: ToolbarMoreOptionsAdditionalMenuItemsDirective;
    /**
     * @internal
     * Gets the template for additional menu items in more options
     */
    get moreOptionsAdditionalMenuItemsTemplate(): TemplateRef<any> | undefined;
    _recordingStatus: typeof RecordingStatus;
    _broadcastingStatus: typeof BroadcastingStatus;
    private viewportService;
    readonly isMobileView: i0.Signal<boolean>;
    readonly isTabletView: i0.Signal<boolean>;
    readonly isDesktopView: i0.Signal<boolean>;
    readonly showCameraButtonDirect: i0.Signal<boolean>;
    readonly showMicrophoneButtonDirect: i0.Signal<boolean>;
    readonly showScreenshareButtonDirect: i0.Signal<boolean>;
    readonly showMoreOptionsButtonDirect: i0.Signal<boolean>;
    readonly hasActiveFeatures: i0.Signal<boolean>;
    readonly showAdditionalButtonsOutside: i0.Signal<TemplateRef<any>>;
    readonly showAdditionalButtonsInsideMenu: i0.Signal<TemplateRef<any>>;
    cameraToggled: EventEmitter<void>;
    microphoneToggled: EventEmitter<void>;
    screenShareToggled: EventEmitter<void>;
    screenTrackReplaced: EventEmitter<void>;
    fullscreenToggled: EventEmitter<void>;
    recordingToggled: EventEmitter<void>;
    viewRecordingsClicked: EventEmitter<void>;
    broadcastingToggled: EventEmitter<void>;
    backgroundEffectsToggled: EventEmitter<void>;
    captionsToggled: EventEmitter<void>;
    settingsToggled: EventEmitter<void>;
    leaveClicked: EventEmitter<void>;
    onCameraToggle(): void;
    onMicrophoneToggle(): void;
    onScreenShareToggle(): void;
    onScreenTrackReplace(): void;
    onFullscreenToggle(): void;
    onRecordingToggle(): void;
    onViewRecordingsClick(): void;
    onBroadcastingToggle(): void;
    onBackgroundEffectsToggle(): void;
    onCaptionsToggle(): void;
    onSettingsToggle(): void;
    onLeaveClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarMediaButtonsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarMediaButtonsComponent, "ov-toolbar-media-buttons", never, { "showCameraButton": { "alias": "showCameraButton"; "required": false; "isSignal": true; }; "isCameraEnabled": { "alias": "isCameraEnabled"; "required": false; "isSignal": true; }; "cameraMuteChanging": { "alias": "cameraMuteChanging"; "required": false; "isSignal": true; }; "showMicrophoneButton": { "alias": "showMicrophoneButton"; "required": false; "isSignal": true; }; "isMicrophoneEnabled": { "alias": "isMicrophoneEnabled"; "required": false; "isSignal": true; }; "microphoneMuteChanging": { "alias": "microphoneMuteChanging"; "required": false; "isSignal": true; }; "showScreenshareButton": { "alias": "showScreenshareButton"; "required": false; "isSignal": true; }; "isScreenShareEnabled": { "alias": "isScreenShareEnabled"; "required": false; "isSignal": true; }; "isFirefoxBrowser": { "alias": "isFirefoxBrowser"; "required": false; "isSignal": true; }; "hasVideoDevices": { "alias": "hasVideoDevices"; "required": false; "isSignal": true; }; "hasAudioDevices": { "alias": "hasAudioDevices"; "required": false; "isSignal": true; }; "isConnectionLost": { "alias": "isConnectionLost"; "required": false; "isSignal": true; }; "isMinimal": { "alias": "isMinimal"; "required": false; "isSignal": true; }; "showMoreOptionsButton": { "alias": "showMoreOptionsButton"; "required": false; "isSignal": true; }; "showFullscreenButton": { "alias": "showFullscreenButton"; "required": false; "isSignal": true; }; "showRecordingButton": { "alias": "showRecordingButton"; "required": false; "isSignal": true; }; "showViewRecordingsButton": { "alias": "showViewRecordingsButton"; "required": false; "isSignal": true; }; "showBroadcastingButton": { "alias": "showBroadcastingButton"; "required": false; "isSignal": true; }; "showBackgroundEffectsButton": { "alias": "showBackgroundEffectsButton"; "required": false; "isSignal": true; }; "showCaptionsButton": { "alias": "showCaptionsButton"; "required": false; "isSignal": true; }; "showSettingsButton": { "alias": "showSettingsButton"; "required": false; "isSignal": true; }; "isFullscreenActive": { "alias": "isFullscreenActive"; "required": false; "isSignal": true; }; "recordingStatus": { "alias": "recordingStatus"; "required": false; "isSignal": true; }; "hasRoomTracksPublished": { "alias": "hasRoomTracksPublished"; "required": false; "isSignal": true; }; "broadcastingStatus": { "alias": "broadcastingStatus"; "required": false; "isSignal": true; }; "captionsEnabled": { "alias": "captionsEnabled"; "required": false; "isSignal": true; }; "showLeaveButton": { "alias": "showLeaveButton"; "required": false; "isSignal": true; }; "toolbarAdditionalButtonsTemplate": { "alias": "toolbarAdditionalButtonsTemplate"; "required": false; "isSignal": true; }; "additionalButtonsPosition": { "alias": "additionalButtonsPosition"; "required": false; "isSignal": true; }; "toolbarLeaveButtonTemplate": { "alias": "toolbarLeaveButtonTemplate"; "required": false; "isSignal": true; }; }, { "cameraToggled": "cameraToggled"; "microphoneToggled": "microphoneToggled"; "screenShareToggled": "screenShareToggled"; "screenTrackReplaced": "screenTrackReplaced"; "fullscreenToggled": "fullscreenToggled"; "recordingToggled": "recordingToggled"; "viewRecordingsClicked": "viewRecordingsClicked"; "broadcastingToggled": "broadcastingToggled"; "backgroundEffectsToggled": "backgroundEffectsToggled"; "captionsToggled": "captionsToggled"; "settingsToggled": "settingsToggled"; "leaveClicked": "leaveClicked"; }, ["externalMoreOptionsAdditionalMenuItems"], never, false, never>;
}

declare class ToolbarPanelButtonsComponent {
    viewportService: ViewportService;
    isMinimal: i0.InputSignal<boolean>;
    isConnectionLost: i0.InputSignal<boolean>;
    isActivitiesOpened: i0.InputSignal<boolean>;
    isParticipantsOpened: i0.InputSignal<boolean>;
    isChatOpened: i0.InputSignal<boolean>;
    unreadMessages: i0.InputSignal<number>;
    showActivitiesPanelButton: i0.InputSignal<boolean>;
    showParticipantsPanelButton: i0.InputSignal<boolean>;
    showChatPanelButton: i0.InputSignal<boolean>;
    recordingStatus: i0.InputSignal<any>;
    broadcastingStatus: i0.InputSignal<any>;
    toolbarAdditionalPanelButtonsTemplate: i0.InputSignal<TemplateRef<any>>;
    totalParticipants: i0.InputSignal<number>;
    toggleActivitiesPanel: i0.OutputEmitterRef<string>;
    toggleParticipantsPanel: i0.OutputEmitterRef<void>;
    toggleChatPanel: i0.OutputEmitterRef<void>;
    visibleButtonsCount: i0.Signal<number>;
    isAnyPanelOpened: i0.Signal<boolean>;
    constructor(viewportService: ViewportService);
    get shouldShowCollapsed(): boolean;
    onToggleActivities(expand?: string): void;
    onToggleParticipants(): void;
    onToggleChat(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarPanelButtonsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarPanelButtonsComponent, "ov-toolbar-panel-buttons", never, { "isMinimal": { "alias": "isMinimal"; "required": false; "isSignal": true; }; "isConnectionLost": { "alias": "isConnectionLost"; "required": false; "isSignal": true; }; "isActivitiesOpened": { "alias": "isActivitiesOpened"; "required": false; "isSignal": true; }; "isParticipantsOpened": { "alias": "isParticipantsOpened"; "required": false; "isSignal": true; }; "isChatOpened": { "alias": "isChatOpened"; "required": false; "isSignal": true; }; "unreadMessages": { "alias": "unreadMessages"; "required": false; "isSignal": true; }; "showActivitiesPanelButton": { "alias": "showActivitiesPanelButton"; "required": false; "isSignal": true; }; "showParticipantsPanelButton": { "alias": "showParticipantsPanelButton"; "required": false; "isSignal": true; }; "showChatPanelButton": { "alias": "showChatPanelButton"; "required": false; "isSignal": true; }; "recordingStatus": { "alias": "recordingStatus"; "required": false; "isSignal": true; }; "broadcastingStatus": { "alias": "broadcastingStatus"; "required": false; "isSignal": true; }; "toolbarAdditionalPanelButtonsTemplate": { "alias": "toolbarAdditionalPanelButtonsTemplate"; "required": false; "isSignal": true; }; "totalParticipants": { "alias": "totalParticipants"; "required": false; "isSignal": true; }; }, { "toggleActivitiesPanel": "toggleActivitiesPanel"; "toggleParticipantsPanel": "toggleParticipantsPanel"; "toggleChatPanel": "toggleChatPanel"; }, never, never, false, never>;
}

/**
 * @internal
 */
declare class DocumentService {
    constructor();
    toggleFullscreen(elementId: string): void;
    isSmallElement(element: HTMLElement | Element): boolean;
    /**
     * @internal
     * Get the document object (can be overridden for testing)
     */
    protected getDocument(): any;
    /**
     * @internal
     * Get element by ID (can be overridden for testing)
     */
    protected getElementById(elementId: string): any;
    /**
     * @internal
     * Check if currently in fullscreen mode
     */
    protected isInFullscreen(): boolean;
    /**
     * @internal
     * Request fullscreen on element using vendor-specific methods
     */
    protected requestFullscreen(element: any): void;
    /**
     * @internal
     * Exit fullscreen using vendor-specific methods
     */
    protected exitFullscreen(document: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentService>;
}

/**
 * The **ToolbarComponent** is hosted inside of the {@link VideoconferenceComponent}.
 * It is in charge of displaying the participants controlls for handling the media, panels and more videoconference features.
 */
declare class ToolbarComponent implements OnInit, OnDestroy, AfterViewInit {
    private layoutService;
    private documentService;
    private chatService;
    private panelService;
    private participantService;
    private openviduService;
    private deviceService;
    private actionService;
    private loggerSrv;
    private cd;
    private libService;
    private platformService;
    private recordingService;
    private broadcastingService;
    private translateService;
    private storageSrv;
    private cdkOverlayService;
    private templateManagerService;
    /**
     * @ignore
     */
    toolbarAdditionalButtonsTemplate: TemplateRef<any> | undefined;
    /**
     * @ignore
     */
    toolbarLeaveButtonTemplate: TemplateRef<any> | undefined;
    /**
     * @ignore
     */
    toolbarAdditionalPanelButtonsTemplate: TemplateRef<any> | undefined;
    /**
     * @internal
     * Template for additional menu items in the more options menu
     */
    moreOptionsAdditionalMenuItemsTemplate: TemplateRef<any> | undefined;
    private _externalMoreOptionsAdditionalMenuItems?;
    /**
     * @internal
     */
    set externalMoreOptionsAdditionalMenuItems(value: ToolbarMoreOptionsAdditionalMenuItemsDirective);
    /**
     * @internal
     */
    get externalMoreOptionsAdditionalMenuItems(): ToolbarMoreOptionsAdditionalMenuItemsDirective | undefined;
    /**
     * @ignore
     */
    set externalAdditionalButtons(externalAdditionalButtons: ToolbarAdditionalButtonsDirective);
    /**
     * @ignore
     */
    set externalLeaveButton(externalLeaveButton: LeaveButtonDirective);
    /**
     * @ignore
     */
    set externalAdditionalPanelButtons(externalAdditionalPanelButtons: ToolbarAdditionalPanelButtonsDirective);
    /**
     * This event is emitted when the room has been disconnected.
     *  @deprecated Use {@link ToolbarComponent.onParticipantLeft} instead.
     */
    onRoomDisconnected: EventEmitter<void>;
    /**
     * This event is emitted when the local participant leaves the room.
     */
    onParticipantLeft: EventEmitter<ParticipantLeftEvent>;
    /**
     * This event is emitted when the video state changes, providing information about if the video is enabled (true) or disabled (false).
     */
    onVideoEnabledChanged: EventEmitter<boolean>;
    /**
     * This event is emitted when the video state changes, providing information about if the video is enabled (true) or disabled (false).
     */
    onAudioEnabledChanged: EventEmitter<boolean>;
    /**
     * This event is emitted when the fullscreen state changes, providing information about if the fullscreen is enabled (true) or disabled (false).
     */
    onFullscreenEnabledChanged: EventEmitter<boolean>;
    /**
     * This event is emitted when the screen share state changes, providing information about if the screen share is enabled (true) or disabled (false).
     */
    onScreenShareEnabledChanged: EventEmitter<boolean>;
    /**
     * This event is fired when the user clicks on the start recording button.
     * It provides the {@link RecordingStartRequestedEvent} payload as event data.
     */
    onRecordingStartRequested: EventEmitter<RecordingStartRequestedEvent>;
    /**
     * Provides event notifications that fire when stop recording has been requested.
     * It provides the {@link RecordingStopRequestedEvent} payload as event data.
     */
    onRecordingStopRequested: EventEmitter<RecordingStopRequestedEvent>;
    /**
     * Provides event notifications that fire when stop broadcasting has been requested.
     * It provides the {@link BroadcastingStopRequestedEvent} payload as event data.
     */
    onBroadcastingStopRequested: EventEmitter<BroadcastingStopRequestedEvent>;
    /**
     * @internal
     * This event is fired when the user clicks on the view recordings button.
     */
    onViewRecordingsClicked: EventEmitter<void>;
    /**
     * @ignore
     */
    menuTrigger: MatMenuTrigger | undefined;
    /**
     * @ignore
     */
    room: Room;
    /**
     * @ignore
     */
    unreadMessages: number;
    /**
     * @ignore
     */
    messageList: ChatMessage[];
    /**
     * @ignore
     */
    isScreenShareEnabled: boolean;
    /**
     * @ignore
     */
    isCameraEnabled: boolean;
    /**
     * @ignore
     */
    isMicrophoneEnabled: boolean;
    /**
     * @ignore
     */
    isConnectionLost: boolean;
    /**
     * @ignore
     */
    hasVideoDevices: boolean;
    /**
     * @ignore
     */
    hasAudioDevices: boolean;
    /**
     * @ignore
     */
    isFullscreenActive: boolean;
    /**
     * @ignore
     */
    isChatOpened: boolean;
    /**
     * @ignore
     */
    isParticipantsOpened: boolean;
    /**
     * @ignore
     */
    isActivitiesOpened: boolean;
    /**
     * @ignore
     */
    isMinimal: boolean;
    /**
     * @ignore
     */
    showCameraButton: boolean;
    /**
     * @ignore
     */
    showMicrophoneButton: boolean;
    /**
     * @ignore
     */
    showScreenshareButton: boolean;
    /**
     * @ignore
     */
    showFullscreenButton: boolean;
    /**
     * @ignore
     */
    showBackgroundEffectsButton: boolean;
    /**
     * @ignore
     */
    showLeaveButton: boolean;
    /**
     * @ignore
     */
    showRecordingButton: boolean;
    /**
     * @ignore
     */
    showViewRecordingsButton: boolean;
    /**
     * @ignore
     */
    showBroadcastingButton: boolean;
    /**
     * @ignore
     */
    showSettingsButton: boolean;
    /**
     * @ignore
     */
    showMoreOptionsButton: boolean;
    /**
     * @ignore
     */
    showParticipantsPanelButton: boolean;
    /**
     * @ignore
     */
    showActivitiesPanelButton: boolean;
    /**
     * @ignore
     */
    showChatPanelButton: boolean;
    /**
     * @ignore
     */
    showLogo: boolean;
    /**
     * @ignore
     */
    brandingLogo: string;
    /**
     * @ignore
     */
    showRoomName: boolean;
    /**
     * @ignore
     */
    roomName: string;
    /**
     * @ignore
     */
    showCaptionsButton: boolean;
    /**
     * @internal
     */
    isFirefoxBrowser: boolean;
    /**
     * @ignore
     */
    additionalButtonsPosition: ToolbarAdditionalButtonsPosition;
    /**
     * @ignore
     */
    captionsEnabled: boolean;
    /**
     * @ignore
     */
    cameraMuteChanging: boolean;
    /**
     * @ignore
     */
    microphoneMuteChanging: boolean;
    /**
     * @ignore
     */
    recordingStatus: RecordingStatus;
    /**
     * @ignore
     */
    isRecordingReadOnlyMode: boolean;
    /**
     * @ignore
     */
    private startedRecording;
    /**
     * @ignore
     */
    broadcastingStatus: BroadcastingStatus;
    /**
     * @ignore
     */
    broadcastingId: string | undefined;
    /**
     * @ignore
     */
    _recordingStatus: typeof RecordingStatus;
    /**
     * @ignore
     */
    _broadcastingStatus: typeof BroadcastingStatus;
    /**
     * @ignore
     */
    recordingTime: Date | undefined;
    /**
     * @internal
     * Template configuration managed by the service
     */
    templateConfig: ToolbarTemplateConfiguration;
    /**
     * @internal
     * Computed signal for total participants count (local + remote)
     */
    totalParticipants: i0.Signal<number>;
    private _externalAdditionalButtons?;
    private _externalLeaveButton?;
    private _externalAdditionalPanelButtons?;
    private log;
    private destroy$;
    private currentWindowHeight;
    /**
     * @ignore
     */
    constructor(layoutService: LayoutService, documentService: DocumentService, chatService: ChatService, panelService: PanelService, participantService: ParticipantService, openviduService: OpenViduService, deviceService: DeviceService, actionService: ActionService, loggerSrv: LoggerService, cd: ChangeDetectorRef, libService: OpenViduComponentsConfigService, platformService: PlatformService, recordingService: RecordingService, broadcastingService: BroadcastingService, translateService: TranslateService, storageSrv: StorageService, cdkOverlayService: CdkOverlayService, templateManagerService: TemplateManagerService);
    /**
     * @ignore
     */
    get isRecordingStarted(): boolean;
    /**
     * @ignore
     */
    get isBroadcastingStarted(): boolean;
    /**
     * @ignore
     */
    sizeChange(_: Event): void;
    /**
     * @ignore
     */
    keyDown(event: KeyboardEvent): boolean;
    ngOnInit(): Promise<void>;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * @internal
     * Sets up all templates using the template manager service
     */
    private setupTemplates;
    /**
     * @internal
     * Applies the template configuration to component properties
     */
    private applyTemplateConfiguration;
    /**
     * @internal
     * Updates templates and triggers change detection
     */
    private updateTemplatesAndMarkForCheck;
    /**
     * @internal
     */
    get hasRoomTracksPublished(): boolean;
    /**
     * @ignore
     */
    toggleMicrophone(): Promise<void>;
    /**
     * @ignore
     */
    toggleCamera(): Promise<void>;
    /**
     * @ignore
     */
    toggleScreenShare(): Promise<void>;
    /**
     * @ignore
     */
    replaceScreenTrack(): Promise<void>;
    /**
     * The participant leaves the room voluntarily.
     * @ignore
     */
    disconnect(): Promise<void>;
    /**
     * @ignore
     */
    openRecordingActivityPanel(): void;
    /**
     * @ignore
     */
    openBroadcastingActivityPanel(): void;
    /**
     * @ignore
     */
    toggleRecording(): void;
    /**
     * @ignore
     */
    toggleBroadcasting(): void;
    /**
     * @ignore
     */
    toggleBackgroundEffects(): void;
    /**
     * @ignore
     */
    onCaptionsToggle(): void;
    /**
     * @ignore
     */
    toggleSettings(): void;
    /**
     * @ignore
     */
    toggleParticipantsPanel(): void;
    /**
     * @ignore
     */
    toggleChatPanel(): void;
    /**
     * @ignore
     */
    toggleFullscreen(): void;
    /**
     * @internal
     * @param expandPanel
     */
    toggleActivitiesPanel(expandPanel: string): void;
    private subscribeToReconnection;
    private subscribeToFullscreenChanged;
    private subscribeToMenuToggling;
    private subscribeToChatMessages;
    private subscribeToRecordingStatus;
    private subscribeToBroadcastingStatus;
    private subscribeToToolbarDirectives;
    private subscribeToCaptionsToggling;
    private checkDisplayMoreOptions;
    private evalAndSetRoomName;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "ov-toolbar", never, {}, { "onRoomDisconnected": "onRoomDisconnected"; "onParticipantLeft": "onParticipantLeft"; "onVideoEnabledChanged": "onVideoEnabledChanged"; "onAudioEnabledChanged": "onAudioEnabledChanged"; "onFullscreenEnabledChanged": "onFullscreenEnabledChanged"; "onScreenShareEnabledChanged": "onScreenShareEnabledChanged"; "onRecordingStartRequested": "onRecordingStartRequested"; "onRecordingStopRequested": "onRecordingStopRequested"; "onBroadcastingStopRequested": "onBroadcastingStopRequested"; "onViewRecordingsClicked": "onViewRecordingsClicked"; }, ["toolbarAdditionalButtonsTemplate", "toolbarLeaveButtonTemplate", "toolbarAdditionalPanelButtonsTemplate", "externalMoreOptionsAdditionalMenuItems", "externalAdditionalButtons", "externalLeaveButton", "externalAdditionalPanelButtons"], never, false, never>;
}

/**
 * Enum representing the possible states of the videoconference component
 */
declare enum VideoconferenceState {
    /**
     * Initial state when the component is loading
     */
    INITIALIZING = "INITIALIZING",
    /**
     * Prejoin page is being shown to the user
     */
    PREJOIN_SHOWN = "PREJOIN_SHOWN",
    /**
     * User has initiated the join process, waiting for token
     */
    JOINING = "JOINING",
    /**
     * Token received and room is ready to connect
     */
    READY_TO_CONNECT = "READY_TO_CONNECT",
    /**
     * Successfully connected to the room
     */
    CONNECTED = "CONNECTED",
    /**
     * Disconnected from the room
     */
    DISCONNECTED = "DISCONNECTED",
    /**
     * Error state
     */
    ERROR = "ERROR"
}
/**
 * Interface representing the state information of the videoconference component
 */
interface VideoconferenceStateInfo {
    /**
     * Current state of the videoconference
     */
    state: VideoconferenceState;
    /**
     * Whether prejoin page should be visible
     */
    showPrejoin: boolean;
    /**
     * Whether room is ready for connection
     */
    isRoomReady: boolean;
    /**
     * Whether user is connected to the room
     */
    isConnected: boolean;
    /**
     * Whether audio devices are available
     */
    hasAudioDevices: boolean;
    /**
     * Whether video devices are available
     */
    hasVideoDevices: boolean;
    /**
     * Whether user has initiated the join process
     */
    hasUserInitiatedJoin: boolean;
    /**
     * Whether prejoin was shown to the user at least once
     */
    wasPrejoinShown: boolean;
    /**
     * Whether the component is in loading state
     */
    isLoading: boolean;
    /**
     * Error information if any
     */
    error?: {
        hasError: boolean;
        message?: string;
        tokenError?: any;
    };
}

/**
 * Service for managing OpenVidu component themes dynamically
 *
 * This service allows you to:
 * - Switch between light, dark and classic themes
 * - Apply custom theme variables
 * - Listen to theme changes
 * - Integrate with Angular Material themes
 *
 * @internal
 */
declare class OpenViduThemeService {
    private document;
    protected storageService: StorageService;
    private readonly THEME_ATTRIBUTE;
    private currentThemeSubject;
    private currentVariablesSubject;
    /**
     * Observable that emits the current theme mode
     */
    readonly currentTheme$: Observable<OpenViduThemeMode>;
    /**
     * Observable that emits the current theme variables
     */
    readonly currentVariables$: Observable<OpenViduThemeVariables>;
    constructor(document: Document, storageService: StorageService);
    initializeTheme(): void;
    getAllThemes(): OpenViduThemeMode[];
    /**
     * Gets the current theme mode
     */
    getCurrentTheme(): OpenViduThemeMode;
    /**
     * Gets the current theme variables
     */
    getCurrentVariables(): OpenViduThemeVariables;
    /**
     * Sets the theme mode to apply {@link OpenViduThemeMode}
     * @param theme The theme mode to apply
     */
    setTheme(theme: OpenViduThemeMode): void;
    /**
     * Updates specific theme variables
     * @param variables Object containing CSS variables to update
     */
    updateThemeVariables(variables: OpenViduThemeVariables): void;
    /**
     * Replaces all theme variables with a new set
     * @param variables Complete set of theme variables
     */
    setThemeVariables(variables: OpenViduThemeVariables): void;
    /**
     * Resets theme variables to default values based on current theme
     */
    resetThemeVariables(): void;
    /**
     * Applies a predefined theme configuration
     * @param themeVariables Predefined theme configuration (e.g., OPENVIDU_LIGHT_THEME)
     */
    applyThemeConfiguration(themeVariables: OpenViduThemeVariables): void;
    /**
     * Toggles between light and dark themes
     */
    toggleTheme(): void;
    /**
     * Gets a specific CSS variable value
     * @param variableName The CSS variable name (with or without --)
     */
    getThemeVariable(variableName: string): string;
    /**
     * Checks if the system prefers dark mode
     */
    prefersDarkMode(): boolean;
    private applyTheme;
    private applyCSSVariables;
    private removeCSSVariables;
    private getDefaultVariablesForTheme;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenViduThemeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OpenViduThemeService>;
}

/**
 * The **VideoconferenceComponent** is the parent of all OpenVidu components.
 * It allow us to create a modern, useful and powerful videoconference apps with ease.
 */
declare class VideoconferenceComponent implements OnDestroy, AfterViewInit {
    private loggerSrv;
    private storageSrv;
    private deviceSrv;
    private openviduService;
    private actionService;
    private libService;
    private templateManagerService;
    private themeService;
    private e2eeService;
    private static readonly PARTICIPANT_NAME_TIMEOUT_MS;
    private static readonly ANIMATION_DURATION_MS;
    private static readonly MATERIAL_ICONS_URL;
    private static readonly MATERIAL_ICONS_SELECTOR;
    private static readonly SPINNER_DIAMETER;
    private _externalToolbar?;
    /**
     * @internal
     */
    set externalToolbar(value: ToolbarDirective);
    get externalToolbar(): ToolbarDirective | undefined;
    private _externalToolbarAdditionalButtons?;
    /**
     * @internal
     */
    set externalToolbarAdditionalButtons(value: ToolbarAdditionalButtonsDirective);
    /**
     * @internal
     */
    get externalToolbarAdditionalButtons(): ToolbarAdditionalButtonsDirective | undefined;
    private _externalToolbarLeaveButton?;
    /**
     * @internal
     */
    set externalToolbarLeaveButton(value: LeaveButtonDirective);
    /**
     * @internal
     */
    get externalToolbarLeaveButton(): LeaveButtonDirective | undefined;
    private _externalToolbarAdditionalPanelButtons?;
    /**
     * @internal
     */
    set externalToolbarAdditionalPanelButtons(value: ToolbarAdditionalPanelButtonsDirective);
    /**
     * @internal
     */
    get externalToolbarAdditionalPanelButtons(): ToolbarAdditionalPanelButtonsDirective | undefined;
    private _externalAdditionalPanels?;
    /**
     * @internal
     */
    set externalAdditionalPanels(value: AdditionalPanelsDirective);
    /**
     * @internal
     */
    get externalAdditionalPanels(): AdditionalPanelsDirective | undefined;
    private _externalPanel?;
    /**
     * @internal
     */
    set externalPanel(value: PanelDirective);
    /**
     * @internal
     */
    get externalPanel(): PanelDirective | undefined;
    private _externalChatPanel?;
    /**
     * @internal
     */
    set externalChatPanel(value: ChatPanelDirective);
    /**
     * @internal
     */
    get externalChatPanel(): ChatPanelDirective | undefined;
    private _externalActivitiesPanel?;
    /**
     * @internal
     */
    set externalActivitiesPanel(value: ActivitiesPanelDirective);
    /**
     * @internal
     */
    get externalActivitiesPanel(): ActivitiesPanelDirective | undefined;
    private _externalParticipantsPanel?;
    /**
     * @internal
     */
    set externalParticipantsPanel(value: ParticipantsPanelDirective);
    /**
     * @internal
     */
    get externalParticipantsPanel(): ParticipantsPanelDirective | undefined;
    private _externalParticipantPanelItem?;
    /**
     * @internal
     */
    set externalParticipantPanelItem(value: ParticipantPanelItemDirective);
    /**
     * @internal
     */
    get externalParticipantPanelItem(): ParticipantPanelItemDirective | undefined;
    private _externalParticipantPanelItemElements?;
    /**
     * @internal
     */
    set externalParticipantPanelItemElements(value: ParticipantPanelItemElementsDirective);
    /**
     * @internal
     */
    get externalParticipantPanelItemElements(): ParticipantPanelItemElementsDirective | undefined;
    private _externalLayout?;
    /**
     * @internal
     */
    set externalLayout(value: LayoutDirective);
    /**
     * @internal
     */
    get externalLayout(): LayoutDirective | undefined;
    private _externalStream?;
    /**
     * @internal
     */
    set externalStream(value: StreamDirective);
    /**
     * @internal
     */
    get externalStream(): StreamDirective | undefined;
    private _externalPreJoin?;
    /**
     * @internal
     */
    set externalPreJoin(value: PreJoinDirective);
    /**
     * @internal
     */
    get externalPreJoin(): PreJoinDirective | undefined;
    private _externalParticipantPanelAfterLocalParticipant?;
    /**
     * @internal
     */
    set externalParticipantPanelAfterLocalParticipant(value: ParticipantPanelAfterLocalParticipantDirective);
    /**
     * @internal
     */
    get externalParticipantPanelAfterLocalParticipant(): ParticipantPanelAfterLocalParticipantDirective | undefined;
    private _externalLayoutAdditionalElements?;
    /**
     * @internal
     */
    set externalLayoutAdditionalElements(value: LayoutAdditionalElementsDirective);
    /**
     * @internal
     */
    get externalLayoutAdditionalElements(): LayoutAdditionalElementsDirective | undefined;
    private _externalSettingsPanelGeneralAdditionalElements?;
    /**
     * @internal
     */
    set externalSettingsPanelGeneralAdditionalElements(value: SettingsPanelGeneralAdditionalElementsDirective);
    /**
     * @internal
     */
    get externalSettingsPanelGeneralAdditionalElements(): SettingsPanelGeneralAdditionalElementsDirective | undefined;
    private _externalToolbarMoreOptionsAdditionalMenuItems?;
    /**
     * @internal
     */
    set externalToolbarMoreOptionsAdditionalMenuItems(value: ToolbarMoreOptionsAdditionalMenuItemsDirective);
    /**
     * @internal
     */
    get externalToolbarMoreOptionsAdditionalMenuItems(): ToolbarMoreOptionsAdditionalMenuItemsDirective | undefined;
    /**
     * @internal
     */
    defaultToolbarTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    defaultPanelTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    defaultChatPanelTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    defaultParticipantsPanelTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    defaultActivitiesPanelTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    defaultParticipantPanelItemTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    defaultLayoutTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    defaultStreamTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularToolbarTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularToolbarAdditionalButtonsTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularToolbarLeaveButtonTemplate: TemplateRef<any> | undefined;
    /**
     * @internal
     */
    openviduAngularActivitiesPanelTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularToolbarAdditionalPanelButtonsTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularPanelTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularChatPanelTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularParticipantsPanelTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularAdditionalPanelsTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularParticipantPanelAfterLocalParticipantTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularParticipantPanelItemTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularParticipantPanelItemElementsTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularLayoutTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularStreamTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    openviduAngularPreJoinTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    ovLayoutAdditionalElementsTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    ovSettingsPanelGeneralAdditionalElementsTemplate: TemplateRef<any>;
    /**
     * @internal
     */
    ovToolbarMoreOptionsAdditionalMenuItemsTemplate: TemplateRef<any>;
    /**
     * @internal
     * Template configuration managed by TemplateManagerService
     */
    private templateConfig;
    /**
     * Provides event notifications that fire when the local participant is ready to join to the room.
     * This event emits the participant name as data.
     */
    onTokenRequested: EventEmitter<string>;
    /**
     * Provides event notifications that fire when the local participant is ready to join to the room.
     * This event is only emitted when the prejoin page has been shown.
     */
    onReadyToJoin: EventEmitter<void>;
    /**
     * Provides event notifications that fire when Room is disconnected for the local participant.
     * @deprecated Use {@link VideoconferenceComponent.onParticipantLeft} instead
     */
    onRoomDisconnected: EventEmitter<void>;
    /**
     * Provides event notifications that fire when Room is being reconnected for the local participant.
     */
    onRoomReconnecting: EventEmitter<void>;
    /**
     * Provides event notifications that fire when Room is reconnected for the local participant.
     */
    onRoomReconnected: EventEmitter<void>;
    /**
     * This event is emitted when the local participant leaves the room.
     */
    onParticipantLeft: EventEmitter<ParticipantLeftEvent>;
    /**
     * This event is emitted when the video state changes, providing information about if the video is enabled (true) or disabled (false).
     */
    onVideoEnabledChanged: EventEmitter<boolean>;
    /**
     * This event is emitted when the selected video device changes, providing information about the new custom device that has been selected.
     */
    onVideoDeviceChanged: EventEmitter<CustomDevice>;
    /**
     * This event is emitted when the audio state changes, providing information about if the audio is enabled (true) or disabled (false).
     */
    onAudioEnabledChanged: EventEmitter<boolean>;
    /**
     * This event is emitted when the selected audio device changes, providing information about the new custom device that has been selected.
     */
    onAudioDeviceChanged: EventEmitter<CustomDevice>;
    /**
     * This event is emitted when the language changes, providing information about the new language that has been selected.
     */
    onLangChanged: EventEmitter<LangOption>;
    /**
     * This event is emitted when the screen share state changes, providing information about if the screen share is enabled (true) or disabled (false).
     */
    onScreenShareEnabledChanged: EventEmitter<boolean>;
    /**
     * The event is emitted when the fullscreen state changes, providing information about if the fullscreen is enabled (true) or disabled (false).
     */
    onFullscreenEnabledChanged: EventEmitter<boolean>;
    /**
     * This event is fired when the chat panel status has been changed.
     * It provides the new status of the chat panel as {@link ChatPanelStatusEvent} payload.
     */
    onChatPanelStatusChanged: EventEmitter<ChatPanelStatusEvent>;
    /**
     * This event is fired when the participants panel status has been changed.
     * It provides the new status of the participants panel as {@link ParticipantsPanelStatusEvent} payload.
     */
    onParticipantsPanelStatusChanged: EventEmitter<ParticipantsPanelStatusEvent>;
    /**
     * This event is fired when the settings panel status has been changed.
     * It provides the new status of the settings panel as {@link SettingsPanelStatusEvent} payload.
     */
    onSettingsPanelStatusChanged: EventEmitter<SettingsPanelStatusEvent>;
    /**
     * This event is fired when the activities panel status has been changed.
     * It provides the new status of the activities panel as {@link ActivitiesPanelStatusEvent} payload.
     */
    onActivitiesPanelStatusChanged: EventEmitter<ActivitiesPanelStatusEvent>;
    /**
     * Provides event notifications that fire when stop recording button has been clicked.
     * It provides the {@link RecordingStopRequestedEvent} payload as event data.
     */
    onRecordingStopRequested: EventEmitter<RecordingStopRequestedEvent>;
    /**
     * This event is fired when the user clicks on the start recording button.
     * It provides the {@link RecordingStartRequestedEvent} payload as event data.
     */
    onRecordingStartRequested: EventEmitter<RecordingStartRequestedEvent>;
    /**
     * Provides event notifications that fire when delete recording button has been clicked.
     * It provides the {@link RecordingDeleteRequestedEvent} payload as event data.
     */
    onRecordingDeleteRequested: EventEmitter<RecordingDeleteRequestedEvent>;
    /**
     * Provides event notifications that fire when play recording button is clicked from {@link ActivitiesPanelComponent}.
     * It provides the {@link RecordingPlayClickedEvent} payload as event data.
     */
    onRecordingPlayClicked: EventEmitter<RecordingPlayClickedEvent>;
    /**
     * @internal
     * This event is fired when the user clicks on the view recording button.
     * It provides the recording ID as event data.
     */
    onViewRecordingClicked: EventEmitter<string>;
    /**
     * Provides event notifications that fire when download recording button is clicked from {@link ActivitiesPanelComponent}.
     * It provides the {@link RecordingDownloadClickedEvent} payload as event data.
     */
    onRecordingDownloadClicked: EventEmitter<RecordingDownloadClickedEvent>;
    /**
     * Provides event notifications that fire when start broadcasting button is clicked.
     * It provides the {@link BroadcastingStartRequestedEvent} payload as event data.
     */
    onBroadcastingStartRequested: EventEmitter<BroadcastingStartRequestedEvent>;
    /**
     * Provides event notifications that fire when stop broadcasting button is clicked.
     * It provides the {@link BroadcastingStopRequestedEvent} payload as event data.
     */
    onBroadcastingStopRequested: EventEmitter<BroadcastingStopRequestedEvent>;
    /**
     * @internal
     * This event is fired when the user clicks on the view recordings button.
     */
    onViewRecordingsClicked: EventEmitter<void>;
    /**
     * Provides event notifications that fire when Room is created for the local participant.
     * It provides the {@link https://openvidu.io/latest/docs/getting-started/#room Room} payload as event data.
     */
    onRoomCreated: EventEmitter<Room>;
    /**
     * Provides event notifications that fire when local participant is created and connected to the Room.
     * @deprecated Use `onParticipantConnected` instead
     */
    onParticipantCreated: EventEmitter<ParticipantModel>;
    /**
     * Provides event notifications that fire when local participant is connected to the Room.
     * It provides the {@link ParticipantModel} payload as event data.
     */
    onParticipantConnected: EventEmitter<ParticipantModel>;
    /**
     * @internal
     * Centralized state management for the videoconference component
     */
    componentState: VideoconferenceStateInfo;
    private destroy$;
    private log;
    private latestParticipantName;
    get spinnerDiameter(): number;
    /**
     * @internal
     * Updates the component state
     */
    private updateComponentState;
    /**
     * @internal
     * Checks if user has initiated the join process
     */
    private hasUserInitiatedJoin;
    /**
     * @internal
     */
    constructor(loggerSrv: LoggerService, storageSrv: StorageService, deviceSrv: DeviceService, openviduService: OpenViduService, actionService: ActionService, libService: OpenViduComponentsConfigService, templateManagerService: TemplateManagerService, themeService: OpenViduThemeService, e2eeService: E2eeService);
    ngOnDestroy(): void;
    /**
     * @internal
     */
    ngAfterViewInit(): void;
    /**
     * @internal
     */
    private addMaterialIconsIfNeeded;
    /**
     * @internal
     */
    private setupTemplates;
    /**
     * @internal
     * Applies the template configuration to component properties
     */
    private applyTemplateConfiguration;
    /**
     * @internal
     * Handles the ready-to-join event, initializing the room and managing the prejoin flow.
     * This method coordinates the transition from prejoin state to actual room joining.
     */
    _onReadyToJoin(): void;
    /**
     * @internal
     */
    _onParticipantLeft(event: ParticipantLeftEvent): void;
    private subscribeToVideconferenceDirectives;
    static ɵfac: i0.ɵɵFactoryDeclaration<VideoconferenceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VideoconferenceComponent, "ov-videoconference", never, {}, { "onTokenRequested": "onTokenRequested"; "onReadyToJoin": "onReadyToJoin"; "onRoomDisconnected": "onRoomDisconnected"; "onRoomReconnecting": "onRoomReconnecting"; "onRoomReconnected": "onRoomReconnected"; "onParticipantLeft": "onParticipantLeft"; "onVideoEnabledChanged": "onVideoEnabledChanged"; "onVideoDeviceChanged": "onVideoDeviceChanged"; "onAudioEnabledChanged": "onAudioEnabledChanged"; "onAudioDeviceChanged": "onAudioDeviceChanged"; "onLangChanged": "onLangChanged"; "onScreenShareEnabledChanged": "onScreenShareEnabledChanged"; "onFullscreenEnabledChanged": "onFullscreenEnabledChanged"; "onChatPanelStatusChanged": "onChatPanelStatusChanged"; "onParticipantsPanelStatusChanged": "onParticipantsPanelStatusChanged"; "onSettingsPanelStatusChanged": "onSettingsPanelStatusChanged"; "onActivitiesPanelStatusChanged": "onActivitiesPanelStatusChanged"; "onRecordingStopRequested": "onRecordingStopRequested"; "onRecordingStartRequested": "onRecordingStartRequested"; "onRecordingDeleteRequested": "onRecordingDeleteRequested"; "onRecordingPlayClicked": "onRecordingPlayClicked"; "onViewRecordingClicked": "onViewRecordingClicked"; "onRecordingDownloadClicked": "onRecordingDownloadClicked"; "onBroadcastingStartRequested": "onBroadcastingStartRequested"; "onBroadcastingStopRequested": "onBroadcastingStopRequested"; "onViewRecordingsClicked": "onViewRecordingsClicked"; "onRoomCreated": "onRoomCreated"; "onParticipantCreated": "onParticipantCreated"; "onParticipantConnected": "onParticipantConnected"; }, ["externalToolbar", "externalToolbarAdditionalButtons", "externalToolbarLeaveButton", "externalToolbarAdditionalPanelButtons", "externalAdditionalPanels", "externalPanel", "externalChatPanel", "externalActivitiesPanel", "externalParticipantsPanel", "externalParticipantPanelItem", "externalParticipantPanelItemElements", "externalLayout", "externalStream", "externalPreJoin", "externalParticipantPanelAfterLocalParticipant", "externalLayoutAdditionalElements", "externalSettingsPanelGeneralAdditionalElements", "externalToolbarMoreOptionsAdditionalMenuItems"], never, false, never>;
}

/**
 * The **recordingActivity** directive allows show/hide the recording activity in {@link ActivitiesPanelComponent}.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `activitiesPanel` component:
 *
 * @example
 * <ov-videoconference [activitiesPanelRecordingActivity]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ActivitiesPanelComponent}.
 * @example
 * <ov-activities-panel *ovActivitiesPanel [recordingActivity]="false"></ov-activities-panel>
 */
declare class ActivitiesPanelRecordingActivityDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set activitiesPanelRecordingActivity(value: boolean);
    set recordingActivity(value: boolean);
    recordingActivityValue: boolean;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    clear(): void;
    update(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivitiesPanelRecordingActivityDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ActivitiesPanelRecordingActivityDirective, "ov-videoconference[activitiesPanelRecordingActivity], ov-activities-panel[recordingActivity]", never, { "activitiesPanelRecordingActivity": { "alias": "activitiesPanelRecordingActivity"; "required": false; }; "recordingActivity": { "alias": "recordingActivity"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **broadcastingActivity** directive allows show/hide the broadcasting activity in {@link ActivitiesPanelComponent}.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `activitiesPanel` component:
 *
 * @example
 * <ov-videoconference [activitiesPanelBroadcastingActivity]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ActivitiesPanelComponent}.
 * @example
 * <ov-activities-panel *ovActivitiesPanel [broadcastingActivity]="false"></ov-activities-panel>
 */
declare class ActivitiesPanelBroadcastingActivityDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set activitiesPanelBroadcastingActivity(value: boolean);
    set broadcastingActivity(value: boolean);
    broadcastingActivityValue: boolean;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    clear(): void;
    update(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivitiesPanelBroadcastingActivityDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ActivitiesPanelBroadcastingActivityDirective, "ov-videoconference[activitiesPanelBroadcastingActivity], ov-activities-panel[broadcastingActivity]", never, { "activitiesPanelBroadcastingActivity": { "alias": "activitiesPanelBroadcastingActivity"; "required": false; }; "broadcastingActivity": { "alias": "broadcastingActivity"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * The **recordingsList** directive allows show all recordings saved in your OpenVidu deployment in {@link AdminDashboardComponent}.
 *
 * Default: `[]`
 *
 * @example
 * <ov-admin-dashboard [recordingsList]="recordings"></ov-admin-dashboard>
 *
 */
declare class AdminDashboardRecordingsListDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set recordingsList(value: RecordingInfo[]);
    recordingsValue: RecordingInfo[];
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    clear(): void;
    update(value: RecordingInfo[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdminDashboardRecordingsListDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AdminDashboardRecordingsListDirective, "ov-admin-dashboard[recordingsList]", never, { "recordingsList": { "alias": "recordingsList"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **navbarTitle** directive allows customize the title of the navbar in {@link AdminLoginComponent}.
 *
 * Default: `'OpenVidu Call Dashboard'`
 *
 * @example
 * <ov-admin-dashboard [navbarTitle]="'My Dashboard'"></ov-admin-dashboard>
 *
 */
declare class AdminDashboardTitleDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set navbarTitle(value: string);
    navbarTitleValue: string;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    clear(): void;
    update(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdminDashboardTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AdminDashboardTitleDirective, "ov-admin-dashboard[navbarTitle]", never, { "navbarTitle": { "alias": "navbarTitle"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **navbarTitle** directive allows customize the title of the navbar in {@link AdminLoginComponent}.
 *
 * Default: `'OpenVidu Call Dashboard'`
 *
 * @example
 * <ov-admin-login [navbarTitle]="'My login'"></ov-admin-login>
 *
 */
declare class AdminLoginTitleDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set navbarTitle(value: any);
    navbarTitleValue: any;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    clear(): void;
    update(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdminLoginTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AdminLoginTitleDirective, "ov-admin-login[navbarTitle]", never, { "navbarTitle": { "alias": "navbarTitle"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **error** directive allows show the authentication error in {@link AdminLoginComponent}.
 *
 * Default: `null`
 *
 * @example
 * <ov-admin-login [error]="error"></ov-admin-login>
 *
 */
declare class AdminLoginErrorDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set error(value: any);
    errorValue: any;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    clear(): void;
    update(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdminLoginErrorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AdminLoginErrorDirective, "ov-admin-login[error]", never, { "error": { "alias": "error"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * The **livekitUrl** directive sets the livekitUrl to grant a participant access to a Room.
 * This Livekit Url will be use by each participant when connecting to a Room.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 *  Default: `""`
 *
 * @example
 * <ov-videoconference [livekitUrl]="http://localhost:1234"></ov-videoconference>
 */
declare class LivekitUrlDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set livekitUrl(value: string);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LivekitUrlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LivekitUrlDirective, "ov-videoconference[livekitUrl]", never, { "livekitUrl": { "alias": "livekitUrl"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **token** directive sets the token to grant a participant access to a Room.
 * This OpenVidu token will be use by each participant when connecting to a Room.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 *  Default: `""`
 *
 * @example
 * <ov-videoconference [token]="token"></ov-videoconference>
 */
declare class TokenDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set token(value: string);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TokenDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TokenDirective, "ov-videoconference[token]", never, { "token": { "alias": "token"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **tokenError** directive allows to display an error message in case of issues during token request.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 *  Default: `undefined`
 *
 * @example
 * <ov-videoconference [tokenError]="error"></ov-videoconference>
 */
declare class TokenErrorDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set tokenError(value: any);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TokenErrorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TokenErrorDirective, "ov-videoconference[tokenError]", never, { "tokenError": { "alias": "tokenError"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **minimal** directive applies a minimal UI hiding all controls except for cam and mic.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * Default: `false`
 *
 * @example
 * <ov-videoconference [minimal]="true"></ov-videoconference>
 */
declare class MinimalDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set minimal(value: boolean);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MinimalDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MinimalDirective, "ov-videoconference[minimal]", never, { "minimal": { "alias": "minimal"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **lang** directive allows set the UI language to a default language.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * **Default:** English `en`
 *
 * **Available Langs:**
 *
 * * English: `en`
 * * Spanish: `es`
 * * German: `de`
 * * French: `fr`
 * * Chinese: `cn`
 * * Hindi: `hi`
 * * Italian: `it`
 * * Japanese: `ja`
 * * Netherlands: `nl`
 * * Portuguese: `pt`
 *
 * @example
 * <ov-videoconference [lang]="'es'"></ov-videoconference>
 */
declare class LangDirective implements OnDestroy {
    elementRef: ElementRef;
    private translateService;
    /**
     * @ignore
     */
    set lang(value: AvailableLangs);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, translateService: TranslateService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: AvailableLangs): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LangDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LangDirective, "ov-videoconference[lang]", never, { "lang": { "alias": "lang"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **langOptions** directive allows to set the application language options.
 * It will override the application languages provided by default.
 * This propety is an array of objects which must comply with the {@link LangOption} interface.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * Default: ```
 * [
 * 	{ name: 'English', lang: 'en' },
 *  { name: 'Español', lang: 'es' },
 *  { name: 'Deutsch', lang: 'de' },
 *  { name: 'Français', lang: 'fr' },
 *  { name: '中国', lang: 'cn' },
 *  { name: 'हिन्दी', lang: 'hi' },
 *  { name: 'Italiano', lang: 'it' },
 *  { name: 'やまと', lang: 'ja' },
 *  { name: 'Dutch', lang: 'nl' },
 *  { name: 'Português', lang: 'pt' }
 * ]```
 *
 * Note: If you want to add a new language, you must add a new object with the name and the language code (e.g. `{ name: 'Custom', lang: 'cus' }`)
 * and then add the language file in the `assets/lang` folder with the name `cus.json`.
 *
 *
 * @example
 * <ov-videoconference [langOptions]="[{name:'Spanish', lang: 'es'}]"></ov-videoconference>
 */
declare class LangOptionsDirective implements OnDestroy {
    elementRef: ElementRef;
    private translateService;
    /**
     * @ignore
     */
    set langOptions(value: LangOption[]);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, translateService: TranslateService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: LangOption[] | undefined): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LangOptionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LangOptionsDirective, "ov-videoconference[langOptions]", never, { "langOptions": { "alias": "langOptions"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **captionsLang** directive allows specify the deafult language that OpenVidu will try to recognise.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * It must be a valid [BCP-47](https://tools.ietf.org/html/bcp47) language tag like "en-US" or "es-ES".
 *
 *
 * **Default:** English `en-US`
 *
 * **Available:**
 *
 * * English: `en-US`
 * * Spanish: `es-ES`
 * * German: `de-DE`
 * * French: `fr-FR`
 * * Chinese: `zh-CN`
 * * Hindi: `hi-IN`
 * * Italian: `it-IT`
 * * Japanese: `jp-JP`
 * * Portuguese: `pt-PT`
 *
 * @example
 * <ov-videoconference [captionsLang]="'es-ES'"></ov-videoconference>
 * TODO: Uncomment when captions are implemented
 */
/**
 * The **captionsLangOptions** directive allows to set the language options for the captions.
 * It will override the languages provided by default.
 * This propety is an array of objects which must comply with the {@link CaptionsLangOption} interface.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * Default: ```
 * [
 * 	{ name: 'English', lang: 'en-US' },
 * 	{ name: 'Español', lang: 'es-ES' },
 * 	{ name: 'Deutsch', lang: 'de-DE' },
 * 	{ name: 'Français', lang: 'fr-FR' },
 * 	{ name: '中国', lang: 'zh-CN' },
 * 	{ name: 'हिन्दी', lang: 'hi-IN' },
 * 	{ name: 'Italiano', lang: 'it-IT' },
 * 	{ name: '日本語', lang: 'jp-JP' },
 * 	{ name: 'Português', lang: 'pt-PT' }
 * ]```
 *
 * @example
 * <ov-videoconference [captionsLangOptions]="[{name:'Spanish', lang: 'es-ES'}]"></ov-videoconference>
 * TODO: Uncomment when captions are implemented
 */
/**
 * The **participantName** directive sets the participant name. It can be useful for aplications which doesn't need the prejoin page.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * @example
 * <ov-videoconference [participantName]="'OpenVidu'"></ov-videoconference>
 */
declare class ParticipantNameDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set participantName(name: string);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngAfterViewInit(): void;
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(participantName: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantNameDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ParticipantNameDirective, "ov-videoconference[participantName]", never, { "participantName": { "alias": "participantName"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **prejoin** directive allows show/hide the prejoin page for selecting media devices.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * Default: `true`
 *
 * @example
 * <ov-videoconference [prejoin]="false"></ov-videoconference>
 */
declare class PrejoinDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set prejoin(value: boolean);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrejoinDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PrejoinDirective, "ov-videoconference[prejoin]", never, { "prejoin": { "alias": "prejoin"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **videoEnabled** directive allows to join the room with camera enabled or disabled.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * Default: `true`
 *
 *
 * @example
 * <ov-videoconference [videoEnabled]="false"></ov-videoconference>
 */
declare class VideoEnabledDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    private storageService;
    /**
     * @ignore
     */
    set videoEnabled(value: boolean);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService, storageService: StorageService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(enabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VideoEnabledDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VideoEnabledDirective, "ov-videoconference[videoEnabled]", never, { "videoEnabled": { "alias": "videoEnabled"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **audioEnabled** directive allows to join the room with microphone enabled or disabled.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * Default: `true`
 *
 * @example
 * <ov-videoconference [audioEnabled]="false"></ov-videoconference>
 */
declare class AudioEnabledDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    private storageService;
    /**
     * @ignore
     */
    set audioEnabled(value: boolean);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService, storageService: StorageService);
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(enabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AudioEnabledDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AudioEnabledDirective, "ov-videoconference[audioEnabled]", never, { "audioEnabled": { "alias": "audioEnabled"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **showDisconnectionDialog** directive allows to show/hide the disconnection dialog when the local participant is disconnected from the room.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * Default: `true`
 *
 * @example
 * <ov-videoconference [showDisconnectionDialog]="false"></ov-videoconference>
 */
declare class ShowDisconnectionDialogDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set showDisconnectionDialog(value: boolean);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShowDisconnectionDialogDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ShowDisconnectionDialogDirective, "ov-videoconference[showDisconnectionDialog]", never, { "showDisconnectionDialog": { "alias": "showDisconnectionDialog"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **recordingStreamBaseUrl** directive sets the base URL for retrieving recording streams.
 * The complete request URL is dynamically constructed by concatenating the supplied URL, the
 * internally managed recordingId, and the `/media` segment.
 *
 * The final URL format will be:
 *
 *    {recordingStreamBaseUrl}/{recordingId}/media
 *
 * Default: `"call/api/recordings/{recordingId}/stream"`
 *
 * Example:
 * Given a recordingStreamBaseUrl of `api/recordings`, the resulting URL for a recordingId of `12345` would be:
 *   `api/recordings/12345/media`
 *
 * It is essential that the resulting route is declared and configured on your backend, as it is
 * used for serving and accessing the recording streams.
 *
 * @example
 * <ov-videoconference [recordingStreamBaseUrl]="'https://myserver.com/api/recordings'">
 * </ov-videoconference>
 */
declare class RecordingStreamBaseUrlDirective implements AfterViewInit, OnDestroy {
    private elementRef;
    private libService;
    /**
     * @ignore
     */
    set recordingStreamBaseUrl(url: string);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngAfterViewInit(): void;
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecordingStreamBaseUrlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RecordingStreamBaseUrlDirective, "ov-videoconference[recordingStreamBaseUrl]", never, { "recordingStreamBaseUrl": { "alias": "recordingStreamBaseUrl"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * Load default OpenVidu logo if custom one is not exist
 * @internal
 */
declare class FallbackLogoDirective implements OnInit {
    elementRef: ElementRef;
    defaultLogo: string;
    assetsLogo: string;
    ovLogo: string;
    constructor(elementRef: ElementRef);
    ngOnInit(): void;
    private loadImage;
    static ɵfac: i0.ɵɵFactoryDeclaration<FallbackLogoDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FallbackLogoDirective, "img[ovLogo]", never, { "ovLogo": { "alias": "ovLogo"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 */
declare class LayoutRemoteParticipantsDirective {
    elementRef: ElementRef;
    private directiveService;
    private _ovRemoteParticipants;
    set ovRemoteParticipants(value: ParticipantModel[] | undefined);
    constructor(elementRef: ElementRef, directiveService: OpenViduComponentsConfigService);
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    update(value: ParticipantModel[] | undefined): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutRemoteParticipantsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LayoutRemoteParticipantsDirective, "ov-layout[ovRemoteParticipants]", never, { "ovRemoteParticipants": { "alias": "ovRemoteParticipants"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 */
declare class ToolbarBrandingLogoDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set brandingLogo(value: string);
    private _brandingLogo;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarBrandingLogoDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarBrandingLogoDirective, "ov-videoconference[brandingLogo], ov-toolbar[brandingLogo]", never, { "brandingLogo": { "alias": "brandingLogo"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 */
declare class PrejoinDisplayParticipantName implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set prejoinDisplayParticipantName(value: boolean);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrejoinDisplayParticipantName, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PrejoinDisplayParticipantName, "ov-videoconference[prejoinDisplayParticipantName]", never, { "prejoinDisplayParticipantName": { "alias": "prejoinDisplayParticipantName"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 *
 * The **recordingActivityReadOnly** directive sets the recording activity panel to read-only mode.
 * In this mode, users can only view recordings without the ability to start, stop, or delete them.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * Default: `false`
 *
 * @example
 * <ov-videoconference [recordingActivityReadOnly]="true"></ov-videoconference>
 */
declare class RecordingActivityReadOnlyDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set recordingActivityReadOnly(value: boolean);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecordingActivityReadOnlyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RecordingActivityReadOnlyDirective, "ov-videoconference[recordingActivityReadOnly]", never, { "recordingActivityReadOnly": { "alias": "recordingActivityReadOnly"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 *
 * @internal
 *
 * The **recordingActivityShowControls** directive allows to show/hide specific recording controls (play, download, delete, externalView).
 * You can pass an object with boolean properties to control which buttons are shown.
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * Default: `{ play: true, download: true, delete: true, externalView: false }`
 *
 * @example
 * <ov-videoconference [recordingActivityShowControls]="{ play: false, download: true, delete: false }"></ov-videoconference>
 */
declare class RecordingActivityShowControlsDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set recordingActivityShowControls(value: {
        play: boolean;
        download: boolean;
        delete: boolean;
        externalView: boolean;
    });
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    /**
     * @ignore
     */
    ngOnDestroy(): void;
    /**
     * @ignore
     */
    clear(): void;
    /**
     * @ignore
     */
    update(value: {
        play: boolean;
        download: boolean;
        delete: boolean;
        externalView: boolean;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecordingActivityShowControlsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RecordingActivityShowControlsDirective, "ov-videoconference[recordingActivityShowControls]", never, { "recordingActivityShowControls": { "alias": "recordingActivityShowControls"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 * The **viewRecordingsButton** directive allows show/hide the view recordings toolbar button.
 *
 * Default: `false`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarViewRecordingsButton]="true"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [viewRecordingsButton]="true"></ov-toolbar>
 *
 * When the button is clicked, it will fire the `onViewRecordingsClicked` event.
 */
declare class ToolbarViewRecordingsButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarViewRecordingsButton(value: boolean);
    /**
     * @ignore
     */
    set viewRecordingsButton(value: boolean);
    private viewRecordingsValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarViewRecordingsButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarViewRecordingsButtonDirective, "ov-videoconference[toolbarViewRecordingsButton], ov-toolbar[viewRecordingsButton]", never, { "toolbarViewRecordingsButton": { "alias": "toolbarViewRecordingsButton"; "required": false; }; "viewRecordingsButton": { "alias": "viewRecordingsButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 *
 * The **recordingActivityStartStopRecordingButton** directive allows to show or hide the start/stop recording buttons in recording activity.
 *
 * Default: `true`
 *
 * It is only available for {@link VideoconferenceComponent}.
 *
 * @example
 * <ov-videoconference [recordingActivityStartStopRecordingButton]="false"></ov-videoconference>
 */
declare class StartStopRecordingButtonsDirective implements OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set recordingActivityStartStopRecordingButton(value: boolean);
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<StartStopRecordingButtonsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StartStopRecordingButtonsDirective, "ov-videoconference[recordingActivityStartStopRecordingButton]", never, { "recordingActivityStartStopRecordingButton": { "alias": "recordingActivityStartStopRecordingButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 * The **recordingActivityViewRecordingsButton** directive allows to show/hide the view recordings button in the recording activity panel.
 *
 * Default: `false`
 *
 * Can be used in {@link VideoconferenceComponent}.
 *
 * @example
 * <ov-videoconference [recordingActivityViewRecordingsButton]="true"></ov-videoconference>
 */
declare class RecordingActivityViewRecordingsButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set recordingActivityViewRecordingsButton(value: boolean);
    private _value;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecordingActivityViewRecordingsButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RecordingActivityViewRecordingsButtonDirective, "ov-videoconference[recordingActivityViewRecordingsButton]", never, { "recordingActivityViewRecordingsButton": { "alias": "recordingActivityViewRecordingsButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 * The **recordingActivityShowRecordingsList** directive allows to show or hide the recordings list in the recording activity panel.
 *
 * Default: `true`
 *
 * Can be used in {@link VideoconferenceComponent}.
 *
 * @example
 * <ov-videoconference [recordingActivityShowRecordingsList]="false"></ov-videoconference>
 */
declare class RecordingActivityShowRecordingsListDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set recordingActivityShowRecordingsList(value: boolean);
    private _value;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecordingActivityShowRecordingsListDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RecordingActivityShowRecordingsListDirective, "ov-videoconference[recordingActivityShowRecordingsList]", never, { "recordingActivityShowRecordingsList": { "alias": "recordingActivityShowRecordingsList"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 * The **toolbarRoomName** directive allows to display a specific room name in the toolbar.
 * If the room name is not set, it will display the room ID instead.
 *
 * Can be used in {@link ToolbarComponent}.
 *
 * @example
 * <ov-videoconference [toolbarRoomName]="roomName"></ov-videoconference>
 */
declare class ToolbarRoomNameDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set toolbarRoomName(value: string | undefined);
    set roomName(value: string | undefined);
    private _roomName?;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private updateRoomName;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarRoomNameDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarRoomNameDirective, "ov-videoconference[toolbarRoomName], ov-toolbar[roomName]", never, { "toolbarRoomName": { "alias": "toolbarRoomName"; "required": false; }; "roomName": { "alias": "roomName"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 *
 * The **showThemeSelector** directive allows to enable or disable the theme selector control.
 * When disabled, users won't be able to change the UI theme.
 *
 * Default: `false`
 *
 * Usage:
 * <ov-videoconference [showThemeSelector]="false"></ov-videoconference>
 */
declare class ShowThemeSelectorDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set showThemeSelector(value: boolean);
    private _value;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShowThemeSelectorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ShowThemeSelectorDirective, "ov-videoconference[showThemeSelector]", never, { "showThemeSelector": { "alias": "showThemeSelector"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * @internal
 *
 * The **e2eeKey** directive allows to configure end-to-end encryption for the videoconference.
 * When provided, the room will be configured with E2EE using an external key provider.
 *
 * Default: `undefined`
 *
 * Usage:
 * <ov-videoconference [e2eeKey]="yourEncryptionKey"></ov-videoconference>
 */
declare class E2EEKeyDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set e2eeKey(value: string | undefined);
    private _value;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<E2EEKeyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<E2EEKeyDirective, "ov-videoconference[e2eeKey]", never, { "e2eeKey": { "alias": "e2eeKey"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * The **cameraButton** directive allows show/hide the camera toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarCameraButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [cameraButton]="false"></ov-toolbar>
 */
declare class ToolbarCameraButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarCameraButton(value: boolean);
    /**
     * @ignore
     */
    set cameraButton(value: boolean);
    private cameraValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarCameraButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarCameraButtonDirective, "ov-videoconference[toolbarCameraButton], ov-toolbar[cameraButton]", never, { "toolbarCameraButton": { "alias": "toolbarCameraButton"; "required": false; }; "cameraButton": { "alias": "cameraButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **microphoneButton** directive allows show/hide the microphone toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarMicrophoneButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [microphoneButton]="false"></ov-toolbar>
 */
declare class ToolbarMicrophoneButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarMicrophoneButton(value: boolean);
    /**
     * @ignore
     */
    set microphoneButton(value: boolean);
    private microphoneValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarMicrophoneButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarMicrophoneButtonDirective, "ov-videoconference[toolbarMicrophoneButton], ov-toolbar[microphoneButton]", never, { "toolbarMicrophoneButton": { "alias": "toolbarMicrophoneButton"; "required": false; }; "microphoneButton": { "alias": "microphoneButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **screenshareButton** directive allows show/hide the screenshare toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarScreenshareButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [screenshareButton]="false"></ov-toolbar>
 */
declare class ToolbarScreenshareButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarScreenshareButton(value: boolean);
    /**
     * @ignore
     */
    set screenshareButton(value: boolean);
    private screenshareValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarScreenshareButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarScreenshareButtonDirective, "ov-videoconference[toolbarScreenshareButton], ov-toolbar[screenshareButton]", never, { "toolbarScreenshareButton": { "alias": "toolbarScreenshareButton"; "required": false; }; "screenshareButton": { "alias": "screenshareButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **recordingButton** directive allows show/hide the start/stop recording toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarRecordingButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [recordingButton]="false"></ov-toolbar>
 */
declare class ToolbarRecordingButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarRecordingButton(value: boolean);
    /**
     * @ignore
     */
    set recordingButton(value: boolean);
    private recordingValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarRecordingButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarRecordingButtonDirective, "ov-videoconference[toolbarRecordingButton], ov-toolbar[recordingButton]", never, { "toolbarRecordingButton": { "alias": "toolbarRecordingButton"; "required": false; }; "recordingButton": { "alias": "recordingButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **broadcastingButton** directive allows show/hide the start/stop broadcasting toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarBroadcastingButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [broadcastingButton]="false"></ov-toolbar>
 *
 */
declare class ToolbarBroadcastingButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarBroadcastingButton(value: boolean);
    /**
     * @ignore
     */
    set broadcastingButton(value: boolean);
    private broadcastingValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarBroadcastingButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarBroadcastingButtonDirective, "ov-videoconference[toolbarBroadcastingButton], ov-toolbar[broadcastingButton]", never, { "toolbarBroadcastingButton": { "alias": "toolbarBroadcastingButton"; "required": false; }; "broadcastingButton": { "alias": "broadcastingButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **fullscreenButton** directive allows show/hide the fullscreen toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarFullscreenButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [fullscreenButton]="false"></ov-toolbar>
 */
declare class ToolbarFullscreenButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarFullscreenButton(value: boolean);
    /**
     * @ignore
     */
    set fullscreenButton(value: boolean);
    private fullscreenValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarFullscreenButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarFullscreenButtonDirective, "ov-videoconference[toolbarFullscreenButton], ov-toolbar[fullscreenButton]", never, { "toolbarFullscreenButton": { "alias": "toolbarFullscreenButton"; "required": false; }; "fullscreenButton": { "alias": "fullscreenButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **backgroundEffectsButton** directive allows show/hide the background effects toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarBackgroundEffectsButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [backgroundEffectsButton]="false"></ov-toolbar>
 */
declare class ToolbarBackgroundEffectsButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarBackgroundEffectsButton(value: boolean);
    /**
     * @ignore
     */
    set backgroundEffectsButton(value: boolean);
    private backgroundEffectsValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarBackgroundEffectsButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarBackgroundEffectsButtonDirective, "ov-videoconference[toolbarBackgroundEffectsButton], ov-toolbar[backgroundEffectsButton]", never, { "toolbarBackgroundEffectsButton": { "alias": "toolbarBackgroundEffectsButton"; "required": false; }; "backgroundEffectsButton": { "alias": "backgroundEffectsButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **captionsButton** directive allows show/hide the captions toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarCaptionsButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [captionsButton]="false"></ov-toolbar>
 */
/**
 * The **settingsButton** directive allows show/hide the settings toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarSettingsButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [settingsButton]="false"></ov-toolbar>
 */
declare class ToolbarSettingsButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarSettingsButton(value: boolean);
    /**
     * @ignore
     */
    set settingsButton(value: boolean);
    private settingsValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarSettingsButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarSettingsButtonDirective, "ov-videoconference[toolbarSettingsButton], ov-toolbar[settingsButton]", never, { "toolbarSettingsButton": { "alias": "toolbarSettingsButton"; "required": false; }; "settingsButton": { "alias": "settingsButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **leaveButton** directive allows show/hide the leave toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarLeaveButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [leaveButton]="false"></ov-toolbar>
 */
declare class ToolbarLeaveButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarLeaveButton(value: boolean);
    /**
     * @ignore
     */
    set leaveButton(value: boolean);
    private leaveValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarLeaveButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarLeaveButtonDirective, "ov-videoconference[toolbarLeaveButton], ov-toolbar[leaveButton]", never, { "toolbarLeaveButton": { "alias": "toolbarLeaveButton"; "required": false; }; "leaveButton": { "alias": "leaveButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **participantsPanelButton** directive allows show/hide the participants panel toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarParticipantsPanelButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [participantsPanelButton]="false"></ov-toolbar>
 */
declare class ToolbarParticipantsPanelButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarParticipantsPanelButton(value: boolean);
    /**
     * @ignore
     */
    set participantsPanelButton(value: boolean);
    private participantsPanelValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarParticipantsPanelButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarParticipantsPanelButtonDirective, "ov-videoconference[toolbarParticipantsPanelButton], ov-toolbar[participantsPanelButton]", never, { "toolbarParticipantsPanelButton": { "alias": "toolbarParticipantsPanelButton"; "required": false; }; "participantsPanelButton": { "alias": "participantsPanelButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **chatPanelButton** directive allows show/hide the chat panel toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarChatPanelButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [chatPanelButton]="false"></ov-toolbar>
 */
declare class ToolbarChatPanelButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarChatPanelButton(value: boolean);
    /**
     * @ignore
     */
    set chatPanelButton(value: boolean);
    private toolbarChatPanelValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarChatPanelButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarChatPanelButtonDirective, "ov-videoconference[toolbarChatPanelButton], ov-toolbar[chatPanelButton]", never, { "toolbarChatPanelButton": { "alias": "toolbarChatPanelButton"; "required": false; }; "chatPanelButton": { "alias": "chatPanelButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **activitiesPanelButton** directive allows show/hide the activities panel toolbar button.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarActivitiesPanelButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [activitiesPanelButton]="false"></ov-toolbar>
 */
declare class ToolbarActivitiesPanelButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarActivitiesPanelButton(value: boolean);
    /**
     * @ignore
     */
    set activitiesPanelButton(value: boolean);
    private toolbarActivitiesPanelValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarActivitiesPanelButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarActivitiesPanelButtonDirective, "ov-videoconference[toolbarActivitiesPanelButton], ov-toolbar[activitiesPanelButton]", never, { "toolbarActivitiesPanelButton": { "alias": "toolbarActivitiesPanelButton"; "required": false; }; "activitiesPanelButton": { "alias": "activitiesPanelButton"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **displayRoomName** directive allows show/hide the room name.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarDisplayRoomName]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [displayRoomName]="false"></ov-toolbar>
 */
declare class ToolbarDisplayRoomNameDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarDisplayRoomName(value: boolean);
    /**
     * @ignore
     */
    set displayRoomName(value: boolean);
    private displayRoomValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarDisplayRoomNameDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarDisplayRoomNameDirective, "ov-videoconference[toolbarDisplayRoomName], ov-toolbar[displayRoomName]", never, { "toolbarDisplayRoomName": { "alias": "toolbarDisplayRoomName"; "required": false; }; "displayRoomName": { "alias": "displayRoomName"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **displayLogo** directive allows show/hide the branding logo.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `toolbar` component:
 *
 * @example
 * <ov-videoconference [toolbarDisplayLogo]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ToolbarComponent}.
 * @example
 * <ov-toolbar [displayLogo]="false"></ov-toolbar>
 */
declare class ToolbarDisplayLogoDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set toolbarDisplayLogo(value: boolean);
    /**
     * @ignore
     */
    set displayLogo(value: boolean);
    private displayLogoValue;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarDisplayLogoDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarDisplayLogoDirective, "ov-videoconference[toolbarDisplayLogo], ov-toolbar[displayLogo]", never, { "toolbarDisplayLogo": { "alias": "toolbarDisplayLogo"; "required": false; }; "displayLogo": { "alias": "displayLogo"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **ovToolbarAdditionalButtonsPosition** defines the position where the additional buttons should be inserted.
 *
 * The possible values are: {@link ToolbarAdditionalButtonsPosition}
 * Default: `afterMenu`
 *
 * It can be used in the any element which contains the  structural directive {@link ToolbarAdditionalButtonsDirective}.
 *
 * @example
 * <div *ovToolbarAdditionalButtons [ovToolbarAdditionalButtonsPosition]="'beforeMenu'"></div>
 *
 */
declare class ToolbarAdditionalButtonsPossitionDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    /**
     * @ignore
     */
    set ovToolbarAdditionalButtonsPosition(value: ToolbarAdditionalButtonsPosition);
    private additionalButtonsPosition;
    /**
     * @ignore
     */
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private clear;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarAdditionalButtonsPossitionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarAdditionalButtonsPossitionDirective, "[ovToolbarAdditionalButtonsPosition]", never, { "ovToolbarAdditionalButtonsPosition": { "alias": "ovToolbarAdditionalButtonsPosition"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * The **displayParticipantName** directive allows show/hide the participants name in stream component.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `stream` component:
 *
 * @example
 * <ov-videoconference [streamDisplayParticipantName]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link StreamComponent}.
 * @example
 * <ov-stream [displayParticipantName]="false"></ov-stream>
 */
declare class StreamDisplayParticipantNameDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set streamDisplayParticipantName(value: boolean);
    set displayParticipantName(value: boolean);
    displayParticipantNameValue: boolean;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    update(value: boolean): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StreamDisplayParticipantNameDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StreamDisplayParticipantNameDirective, "ov-videoconference[streamDisplayParticipantName], ov-stream[displayParticipantName]", never, { "streamDisplayParticipantName": { "alias": "streamDisplayParticipantName"; "required": false; }; "displayParticipantName": { "alias": "displayParticipantName"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **displayAudioDetection** directive allows show/hide the participants audio detection in stream component.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `stream` component:
 *
 * @example
 * <ov-videoconference [streamDisplayAudioDetection]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link StreamComponent}.
 * @example
 * <ov-stream [displayAudioDetection]="false"></ov-stream>
 */
declare class StreamDisplayAudioDetectionDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set streamDisplayAudioDetection(value: boolean);
    set displayAudioDetection(value: boolean);
    displayAudioDetectionValue: boolean;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    update(value: boolean): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StreamDisplayAudioDetectionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StreamDisplayAudioDetectionDirective, "ov-videoconference[streamDisplayAudioDetection], ov-stream[displayAudioDetection]", never, { "streamDisplayAudioDetection": { "alias": "streamDisplayAudioDetection"; "required": false; }; "displayAudioDetection": { "alias": "displayAudioDetection"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * The **videoControls** directive allows show/hide the participants video controls in stream component.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `stream` component:
 *
 * @example
 * <ov-videoconference [streamVideoControls]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link StreamComponent}.
 * @example
 * <ov-stream [videoControls]="false"></ov-stream>
 */
declare class StreamVideoControlsDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set streamVideoControls(value: boolean);
    set videoControls(value: boolean);
    videoControlsValue: boolean;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    update(value: boolean): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StreamVideoControlsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StreamVideoControlsDirective, "ov-videoconference[streamVideoControls], ov-stream[videoControls]", never, { "streamVideoControls": { "alias": "streamVideoControls"; "required": false; }; "videoControls": { "alias": "videoControls"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * The **muteButton** directive allows show/hide the muted button in participant panel item component.
 *
 * Default: `true`
 *
 * It can be used in the parent element {@link VideoconferenceComponent} specifying the name of the `participantPanelItem` component:
 *
 * @example
 * <ov-videoconference [participantPanelItemMuteButton]="false"></ov-videoconference>
 *
 * \
 * And it also can be used in the {@link ParticipantPanelItemComponent}.
 * @example
 * <ov-participant-panel-item [muteButton]="false"></ov-participant-panel-item>
 */
declare class ParticipantPanelItemMuteButtonDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private libService;
    set participantPanelItemMuteButton(value: boolean);
    set muteButton(value: boolean);
    muteValue: boolean;
    constructor(elementRef: ElementRef, libService: OpenViduComponentsConfigService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    clear(): void;
    update(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantPanelItemMuteButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ParticipantPanelItemMuteButtonDirective, "ov-videoconference[participantPanelItemMuteButton], ov-participant-panel-item[muteButton]", never, { "participantPanelItemMuteButton": { "alias": "participantPanelItemMuteButton"; "required": false; }; "muteButton": { "alias": "muteButton"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ApiDirectiveModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiDirectiveModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ApiDirectiveModule, [typeof LivekitUrlDirective, typeof TokenDirective, typeof TokenErrorDirective, typeof MinimalDirective, typeof LangDirective, typeof LangOptionsDirective, typeof PrejoinDirective, typeof PrejoinDisplayParticipantName, typeof VideoEnabledDirective, typeof RecordingActivityReadOnlyDirective, typeof RecordingActivityShowControlsDirective, typeof AudioEnabledDirective, typeof ShowDisconnectionDialogDirective, typeof RecordingStreamBaseUrlDirective, typeof ToolbarCameraButtonDirective, typeof ToolbarMicrophoneButtonDirective, typeof ToolbarScreenshareButtonDirective, typeof ToolbarFullscreenButtonDirective, typeof ToolbarBackgroundEffectsButtonDirective, typeof ToolbarLeaveButtonDirective, typeof ToolbarRecordingButtonDirective, typeof ToolbarBroadcastingButtonDirective, typeof ToolbarParticipantsPanelButtonDirective, typeof ToolbarChatPanelButtonDirective, typeof ToolbarActivitiesPanelButtonDirective, typeof ToolbarDisplayRoomNameDirective, typeof ToolbarDisplayLogoDirective, typeof ToolbarSettingsButtonDirective, typeof ToolbarAdditionalButtonsPossitionDirective, typeof ToolbarViewRecordingsButtonDirective, typeof StreamDisplayParticipantNameDirective, typeof StreamDisplayAudioDetectionDirective, typeof StreamVideoControlsDirective, typeof FallbackLogoDirective, typeof ToolbarBrandingLogoDirective, typeof ParticipantPanelItemMuteButtonDirective, typeof ParticipantNameDirective, typeof ActivitiesPanelRecordingActivityDirective, typeof ActivitiesPanelBroadcastingActivityDirective, typeof AdminDashboardRecordingsListDirective, typeof AdminLoginTitleDirective, typeof AdminLoginErrorDirective, typeof AdminDashboardTitleDirective, typeof LayoutRemoteParticipantsDirective, typeof StartStopRecordingButtonsDirective, typeof RecordingActivityViewRecordingsButtonDirective, typeof RecordingActivityShowRecordingsListDirective, typeof ToolbarRoomNameDirective, typeof ShowThemeSelectorDirective, typeof E2EEKeyDirective], never, [typeof LivekitUrlDirective, typeof TokenDirective, typeof TokenErrorDirective, typeof MinimalDirective, typeof LangDirective, typeof LangOptionsDirective, typeof PrejoinDirective, typeof PrejoinDisplayParticipantName, typeof VideoEnabledDirective, typeof RecordingActivityReadOnlyDirective, typeof RecordingActivityShowControlsDirective, typeof AudioEnabledDirective, typeof ShowDisconnectionDialogDirective, typeof RecordingStreamBaseUrlDirective, typeof ToolbarCameraButtonDirective, typeof ToolbarMicrophoneButtonDirective, typeof ToolbarScreenshareButtonDirective, typeof ToolbarFullscreenButtonDirective, typeof ToolbarBackgroundEffectsButtonDirective, typeof ToolbarLeaveButtonDirective, typeof ToolbarRecordingButtonDirective, typeof ToolbarBroadcastingButtonDirective, typeof ToolbarParticipantsPanelButtonDirective, typeof ToolbarChatPanelButtonDirective, typeof ToolbarActivitiesPanelButtonDirective, typeof ToolbarDisplayRoomNameDirective, typeof ToolbarDisplayLogoDirective, typeof ToolbarSettingsButtonDirective, typeof ToolbarAdditionalButtonsPossitionDirective, typeof ToolbarViewRecordingsButtonDirective, typeof StreamDisplayParticipantNameDirective, typeof StreamDisplayAudioDetectionDirective, typeof StreamVideoControlsDirective, typeof FallbackLogoDirective, typeof ToolbarBrandingLogoDirective, typeof ParticipantPanelItemMuteButtonDirective, typeof ParticipantNameDirective, typeof ActivitiesPanelRecordingActivityDirective, typeof ActivitiesPanelBroadcastingActivityDirective, typeof AdminDashboardRecordingsListDirective, typeof AdminLoginTitleDirective, typeof AdminLoginErrorDirective, typeof AdminDashboardTitleDirective, typeof LayoutRemoteParticipantsDirective, typeof StartStopRecordingButtonsDirective, typeof RecordingActivityViewRecordingsButtonDirective, typeof RecordingActivityShowRecordingsListDirective, typeof ToolbarRoomNameDirective, typeof ShowThemeSelectorDirective, typeof E2EEKeyDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ApiDirectiveModule>;
}

declare class OpenViduComponentsDirectiveModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenViduComponentsDirectiveModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<OpenViduComponentsDirectiveModule, [typeof ChatPanelDirective, typeof LayoutDirective, typeof PanelDirective, typeof AdditionalPanelsDirective, typeof ParticipantPanelItemDirective, typeof ParticipantsPanelDirective, typeof StreamDirective, typeof ToolbarDirective, typeof ToolbarAdditionalButtonsDirective, typeof LeaveButtonDirective, typeof ToolbarAdditionalPanelButtonsDirective, typeof ParticipantPanelItemElementsDirective, typeof ActivitiesPanelDirective, typeof PreJoinDirective, typeof ParticipantPanelAfterLocalParticipantDirective, typeof LayoutAdditionalElementsDirective, typeof ParticipantPanelParticipantBadgeDirective, typeof SettingsPanelGeneralAdditionalElementsDirective, typeof ToolbarMoreOptionsAdditionalMenuItemsDirective], never, [typeof ChatPanelDirective, typeof LayoutDirective, typeof PanelDirective, typeof AdditionalPanelsDirective, typeof ParticipantPanelItemDirective, typeof ParticipantsPanelDirective, typeof StreamDirective, typeof ToolbarDirective, typeof ToolbarAdditionalButtonsDirective, typeof LeaveButtonDirective, typeof ToolbarAdditionalPanelButtonsDirective, typeof ParticipantPanelItemElementsDirective, typeof ActivitiesPanelDirective, typeof PreJoinDirective, typeof ParticipantPanelAfterLocalParticipantDirective, typeof LayoutAdditionalElementsDirective, typeof ParticipantPanelParticipantBadgeDirective, typeof SettingsPanelGeneralAdditionalElementsDirective, typeof ToolbarMoreOptionsAdditionalMenuItemsDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<OpenViduComponentsDirectiveModule>;
}

/**
 * @internal
 */
declare enum DataTopic {
    CHAT = "chat",
    RECORDING_STARTING = "recordingStarting",
    RECORDING_STARTED = "recordingStarted",
    RECORDING_STOPPING = "recordingStopping",
    RECORDING_STOPPED = "recordingStopped",
    RECORDING_DELETED = "recordingDeleted",
    RECORDING_FAILED = "recordingFailed",
    BROADCASTING_STARTING = "broadcastingStarting",
    BROADCASTING_STARTED = "broadcastingStarted",
    BROADCASTING_STOPPING = "broadcastingStopping",
    BROADCASTING_STOPPED = "broadcastingStopped",
    BROADCASTING_FAILED = "broadcastingFailed",
    ROOM_STATUS = "roomStatus"
}

/**
 * @internal
 */
interface RoomStatusData {
    isRecordingStarted: boolean;
    isBroadcastingStarted: boolean;
    recordingList: RecordingInfo[];
    broadcastingId: string;
}

/**
 * @internal
 */
declare enum StorageKeys {
    PARTICIPANT_NAME = "participantName",
    VIDEO_DEVICE = "videoDevice",
    AUDIO_DEVICE = "audioDevice",
    MICROPHONE_ENABLED = "microphoneEnabled",
    CAMERA_ENABLED = "cameraEnabled",
    LANG = "lang",
    CAPTION_LANG = "captionLang",
    BACKGROUND = "virtualBg",
    THEME = "theme",
    TAB_ID = "tabId",
    ACTIVE_TABS = "activeTabs"
}
declare const SESSION_KEYS: StorageKeys[];
declare const TAB_MANAGEMENT_KEYS: StorageKeys[];
declare const TAB_SPECIFIC_KEYS: StorageKeys[];
declare const SHARED_PERSISTENT_KEYS: StorageKeys[];
declare const STORAGE_PREFIX = "ovComponents-";

/**
 * The **RemoteParticipantTracksPipe** allows us to get all the tracks from all remote participants.
 * This is used to display the tracks in the videoconference layout.
 * @returns {ParticipantTrackPublication[]} Array of tracks
 */
declare class RemoteParticipantTracksPipe implements PipeTransform {
    constructor();
    transform(participants: ParticipantModel[]): ParticipantTrackPublication[];
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoteParticipantTracksPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RemoteParticipantTracksPipe, "tracks", false>;
}
/**
 * @internal
 */
declare class TrackPublishedTypesPipe implements PipeTransform {
    private translateService;
    constructor(translateService: TranslateService);
    transform(participant: ParticipantModel): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TrackPublishedTypesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TrackPublishedTypesPipe, "tracksPublishedTypes", false>;
}

/**
 * @internal
 */
declare class DurationFromSecondsPipe implements PipeTransform {
    transform(durationInSeconds: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DurationFromSecondsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DurationFromSecondsPipe, "duration", false>;
}
/**
 * @internal
 */
declare class SearchByStringPropertyPipe implements PipeTransform {
    transform(items: any[], props: {
        properties: string[];
        filter: string;
    }): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchByStringPropertyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SearchByStringPropertyPipe, "searchByStringProperty", false>;
}
/**
 * @internal
 */
declare class ThumbnailFromUrlPipe implements PipeTransform {
    transform(url: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThumbnailFromUrlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThumbnailFromUrlPipe, "thumbnailUrl", false>;
}

/**
 * @internal
 */
declare class TranslatePipe implements PipeTransform {
    private translateService;
    constructor(translateService: TranslateService);
    transform(str: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TranslatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TranslatePipe, "translate", false>;
}

/**
 * @internal
 */
declare class PreJoinComponent implements OnInit, OnDestroy {
    private loggerSrv;
    private libService;
    private cdkSrv;
    private openviduService;
    private translateService;
    private changeDetector;
    protected viewportService: ViewportService;
    set error(error: {
        name: string;
        message: string;
    } | undefined);
    onVideoDeviceChanged: EventEmitter<CustomDevice>;
    onAudioDeviceChanged: EventEmitter<CustomDevice>;
    onVideoEnabledChanged: EventEmitter<boolean>;
    onAudioEnabledChanged: EventEmitter<boolean>;
    onLangChanged: EventEmitter<LangOption>;
    onReadyToJoin: EventEmitter<any>;
    _error: string | undefined;
    windowSize: number;
    isLoading: boolean;
    participantName: string | undefined;
    /**
     * @ignore
     */
    isMinimal: boolean;
    showCameraButton: boolean;
    showMicrophoneButton: boolean;
    showLogo: boolean;
    showParticipantName: boolean;
    backgroundEffectEnabled: boolean;
    showBackgroundPanel: boolean;
    videoTrack: LocalTrack | undefined;
    audioTrack: LocalTrack | undefined;
    isVideoEnabled: boolean;
    hasVideoDevices: boolean;
    private tracks;
    private log;
    private destroy$;
    private shouldRemoveTracksWhenComponentIsDestroyed;
    sizeChange(): void;
    constructor(loggerSrv: LoggerService, libService: OpenViduComponentsConfigService, cdkSrv: CdkOverlayService, openviduService: OpenViduService, translateService: TranslateService, changeDetector: ChangeDetectorRef, viewportService: ViewportService);
    ngOnInit(): Promise<void>;
    ngOnDestroy(): Promise<void>;
    onDeviceSelectorClicked(): void;
    join(): void;
    onParticipantNameChanged(name: string): void;
    onEnterPressed(): void;
    private subscribeToPrejoinDirectives;
    videoEnabledChanged(enabled: boolean): Promise<void>;
    videoDeviceChanged(device: CustomDevice): Promise<void>;
    onVideoDevicesLoaded(devices: CustomDevice[]): void;
    audioDeviceChanged(device: CustomDevice): void;
    audioEnabledChanged(enabled: boolean): Promise<void>;
    /**
     * Toggle virtual background panel visibility with smooth animation
     */
    toggleBackgroundPanel(): void;
    /**
     * Close virtual background panel with smooth animation
     */
    closeBackgroundPanel(): void;
    /**
     * Enhanced error handling with better UX
     */
    private handleError;
    /**
     * Improved device initialization with error handling
     */
    private initializeDevicesWithRetry;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreJoinComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PreJoinComponent, "ov-pre-join", never, { "error": { "alias": "error"; "required": false; }; }, { "onVideoDeviceChanged": "onVideoDeviceChanged"; "onAudioDeviceChanged": "onAudioDeviceChanged"; "onVideoEnabledChanged": "onVideoEnabledChanged"; "onAudioEnabledChanged": "onAudioEnabledChanged"; "onLangChanged": "onLangChanged"; "onReadyToJoin": "onReadyToJoin"; }, never, never, false, never>;
}

/**
 * @internal
 */
declare enum EffectType {
    NONE = "NONE",
    BLUR = "BLUR",
    IMAGE = "IMAGE"
}
/**
 * @internal
 */
interface BackgroundEffect {
    id: string;
    type: EffectType;
    thumbnail: string;
    src?: string;
}

/**
 * @internal
 */
declare class VirtualBackgroundService {
    private openviduService;
    private storageService;
    private loggerSrv;
    backgroundIdSelected: BehaviorSubject<string>;
    backgroundIdSelected$: Observable<string>;
    backgrounds: BackgroundEffect[];
    private SOFT_BLUR_INTENSITY;
    private HARD_BLUR_INTENSITY;
    private log;
    constructor(openviduService: OpenViduService, storageService: StorageService, loggerSrv: LoggerService);
    getBackgrounds(): BackgroundEffect[];
    /**
     * Computed signal that checks if virtual background is supported (requires GPU).
     * Reactively tracks the support status from OpenViduService.
     */
    readonly isVirtualBackgroundSupported: Signal<boolean>;
    isBackgroundApplied(): boolean;
    applyBackgroundFromStorage(): Promise<void>;
    /**
     * Applies a background effect to the local video track.
     * Works both in prejoin (using OpenViduService's processor) and in-room states.
     * The background processor is centralized in OpenViduService for consistency.
     */
    applyBackground(bg: BackgroundEffect): Promise<void>;
    removeBackground(): Promise<void>;
    private getBackgroundOptions;
    private backgroundIsAlreadyApplied;
    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualBackgroundService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VirtualBackgroundService>;
}

/**
 * @internal
 */
declare class SessionComponent implements OnInit, OnDestroy {
    private layoutService;
    private actionService;
    private openviduService;
    private participantService;
    private loggerSrv;
    private chatService;
    private libService;
    private panelService;
    private recordingService;
    private broadcastingService;
    private translateService;
    private backgroundService;
    private cd;
    private templateManagerService;
    protected viewportService: ViewportService;
    toolbarTemplate: TemplateRef<any> | undefined;
    panelTemplate: TemplateRef<any> | undefined;
    layoutTemplate: TemplateRef<any> | undefined;
    /**
     * Provides event notifications that fire when Room is created for the local participant.
     */
    onRoomCreated: EventEmitter<Room>;
    /**
     * Provides event notifications that fire when Room is being reconnected for the local participant.
     */
    onRoomReconnecting: EventEmitter<void>;
    /**
     * Provides event notifications that fire when Room is reconnected for the local participant.
     */
    onRoomReconnected: EventEmitter<void>;
    /**
     * Provides event notifications that fire when participant is disconnected from Room.
     * @deprecated Use {@link SessionComponent.onParticipantLeft} instead.
     */
    onRoomDisconnected: EventEmitter<void>;
    /**
     * Provides event notifications that fire when local participant is connected to the Room.
     */
    onParticipantConnected: EventEmitter<ParticipantModel>;
    /**
     * This event is emitted when the local participant leaves the room.
     */
    onParticipantLeft: EventEmitter<ParticipantLeftEvent>;
    room: Room;
    sideMenu: MatSidenav;
    sidenavMode: SidenavMode;
    settingsPanelOpened: boolean;
    drawer: MatDrawerContainer;
    loading: boolean;
    /**
     * @internal
     * Template configuration managed by the service
     */
    templateConfig: SessionTemplateConfiguration;
    private shouldDisconnectRoomWhenComponentIsDestroyed;
    private readonly SIDENAV_WIDTH_LIMIT_MODE;
    private destroy$;
    private updateLayoutInterval;
    private log;
    constructor(layoutService: LayoutService, actionService: ActionService, openviduService: OpenViduService, participantService: ParticipantService, loggerSrv: LoggerService, chatService: ChatService, libService: OpenViduComponentsConfigService, panelService: PanelService, recordingService: RecordingService, broadcastingService: BroadcastingService, translateService: TranslateService, backgroundService: VirtualBackgroundService, cd: ChangeDetectorRef, templateManagerService: TemplateManagerService, viewportService: ViewportService);
    beforeunloadHandler(): void;
    sizeChange(): void;
    set sidenavMenu(menu: MatSidenav);
    set videoContainer(container: ElementRef);
    set container(container: MatDrawerContainer);
    set layoutContainer(container: ElementRef);
    ngOnInit(): Promise<void>;
    protected subscribeToEncryptionErrors(): void;
    protected subscribeToActiveSpeakersChanged(): void;
    /**
     * @internal
     * Sets up all templates using the template manager service
     */
    private setupTemplates;
    ngOnDestroy(): Promise<void>;
    disconnectRoom(reason: ParticipantLeftReason): Promise<void>;
    private subscribeToTogglingMenu;
    private subscribeToLayoutWidth;
    private subscribeToParticipantConnected;
    /**
     * The LocalParticipant has subscribed to a new track because of the RoomConnectionOptions has beed set with autosubscribe = 'true'.
     * The LocalParticipant will subscribe to all tracks after joining.
     */
    private subscribeToTrackSubscribed;
    /**
     * The LocalParticipant has unsubscribed from a track.
     */
    private subscribeToTrackUnsubscribed;
    private subscribeToParticipantDisconnected;
    private subscribeToParticipantMetadataChanged;
    private subscribeToDataMessage;
    private handleDataEvent;
    private subscribeToReconnection;
    private subscribeToVirtualBackground;
    private startUpdateLayoutInterval;
    private stopUpdateLayoutInterval;
    static ɵfac: i0.ɵɵFactoryDeclaration<SessionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SessionComponent, "ov-session", never, {}, { "onRoomCreated": "onRoomCreated"; "onRoomReconnecting": "onRoomReconnecting"; "onRoomReconnected": "onRoomReconnected"; "onRoomDisconnected": "onRoomDisconnected"; "onParticipantConnected": "onParticipantConnected"; "onParticipantLeft": "onParticipantLeft"; }, ["toolbarTemplate", "panelTemplate", "layoutTemplate"], never, false, never>;
}

/**
 * @internal
 */
declare class BackgroundEffectsPanelComponent implements OnInit {
    private panelService;
    private backgroundService;
    private cd;
    mode: 'prejoin' | 'meeting';
    onClose: EventEmitter<void>;
    backgroundSelectedId: string;
    effectType: typeof EffectType;
    backgroundImages: BackgroundEffect[];
    noEffectAndBlurredBackground: BackgroundEffect[];
    private backgrounds;
    private backgroundSubs;
    /**
     * @internal
     * @param panelService
     * @param backgroundService
     * @param cd
     */
    constructor(panelService: PanelService, backgroundService: VirtualBackgroundService, cd: ChangeDetectorRef);
    /**
     * Computed signal that reactively tracks if virtual background is supported.
     * Updates automatically when browser support changes.
     */
    readonly isVirtualBackgroundSupported: Signal<boolean>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    subscribeToBackgroundSelected(): void;
    close(): void;
    applyBackground(effect: BackgroundEffect): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BackgroundEffectsPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BackgroundEffectsPanelComponent, "ov-background-effects-panel", never, { "mode": { "alias": "mode"; "required": false; }; }, { "onClose": "onClose"; }, never, never, false, never>;
}

/**
 * @internal
 */
declare class SettingsPanelComponent implements OnInit {
    private panelService;
    private platformService;
    private libService;
    viewportService: ViewportService;
    onVideoEnabledChanged: EventEmitter<boolean>;
    onVideoDeviceChanged: EventEmitter<CustomDevice>;
    onAudioEnabledChanged: EventEmitter<boolean>;
    onAudioDeviceChanged: EventEmitter<CustomDevice>;
    onLangChanged: EventEmitter<LangOption>;
    /**
     * @internal
     * ContentChild for custom elements in general section
     */
    externalGeneralAdditionalElements: SettingsPanelGeneralAdditionalElementsDirective;
    settingsOptions: typeof PanelSettingsOptions;
    selectedOption: PanelSettingsOptions;
    showCameraButton: boolean;
    showMicrophoneButton: boolean;
    showCaptions: boolean;
    showThemeSelector: boolean;
    isMobile: boolean;
    private destroy$;
    /**
     * @internal
     * Gets the template for additional elements in general section
     */
    get generalAdditionalElementsTemplate(): TemplateRef<any> | undefined;
    constructor(panelService: PanelService, platformService: PlatformService, libService: OpenViduComponentsConfigService, viewportService: ViewportService);
    get isCompactView(): boolean;
    get isVerticalLayout(): boolean;
    get shouldHideMenuText(): boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    close(): void;
    onSelectionChanged(option: PanelSettingsOptions): void;
    private subscribeToDirectives;
    private subscribeToPanelToggling;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsPanelComponent, "ov-settings-panel", never, {}, { "onVideoEnabledChanged": "onVideoEnabledChanged"; "onVideoDeviceChanged": "onVideoDeviceChanged"; "onAudioEnabledChanged": "onAudioEnabledChanged"; "onAudioDeviceChanged": "onAudioDeviceChanged"; "onLangChanged": "onLangChanged"; }, ["externalGeneralAdditionalElements"], never, false, never>;
}

/**
 * @internal
 */
declare class AudioWaveComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<AudioWaveComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AudioWaveComponent, "ov-audio-wave", never, {}, {}, never, never, false, never>;
}

/**
 * @internal
 */
interface DialogData {
    title: string;
    description: string;
    showActionButtons: boolean;
}
/**
 * @internal
 */
interface RecordingDialogData {
    src: string;
    showActionButtons: boolean;
}

/**
 * @internal
 */
declare class DialogTemplateComponent {
    dialogRef: MatDialogRef<DialogTemplateComponent>;
    data: DialogData;
    constructor(dialogRef: MatDialogRef<DialogTemplateComponent>, data: DialogData);
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogTemplateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogTemplateComponent, "ov-dialog-template", never, {}, {}, never, never, false, never>;
}

/**
 * @internal
 */
declare class ProFeatureDialogTemplateComponent {
    dialogRef: MatDialogRef<ProFeatureDialogTemplateComponent>;
    data: DialogData;
    constructor(dialogRef: MatDialogRef<ProFeatureDialogTemplateComponent>, data: DialogData);
    close(): void;
    seeMore(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProFeatureDialogTemplateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProFeatureDialogTemplateComponent, "ov-pro-feature-template", never, {}, {}, never, never, false, never>;
}

/**
 * @internal
 */
declare class RecordingDialogComponent {
    dialogRef: MatDialogRef<RecordingDialogComponent>;
    data: RecordingDialogData;
    videoElement: ElementRef<HTMLVideoElement>;
    src: string;
    constructor(dialogRef: MatDialogRef<RecordingDialogComponent>, data: RecordingDialogData);
    close(): void;
    handleError(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RecordingDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RecordingDialogComponent, "app-recording-dialog", never, {}, {}, never, never, false, never>;
}

/**
 * @internal
 */
declare class DeleteDialogComponent {
    dialogRef: MatDialogRef<DeleteDialogComponent>;
    constructor(dialogRef: MatDialogRef<DeleteDialogComponent>);
    close(succsess?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeleteDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DeleteDialogComponent, "app-delete-dialog", never, {}, {}, never, never, false, never>;
}

declare class VideoPosterComponent {
    letter: string;
    set nickname(name: string);
    color: string;
    showAvatar: boolean;
    hasEncryptionError: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<VideoPosterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VideoPosterComponent, "ov-video-poster", never, { "nickname": { "alias": "nickname"; "required": false; }; "color": { "alias": "color"; "required": false; }; "showAvatar": { "alias": "showAvatar"; "required": false; }; "hasEncryptionError": { "alias": "hasEncryptionError"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * @internal
 */
declare class MediaElementComponent implements AfterViewInit, OnDestroy {
    _track: Track;
    _videoElement: ElementRef;
    _audioElement: ElementRef;
    type: Track.Source;
    private _muted;
    private previousTrack;
    showAvatar: boolean;
    avatarColor: string;
    avatarName: string;
    isLocal: boolean;
    hasEncryptionError: boolean;
    set videoElement(element: ElementRef);
    set audioElement(element: ElementRef);
    set track(track: Track);
    set muted(muted: boolean);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private detachPreviousTrack;
    private updateVideoStyles;
    private attachTracks;
    private attachVideoTrack;
    private attachAudioTrack;
    private muteAudioTrack;
    private isAudioTrack;
    private isVideoTrack;
    static ɵfac: i0.ɵɵFactoryDeclaration<MediaElementComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MediaElementComponent, "ov-media-element", never, { "showAvatar": { "alias": "showAvatar"; "required": false; }; "avatarColor": { "alias": "avatarColor"; "required": false; }; "avatarName": { "alias": "avatarName"; "required": false; }; "isLocal": { "alias": "isLocal"; "required": false; }; "hasEncryptionError": { "alias": "hasEncryptionError"; "required": false; }; "track": { "alias": "track"; "required": false; }; "muted": { "alias": "muted"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * @internal
 */
declare class VideoDevicesComponent implements OnInit {
    private storageSrv;
    private deviceSrv;
    private participantService;
    private loggerSrv;
    compact: boolean;
    onVideoDeviceChanged: EventEmitter<CustomDevice>;
    onVideoEnabledChanged: EventEmitter<boolean>;
    onVideoDevicesLoaded: EventEmitter<CustomDevice[]>;
    cameraStatusChanging: boolean;
    isCameraEnabled: boolean;
    protected readonly cameras: WritableSignal<CustomDevice[]>;
    protected readonly cameraSelected: WritableSignal<CustomDevice | undefined>;
    protected readonly hasVideoDevices: Signal<boolean>;
    private log;
    constructor(storageSrv: StorageService, deviceSrv: DeviceService, participantService: ParticipantService, loggerSrv: LoggerService);
    ngOnInit(): Promise<void>;
    toggleCam(event: any): Promise<void>;
    onCameraSelected(event: any): Promise<void>;
    /**
     * @internal
     * Compare two devices to check if they are the same. Used by the mat-select
     */
    compareObjectDevices(o1: CustomDevice, o2: CustomDevice): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<VideoDevicesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VideoDevicesComponent, "ov-video-devices-select", never, { "compact": { "alias": "compact"; "required": false; }; }, { "onVideoDeviceChanged": "onVideoDeviceChanged"; "onVideoEnabledChanged": "onVideoEnabledChanged"; "onVideoDevicesLoaded": "onVideoDevicesLoaded"; }, never, never, false, never>;
}

/**
 * @internal
 */
declare class AudioDevicesComponent implements OnInit {
    private deviceSrv;
    private storageSrv;
    private participantService;
    private loggerSrv;
    compact: boolean;
    onAudioDeviceChanged: EventEmitter<CustomDevice>;
    onAudioEnabledChanged: EventEmitter<boolean>;
    microphoneStatusChanging: boolean;
    isMicrophoneEnabled: boolean;
    private log;
    protected readonly microphones: WritableSignal<CustomDevice[]>;
    protected readonly microphoneSelected: WritableSignal<CustomDevice | undefined>;
    protected readonly hasAudioDevices: Signal<boolean>;
    constructor(deviceSrv: DeviceService, storageSrv: StorageService, participantService: ParticipantService, loggerSrv: LoggerService);
    ngOnInit(): Promise<void>;
    toggleMic(event: any): Promise<void>;
    onMicrophoneSelected(event: any): Promise<void>;
    /**
     * @internal
     * Compare two devices to check if they are the same. Used by the mat-select
     */
    compareObjectDevices(o1: CustomDevice, o2: CustomDevice): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AudioDevicesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AudioDevicesComponent, "ov-audio-devices-select", never, { "compact": { "alias": "compact"; "required": false; }; }, { "onAudioDeviceChanged": "onAudioDeviceChanged"; "onAudioEnabledChanged": "onAudioEnabledChanged"; }, never, never, false, never>;
}

/**
 * @internal
 */
declare class ParticipantNameInputComponent implements OnInit {
    private participantService;
    private storageSrv;
    name: string;
    localParticipantSubscription: Subscription;
    isPrejoinPage: boolean;
    error: boolean;
    onNameUpdated: EventEmitter<string>;
    onEnterPressed: EventEmitter<void>;
    constructor(participantService: ParticipantService, storageSrv: StorageService);
    ngOnInit(): void;
    /**
     * As updating name requires that the participant has the `canUpdateOwnMetadata` to true in server side, which is a little bit insecure,
     * we decided to not allow this feature for now.
     */
    updateName(): void;
    /**
     * @ignore
     */
    eventKeyPress(event: any): void;
    private subscribeToParticipantProperties;
    private generateRandomName;
    static ɵfac: i0.ɵɵFactoryDeclaration<ParticipantNameInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ParticipantNameInputComponent, "ov-participant-name-input", never, { "isPrejoinPage": { "alias": "isPrejoinPage"; "required": false; }; "error": { "alias": "error"; "required": false; }; }, { "onNameUpdated": "onNameUpdated"; "onEnterPressed": "onEnterPressed"; }, never, never, false, never>;
}

/**
 * @internal
 */
declare class LangSelectorComponent implements OnInit, OnDestroy {
    private translateService;
    private storageSrv;
    /**
     * @internal
     */
    compact: boolean;
    onLangChanged: EventEmitter<LangOption>;
    langSelected: LangOption;
    languages: LangOption[];
    /**
     * @ignore
     */
    menuTrigger: MatMenuTrigger;
    /**
     * @ignore
     */
    matSelect: MatSelect;
    private langSub;
    constructor(translateService: TranslateService, storageSrv: StorageService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onLangSelected(lang: AvailableLangs): void;
    subscribeToLangSelected(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LangSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LangSelectorComponent, "ov-lang-selector", never, { "compact": { "alias": "compact"; "required": false; }; }, { "onLangChanged": "onLangChanged"; }, never, never, false, never>;
}

declare class ThemeSelectorComponent {
    private themeService;
    protected predefinedThemes: OpenViduThemeMode[];
    constructor(themeService: OpenViduThemeService);
    ngOnInit(): void;
    get currentTheme(): OpenViduThemeMode;
    setTheme(theme: OpenViduThemeMode): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThemeSelectorComponent, "ov-theme-selector", never, {}, {}, never, never, false, never>;
}

/**
 * @internal
 */
declare class LinkifyPipe implements PipeTransform {
    private linkifer;
    constructor();
    transform(str: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinkifyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LinkifyPipe, "linkify", false>;
}

declare class AppMaterialModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AppMaterialModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AppMaterialModule, never, never, [typeof i1.MatButtonModule, typeof i2.MatCardModule, typeof i3.MatToolbarModule, typeof i4.MatIconModule, typeof i5.MatInputModule, typeof i6.MatFormFieldModule, typeof i7.MatDialogModule, typeof i8.MatTooltipModule, typeof i9.MatBadgeModule, typeof i10.MatGridListModule, typeof i11.MatSelectModule, typeof i12.MatOptionModule, typeof i13.MatProgressSpinnerModule, typeof i14.MatSliderModule, typeof i15.MatSidenavModule, typeof i16.MatSnackBarModule, typeof i17.MatMenuModule, typeof i18.MatDividerModule, typeof i19.MatListModule, typeof i20.MatExpansionModule, typeof i21.MatSlideToggleModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AppMaterialModule>;
}

declare class OpenViduComponentsUiModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenViduComponentsUiModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<OpenViduComponentsUiModule, [typeof AdminDashboardComponent, typeof AdminLoginComponent, typeof VideoconferenceComponent, typeof ToolbarComponent, typeof PanelComponent, typeof ActivitiesPanelComponent, typeof RecordingActivityComponent, typeof BroadcastingActivityComponent, typeof ParticipantsPanelComponent, typeof ParticipantPanelItemComponent, typeof ChatPanelComponent, typeof StreamComponent, typeof LayoutComponent, typeof PreJoinComponent, typeof SessionComponent, typeof BackgroundEffectsPanelComponent, typeof SettingsPanelComponent, typeof AudioWaveComponent, typeof DialogTemplateComponent, typeof ProFeatureDialogTemplateComponent, typeof RecordingDialogComponent, typeof DeleteDialogComponent, typeof VideoPosterComponent, typeof MediaElementComponent, typeof VideoDevicesComponent, typeof AudioDevicesComponent, typeof ParticipantNameInputComponent, typeof LangSelectorComponent, typeof ToolbarMediaButtonsComponent, typeof ToolbarPanelButtonsComponent, typeof ThemeSelectorComponent, typeof LandscapeWarningComponent, typeof LinkifyPipe, typeof RemoteParticipantTracksPipe, typeof DurationFromSecondsPipe, typeof SearchByStringPropertyPipe, typeof ThumbnailFromUrlPipe, typeof TrackPublishedTypesPipe, typeof TranslatePipe], [typeof i37.CommonModule, typeof i38.FormsModule, typeof i38.ReactiveFormsModule, typeof AppMaterialModule, typeof OpenViduComponentsDirectiveModule, typeof ApiDirectiveModule, typeof i42.DragDropModule], [typeof AdminDashboardComponent, typeof AdminLoginComponent, typeof VideoconferenceComponent, typeof ToolbarComponent, typeof PanelComponent, typeof ActivitiesPanelComponent, typeof RecordingActivityComponent, typeof BroadcastingActivityComponent, typeof ParticipantsPanelComponent, typeof ParticipantPanelItemComponent, typeof ChatPanelComponent, typeof StreamComponent, typeof LayoutComponent, typeof RemoteParticipantTracksPipe, typeof DurationFromSecondsPipe, typeof TrackPublishedTypesPipe, typeof TranslatePipe, typeof OpenViduComponentsDirectiveModule, typeof ApiDirectiveModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<OpenViduComponentsUiModule>;
}

declare class OpenViduComponentsModule {
    static forRoot(config: OpenViduComponentsConfig): ModuleWithProviders<OpenViduComponentsModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenViduComponentsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<OpenViduComponentsModule, never, [typeof OpenViduComponentsUiModule], [typeof OpenViduComponentsUiModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<OpenViduComponentsModule>;
}

export { ActionService, ActivitiesPanelBroadcastingActivityDirective, ActivitiesPanelComponent, ActivitiesPanelDirective, ActivitiesPanelRecordingActivityDirective, AdditionalPanelsDirective, AdminDashboardComponent, AdminDashboardRecordingsListDirective, AdminDashboardTitleDirective, AdminLoginComponent, AdminLoginErrorDirective, AdminLoginTitleDirective, ApiDirectiveModule, AudioEnabledDirective, BackgroundEffectsPanelDirective, BroadcastingActivityComponent, BroadcastingService, BroadcastingStatus, CameraType, CdkOverlayContainer, ChatPanelComponent, ChatPanelDirective, ChatService, DataTopic, DeviceType, DurationFromSecondsPipe, E2EEKeyDirective, E2eeService, FallbackLogoDirective, GlobalConfigService, LAYOUT_CONSTANTS, LandscapeWarningComponent, LangDirective, LangOptionsDirective, LayoutAdditionalElementsDirective, LayoutAlignment, LayoutClass, LayoutComponent, LayoutDirective, LayoutRemoteParticipantsDirective, LayoutService, LeaveButtonDirective, LivekitUrlDirective, LoggerService, MinimalDirective, OPENVIDU_COMPONENTS_DARK_THEME, OPENVIDU_COMPONENTS_LIGHT_THEME, OpenViduComponentsDirectiveModule, OpenViduComponentsModule, OpenViduComponentsUiModule, OpenViduLayout, OpenViduService, OpenViduThemeMode, OpenViduThemeService, PanelComponent, PanelDirective, PanelService, PanelSettingsOptions, PanelType, ParticipantLeftReason, ParticipantModel, ParticipantNameDirective, ParticipantPanelAfterLocalParticipantDirective, ParticipantPanelItemComponent, ParticipantPanelItemDirective, ParticipantPanelItemElementsDirective, ParticipantPanelItemMuteButtonDirective, ParticipantPanelParticipantBadgeDirective, ParticipantService, ParticipantsPanelComponent, ParticipantsPanelDirective, PreJoinDirective, PrejoinDirective, PrejoinDisplayParticipantName, RecordingActivityComponent, RecordingActivityReadOnlyDirective, RecordingActivityShowControlsDirective, RecordingActivityShowRecordingsListDirective, RecordingActivityViewRecordingsButtonDirective, RecordingOutputMode, RecordingService, RecordingStatus, RecordingStreamBaseUrlDirective, RemoteParticipantTracksPipe, SESSION_KEYS, SHARED_PERSISTENT_KEYS, STORAGE_PREFIX, SearchByStringPropertyPipe, SettingsPanelGeneralAdditionalElementsDirective, ShowDisconnectionDialogDirective, ShowThemeSelectorDirective, SidenavMode, StartStopRecordingButtonsDirective, StorageKeys, StorageService, StreamComponent, StreamDirective, StreamDisplayAudioDetectionDirective, StreamDisplayParticipantNameDirective, StreamVideoControlsDirective, TAB_MANAGEMENT_KEYS, TAB_SPECIFIC_KEYS, ThumbnailFromUrlPipe, TokenDirective, TokenErrorDirective, ToolbarActivitiesPanelButtonDirective, ToolbarAdditionalButtonsDirective, ToolbarAdditionalButtonsPosition, ToolbarAdditionalButtonsPossitionDirective, ToolbarAdditionalPanelButtonsDirective, ToolbarBackgroundEffectsButtonDirective, ToolbarBrandingLogoDirective, ToolbarBroadcastingButtonDirective, ToolbarCameraButtonDirective, ToolbarChatPanelButtonDirective, ToolbarComponent, ToolbarDirective, ToolbarDisplayLogoDirective, ToolbarDisplayRoomNameDirective, ToolbarFullscreenButtonDirective, ToolbarLeaveButtonDirective, ToolbarMediaButtonsComponent, ToolbarMicrophoneButtonDirective, ToolbarMoreOptionsAdditionalMenuItemsDirective, ToolbarPanelButtonsComponent, ToolbarParticipantsPanelButtonDirective, ToolbarRecordingButtonDirective, ToolbarRoomNameDirective, ToolbarScreenshareButtonDirective, ToolbarSettingsButtonDirective, ToolbarViewRecordingsButtonDirective, TrackPublishedTypesPipe, TranslatePipe, TranslateService, VideoEnabledDirective, VideoconferenceComponent, ViewportService };
export type { ActivitiesPanelStatusEvent, AdditionalTranslationsType, AvailableLangs, BestDimensions, BigFirstOption, BroadcastingStartRequestedEvent, BroadcastingStatusInfo, BroadcastingStopRequestedEvent, ChatPanelStatusEvent, CustomDevice, DeviceOrientation, ElementDimensions, ExtendedLayoutOptions, ILogService, ILogger, LangOption, LayoutArea, LayoutBox, LayoutRow, OpenViduComponentsConfig, OpenViduLayoutOptions, OpenViduThemeVariables, PanelStatusInfo, ParticipantFactoryFunction, ParticipantLeftEvent, ParticipantProperties, ParticipantTrackPublication, ParticipantsPanelStatusEvent, RecordingDeleteRequestedEvent, RecordingDownloadClickedEvent, RecordingInfo, RecordingPlayClickedEvent, RecordingStartRequestedEvent, RecordingStatusInfo, RecordingStopRequestedEvent, RoomStatusData, SettingsPanelStatusEvent, ViewportInfo, ViewportSize };