import { GlobalConfig, I18nServiceConfig } from '@eui/base';
export * from '@eui/base';
import { Observable, Subscription } from 'rxjs';
import * as i0 from '@angular/core';
import { OnInit, OnDestroy, ChangeDetectorRef, EventEmitter, AfterContentInit, AfterViewInit, ElementRef, QueryList, Renderer2, OnChanges, SimpleChanges, AfterContentChecked } from '@angular/core';
import { EuiLanguage, I18nService, EuiAppShellService } from '@eui/core';
import { ModalController, NavController, IonSearchbar, MenuController, GestureController, AlertController } from '@ionic/angular';
import * as i3 from '@angular/router';
import { Router } from '@angular/router';
import { BooleanInput } from '@angular/cdk/coercion';
import { PDFDocumentProxy } from 'ng2-pdf-viewer';
import * as i1 from '@mapaxe/ngx-pinch-zoom';
import { PinchZoomComponent, ZoomEvent } from '@mapaxe/ngx-pinch-zoom';
import { HttpClient } from '@angular/common/http';
import { SafeResourceUrl, DomSanitizer } from '@angular/platform-browser';
import * as i2 from '@ngx-translate/core';
import { TranslateService } from '@ngx-translate/core';
import { Location } from '@angular/common';

interface UIState {
    isLanguageListVisible: boolean;
}
declare class EuimAppService {
    private _state$;
    constructor();
    get state$(): Observable<UIState>;
    get state(): UIState;
    set isLanguageListVisible(isVisible: boolean);
    setState(nextState: UIState): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAppService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EuimAppService>;
}

declare class BaseStatesDirective {
    get color(): string;
    set color(value: string);
    euimDisabled: boolean;
    euimPositionTopEnd: boolean;
    euimFontBold: boolean;
    euimFontRegular: boolean;
    euimFontBoldItalic: boolean;
    euimFontItalic: boolean;
    euimFontLight: boolean;
    euimSize2XS: boolean;
    euimSizeXS: boolean;
    euimSizeS: boolean;
    euimSizeM: boolean;
    euimSizeL: boolean;
    euimSizeXL: boolean;
    euimSize2XL: boolean;
    euimSize3XL: boolean;
    euimSize4XL: boolean;
    euimSize5XL: boolean;
    get euimSizeVariant(): string;
    set euimSizeVariant(value: string);
    private _euimSizeVariant;
    private _color;
    getCssClasses(rootClass: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseStatesDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseStatesDirective, "[euimBase]", never, { "color": { "alias": "color"; "required": false; }; "euimDisabled": { "alias": "euimDisabled"; "required": false; }; "euimPositionTopEnd": { "alias": "euimPositionTopEnd"; "required": false; }; "euimFontBold": { "alias": "euimFontBold"; "required": false; }; "euimFontRegular": { "alias": "euimFontRegular"; "required": false; }; "euimFontBoldItalic": { "alias": "euimFontBoldItalic"; "required": false; }; "euimFontItalic": { "alias": "euimFontItalic"; "required": false; }; "euimFontLight": { "alias": "euimFontLight"; "required": false; }; "euimSize2XS": { "alias": "euimSize2XS"; "required": false; }; "euimSizeXS": { "alias": "euimSizeXS"; "required": false; }; "euimSizeS": { "alias": "euimSizeS"; "required": false; }; "euimSizeM": { "alias": "euimSizeM"; "required": false; }; "euimSizeL": { "alias": "euimSizeL"; "required": false; }; "euimSizeXL": { "alias": "euimSizeXL"; "required": false; }; "euimSize2XL": { "alias": "euimSize2XL"; "required": false; }; "euimSize3XL": { "alias": "euimSize3XL"; "required": false; }; "euimSize4XL": { "alias": "euimSize4XL"; "required": false; }; "euimSize5XL": { "alias": "euimSize5XL"; "required": false; }; "euimSizeVariant": { "alias": "euimSizeVariant"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_euimDisabled: unknown;
    static ngAcceptInputType_euimPositionTopEnd: unknown;
    static ngAcceptInputType_euimFontBold: unknown;
    static ngAcceptInputType_euimFontRegular: unknown;
    static ngAcceptInputType_euimFontBoldItalic: unknown;
    static ngAcceptInputType_euimFontItalic: unknown;
    static ngAcceptInputType_euimFontLight: unknown;
    static ngAcceptInputType_euimSize2XS: unknown;
    static ngAcceptInputType_euimSizeXS: unknown;
    static ngAcceptInputType_euimSizeS: unknown;
    static ngAcceptInputType_euimSizeM: unknown;
    static ngAcceptInputType_euimSizeL: unknown;
    static ngAcceptInputType_euimSizeXL: unknown;
    static ngAcceptInputType_euimSize2XL: unknown;
    static ngAcceptInputType_euimSize3XL: unknown;
    static ngAcceptInputType_euimSize4XL: unknown;
    static ngAcceptInputType_euimSize5XL: unknown;
}

declare class EuimLabelComponent {
    baseStatesDirective: BaseStatesDirective;
    euimLabelTruncateWithLines: number;
    euimLabelTitle: boolean;
    euimLabelSubTitle: boolean;
    euimLabelMeta: boolean;
    euimLabelTruncate: boolean;
    euimLabelTextWrap: boolean;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimLabelComponent, "div[euimLabel], p[euimLabel], span[euimLabel], euim-label", never, { "euimLabelTruncateWithLines": { "alias": "euimLabelTruncateWithLines"; "required": false; }; "euimLabelTitle": { "alias": "euimLabelTitle"; "required": false; }; "euimLabelSubTitle": { "alias": "euimLabelSubTitle"; "required": false; }; "euimLabelMeta": { "alias": "euimLabelMeta"; "required": false; }; "euimLabelTruncate": { "alias": "euimLabelTruncate"; "required": false; }; "euimLabelTextWrap": { "alias": "euimLabelTextWrap"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof BaseStatesDirective; inputs: { "euimSizeXS": "euimSizeXS"; "euimSizeS": "euimSizeS"; "euimSizeM": "euimSizeM"; "euimSizeL": "euimSizeL"; "euimSizeXL": "euimSizeXL"; "euimSize2XL": "euimSize2XL"; "euimSize3XL": "euimSize3XL"; "euimSize4XL": "euimSize4XL"; "color": "color"; }; outputs: {}; }]>;
    static ngAcceptInputType_euimLabelTruncateWithLines: unknown;
    static ngAcceptInputType_euimLabelTitle: unknown;
    static ngAcceptInputType_euimLabelSubTitle: unknown;
    static ngAcceptInputType_euimLabelMeta: unknown;
    static ngAcceptInputType_euimLabelTruncate: unknown;
    static ngAcceptInputType_euimLabelTextWrap: unknown;
}

/**
 * @deprecated Use {@link EUIM_LABEL} instead.
 */
declare class EuimLabelModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimLabelModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimLabelModule, never, [typeof EuimLabelComponent], [typeof EuimLabelComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimLabelModule>;
}

declare const EUIM_LABEL: readonly [typeof EuimLabelComponent];

declare class EuimNotificationItemComponent {
    baseStatesDirective: BaseStatesDirective;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimNotificationItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimNotificationItemComponent, "euim-notification-item", never, {}, {}, never, never, true, [{ directive: typeof BaseStatesDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
}

/**
 * @deprecated Use {@link EUIM_NOTIFICATION_ITEM} instead.
 */
declare class EuimNotificationItemModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimNotificationItemModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimNotificationItemModule, never, [typeof EuimNotificationItemComponent], [typeof EuimNotificationItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimNotificationItemModule>;
}

declare const EUIM_NOTIFICATION_ITEM: readonly [typeof EuimNotificationItemComponent];

declare class EuimAppComponent {
    asService: EuimAppService;
    ionMenuId: string;
    constructor(asService: EuimAppService);
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAppComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimAppComponent, "euim-app", never, { "ionMenuId": { "alias": "ionMenuId"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_APP} instead.
 */
declare class EuimAppModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAppModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimAppModule, never, [typeof EuimAppComponent], [typeof EuimAppComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimAppModule>;
}

declare const EUIM_APP: readonly [typeof EuimAppComponent];

declare class EuimLanguageSelectorComponent implements OnInit, OnDestroy {
    private cd;
    private i18nService;
    private modalCtrl;
    baseStatesDirective: BaseStatesDirective;
    protected baseGlobalConfig: GlobalConfig;
    hasSearchbar: boolean;
    _euimBranding: boolean;
    private languages;
    protected config: I18nServiceConfig;
    selectedLanguage: EuiLanguage;
    private destroy$;
    constructor(cd: ChangeDetectorRef, i18nService: I18nService, modalCtrl: ModalController, baseStatesDirective: BaseStatesDirective, baseGlobalConfig: GlobalConfig);
    get cssClasses(): string;
    ngOnInit(): void;
    ngOnDestroy(): void;
    onShowLanguageList(): Promise<void>;
    protected getAllLanguages(): void;
    protected getLanguageLabel(languageCode: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimLanguageSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimLanguageSelectorComponent, "euim-language-selector", never, { "hasSearchbar": { "alias": "hasSearchbar"; "required": false; }; }, {}, never, never, true, [{ directive: typeof BaseStatesDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
    static ngAcceptInputType_hasSearchbar: unknown;
}

declare class EuimLanguageListComponent implements OnInit {
    private modalCtrl;
    private i18nService;
    languages: EuiLanguage[];
    selectedLanguage: EuiLanguage;
    euLanguageList: EuiLanguage[];
    nonEULanguageList: EuiLanguage[];
    private languagesSortedByEUAndNonEU;
    results: EuiLanguage[];
    hasSearchbar: boolean;
    constructor(modalCtrl: ModalController, i18nService: I18nService);
    ngOnInit(): void;
    onLanguageSelected(language: EuiLanguage): void;
    isLastElementOfArray<T>(array: T[], element: T): boolean;
    protected setLanguages(): void;
    protected onClose(): Promise<boolean>;
    protected handleChange(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimLanguageListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimLanguageListComponent, "euim-language-list", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated Use {@link EUIM_LANGUAGE_SELECTOR} instead.
 */
declare class EuimLanguageSelectorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimLanguageSelectorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimLanguageSelectorModule, never, [typeof EuimLanguageSelectorComponent, typeof EuimLanguageListComponent], [typeof EuimLanguageSelectorComponent, typeof EuimLanguageListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimLanguageSelectorModule>;
}

declare const EUIM_LANGUAGE_SELECTOR: readonly [typeof EuimLanguageSelectorComponent, typeof EuimLanguageListComponent];

declare class EuimUserProfileComponent {
    color: 'dark' | 'white' | 'primary' | 'info' | 'success' | 'warning' | 'danger' | 'branding';
    get cssClasses(): string;
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimUserProfileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimUserProfileComponent, "euim-user-profile", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, ["euim-user-profile-avatar", "euim-user-profile-infos", "euim-user-profile-action"], true, never>;
}

declare class EuiMUserProfileAvatarComponent {
    class: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiMUserProfileAvatarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiMUserProfileAvatarComponent, "euim-user-profile-avatar", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiMUserProfileInfosComponent {
    color: 'dark' | 'white' | 'primary' | 'info' | 'success' | 'warning' | 'danger';
    get cssClasses(): string;
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiMUserProfileInfosComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiMUserProfileInfosComponent, "euim-user-profile-infos", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class EuiMUserProfileInfosItemComponent {
    class: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiMUserProfileInfosItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiMUserProfileInfosItemComponent, "euim-user-profile-infos-item", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiMUserProfileActionComponent {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiMUserProfileActionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiMUserProfileActionComponent, "euim-user-profile-action", never, {}, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_USER_PROFILE} instead.
 */
declare class EuimUserProfileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimUserProfileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimUserProfileModule, never, [typeof EuimUserProfileComponent, typeof EuiMUserProfileAvatarComponent, typeof EuiMUserProfileInfosComponent, typeof EuiMUserProfileInfosItemComponent, typeof EuiMUserProfileActionComponent], [typeof EuimUserProfileComponent, typeof EuiMUserProfileAvatarComponent, typeof EuiMUserProfileInfosComponent, typeof EuiMUserProfileInfosItemComponent, typeof EuiMUserProfileActionComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimUserProfileModule>;
}

declare const EUIM_USER_PROFILE: readonly [typeof EuimUserProfileComponent, typeof EuiMUserProfileAvatarComponent, typeof EuiMUserProfileInfosComponent, typeof EuiMUserProfileInfosItemComponent, typeof EuiMUserProfileActionComponent];

declare class EuimToolbarComponent implements OnInit {
    private navCtrl;
    hasBackButton: boolean;
    backButtonDefaultHref: string;
    ionMenuId: string;
    hasSidebarTrigger: boolean;
    hasLanguageSelector: boolean;
    backButtonClick: EventEmitter<Event>;
    className: string;
    constructor(navCtrl: NavController);
    ngOnInit(): void;
    onBackButtonClick(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimToolbarComponent, "euim-toolbar", never, { "hasBackButton": { "alias": "hasBackButton"; "required": false; }; "backButtonDefaultHref": { "alias": "backButtonDefaultHref"; "required": false; }; "ionMenuId": { "alias": "ionMenuId"; "required": false; }; "hasSidebarTrigger": { "alias": "hasSidebarTrigger"; "required": false; }; "hasLanguageSelector": { "alias": "hasLanguageSelector"; "required": false; }; }, { "backButtonClick": "backButtonClick"; }, never, ["*", "euim-toolbar-title", "euim-toolbar-action-items"], true, never>;
    static ngAcceptInputType_hasBackButton: unknown;
    static ngAcceptInputType_hasSidebarTrigger: unknown;
    static ngAcceptInputType_hasLanguageSelector: unknown;
}

declare class EuimToolbarTitleComponent {
    baseStatesDirective: BaseStatesDirective;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimToolbarTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimToolbarTitleComponent, "euim-toolbar-title", never, {}, {}, never, ["*"], true, [{ directive: typeof BaseStatesDirective; inputs: {}; outputs: {}; }]>;
}

declare class EuimToolbarActionItemsComponent {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimToolbarActionItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimToolbarActionItemsComponent, "euim-toolbar-action-items", never, {}, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_TOOLBAR} instead.
 */
declare class EuimToolbarComponentModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimToolbarComponentModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimToolbarComponentModule, never, [typeof EuimToolbarComponent, typeof EuimToolbarTitleComponent, typeof EuimToolbarActionItemsComponent], [typeof EuimToolbarComponent, typeof EuimToolbarTitleComponent, typeof EuimToolbarActionItemsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimToolbarComponentModule>;
}

declare const EUIM_TOOLBAR: readonly [typeof EuimToolbarComponent, typeof EuimToolbarTitleComponent, typeof EuimToolbarActionItemsComponent];

type IconColor = 'primary' | 'default' | 'info' | 'success' | 'warning' | 'danger' | 'dark' | 'white' | 'accent' | 'secondary';
declare class EuimSidebarContentComponent implements OnInit {
    private i18nService;
    asService: EuiAppShellService;
    private menuCtrl;
    private navCtrl;
    className: string;
    sidebarItems: MenuItem[];
    ionMenuId: string;
    hasSearchbar: BooleanInput;
    isSearchbarSticky: BooleanInput;
    sidebarItemsFilter: EventEmitter<MenuItem[]>;
    searchbar: IonSearchbar;
    protected filteredItems: MenuItem[];
    protected query: string;
    constructor(i18nService: I18nService, asService: EuiAppShellService, menuCtrl: MenuController, navCtrl: NavController);
    ngOnInit(): void;
    handleInput(event: CustomEvent): void;
    closeMenu(): void;
    protected sortSidebarItems(): void;
    protected filterMenuItems(items: any, searchPhrase: string): MenuItem[];
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSidebarContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimSidebarContentComponent, "euim-sidebar-content", never, { "sidebarItems": { "alias": "sidebarItems"; "required": false; }; "ionMenuId": { "alias": "ionMenuId"; "required": false; }; "hasSearchbar": { "alias": "hasSearchbar"; "required": false; }; "isSearchbarSticky": { "alias": "isSearchbarSticky"; "required": false; }; }, { "sidebarItemsFilter": "sidebarItemsFilter"; }, never, ["*"], true, never>;
    static ngAcceptInputType_hasSearchbar: unknown;
    static ngAcceptInputType_isSearchbarSticky: unknown;
}
interface MenuItem {
    icon?: string;
    iconColor?: IconColor;
    label: string;
    url?: string;
    isSection?: boolean;
    section?: string;
    group?: number;
    groupHeader?: string;
}

declare class EuimSidebarComponent implements OnInit, AfterContentInit {
    private router;
    menuCtrl: MenuController;
    sidebarContent: EuimSidebarContentComponent;
    className: string;
    ionMenuId: string;
    routerPath: string;
    constructor(router: Router, menuCtrl: MenuController);
    ngOnInit(): void;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimSidebarComponent, "euim-sidebar", never, { "ionMenuId": { "alias": "ionMenuId"; "required": false; }; "routerPath": { "alias": "routerPath"; "required": false; }; }, {}, ["sidebarContent"], ["*", "euim-sidebar-content"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_SIDEBAR} instead.
 */
declare class EuimSidebarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSidebarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimSidebarModule, never, [typeof EuimSidebarComponent, typeof EuimSidebarContentComponent], [typeof EuimSidebarComponent, typeof EuimSidebarContentComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimSidebarModule>;
}

declare const EUIM_SIDEBAR: readonly [typeof EuimSidebarComponent, typeof EuimSidebarContentComponent];

declare class EuimHeaderDetailsComponent {
    baseStatesDirective: BaseStatesDirective;
    hasBorderBottom: BooleanInput;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimHeaderDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimHeaderDetailsComponent, "euim-header-details", never, { "hasBorderBottom": { "alias": "hasBorderBottom"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof BaseStatesDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
    static ngAcceptInputType_hasBorderBottom: unknown;
}

declare class EuimHeaderDetailsMetaDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimHeaderDetailsMetaDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimHeaderDetailsMetaDirective, "[euimHeaderDetailsMeta]", never, {}, {}, never, never, true, never>;
}

declare class EuimHeaderDetailsTitleDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimHeaderDetailsTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimHeaderDetailsTitleDirective, "[euimHeaderDetailsTitle]", never, {}, {}, never, never, true, never>;
}

declare class EuimHeaderDetailsIconDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimHeaderDetailsIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimHeaderDetailsIconDirective, "[euimHeaderDetailsIcon]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated Use {@link EUIM_HEADER_DETAILS} instead.
 */
declare class EuimHeaderDetailsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimHeaderDetailsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimHeaderDetailsModule, never, [typeof EuimHeaderDetailsComponent, typeof EuimHeaderDetailsTitleDirective, typeof EuimHeaderDetailsMetaDirective, typeof EuimHeaderDetailsIconDirective], [typeof EuimHeaderDetailsComponent, typeof EuimHeaderDetailsTitleDirective, typeof EuimHeaderDetailsMetaDirective, typeof EuimHeaderDetailsIconDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimHeaderDetailsModule>;
}

declare const EUIM_HEADER_DETAILS: readonly [typeof EuimHeaderDetailsComponent, typeof EuimHeaderDetailsMetaDirective, typeof EuimHeaderDetailsTitleDirective, typeof EuimHeaderDetailsIconDirective];

declare class EuimBadgeComponent {
    baseStatesDirective: BaseStatesDirective;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimBadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimBadgeComponent, "euim-badge", never, {}, {}, never, ["*"], true, [{ directive: typeof BaseStatesDirective; inputs: { "euimPositionTopEnd": "euimPositionTopEnd"; "euimSizeM": "euimSizeM"; "euimSizeS": "euimSizeS"; "euimSizeL": "euimSizeL"; "euimSizeXL": "euimSizeXL"; "color": "color"; }; outputs: {}; }]>;
}

/**
 * @deprecated Use {@link EUIM_BADGE} instead.
 */
declare class EuimBadgeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimBadgeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimBadgeModule, never, [typeof EuimBadgeComponent], [typeof EuimBadgeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimBadgeModule>;
}

declare const EUIM_BADGE: readonly [typeof EuimBadgeComponent];

declare class EuimEmptyListPlaceholderTitleDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimEmptyListPlaceholderTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimEmptyListPlaceholderTitleDirective, "[euimEmptyListPlaceholderTitle]", never, {}, {}, never, never, true, never>;
}

declare class EuimEmptyListPlaceholderSubtitleDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimEmptyListPlaceholderSubtitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimEmptyListPlaceholderSubtitleDirective, "[euimEmptyListPlaceholderSubtitle]", never, {}, {}, never, never, true, never>;
}

declare class EuimEmptyListPlaceholderIconDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimEmptyListPlaceholderIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimEmptyListPlaceholderIconDirective, "[euimEmptyListPlaceholderIcon]", never, {}, {}, never, never, true, never>;
}

declare class EuimEmptyListPlaceholderComponent implements AfterViewInit {
    private cdr;
    message: string;
    icon: string;
    description: string;
    button: string;
    euimMarginTopLarge: boolean;
    euimMarginTopSmall: boolean;
    euimMarginBottomSmall: boolean;
    get cssClasses(): string;
    contentWrapper: ElementRef;
    isEmptyContent: boolean;
    constructor(cdr: ChangeDetectorRef);
    ngAfterViewInit(): void;
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimEmptyListPlaceholderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimEmptyListPlaceholderComponent, "euim-empty-list-placeholder", never, { "message": { "alias": "message"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "description": { "alias": "description"; "required": false; }; "button": { "alias": "button"; "required": false; }; "euimMarginTopLarge": { "alias": "euimMarginTopLarge"; "required": false; }; "euimMarginTopSmall": { "alias": "euimMarginTopSmall"; "required": false; }; "euimMarginBottomSmall": { "alias": "euimMarginBottomSmall"; "required": false; }; }, {}, never, ["*"], true, never>;
    static ngAcceptInputType_euimMarginTopLarge: unknown;
    static ngAcceptInputType_euimMarginTopSmall: unknown;
    static ngAcceptInputType_euimMarginBottomSmall: unknown;
}

/**
 * @deprecated Use {@link EUIM_EMPTY_LIST_PLACEHOLDER} instead.
 */
declare class EuimEmptyListPlaceholderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimEmptyListPlaceholderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimEmptyListPlaceholderModule, never, [typeof EuimEmptyListPlaceholderComponent, typeof EuimEmptyListPlaceholderTitleDirective, typeof EuimEmptyListPlaceholderSubtitleDirective, typeof EuimEmptyListPlaceholderIconDirective], [typeof EuimEmptyListPlaceholderComponent, typeof EuimEmptyListPlaceholderTitleDirective, typeof EuimEmptyListPlaceholderSubtitleDirective, typeof EuimEmptyListPlaceholderIconDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimEmptyListPlaceholderModule>;
}

declare const EUIM_EMPTY_LIST_PLACEHOLDER: readonly [typeof EuimEmptyListPlaceholderTitleDirective, typeof EuimEmptyListPlaceholderSubtitleDirective, typeof EuimEmptyListPlaceholderIconDirective, typeof EuimEmptyListPlaceholderComponent];

type VariantTypes = 'info' | 'success' | 'warning' | 'danger' | 'accent' | 'primary' | 'secondary';
declare class EuimMessageComponent {
    baseStatesDirective: BaseStatesDirective;
    get icon(): string;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimMessageComponent, "euim-message", never, {}, {}, never, ["euim-message-title", "*"], true, [{ directive: typeof BaseStatesDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
}

declare class EuimMessageTitleComponent {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMessageTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimMessageTitleComponent, "euim-message-title", never, {}, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_MESSAGE} instead.
 */
declare class EuimMessageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMessageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimMessageModule, never, [typeof EuimMessageComponent, typeof EuimMessageTitleComponent], [typeof EuimMessageComponent, typeof EuimMessageTitleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimMessageModule>;
}

declare const EUIM_MESSAGE: readonly [typeof EuimMessageComponent, typeof EuimMessageTitleComponent];

declare class EuimSpinnerComponent {
    variant: 'default' | 'inverted';
    get cssClasses(): string;
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSpinnerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimSpinnerComponent, "euim-spinner", never, { "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class EuimSpinnerMessageComponent {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSpinnerMessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimSpinnerMessageComponent, "[euimSpinnerMessage]", never, {}, {}, never, ["*"], true, never>;
}

declare class EuimSpinnerDescriptionComponent {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSpinnerDescriptionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimSpinnerDescriptionComponent, "[euimSpinnerDescription]", never, {}, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_SPINNER} instead.
 */
declare class EuimSpinnerComponentModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSpinnerComponentModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimSpinnerComponentModule, never, [typeof EuimSpinnerComponent, typeof EuimSpinnerMessageComponent, typeof EuimSpinnerDescriptionComponent], [typeof EuimSpinnerComponent, typeof EuimSpinnerMessageComponent, typeof EuimSpinnerDescriptionComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimSpinnerComponentModule>;
}

declare const EUIM_SPINNER: readonly [typeof EuimSpinnerComponent, typeof EuimSpinnerMessageComponent, typeof EuimSpinnerDescriptionComponent];

declare class EuimMediaHeaderComponent {
    baseStatesDirective: BaseStatesDirective;
    euimNoGradient: boolean;
    euimTwoSidesGradient: boolean;
    hasBlur: boolean;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMediaHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimMediaHeaderComponent, "euim-media-header", never, { "euimNoGradient": { "alias": "euimNoGradient"; "required": false; }; "euimTwoSidesGradient": { "alias": "euimTwoSidesGradient"; "required": false; }; "hasBlur": { "alias": "hasBlur"; "required": false; }; }, {}, never, ["[euimMediaHeaderImage]", "*"], true, [{ directive: typeof BaseStatesDirective; inputs: { "euimSizeM": "euimSizeM"; "euimSizeS": "euimSizeS"; "euimSizeL": "euimSizeL"; }; outputs: {}; }]>;
    static ngAcceptInputType_euimNoGradient: unknown;
    static ngAcceptInputType_euimTwoSidesGradient: unknown;
    static ngAcceptInputType_hasBlur: unknown;
}

declare class EuimMediaHeaderSubTitleDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMediaHeaderSubTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimMediaHeaderSubTitleDirective, "[euimMediaHeaderSubTitle]", never, {}, {}, never, never, true, never>;
}

declare class EuimMediaHeaderTitleDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMediaHeaderTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimMediaHeaderTitleDirective, "[euimMediaHeaderTitle]", never, {}, {}, never, never, true, never>;
}

declare class EuimMediaHeaderImageDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMediaHeaderImageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimMediaHeaderImageDirective, "[euimMediaHeaderImage]", never, {}, {}, never, never, true, never>;
}

declare class EuimMediaHeaderCustomContentDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMediaHeaderCustomContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimMediaHeaderCustomContentDirective, "[euimMediaHeaderCustomContent]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated Use {@link EUIM_MEDIA_HEADER} instead.
 */
declare class EuimMediaHeaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMediaHeaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimMediaHeaderModule, never, [typeof EuimMediaHeaderCustomContentDirective, typeof EuimMediaHeaderComponent, typeof EuimMediaHeaderTitleDirective, typeof EuimMediaHeaderSubTitleDirective, typeof EuimMediaHeaderImageDirective], [typeof EuimMediaHeaderComponent, typeof EuimMediaHeaderTitleDirective, typeof EuimMediaHeaderSubTitleDirective, typeof EuimMediaHeaderImageDirective, typeof EuimMediaHeaderCustomContentDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimMediaHeaderModule>;
}

declare const EUIM_MEDIA_HEADER: readonly [typeof EuimMediaHeaderComponent, typeof EuimMediaHeaderSubTitleDirective, typeof EuimMediaHeaderTitleDirective, typeof EuimMediaHeaderImageDirective, typeof EuimMediaHeaderCustomContentDirective];

declare class EuimDataSummaryColLabelDirective {
    baseStatesDirective: BaseStatesDirective;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimDataSummaryColLabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimDataSummaryColLabelDirective, "[euimDataSummaryColLabel]", never, {}, {}, never, never, true, [{ directive: typeof BaseStatesDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
}

declare class EuimDataSummaryColValueDirective {
    baseStatesDirective: BaseStatesDirective;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimDataSummaryColValueDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimDataSummaryColValueDirective, "[euimDataSummaryColValue]", never, {}, {}, never, never, true, never>;
}

declare class EuimDataSummaryComponent implements AfterContentInit {
    baseStatesDirective: BaseStatesDirective;
    euimDataSummaryColLabelComponent: QueryList<EuimDataSummaryColLabelDirective>;
    euimDataSummaryColValueComponent: QueryList<EuimDataSummaryColValueDirective>;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimDataSummaryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimDataSummaryComponent, "euim-data-summary", never, {}, {}, ["euimDataSummaryColLabelComponent", "euimDataSummaryColValueComponent"], ["*"], true, [{ directive: typeof BaseStatesDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
}

declare class EuimDataSummaryColComponent {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimDataSummaryColComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimDataSummaryColComponent, "euim-data-summary-col", never, {}, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_DATA_SUMMARY} instead.
 */
declare class EuimDataSummaryModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimDataSummaryModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimDataSummaryModule, never, [typeof EuimDataSummaryComponent, typeof EuimDataSummaryColComponent, typeof EuimDataSummaryColLabelDirective, typeof EuimDataSummaryColValueDirective], [typeof EuimDataSummaryComponent, typeof EuimDataSummaryColComponent, typeof EuimDataSummaryColLabelDirective, typeof EuimDataSummaryColValueDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimDataSummaryModule>;
}

declare const EUIM_DATA_SUMMARY: readonly [typeof EuimDataSummaryComponent, typeof EuimDataSummaryColComponent, typeof EuimDataSummaryColLabelDirective, typeof EuimDataSummaryColValueDirective];

declare class EuimAvatarComponent {
    color: 'default' | 'dark' | 'branding' | 'white' | 'primary' | 'info' | 'success' | 'accent' | 'secondary' | 'warning' | 'danger';
    size: 'default' | 'auto' | 's' | 'm' | 'l';
    fill: 'default' | 'clear' | 'outline' | 'outline-solid' | 'solid';
    variant: 'default' | 'rectangle' | 'rounded';
    borderColor: 'default' | 'primary' | 'branding' | 'info' | 'success' | 'danger' | 'white';
    get cssClasses(): string;
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAvatarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimAvatarComponent, "euim-avatar", never, { "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "borderColor": { "alias": "borderColor"; "required": false; }; }, {}, never, ["euim-avatar-icon", "euim-avatar-text", "euim-avatar-image", "euim-avatar-badge", "euim-avatar-icon-sub"], true, never>;
}

declare class EuimAvatarIconComponent {
    string: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAvatarIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimAvatarIconComponent, "euim-avatar-icon", never, {}, {}, never, ["*"], true, never>;
}

declare class EuimAvatarIconSubComponent {
    color: 'default' | 'dark' | 'branding' | 'white' | 'primary' | 'info' | 'success' | 'accent' | 'secondary' | 'warning' | 'danger';
    size: 'default' | 'auto' | 'l' | 'm' | 's';
    fill: 'default' | 'clear' | 'outline' | 'solid' | 'outline-solid';
    variant: 'default' | 'rounded' | 'rectangle';
    borderColor: 'default' | 'primary' | 'info' | 'success' | 'danger' | 'white';
    get cssClasses(): string;
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAvatarIconSubComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimAvatarIconSubComponent, "euim-avatar-icon-sub", never, { "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "borderColor": { "alias": "borderColor"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class EuimAvatarTextComponent {
    color: 'default' | 'white' | 'primary' | 'info' | 'success' | 'accent' | 'secondary' | 'warning' | 'danger';
    get cssClasses(): string;
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAvatarTextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimAvatarTextComponent, "euim-avatar-text", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class EuimAvatarImageComponent {
    string: string;
    imageUrl: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAvatarImageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimAvatarImageComponent, "euim-avatar-image", never, { "imageUrl": { "alias": "imageUrl"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class EuimAvatarBadgeComponent {
    get cssClasses(): string;
    position: 'default' | 'bottom' | 'top';
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAvatarBadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimAvatarBadgeComponent, "euim-avatar-badge", never, { "position": { "alias": "position"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_AVATAR} instead.
 */
declare class EuimAvatarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAvatarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimAvatarModule, never, [typeof EuimAvatarComponent, typeof EuimAvatarIconComponent, typeof EuimAvatarIconSubComponent, typeof EuimAvatarTextComponent, typeof EuimAvatarImageComponent, typeof EuimAvatarBadgeComponent], [typeof EuimAvatarComponent, typeof EuimAvatarIconComponent, typeof EuimAvatarIconSubComponent, typeof EuimAvatarTextComponent, typeof EuimAvatarImageComponent, typeof EuimAvatarBadgeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimAvatarModule>;
}

declare const EUIM_AVATAR: readonly [typeof EuimAvatarComponent, typeof EuimAvatarIconComponent, typeof EuimAvatarIconSubComponent, typeof EuimAvatarTextComponent, typeof EuimAvatarImageComponent, typeof EuimAvatarBadgeComponent];

declare class EuimCardImageDirective {
    euimCardImageHeight: string;
    euimCardImageWidth: string;
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimCardImageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimCardImageDirective, "[euimCardImage]", never, { "euimCardImageHeight": { "alias": "euimCardImageHeight"; "required": false; }; "euimCardImageWidth": { "alias": "euimCardImageWidth"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuimCardComponent implements AfterContentInit {
    baseStatesDirective: BaseStatesDirective;
    cardImageDirective: EuimCardImageDirective;
    imageWidth: string;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimCardComponent, "euim-card", never, {}, {}, ["cardImageDirective"], ["[euimCardImage]", "*"], true, [{ directive: typeof BaseStatesDirective; inputs: { "euimSizeM": "euimSizeM"; "euimSizeS": "euimSizeS"; "euimSizeL": "euimSizeL"; }; outputs: {}; }]>;
}

/**
 * @deprecated Use {@link EUIM_CARD} instead.
 */
declare class EuimCardModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimCardModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimCardModule, never, [typeof EuimCardComponent, typeof EuimCardImageDirective], [typeof EuimCardComponent, typeof EuimCardImageDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimCardModule>;
}

declare const EUIM_CARD: readonly [typeof EuimCardComponent, typeof EuimCardImageDirective];

declare class EuimCardListComponent {
    direction: 'column' | '';
    get cssClasses(): string;
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimCardListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimCardListComponent, "euim-card-list", never, { "direction": { "alias": "direction"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_CARD_LIST} instead.
 */
declare class EuimCardListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimCardListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimCardListModule, never, [typeof EuimCardListComponent], [typeof EuimCardListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimCardListModule>;
}

declare const EUIM_CARD_LIST: readonly [typeof EuimCardListComponent];

declare class EuimAlertMessageComponent implements OnInit {
    baseStatesDirective: BaseStatesDirective;
    _variant: string;
    euimClose: EventEmitter<null>;
    euimLabelTruncate: boolean;
    hasIcon: boolean;
    isCloseable: boolean;
    isVisible: boolean;
    constructor(baseStatesDirective: BaseStatesDirective);
    ngOnInit(): void;
    setVariants(): void;
    get icon(): string;
    get cssClasses(): string;
    getCssClasses(): string;
    onClose(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAlertMessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimAlertMessageComponent, "euim-alert-message", never, { "euimLabelTruncate": { "alias": "euimLabelTruncate"; "required": false; }; "hasIcon": { "alias": "hasIcon"; "required": false; }; "isCloseable": { "alias": "isCloseable"; "required": false; }; }, { "euimClose": "euimClose"; }, never, ["[slotStart]", "*", "[slotEnd]"], true, [{ directive: typeof BaseStatesDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
    static ngAcceptInputType_euimLabelTruncate: unknown;
    static ngAcceptInputType_hasIcon: unknown;
    static ngAcceptInputType_isCloseable: unknown;
}

/**
 * @deprecated Use {@link EUIM_ALERT_MESSAGE} instead.
 */
declare class EuimAlertMessageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAlertMessageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimAlertMessageModule, never, [typeof EuimAlertMessageComponent], [typeof EuimAlertMessageComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimAlertMessageModule>;
}

declare const EUIM_ALERT_MESSAGE: readonly [typeof EuimAlertMessageComponent];

declare class EuimSlideInfoScreenComponent {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSlideInfoScreenComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimSlideInfoScreenComponent, "euim-slide-info-screen", never, {}, {}, never, ["*"], true, never>;
}

declare class EuimSliderInfoScreenComponent implements OnInit, AfterViewInit, OnDestroy {
    private renderer;
    private gestureCtrl;
    private sliderElement;
    private cdr;
    slides: ElementRef;
    rightActionClicked: EventEmitter<MouseEvent>;
    lastStepActionClicked: EventEmitter<MouseEvent>;
    leftActionClicked: EventEmitter<MouseEvent>;
    isLastItemReached: BooleanInput;
    isCarousel: boolean;
    showLeftBtn: boolean;
    showRightBtn: boolean;
    isPreviousBtn: boolean;
    isNextBtn: boolean;
    paginationColor: 'dark' | 'white' | 'primary' | 'info' | 'success' | 'warning' | 'danger';
    actionBtnNames: ActionBtnsNames;
    actionBtnIconsNames: ActionBtnsIconsNames;
    slideChild: QueryList<EuimSlideInfoScreenComponent>;
    showLeftBtnAsPrevious: BooleanInput;
    slidesArray: any[];
    currentSlide: number;
    startX: number;
    isDataLoaded: i0.WritableSignal<boolean>;
    private hasNoContent;
    private destroy$;
    constructor(renderer: Renderer2, gestureCtrl: GestureController, sliderElement: ElementRef, cdr: ChangeDetectorRef);
    onResize(event: Event): void;
    get cssClasses(): string;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    ngOnInit(): void;
    setSliderStyles(): void;
    handleTouchEnd(e: any): void;
    goToSlide(index: any): void;
    goToPreviousSlide(): void;
    goToNextSlide(): void;
    isPreviousButtonVisible(): void;
    isNextButtonVisible(): void;
    onRightBtnAction(event: MouseEvent): void;
    onLastStepAction(event: MouseEvent): void;
    onLeftBtnAction(event: MouseEvent): void;
    isImageOnly(): boolean;
    getCssClasses(): string;
    private isImageWithNoContent;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSliderInfoScreenComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimSliderInfoScreenComponent, "euim-slider-info-screen", never, { "isCarousel": { "alias": "isCarousel"; "required": false; }; "showLeftBtn": { "alias": "showLeftBtn"; "required": false; }; "showRightBtn": { "alias": "showRightBtn"; "required": false; }; "isPreviousBtn": { "alias": "isPreviousBtn"; "required": false; }; "isNextBtn": { "alias": "isNextBtn"; "required": false; }; "paginationColor": { "alias": "paginationColor"; "required": false; }; "actionBtnNames": { "alias": "actionBtnNames"; "required": false; }; "actionBtnIconsNames": { "alias": "actionBtnIconsNames"; "required": false; }; }, { "rightActionClicked": "rightActionClicked"; "lastStepActionClicked": "lastStepActionClicked"; "leftActionClicked": "leftActionClicked"; }, ["slideChild"], ["*"], true, never>;
    static ngAcceptInputType_isCarousel: unknown;
    static ngAcceptInputType_showLeftBtn: unknown;
    static ngAcceptInputType_showRightBtn: unknown;
    static ngAcceptInputType_isPreviousBtn: unknown;
    static ngAcceptInputType_isNextBtn: unknown;
}
interface ActionBtnsNames {
    rightBtnName: string;
    lastStepActionBtnName: string;
    leftBtnName: string;
}
interface ActionBtnsIconsNames {
    rightBtnIconName: string;
    lastStepActionBtnIconName: string;
    leftBtnIconName: string;
}

declare class EuimSliderInfoScreenContentDirective {
    euimTextCenter: boolean;
    get cssClasses(): string;
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSliderInfoScreenContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimSliderInfoScreenContentDirective, "[euimSliderInfoScreenContent]", never, { "euimTextCenter": { "alias": "euimTextCenter"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_euimTextCenter: unknown;
}

declare class EuimSliderInfoScreenTitleDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSliderInfoScreenTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimSliderInfoScreenTitleDirective, "[euimSliderInfoScreenTitle]", never, {}, {}, never, never, true, never>;
}

declare class EuimSliderInfoScreenSubTitleDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSliderInfoScreenSubTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimSliderInfoScreenSubTitleDirective, "[euimSliderInfoScreenSubTitle]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated Use {@link EUIM_SLIDER_INFO_SCREEN} instead.
 */
declare class EuimSliderInfoScreenModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSliderInfoScreenModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimSliderInfoScreenModule, never, [typeof EuimSliderInfoScreenComponent, typeof EuimSlideInfoScreenComponent, typeof EuimSliderInfoScreenContentDirective, typeof EuimSliderInfoScreenTitleDirective, typeof EuimSliderInfoScreenSubTitleDirective], [typeof EuimSliderInfoScreenComponent, typeof EuimSlideInfoScreenComponent, typeof EuimSliderInfoScreenContentDirective, typeof EuimSliderInfoScreenTitleDirective, typeof EuimSliderInfoScreenSubTitleDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimSliderInfoScreenModule>;
}

declare const EUIM_SLIDER_INFO_SCREEN: readonly [typeof EuimSliderInfoScreenComponent, typeof EuimSlideInfoScreenComponent, typeof EuimSliderInfoScreenContentDirective, typeof EuimSliderInfoScreenTitleDirective, typeof EuimSliderInfoScreenSubTitleDirective];

declare class EuimScrollerXComponent {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimScrollerXComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimScrollerXComponent, "euim-scroller-x", never, {}, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_SCROLLER_X} instead.
 */
declare class EuimScrollerXComponentModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimScrollerXComponentModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimScrollerXComponentModule, never, [typeof EuimScrollerXComponent], [typeof EuimScrollerXComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimScrollerXComponentModule>;
}

declare const EUIM_SCROLLER_X: readonly [typeof EuimScrollerXComponent];

declare class EuimChipSelectorItemDirective {
    renderer: Renderer2;
    el: ElementRef;
    clickEventAdded: boolean;
    id: number;
    euimChipSelectorAll: boolean;
    className: string;
    constructor(renderer: Renderer2, el: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimChipSelectorItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimChipSelectorItemDirective, "[euimChipSelectorItem]", never, { "id": { "alias": "id"; "required": false; }; "euimChipSelectorAll": { "alias": "euimChipSelectorAll"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_id: unknown;
    static ngAcceptInputType_euimChipSelectorAll: unknown;
}

declare class EuimChipSelectorComponent implements AfterViewInit, AfterContentInit, OnChanges, OnDestroy {
    backgroundColor: 'branding' | 'transparent' | 'white' | '';
    color: 'default' | 'dark' | 'branding' | 'white' | 'primary' | 'info' | 'success' | 'warning' | 'danger';
    chipSelectedColor: 'primary' | 'dark' | 'branding' | 'info' | 'success' | 'warning' | 'danger' | 'white';
    chipFill: 'default' | 'clear' | 'outline' | 'outline-solid' | 'solid';
    sourceData: FilteredData[];
    hasBoxShadow: BooleanInput;
    hasNoScrollerX: BooleanInput;
    hasColorTransparency: BooleanInput;
    selectedChips: any[];
    isMultiSelectionMode: BooleanInput;
    isCustomMode: BooleanInput;
    euimKeepSelection: BooleanInput;
    hasSearchbar: BooleanInput;
    filterData: EventEmitter<FilteredData[]>;
    clickItems: EventEmitter<string[]>;
    selectedChipsChange: EventEmitter<string[]>;
    get cssClasses(): string;
    euimChipSelectorItemComponent: QueryList<EuimChipSelectorItemDirective>;
    filteredData: FilteredData[];
    filterConditions: any[];
    searchInput: string;
    isEmitEvent: boolean;
    euimChipSelectorItemSubscription: Subscription;
    clickEventHandled: boolean;
    ngAfterViewInit(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    subscribeToChanges(): void;
    ngOnChanges(changes: SimpleChanges): void;
    getCssClasses(): string;
    setCssItemClasses(): void;
    getCssItemClasses(): string;
    updateChipsAndFilters(): void;
    applyFilter(filterCondition: string, isAllFilter: BooleanInput, multipleFilterConditions: string[]): void;
    clearFiltersAndSelectAll(): void;
    updateChipsAndFilterDataAfterInit(isEmitEvent?: boolean): void;
    onFilterChange(filterCondition: string, isFilterAll: BooleanInput, item: any): void;
    handleChange(event: any): void;
    addSelectedStyles(item: any): void;
    removeSelectedStyles(item: any): void;
    private handleMultiSelectionMode;
    private handleSingleSelectionMode;
    private clearAllSelections;
    private filterBySearch;
    private filterByChips;
    private filterByCondition;
    private filterByMultipleConditions;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimChipSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimChipSelectorComponent, "euim-chip-selector", never, { "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "color": { "alias": "color"; "required": false; }; "chipSelectedColor": { "alias": "chipSelectedColor"; "required": false; }; "chipFill": { "alias": "chipFill"; "required": false; }; "sourceData": { "alias": "sourceData"; "required": false; }; "hasBoxShadow": { "alias": "hasBoxShadow"; "required": false; }; "hasNoScrollerX": { "alias": "hasNoScrollerX"; "required": false; }; "hasColorTransparency": { "alias": "hasColorTransparency"; "required": false; }; "selectedChips": { "alias": "selectedChips"; "required": false; }; "isMultiSelectionMode": { "alias": "isMultiSelectionMode"; "required": false; }; "isCustomMode": { "alias": "isCustomMode"; "required": false; }; "euimKeepSelection": { "alias": "euimKeepSelection"; "required": false; }; "hasSearchbar": { "alias": "hasSearchbar"; "required": false; }; }, { "filterData": "filterData"; "clickItems": "clickItems"; "selectedChipsChange": "selectedChipsChange"; }, ["euimChipSelectorItemComponent"], ["*"], true, never>;
    static ngAcceptInputType_hasBoxShadow: unknown;
    static ngAcceptInputType_hasNoScrollerX: unknown;
    static ngAcceptInputType_hasColorTransparency: unknown;
    static ngAcceptInputType_isMultiSelectionMode: unknown;
    static ngAcceptInputType_isCustomMode: unknown;
    static ngAcceptInputType_euimKeepSelection: unknown;
    static ngAcceptInputType_hasSearchbar: unknown;
}
interface FilteredData {
    title: string;
    filterId: string;
    [key: string]: string;
}

/**
 * @deprecated Use {@link EUIM_CHIP_SELECTOR} instead.
 */
declare class EuimChipSelectorComponentModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimChipSelectorComponentModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimChipSelectorComponentModule, never, [typeof EuimChipSelectorComponent, typeof EuimChipSelectorItemDirective], [typeof EuimChipSelectorComponent, typeof EuimChipSelectorItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimChipSelectorComponentModule>;
}

declare const EUIM_CHIP_SELECTOR: readonly [typeof EuimChipSelectorComponent, typeof EuimChipSelectorItemDirective];

declare class EuimSkeletonListItemComponent {
    baseStatesDirective: BaseStatesDirective;
    get cssClasses(): string;
    hasAvatar: boolean;
    hasTitle: boolean;
    hasSubtitle: boolean;
    hasMetaLine: boolean;
    isAnimated: boolean;
    avatarType: 'default' | 'square';
    separator: 'none' | 'full' | 'inset';
    titleWidth: string;
    subTitleWidth: string;
    metaLineWidth: string;
    constructor(baseStatesDirective: BaseStatesDirective);
    private getCssClasses;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSkeletonListItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimSkeletonListItemComponent, "euim-skeleton-list-item", never, { "hasAvatar": { "alias": "hasAvatar"; "required": false; }; "hasTitle": { "alias": "hasTitle"; "required": false; }; "hasSubtitle": { "alias": "hasSubtitle"; "required": false; }; "hasMetaLine": { "alias": "hasMetaLine"; "required": false; }; "isAnimated": { "alias": "isAnimated"; "required": false; }; "avatarType": { "alias": "avatarType"; "required": false; }; "separator": { "alias": "separator"; "required": false; }; "titleWidth": { "alias": "titleWidth"; "required": false; }; "subTitleWidth": { "alias": "subTitleWidth"; "required": false; }; "metaLineWidth": { "alias": "metaLineWidth"; "required": false; }; }, {}, never, never, true, [{ directive: typeof BaseStatesDirective; inputs: { "euimSize2XL": "euimSize2XL"; "euimSizeL": "euimSizeL"; }; outputs: {}; }]>;
    static ngAcceptInputType_hasAvatar: unknown;
    static ngAcceptInputType_hasTitle: unknown;
    static ngAcceptInputType_hasSubtitle: unknown;
    static ngAcceptInputType_hasMetaLine: unknown;
    static ngAcceptInputType_isAnimated: unknown;
}

/**
 * @deprecated Use {@link EUIM_SKELETON_LIST_ITEM} instead.
 */
declare class EuimSkeletonListItemModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSkeletonListItemModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimSkeletonListItemModule, never, [typeof EuimSkeletonListItemComponent], [typeof EuimSkeletonListItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimSkeletonListItemModule>;
}

declare const EUIM_SKELETON_LIST_ITEM: readonly [typeof EuimSkeletonListItemComponent];

declare class EuimSkeletonListComponent implements AfterContentInit {
    items: number;
    skeletonListItem: EuimSkeletonListItemComponent;
    skeletonItem: any;
    skeletonItemInputs: SkeletonItemInputs;
    ngAfterContentInit(): void;
    get itemsArray(): number[];
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSkeletonListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimSkeletonListComponent, "euim-skeleton-list", never, { "items": { "alias": "items"; "required": false; }; }, {}, ["skeletonListItem"], never, true, never>;
}
type SkeletonItemInputs = {
    hasAvatar?: BooleanInput;
    hasTitle?: BooleanInput;
    hasSubtitle?: BooleanInput;
    hasMetaLine?: BooleanInput;
    isAnimated?: BooleanInput;
    avatarType?: string;
    separator?: string;
    titleWidth?: string;
    subTitleWidth?: string;
    metaLineWidth?: string;
};

/**
 * @deprecated Use {@link EUIM_SKELETON_LIST} instead.
 */
declare class EuimSkeletonListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSkeletonListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimSkeletonListModule, never, [typeof EuimSkeletonListComponent], [typeof EuimSkeletonListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimSkeletonListModule>;
}

declare const EUIM_SKELETON_LIST: readonly [typeof EuimSkeletonListComponent];

declare class EuimMultiselectComponent implements OnInit, AfterContentChecked, OnChanges {
    private ref;
    className: string;
    initialDataProvider: any[];
    currentDataProvider: any[];
    toolbarTitle: string;
    euimKeepSelection: boolean;
    selectAll: boolean;
    indeterminate: boolean;
    numberOfSelected: number;
    constructor(ref: ChangeDetectorRef);
    ngOnInit(): void;
    selectAllItems(): void;
    deselectAllItems(): void;
    countSelectedItems(): number;
    selectedItems(): any[];
    selectByIndex(index: number, state?: boolean): void;
    ngAfterContentChecked(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMultiselectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimMultiselectComponent, "euim-multiselect", ["euimMultiselect"], { "currentDataProvider": { "alias": "currentDataProvider"; "required": false; }; "toolbarTitle": { "alias": "toolbarTitle"; "required": false; }; "euimKeepSelection": { "alias": "euimKeepSelection"; "required": false; }; }, {}, never, ["euim-multiselect-toolbar", "euim-multiselect-filter", "euim-multiselect-list", "euim-empty-list-placeholder"], true, never>;
    static ngAcceptInputType_euimKeepSelection: unknown;
}

declare class EuimMultiselectFilterComponent {
    private multiselect;
    className: string;
    filterByFieldsNames: string[];
    constructor(multiselect: EuimMultiselectComponent);
    handleChange(event: any): void;
    applyStatusToSelectAllCheckControl(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMultiselectFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimMultiselectFilterComponent, "euim-multiselect-filter", never, { "filterByFieldsNames": { "alias": "filterByFieldsNames"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuimMultiselectAllDirective {
    private euimMulti;
    className: string;
    constructor(euimMulti: EuimMultiselectComponent);
    onIonChange(event: CustomEvent): void;
    get indeterminate(): boolean;
    get checked(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMultiselectAllDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimMultiselectAllDirective, "[euimMultiselectAll]", never, {}, {}, never, never, true, never>;
}

declare class EuimMultiselectListComponent {
    protected multiselect: EuimMultiselectComponent;
    className: string;
    constructor(multiselect: EuimMultiselectComponent);
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMultiselectListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimMultiselectListComponent, "euim-multiselect-list", never, {}, {}, never, ["*"], true, never>;
}

declare class EuimMultiselectSelectFieldDirective {
    private euimMulti;
    className: string;
    item: any;
    constructor(euimMulti: EuimMultiselectComponent);
    onIonChange(event: CustomEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMultiselectSelectFieldDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimMultiselectSelectFieldDirective, "[euimMultiselectSelectField]", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuimMultiselectInfoComponent implements AfterContentChecked {
    protected multiselect: EuimMultiselectComponent;
    private ref;
    className: string;
    constructor(multiselect: EuimMultiselectComponent, ref: ChangeDetectorRef);
    ngAfterContentChecked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMultiselectInfoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimMultiselectInfoComponent, "euim-multiselect-info", never, {}, {}, never, never, true, never>;
}

declare class EuimMultiselectToolbarComponent {
    private multiselect;
    className: string;
    toolbarTitle: string;
    euimCustomRender: boolean;
    cancel: EventEmitter<boolean>;
    confirm: EventEmitter<any>;
    constructor(multiselect: EuimMultiselectComponent);
    onConfirm(): void;
    onCancelClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMultiselectToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimMultiselectToolbarComponent, "euim-multiselect-toolbar", never, { "toolbarTitle": { "alias": "toolbarTitle"; "required": false; }; "euimCustomRender": { "alias": "euimCustomRender"; "required": false; }; }, { "cancel": "cancel"; "confirm": "confirm"; }, never, ["ion-button", "*"], true, never>;
    static ngAcceptInputType_euimCustomRender: unknown;
}

/**
 * @deprecated Use {@link EUIM_MULTISELECT} instead.
 */
declare class EuimMultiselectModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMultiselectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimMultiselectModule, never, [typeof EuimMultiselectComponent, typeof EuimMultiselectFilterComponent, typeof EuimMultiselectListComponent, typeof EuimMultiselectInfoComponent, typeof EuimMultiselectSelectFieldDirective, typeof EuimMultiselectAllDirective, typeof EuimMultiselectToolbarComponent], [typeof EuimMultiselectComponent, typeof EuimMultiselectFilterComponent, typeof EuimMultiselectListComponent, typeof EuimMultiselectInfoComponent, typeof EuimMultiselectSelectFieldDirective, typeof EuimMultiselectAllDirective, typeof EuimMultiselectToolbarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimMultiselectModule>;
}

declare const EUIM_MULTISELECT: readonly [typeof EuimMultiselectComponent, typeof EuimMultiselectFilterComponent, typeof EuimMultiselectAllDirective, typeof EuimMultiselectListComponent, typeof EuimMultiselectSelectFieldDirective, typeof EuimMultiselectInfoComponent, typeof EuimMultiselectToolbarComponent];

declare class EuimPdfViewerComponent implements OnInit, OnChanges, OnDestroy {
    private alertService;
    private http;
    url: string;
    page: number;
    className: string;
    pinch: PinchZoomComponent;
    zoom: number;
    loading: boolean;
    errorMessage: string;
    pdf: PDFDocumentProxy;
    eventResult?: ZoomEvent;
    protected pdfNumPages: number;
    protected data: Uint8Array;
    private showDefaultError;
    private urlChange$;
    private subscription;
    constructor(alertService: AlertController, http: HttpClient);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    zoomChange(event: ZoomEvent): void;
    onLoaded(pdf: PDFDocumentProxy): void;
    onError(): void;
    onDownload(): void;
    onZoomIn(): void;
    onZoomOut(): void;
    onResetZoom(): void;
    nextPage(): void;
    prevPage(): void;
    /**
     * Download file from the given data and filename using Blob.
     * It generates an anchor link and clicks on it to download the file.
     * @param data
     * @param filename
     * @private
     */
    private downloadFile;
    /**
     * Fetch PDF data from the given URL and return as Uint8Array.
     * @param url
     * @private
     */
    private getPDFData;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimPdfViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimPdfViewerComponent, "euim-pdf-viewer", never, { "url": { "alias": "url"; "required": false; }; "page": { "alias": "page"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated Use {@link EUIM_PDF_VIEWER} instead.
 */
declare class EuimPdfViewerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimPdfViewerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimPdfViewerModule, never, [typeof EuimPdfViewerComponent], [typeof EuimPdfViewerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimPdfViewerModule>;
}

declare const EUIM_PDF_VIEWER: readonly [typeof EuimPdfViewerComponent];

declare class EuimAboutComponent {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAboutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimAboutComponent, "euim-about", never, {}, {}, never, ["*"], true, never>;
}

declare class EuimChangelogComponent {
    className: string;
    changeLogs: any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimChangelogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimChangelogComponent, "euim-changelog", never, { "changeLogs": { "alias": "changeLogs"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuimHelpSupportComponent {
    private router;
    helpAndSupportItems: HelpAndSupportItem[];
    className: string;
    constructor(router: Router);
    onItemClick(item: Item, linkType: string, linkTitle: string): void;
    isEndIconLink(item: Item): boolean;
    getLinkClass(item: Item): string;
    getLink(item?: Item, linkType?: string, linkTitle?: string): string;
    setTargetAttribute(item?: Item, linkType?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimHelpSupportComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimHelpSupportComponent, "euim-help-support", never, { "helpAndSupportItems": { "alias": "helpAndSupportItems"; "required": false; }; }, {}, never, ["*"], true, never>;
}
interface Item {
    title: string;
    link?: string;
    phone?: string;
    mail?: string;
    routerLink?: string;
    fragment?: string;
    subtitle?: string;
    startIcon?: string;
    endIcon?: string;
    hasBottomLine?: boolean;
}
interface HelpAndSupportItem {
    sectionTitle?: string;
    items: Item[];
}

declare class EuimOpenSourceLicencesComponent {
    className: string;
    items: any[];
    clickItem: EventEmitter<string[]>;
    emitItemClick(itemName: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimOpenSourceLicencesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimOpenSourceLicencesComponent, "euim-opensource-licences", never, { "items": { "alias": "items"; "required": false; }; }, { "clickItem": "clickItem"; }, never, ["*"], true, never>;
}

declare class EuimAboutContentLoadingComponent implements OnInit {
    private sanitizer;
    className: string;
    webUrl: string;
    protected sanitizedUrl: SafeResourceUrl;
    constructor(sanitizer: DomSanitizer);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAboutContentLoadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimAboutContentLoadingComponent, "euim-about-content-loading", never, { "webUrl": { "alias": "webUrl"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * @deprecated Use {@link EUIM_ABOUT} instead.
 */
declare class EuimAboutModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAboutModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimAboutModule, never, [typeof i1.PinchZoomModule, typeof i2.TranslateModule, typeof i3.RouterModule, typeof EuimAboutComponent, typeof EuimChangelogComponent, typeof EuimOpenSourceLicencesComponent, typeof EuimHelpSupportComponent, typeof EuimAboutContentLoadingComponent], [typeof EuimAboutComponent, typeof EuimChangelogComponent, typeof EuimOpenSourceLicencesComponent, typeof EuimHelpSupportComponent, typeof EuimAboutContentLoadingComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimAboutModule>;
}

declare const EUIM_ABOUT: readonly [typeof EuimAboutComponent, typeof EuimChangelogComponent, typeof EuimHelpSupportComponent, typeof EuimOpenSourceLicencesComponent, typeof EuimAboutContentLoadingComponent];

declare class EuimToolbarQrcodeComponent {
    qrCodeUrl: string;
    logoUrl: string;
    showCode: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimToolbarQrcodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimToolbarQrcodeComponent, "euim-toolbar-qrcode", never, { "qrCodeUrl": { "alias": "qrCodeUrl"; "required": false; }; "logoUrl": { "alias": "logoUrl"; "required": false; }; "showCode": { "alias": "showCode"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated Use {@link EUIM_TOOLBAR_QRCODE} instead.
 */
declare class EuimToolbarQrcodeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimToolbarQrcodeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimToolbarQrcodeModule, never, [typeof EuimToolbarQrcodeComponent], [typeof EuimToolbarQrcodeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimToolbarQrcodeModule>;
}

declare const EUIM_TOOLBAR_QRCODE: readonly [typeof EuimToolbarQrcodeComponent];

declare class EuimToolbarDatepickerComponent implements OnInit, OnDestroy {
    baseStatesDirective: BaseStatesDirective;
    private router;
    private location;
    private translate;
    private modalController;
    icon: string;
    title: string;
    subTitle: string;
    euimPrevBtnDisabled: boolean;
    euimNextBtnDisabled: boolean;
    euimReadOnly: boolean;
    closeModalOnBack: boolean;
    selectDateBy: 'week';
    prevBtnClick: EventEmitter<Date>;
    nextBtnClick: EventEmitter<Date>;
    dateChanged: EventEmitter<Date>;
    weekDayName: string;
    protected formattedDate: string;
    protected selectedDate: string;
    private isModalOpen;
    private weekdays;
    private _dateTimeId;
    private langChangeSubscription;
    protected currentLang: string;
    protected modalId: string;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective, router: Router, location: Location, translate: TranslateService, modalController: ModalController);
    dismissModal(): Promise<void>;
    get dateTimeId(): string;
    protected set dateTimeId(val: string);
    protected currentDate: Date;
    ngOnInit(): void;
    ngOnDestroy(): void;
    getCssClasses(): string;
    onModalPresent(): void;
    onModalDismiss(): void;
    updateCurrentDate(date: string): void;
    calendarDateChanged(event: Event): void;
    protected selectPrevDate(): void;
    protected selectNextDate(): void;
    private loadWeekdaysTranslation;
    private formatDateAndWeekDay;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimToolbarDatepickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimToolbarDatepickerComponent, "euim-toolbar-datepicker", never, { "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subTitle": { "alias": "subTitle"; "required": false; }; "euimPrevBtnDisabled": { "alias": "euimPrevBtnDisabled"; "required": false; }; "euimNextBtnDisabled": { "alias": "euimNextBtnDisabled"; "required": false; }; "euimReadOnly": { "alias": "euimReadOnly"; "required": false; }; "closeModalOnBack": { "alias": "closeModalOnBack"; "required": false; }; "selectDateBy": { "alias": "selectDateBy"; "required": false; }; }, { "prevBtnClick": "prevBtnClick"; "nextBtnClick": "nextBtnClick"; "dateChanged": "dateChanged"; }, never, never, true, [{ directive: typeof BaseStatesDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
    static ngAcceptInputType_euimPrevBtnDisabled: unknown;
    static ngAcceptInputType_euimNextBtnDisabled: unknown;
    static ngAcceptInputType_euimReadOnly: unknown;
    static ngAcceptInputType_closeModalOnBack: unknown;
}

/**
 * @deprecated Use {@link EUIM_TOOLBAR_DATEPICKER} instead.
 */
declare class EuimToolbarDatepickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimToolbarDatepickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimToolbarDatepickerModule, never, [typeof EuimToolbarDatepickerComponent], [typeof EuimToolbarDatepickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimToolbarDatepickerModule>;
}

declare const EUIM_TOOLBAR_DATEPICKER: readonly [typeof EuimToolbarDatepickerComponent];

declare class EuimReadOnlyFormLabelDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimReadOnlyFormLabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimReadOnlyFormLabelDirective, "[euimReadOnlyFormLabel]", never, {}, {}, never, never, true, never>;
}

declare class EuimReadOnlyFormValueDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimReadOnlyFormValueDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimReadOnlyFormValueDirective, "[euimReadOnlyFormValue]", never, {}, {}, never, never, true, never>;
}

declare class EuimReadOnlyFormDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimReadOnlyFormDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimReadOnlyFormDirective, "[euimReadOnlyForm]", never, {}, {}, never, never, true, never>;
}

declare class EuimHelperTextComponent {
    baseStatesDirective: BaseStatesDirective;
    hasNoPadding: i0.InputSignalWithTransform<boolean, unknown>;
    get cssClasses(): string;
    constructor(baseStatesDirective: BaseStatesDirective);
    getCssClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimHelperTextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuimHelperTextComponent, "euim-helper-text", never, { "hasNoPadding": { "alias": "hasNoPadding"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof BaseStatesDirective; inputs: { "color": "color"; }; outputs: {}; }]>;
}

declare class EuimDividerDirective {
    lines: 'none' | 'full';
    get cssClasses(): string;
    getCssClasses(rootClass: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimDividerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimDividerDirective, "[euimDivider]", never, { "lines": { "alias": "lines"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated Use {@link EUIM_DIVIDER} instead.
 */
declare class EuimDividerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimDividerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimDividerModule, never, [typeof EuimDividerDirective], [typeof EuimDividerDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimDividerModule>;
}

declare const EUIM_DIVIDER: readonly [typeof EuimDividerDirective];

declare class EuimListHeaderDirective {
    border: 'top' | 'bottom';
    get cssClasses(): string;
    getCssClasses(rootClass: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimListHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimListHeaderDirective, "[euimListHeader]", never, { "border": { "alias": "border"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated Use {@link EUIM_LIST_HEADER} instead.
 */
declare class EuimListHeaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimListHeaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimListHeaderModule, never, [typeof EuimListHeaderDirective], [typeof EuimListHeaderDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimListHeaderModule>;
}

declare const EUIM_LIST_HEADER: readonly [typeof EuimListHeaderDirective];

declare class EuimAlignCenterDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAlignCenterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimAlignCenterDirective, "[euimAlignCenter]", never, {}, {}, never, never, true, never>;
}

declare class EuimAlignTopDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAlignTopDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimAlignTopDirective, "[euimAlignTop]", never, {}, {}, never, never, true, never>;
}

declare class EuimToolbarTransparentDirective {
    scrollThreshold: number;
    hasTitle: boolean;
    isLightToolbar: boolean;
    className: string;
    get cssClasses(): string;
    onContentScroll($event: any): void;
    private updateToolbar;
    private getCssClasses;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimToolbarTransparentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimToolbarTransparentDirective, "[euimToolbarTransparent]", never, { "scrollThreshold": { "alias": "scrollThreshold"; "required": false; }; "hasTitle": { "alias": "hasTitle"; "required": false; }; "isLightToolbar": { "alias": "isLightToolbar"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuimFooterTransparentDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimFooterTransparentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimFooterTransparentDirective, "[euimFooterTransparent]", never, {}, {}, never, never, true, never>;
}

declare class EuimMinWidthDirective implements OnInit {
    minWidth: string;
    widthVar: string;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimMinWidthDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimMinWidthDirective, "[euimMinWidth]", never, { "minWidth": { "alias": "minWidth"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuimListItemNoPaddingsDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimListItemNoPaddingsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimListItemNoPaddingsDirective, "[euimListItemNoPaddings]", never, {}, {}, never, never, true, never>;
}

declare class EuimSidebarFooterNoBordersDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSidebarFooterNoBordersDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimSidebarFooterNoBordersDirective, "[euimSidebarFooterNoBorders]", never, {}, {}, never, never, true, never>;
}

declare class EuimSkeletonTextAvatarDirective {
    className: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSkeletonTextAvatarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuimSkeletonTextAvatarDirective, "[euimSkeletonTextAvatar]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated Use {@link EUIM_SKELETON_TEXT_AVATAR} instead.
 */
declare class EuimSkeletonTextAvatarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimSkeletonTextAvatarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimSkeletonTextAvatarModule, never, [typeof EuimSkeletonTextAvatarDirective], [typeof EuimSkeletonTextAvatarDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimSkeletonTextAvatarModule>;
}

declare const EUIM_SKELETON_TEXT_AVATAR: readonly [typeof EuimSkeletonTextAvatarDirective];

declare class EuimAllModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuimAllModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EuimAllModule, never, [typeof EuimAppModule, typeof EuimEmptyListPlaceholderModule, typeof EuimLanguageSelectorModule, typeof EuimUserProfileModule, typeof EuimMessageModule, typeof EuimSkeletonListItemModule, typeof EuimSkeletonListModule, typeof EuimLabelModule, typeof EuimAlertMessageModule, typeof EuimAboutModule, typeof EuimToolbarComponentModule, typeof EuimNotificationItemModule, typeof EuimMediaHeaderModule, typeof EuimDataSummaryModule, typeof EuimHeaderDetailsModule, typeof EuimAvatarModule, typeof EuimSliderInfoScreenModule, typeof EuimScrollerXComponentModule, typeof EuimChipSelectorComponentModule, typeof EuimBadgeModule, typeof EuimSidebarModule, typeof EuimPdfViewerModule, typeof EuimMultiselectModule, typeof EuimToolbarDatepickerModule, typeof EuimCardModule, typeof EuimCardListModule, typeof EuimToolbarQrcodeModule, typeof EuimSpinnerComponentModule, typeof EuimDividerModule, typeof EuimListHeaderModule, typeof EuimMinWidthDirective, typeof EuimAlignCenterDirective, typeof EuimAlignTopDirective, typeof EuimToolbarTransparentDirective, typeof EuimFooterTransparentDirective, typeof EuimSidebarFooterNoBordersDirective, typeof EuimListItemNoPaddingsDirective, typeof EuimReadOnlyFormDirective, typeof EuimReadOnlyFormValueDirective, typeof EuimReadOnlyFormLabelDirective, typeof EuimMediaHeaderCustomContentDirective, typeof EuimSkeletonTextAvatarModule], [typeof EuimAppModule, typeof EuimEmptyListPlaceholderModule, typeof EuimLanguageSelectorModule, typeof EuimUserProfileModule, typeof EuimMessageModule, typeof EuimSkeletonListItemModule, typeof EuimSkeletonListModule, typeof EuimLabelModule, typeof EuimAlertMessageModule, typeof EuimAboutModule, typeof EuimToolbarComponentModule, typeof EuimNotificationItemModule, typeof EuimMediaHeaderModule, typeof EuimDataSummaryModule, typeof EuimHeaderDetailsModule, typeof EuimAvatarModule, typeof EuimSliderInfoScreenModule, typeof EuimScrollerXComponentModule, typeof EuimChipSelectorComponentModule, typeof EuimBadgeModule, typeof EuimSidebarModule, typeof EuimPdfViewerModule, typeof EuimMultiselectModule, typeof EuimToolbarDatepickerModule, typeof EuimCardModule, typeof EuimCardListModule, typeof EuimToolbarQrcodeModule, typeof EuimSpinnerComponentModule, typeof EuimDividerModule, typeof EuimListHeaderModule, typeof EuimMinWidthDirective, typeof EuimAlignCenterDirective, typeof EuimAlignTopDirective, typeof EuimToolbarTransparentDirective, typeof EuimFooterTransparentDirective, typeof EuimSidebarFooterNoBordersDirective, typeof EuimListItemNoPaddingsDirective, typeof EuimReadOnlyFormDirective, typeof EuimReadOnlyFormValueDirective, typeof EuimReadOnlyFormLabelDirective, typeof EuimMediaHeaderCustomContentDirective, typeof EuimSkeletonTextAvatarModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EuimAllModule>;
}

export { BaseStatesDirective, EUIM_ABOUT, EUIM_ALERT_MESSAGE, EUIM_APP, EUIM_AVATAR, EUIM_BADGE, EUIM_CARD, EUIM_CARD_LIST, EUIM_CHIP_SELECTOR, EUIM_DATA_SUMMARY, EUIM_DIVIDER, EUIM_EMPTY_LIST_PLACEHOLDER, EUIM_HEADER_DETAILS, EUIM_LABEL, EUIM_LANGUAGE_SELECTOR, EUIM_LIST_HEADER, EUIM_MEDIA_HEADER, EUIM_MESSAGE, EUIM_MULTISELECT, EUIM_NOTIFICATION_ITEM, EUIM_PDF_VIEWER, EUIM_SCROLLER_X, EUIM_SIDEBAR, EUIM_SKELETON_LIST, EUIM_SKELETON_LIST_ITEM, EUIM_SKELETON_TEXT_AVATAR, EUIM_SLIDER_INFO_SCREEN, EUIM_SPINNER, EUIM_TOOLBAR, EUIM_TOOLBAR_DATEPICKER, EUIM_TOOLBAR_QRCODE, EUIM_USER_PROFILE, EuiMUserProfileActionComponent, EuiMUserProfileAvatarComponent, EuiMUserProfileInfosComponent, EuiMUserProfileInfosItemComponent, EuimAboutComponent, EuimAboutContentLoadingComponent, EuimAboutModule, EuimAlertMessageComponent, EuimAlertMessageModule, EuimAlignCenterDirective, EuimAlignTopDirective, EuimAllModule, EuimAppComponent, EuimAppModule, EuimAppService, EuimAvatarBadgeComponent, EuimAvatarComponent, EuimAvatarIconComponent, EuimAvatarIconSubComponent, EuimAvatarImageComponent, EuimAvatarModule, EuimAvatarTextComponent, EuimBadgeComponent, EuimBadgeModule, EuimCardComponent, EuimCardImageDirective, EuimCardListComponent, EuimCardListModule, EuimCardModule, EuimChangelogComponent, EuimChipSelectorComponent, EuimChipSelectorComponentModule, EuimChipSelectorItemDirective, EuimDataSummaryColComponent, EuimDataSummaryColLabelDirective, EuimDataSummaryColValueDirective, EuimDataSummaryComponent, EuimDataSummaryModule, EuimDividerDirective, EuimDividerModule, EuimEmptyListPlaceholderComponent, EuimEmptyListPlaceholderIconDirective, EuimEmptyListPlaceholderModule, EuimEmptyListPlaceholderSubtitleDirective, EuimEmptyListPlaceholderTitleDirective, EuimFooterTransparentDirective, EuimHeaderDetailsComponent, EuimHeaderDetailsIconDirective, EuimHeaderDetailsMetaDirective, EuimHeaderDetailsModule, EuimHeaderDetailsTitleDirective, EuimHelpSupportComponent, EuimHelperTextComponent, EuimLabelComponent, EuimLabelModule, EuimLanguageListComponent, EuimLanguageSelectorComponent, EuimLanguageSelectorModule, EuimListHeaderDirective, EuimListHeaderModule, EuimListItemNoPaddingsDirective, EuimMediaHeaderComponent, EuimMediaHeaderCustomContentDirective, EuimMediaHeaderImageDirective, EuimMediaHeaderModule, EuimMediaHeaderSubTitleDirective, EuimMediaHeaderTitleDirective, EuimMessageComponent, EuimMessageModule, EuimMessageTitleComponent, EuimMinWidthDirective, EuimMultiselectAllDirective, EuimMultiselectComponent, EuimMultiselectFilterComponent, EuimMultiselectInfoComponent, EuimMultiselectListComponent, EuimMultiselectModule, EuimMultiselectSelectFieldDirective, EuimMultiselectToolbarComponent, EuimNotificationItemComponent, EuimNotificationItemModule, EuimOpenSourceLicencesComponent, EuimPdfViewerComponent, EuimPdfViewerModule, EuimReadOnlyFormDirective, EuimReadOnlyFormLabelDirective, EuimReadOnlyFormValueDirective, EuimScrollerXComponent, EuimScrollerXComponentModule, EuimSidebarComponent, EuimSidebarContentComponent, EuimSidebarFooterNoBordersDirective, EuimSidebarModule, EuimSkeletonListComponent, EuimSkeletonListItemComponent, EuimSkeletonListItemModule, EuimSkeletonListModule, EuimSkeletonTextAvatarDirective, EuimSkeletonTextAvatarModule, EuimSlideInfoScreenComponent, EuimSliderInfoScreenComponent, EuimSliderInfoScreenContentDirective, EuimSliderInfoScreenModule, EuimSliderInfoScreenSubTitleDirective, EuimSliderInfoScreenTitleDirective, EuimSpinnerComponent, EuimSpinnerComponentModule, EuimSpinnerDescriptionComponent, EuimSpinnerMessageComponent, EuimToolbarActionItemsComponent, EuimToolbarComponent, EuimToolbarComponentModule, EuimToolbarDatepickerComponent, EuimToolbarDatepickerModule, EuimToolbarQrcodeComponent, EuimToolbarQrcodeModule, EuimToolbarTitleComponent, EuimToolbarTransparentDirective, EuimUserProfileComponent, EuimUserProfileModule };
export type { ActionBtnsIconsNames, ActionBtnsNames, IconColor, UIState, VariantTypes };
