import * as i0 from '@angular/core';
import { OnInit, OnDestroy, AfterViewInit, OnChanges, EventEmitter, SimpleChanges, QueryList, AfterContentInit, ElementRef, TemplateRef } from '@angular/core';
import { EuiAppShellService, EuiGrowlService, EuiThemeService, UxLinkLegacy, EuiMenuItem as EuiMenuItem$1 } from '@eui/core';
import { BooleanInput } from '@angular/cdk/coercion';
import { EuiMenuItem, EuiMenuComponent } from '@eui/components/eui-menu';
import { EuiUserProfileMenuComponent, EuiUserProfileComponent } from '@eui/components/eui-user-profile';
import * as i1 from '@eui/components/shared';
import { BaseStatesDirective } from '@eui/components/shared';
import { Subscription } from 'rxjs';
import { UxLinkLegacy as UxLinkLegacy$1 } from '@eui/base';
import { EuiAutoCompleteItem } from '@eui/components/eui-autocomplete';
import { EuiTemplateDirective } from '@eui/components/directives';

declare class EuiAppSidebarComponent implements OnInit, OnDestroy {
    string: string;
    asService: EuiAppShellService;
    private subscriptions;
    private document;
    close(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppSidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppSidebarComponent, "eui-app-sidebar", never, {}, {}, never, ["eui-app-sidebar-header-user-profile", "eui-app-sidebar-header", "eui-app-sidebar-body", "eui-app-sidebar-footer", "eui-app-sidebar-drawer"], true, never>;
}

declare class EuiAppSidebarBodyComponent {
    class: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppSidebarBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppSidebarBodyComponent, "eui-app-sidebar-body", never, {}, {}, never, ["eui-app-sidebar-menu", "*"], true, never>;
}

declare class EuiAppSidebarMenuComponent<Items = any> implements OnInit, AfterViewInit, OnChanges, OnDestroy {
    asService: EuiAppShellService;
    class: string;
    hasFilter: boolean;
    hasIcons: boolean;
    hasIconsLabels: boolean;
    hasTooltip: boolean;
    hasTooltipOnExpanded: boolean;
    expandAllItems: boolean;
    isCollapsed: boolean;
    hasCollapsedInitials: boolean;
    isFlat: boolean;
    hasScrollToItem: boolean;
    hasBoldRootLevel: boolean;
    items: Items[];
    sidebarItemClick: EventEmitter<EuiMenuItem<unknown>>;
    sidebarItemToggle: EventEmitter<EuiMenuItem<unknown>>;
    menu?: EuiMenuComponent;
    private subs;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onMenuItemClicked(event: EuiMenuItem): void;
    onSidebarItemToggled(event: EuiMenuItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppSidebarMenuComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppSidebarMenuComponent<any>, "eui-app-sidebar-menu", never, { "hasFilter": { "alias": "hasFilter"; "required": false; }; "hasIcons": { "alias": "hasIcons"; "required": false; }; "hasIconsLabels": { "alias": "hasIconsLabels"; "required": false; }; "hasTooltip": { "alias": "hasTooltip"; "required": false; }; "hasTooltipOnExpanded": { "alias": "hasTooltipOnExpanded"; "required": false; }; "expandAllItems": { "alias": "expandAllItems"; "required": false; }; "isCollapsed": { "alias": "isCollapsed"; "required": false; }; "hasCollapsedInitials": { "alias": "hasCollapsedInitials"; "required": false; }; "isFlat": { "alias": "isFlat"; "required": false; }; "hasScrollToItem": { "alias": "hasScrollToItem"; "required": false; }; "hasBoldRootLevel": { "alias": "hasBoldRootLevel"; "required": false; }; "items": { "alias": "items"; "required": false; }; }, { "sidebarItemClick": "sidebarItemClick"; "sidebarItemToggle": "sidebarItemToggle"; }, never, never, true, never>;
    static ngAcceptInputType_hasFilter: unknown;
    static ngAcceptInputType_hasIcons: unknown;
    static ngAcceptInputType_hasIconsLabels: unknown;
    static ngAcceptInputType_hasTooltip: unknown;
    static ngAcceptInputType_hasTooltipOnExpanded: unknown;
    static ngAcceptInputType_expandAllItems: unknown;
    static ngAcceptInputType_isCollapsed: unknown;
    static ngAcceptInputType_hasCollapsedInitials: unknown;
    static ngAcceptInputType_isFlat: unknown;
    static ngAcceptInputType_hasScrollToItem: unknown;
    static ngAcceptInputType_hasBoldRootLevel: unknown;
}

declare class EuiAppSidebarHeaderComponent implements OnInit, OnDestroy {
    class: string;
    private asService;
    private document;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppSidebarHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppSidebarHeaderComponent, "eui-app-sidebar-header", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiAppSidebarFooterComponent implements OnInit, OnDestroy {
    class: string;
    private asService;
    private document;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppSidebarFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppSidebarFooterComponent, "eui-app-sidebar-footer", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiAppSidebarHeaderUserProfileComponent {
    get cssClasses(): string;
    welcomeLabel: string;
    impersonateLabel: string;
    avatarUrl: string;
    isShowUserInfos: boolean;
    isShowAvatarInitials: boolean;
    isOnline: boolean;
    hasWelcomeLabel: boolean;
    hasTabNavigation: boolean;
    hasToggle: boolean;
    hasProfileDrawer: boolean;
    toggle: EventEmitter<any>;
    toggleProfile: boolean;
    userProfileMenu: QueryList<EuiUserProfileMenuComponent>;
    onProfileClick(event: any): void;
    onClick(event: MouseEvent): void;
    private _getCssClasses;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppSidebarHeaderUserProfileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppSidebarHeaderUserProfileComponent, "eui-app-sidebar-header-user-profile", never, { "welcomeLabel": { "alias": "welcomeLabel"; "required": false; }; "impersonateLabel": { "alias": "impersonateLabel"; "required": false; }; "avatarUrl": { "alias": "avatarUrl"; "required": false; }; "isShowUserInfos": { "alias": "isShowUserInfos"; "required": false; }; "isShowAvatarInitials": { "alias": "isShowAvatarInitials"; "required": false; }; "isOnline": { "alias": "isOnline"; "required": false; }; "hasWelcomeLabel": { "alias": "hasWelcomeLabel"; "required": false; }; "hasTabNavigation": { "alias": "hasTabNavigation"; "required": false; }; "hasToggle": { "alias": "hasToggle"; "required": false; }; "hasProfileDrawer": { "alias": "hasProfileDrawer"; "required": false; }; }, { "toggle": "toggle"; }, ["userProfileMenu"], ["eui-user-profile-menu"], true, never>;
    static ngAcceptInputType_isShowUserInfos: unknown;
    static ngAcceptInputType_isShowAvatarInitials: unknown;
    static ngAcceptInputType_isOnline: unknown;
    static ngAcceptInputType_hasWelcomeLabel: unknown;
    static ngAcceptInputType_hasTabNavigation: unknown;
    static ngAcceptInputType_hasToggle: unknown;
    static ngAcceptInputType_hasProfileDrawer: unknown;
}

declare class EuiAppSidebarDrawerComponent {
    get isExpanded(): boolean;
    set isExpanded(value: BooleanInput);
    get cssClasses(): string;
    private _isExpanded;
    onSidebarDrawerContentClick(event: Event): void;
    private _getCssClasses;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppSidebarDrawerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppSidebarDrawerComponent, "eui-app-sidebar-drawer", never, { "isExpanded": { "alias": "isExpanded"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class EuiAppToolbarComponent implements OnInit, OnDestroy {
    get cssClasses(): string;
    role: string;
    euiSecondary: boolean;
    asService: EuiAppShellService;
    private document;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarComponent, "eui-app-toolbar", never, { "euiSecondary": { "alias": "euiSecondary"; "required": false; }; }, {}, never, ["*"], true, never>;
    static ngAcceptInputType_euiSecondary: unknown;
}

declare class EuiAppToolbarItemsMobileComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppToolbarItemsMobileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarItemsMobileComponent, "eui-app-toolbar-items-mobile", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiAppComponent implements OnInit, OnDestroy, OnChanges, AfterContentInit {
    cssClasses: string;
    appSubTitle: string;
    themeClass: string;
    hasNoPageWrapper: boolean;
    isViewLoaded: boolean;
    isSidebarOpen: boolean;
    isShrinkHeaderActive: boolean;
    isSidebarHidden: boolean;
    appSidebar: EuiAppSidebarComponent;
    customPageWrapper: EuiAppPageWrapperDirective;
    appToolbar: EuiAppToolbarComponent;
    asService: EuiAppShellService;
    euiGrowlService: EuiGrowlService;
    private destroy$;
    private cdRef;
    private platformId;
    private document;
    ngAfterContentInit(): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppComponent, "eui-app", never, { "appSubTitle": { "alias": "appSubTitle"; "required": false; }; "themeClass": { "alias": "themeClass"; "required": false; }; "isSidebarOpen": { "alias": "isSidebarOpen"; "required": false; }; "isShrinkHeaderActive": { "alias": "isShrinkHeaderActive"; "required": false; }; "isSidebarHidden": { "alias": "isSidebarHidden"; "required": false; }; }, {}, ["appSidebar", "customPageWrapper", "appToolbar"], ["eui-app-sidebar", "eui-app-top-message", "eui-app-header", "eui-app-toolbar-items-mobile", "eui-user-profile", "eui-app-toolbar", "eui-app-breadcrumb", "eui-app-page-wrapper", "eui-app-footer"], true, never>;
    static ngAcceptInputType_isSidebarOpen: unknown;
    static ngAcceptInputType_isShrinkHeaderActive: unknown;
    static ngAcceptInputType_isSidebarHidden: unknown;
}
declare class EuiAppPageWrapperDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppPageWrapperDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiAppPageWrapperDirective, "eui-app-page-wrapper", never, {}, {}, never, never, true, never>;
}

declare class EuiAppHeaderComponent implements OnInit, OnDestroy {
    asService: EuiAppShellService;
    get cssClasses(): string;
    role: string;
    get isShrinkHeaderActive(): boolean;
    set isShrinkHeaderActive(value: BooleanInput);
    private _isShrinkHeaderActive;
    private isHeaderShrinked;
    private destroy$;
    private zone;
    private viewportRuler;
    private scrollDispatcher;
    private document;
    private platformId;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private getCssClasses;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppHeaderComponent, "eui-app-header", never, { "isShrinkHeaderActive": { "alias": "isShrinkHeaderActive"; "required": false; }; }, {}, never, ["eui-header"], true, never>;
}

declare class EuiAppFooterComponent {
    class: string;
    role: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppFooterComponent, "eui-app-footer", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiAppTopMessageComponent implements AfterViewInit, OnInit, OnDestroy {
    get cssClasses(): string;
    role: string;
    appTopMessage: ElementRef;
    appTopMessageChanges: Subscription;
    isCloseable: boolean;
    hasCustomContent: boolean;
    set isVisible(value: boolean);
    get isVisible(): boolean;
    topMessageClose: EventEmitter<null>;
    asService: EuiAppShellService;
    private _isVisible;
    private destroy$;
    private elRef;
    private cd;
    private obs;
    protected baseStatesDirective: BaseStatesDirective;
    private document;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onCloseClick(): void;
    private _calculateHeight;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppTopMessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppTopMessageComponent, "eui-app-top-message", never, { "isCloseable": { "alias": "isCloseable"; "required": false; }; "hasCustomContent": { "alias": "hasCustomContent"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; }, { "topMessageClose": "topMessageClose"; }, never, ["*"], true, [{ directive: typeof i1.BaseStatesDirective; inputs: { "euiPrimary": "euiPrimary"; "euiInfo": "euiInfo"; "euiWarning": "euiWarning"; "euiSuccess": "euiSuccess"; "euiDanger": "euiDanger"; "euiVariant": "euiVariant"; }; outputs: {}; }]>;
    static ngAcceptInputType_isCloseable: unknown;
    static ngAcceptInputType_hasCustomContent: unknown;
}

declare class EuiAppBreadcrumbComponent implements OnInit {
    get cssClasses(): string;
    role: string;
    private asService;
    ngOnInit(): void;
    private getCssClasses;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppBreadcrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppBreadcrumbComponent, "eui-app-breadcrumb", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiFooterComponent {
    get cssClasses(): string;
    euiPrimary: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiFooterComponent, "eui-footer", never, { "euiPrimary": { "alias": "euiPrimary"; "required": false; }; }, {}, never, ["*"], true, never>;
    static ngAcceptInputType_euiPrimary: unknown;
}

declare class EuiHeaderRightContentComponent {
    cssClass: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHeaderRightContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiHeaderRightContentComponent, "eui-header-right-content", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiHeaderComponent {
    string: string;
    rightContent: EuiHeaderRightContentComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiHeaderComponent, "eui-header", never, {}, {}, ["rightContent"], ["eui-header-logo", "eui-header-environment", "eui-header-app", "eui-header-right-content", "eui-header-user-profile", "eui-language-selector", "eui-header-search"], true, never>;
}

declare class EuiHeaderAppNameComponent implements OnInit {
    string: string;
    protected asService: EuiAppShellService;
    private elRef;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHeaderAppNameComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiHeaderAppNameComponent, "eui-header-app-name", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiHeaderAppSubtitleComponent implements OnInit {
    string: string;
    protected asService: EuiAppShellService;
    private elRef;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHeaderAppSubtitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiHeaderAppSubtitleComponent, "eui-header-app-subtitle", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiHeaderAppNameLogoComponent implements OnInit {
    cssClass: string;
    homeUrl: string;
    logoFilename: string;
    private assetsBaseUrl;
    private config;
    ngOnInit(): void;
    get svgUrl(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHeaderAppNameLogoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiHeaderAppNameLogoComponent, "eui-header-app-name-logo", never, { "homeUrl": { "alias": "homeUrl"; "required": false; }; "logoFilename": { "alias": "logoFilename"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuiHeaderAppComponent implements OnInit, OnChanges, OnDestroy {
    cssClass: string;
    appName: string;
    appShortName: string;
    appSubTitle: string;
    customAppName: EuiHeaderAppNameComponent;
    customAppSubtitle: EuiHeaderAppSubtitleComponent;
    customAppNameLogo: EuiHeaderAppNameLogoComponent;
    protected asService: EuiAppShellService;
    private subscriptions;
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHeaderAppComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiHeaderAppComponent, "eui-header-app", never, { "appName": { "alias": "appName"; "required": false; }; "appShortName": { "alias": "appShortName"; "required": false; }; "appSubTitle": { "alias": "appSubTitle"; "required": false; }; }, {}, ["customAppName", "customAppSubtitle", "customAppNameLogo"], ["eui-header-app-name", "eui-header-app-subtitle", "eui-header-app-name-logo"], true, never>;
}

declare class EuiHeaderEnvironmentComponent implements OnInit, OnDestroy {
    cssClass: string;
    protected asService: EuiAppShellService;
    private elRef;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHeaderEnvironmentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiHeaderEnvironmentComponent, "eui-header-environment", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiHeaderLogoComponent implements OnInit, OnDestroy {
    cssClass: string;
    homeUrl: string;
    logoUrl: string;
    logoHeight: string;
    logoWidth: string;
    protected asService: EuiAppShellService;
    protected euiThemeService: EuiThemeService;
    protected logoStyle: any;
    private logo;
    private assetsBaseUrl;
    private config;
    ngOnInit(): void;
    get svgUrl(): string;
    get svgUrlDark(): string;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHeaderLogoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiHeaderLogoComponent, "eui-header-logo", never, { "homeUrl": { "alias": "homeUrl"; "required": false; }; "logoUrl": { "alias": "logoUrl"; "required": false; }; "logoHeight": { "alias": "logoHeight"; "required": false; }; "logoWidth": { "alias": "logoWidth"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuiHeaderUserProfileComponent implements AfterContentInit {
    cssClass: string;
    hasMenuContent: QueryList<EuiUserProfileMenuComponent>;
    userProfile: EuiUserProfileComponent;
    isShowUserInfos: boolean;
    hasWelcomeLabel: boolean;
    isShowAvatarInitials: boolean;
    hasTabNavigation: boolean;
    welcomeLabel: string;
    impersonateLabel: string;
    avatarUrl: string;
    subInfos: string;
    protected hasMenu: boolean;
    /**
     * @description
     * Closes the user profile dropdown menu if it is open.
     *
     * Ensure calling this after the ngAfterViewInit lifecycle hook to ensure the userProfile component is initialized.
     */
    closeUserProfileDropdown(): void;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHeaderUserProfileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiHeaderUserProfileComponent, "eui-header-user-profile", never, { "isShowUserInfos": { "alias": "isShowUserInfos"; "required": false; }; "hasWelcomeLabel": { "alias": "hasWelcomeLabel"; "required": false; }; "isShowAvatarInitials": { "alias": "isShowAvatarInitials"; "required": false; }; "hasTabNavigation": { "alias": "hasTabNavigation"; "required": false; }; "welcomeLabel": { "alias": "welcomeLabel"; "required": false; }; "impersonateLabel": { "alias": "impersonateLabel"; "required": false; }; "avatarUrl": { "alias": "avatarUrl"; "required": false; }; "subInfos": { "alias": "subInfos"; "required": false; }; }, {}, ["hasMenuContent"], ["eui-user-profile-menu"], true, never>;
    static ngAcceptInputType_isShowUserInfos: unknown;
    static ngAcceptInputType_hasWelcomeLabel: unknown;
    static ngAcceptInputType_isShowAvatarInitials: unknown;
    static ngAcceptInputType_hasTabNavigation: unknown;
}

declare class EuiHeaderSearchComponent {
    cssClass: string;
    placeholder: string;
    searchLabel: string;
    searchClick: EventEmitter<string>;
    protected inputValue: string;
    onSearch(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHeaderSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiHeaderSearchComponent, "eui-header-search", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "searchLabel": { "alias": "searchLabel"; "required": false; }; }, { "searchClick": "searchClick"; }, never, never, true, never>;
}

interface NotificationMetadata {
    read?: boolean;
    urlExternal?: string;
    urlExternalTarget?: string;
    important?: boolean;
    new?: boolean;
    url?: string;
    date?: Date | string | number;
}
declare class EuiNotificationItemComponent {
    string: string;
    itemClick: EventEmitter<UxLinkLegacy<NotificationMetadata>>;
    itemMarkAsRead: EventEmitter<UxLinkLegacy<NotificationMetadata>>;
    markAsReadLabel: string;
    item: UxLinkLegacy<NotificationMetadata>;
    dateFormat: string;
    tooltipSize: string;
    isShowMarkAsRead: boolean;
    onItemClick(): void;
    onItemMarkAsRead(event: Event): void;
    get iconColor(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiNotificationItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiNotificationItemComponent, "eui-notification-item", never, { "markAsReadLabel": { "alias": "markAsReadLabel"; "required": false; }; "item": { "alias": "item"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "isShowMarkAsRead": { "alias": "isShowMarkAsRead"; "required": false; }; }, { "itemClick": "itemClick"; "itemMarkAsRead": "itemMarkAsRead"; }, never, never, true, never>;
    static ngAcceptInputType_isShowMarkAsRead: unknown;
}

declare class EuiNotificationsComponent implements OnInit, OnChanges {
    refreshClick: EventEmitter<void>;
    notificationsClick: EventEmitter<void>;
    viewAllClick: EventEmitter<void>;
    settingsClick: EventEmitter<MouseEvent>;
    markAllAsReadClick: EventEmitter<MouseEvent>;
    noNotificationFoundClick: EventEmitter<void>;
    itemClick: EventEmitter<UxLinkLegacy$1<NotificationMetadata>>;
    itemMarkAsReadClick: EventEmitter<UxLinkLegacy$1<NotificationMetadata>>;
    isOverlayActive: boolean;
    currentDayNotifications: any[];
    oldestNotifications: any[];
    unreadNotifications: any[];
    today: Date;
    string: string;
    count: number;
    items: any[];
    unreadLabel: string;
    totalLabel: string;
    markAsReadLabel: string;
    markAsUnReadLabel: string;
    markAllAsReadLabel: string;
    settingsLabel: string;
    refreshLabel: string;
    viewAllNotificationsLabel: string;
    headerTitleLabel: string;
    noNotificationFoundLabel: string;
    nbUnreadCount: number;
    dateFormat: string;
    noNotificationFoundLink: boolean;
    isShowMarkAsRead: boolean;
    isShowViewAllAction: boolean;
    isHidePanelOnViewAllAction: boolean;
    customUnreadCount: boolean;
    isShowMarkAllAsReadButton: boolean;
    isShowSettingsButton: boolean;
    isShowRefreshButton: boolean;
    onClicked(event: MouseEvent | Event): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    onRefresh(event: Event): void;
    onItemClick(link: UxLinkLegacy$1<NotificationMetadata>): void;
    onViewAllClick(event: Event): void;
    onNoNotificationFoundClick(): void;
    onItemMarkAsRead(link: UxLinkLegacy$1<NotificationMetadata>): void;
    onMarkAllAsRead(e: MouseEvent): void;
    onSettings(e: MouseEvent): void;
    protected trackByFn(index: number, item: UxLinkLegacy$1<NotificationMetadata>): string;
    protected updateActiveState(isActive: boolean): void;
    protected getAriaLabel(): string;
    private _getUnreadCount;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiNotificationsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiNotificationsComponent, "eui-notifications", never, { "count": { "alias": "count"; "required": false; }; "items": { "alias": "items"; "required": false; }; "unreadLabel": { "alias": "unreadLabel"; "required": false; }; "totalLabel": { "alias": "totalLabel"; "required": false; }; "markAsReadLabel": { "alias": "markAsReadLabel"; "required": false; }; "markAsUnReadLabel": { "alias": "markAsUnReadLabel"; "required": false; }; "markAllAsReadLabel": { "alias": "markAllAsReadLabel"; "required": false; }; "settingsLabel": { "alias": "settingsLabel"; "required": false; }; "refreshLabel": { "alias": "refreshLabel"; "required": false; }; "viewAllNotificationsLabel": { "alias": "viewAllNotificationsLabel"; "required": false; }; "headerTitleLabel": { "alias": "headerTitleLabel"; "required": false; }; "noNotificationFoundLabel": { "alias": "noNotificationFoundLabel"; "required": false; }; "nbUnreadCount": { "alias": "nbUnreadCount"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "noNotificationFoundLink": { "alias": "noNotificationFoundLink"; "required": false; }; "isShowMarkAsRead": { "alias": "isShowMarkAsRead"; "required": false; }; "isShowViewAllAction": { "alias": "isShowViewAllAction"; "required": false; }; "isHidePanelOnViewAllAction": { "alias": "isHidePanelOnViewAllAction"; "required": false; }; "customUnreadCount": { "alias": "customUnreadCount"; "required": false; }; "isShowMarkAllAsReadButton": { "alias": "isShowMarkAllAsReadButton"; "required": false; }; "isShowSettingsButton": { "alias": "isShowSettingsButton"; "required": false; }; "isShowRefreshButton": { "alias": "isShowRefreshButton"; "required": false; }; }, { "refreshClick": "refreshClick"; "notificationsClick": "notificationsClick"; "viewAllClick": "viewAllClick"; "settingsClick": "settingsClick"; "markAllAsReadClick": "markAllAsReadClick"; "noNotificationFoundClick": "noNotificationFoundClick"; "itemClick": "itemClick"; "itemMarkAsReadClick": "itemMarkAsReadClick"; }, never, never, true, never>;
    static ngAcceptInputType_noNotificationFoundLink: unknown;
    static ngAcceptInputType_isShowMarkAsRead: unknown;
    static ngAcceptInputType_isShowViewAllAction: unknown;
    static ngAcceptInputType_isHidePanelOnViewAllAction: unknown;
    static ngAcceptInputType_customUnreadCount: unknown;
    static ngAcceptInputType_isShowMarkAllAsReadButton: unknown;
    static ngAcceptInputType_isShowSettingsButton: unknown;
    static ngAcceptInputType_isShowRefreshButton: unknown;
}

declare class EuiNotificationItemV2Component {
    string: string;
    itemClick: EventEmitter<UxLinkLegacy>;
    itemMarkAsRead: EventEmitter<UxLinkLegacy>;
    markAsReadLabel: string;
    item: UxLinkLegacy<NotificationMetadata>;
    dateFormat: string;
    tooltipSize: string;
    isShowMarkAsRead: boolean;
    get iconColor(): string;
    onItemClick(): void;
    onItemMarkAsRead(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiNotificationItemV2Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiNotificationItemV2Component, "eui-notification-item-v2", never, { "markAsReadLabel": { "alias": "markAsReadLabel"; "required": false; }; "item": { "alias": "item"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "isShowMarkAsRead": { "alias": "isShowMarkAsRead"; "required": false; }; }, { "itemClick": "itemClick"; "itemMarkAsRead": "itemMarkAsRead"; }, never, never, true, never>;
    static ngAcceptInputType_isShowMarkAsRead: unknown;
}

declare class EuiNotificationsV2Component {
    refreshClick: EventEmitter<Event>;
    notificationsClick: EventEmitter<KeyboardEvent | MouseEvent>;
    viewAllClick: EventEmitter<Event>;
    markAllAsReadClick: EventEmitter<MouseEvent>;
    noNotificationFoundClick: EventEmitter<void>;
    itemClick: EventEmitter<UxLinkLegacy>;
    itemMarkAsReadClick: EventEmitter<UxLinkLegacy>;
    isOverlayActive: boolean;
    currentDayNotifications: any[];
    oldestNotifications: any[];
    unreadNotifications: any[];
    today: Date;
    string: string;
    count: number;
    unreadCount: number;
    unreadSinceLastCheckCount: number;
    items: any[];
    unreadLabel: string;
    totalLabel: string;
    markAsReadLabel: string;
    markAsUnReadLabel: string;
    markAllAsReadLabel: string;
    settingsLabel: string;
    refreshLabel: string;
    viewAllNotificationsLabel: string;
    headerTitleLabel: string;
    headerHideLabel: string;
    headerUnreadSinceLastCheckCountLabel: string;
    headerUnreadCountLabel: string;
    noNotificationFoundLabel: string;
    dateFormat: string;
    noNotificationFoundLink: boolean;
    isShowMarkAsRead: boolean;
    isShowViewAllAction: boolean;
    isHidePanelOnViewAllAction: boolean;
    isShowMarkAllAsReadButton: boolean;
    isShowSettingsButton: boolean;
    isShowRefreshButton: boolean;
    get isShowUnreadSinceLastCheckCount(): boolean;
    onHide(): void;
    onClicked(event: Event): void;
    onRefresh(event: Event): void;
    onItemClick(link: UxLinkLegacy): void;
    onViewAllClick(event: Event): void;
    onNoNotificationFoundClick(): void;
    onItemMarkAsRead(link: UxLinkLegacy): void;
    onMarkAllAsRead(e: MouseEvent): void;
    trackByFn(index: number, item: any): void;
    protected updateActiveState(isActive: boolean): void;
    protected getAriaLabel(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiNotificationsV2Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiNotificationsV2Component, "eui-notifications-v2", never, { "count": { "alias": "count"; "required": false; }; "unreadCount": { "alias": "unreadCount"; "required": false; }; "unreadSinceLastCheckCount": { "alias": "unreadSinceLastCheckCount"; "required": false; }; "items": { "alias": "items"; "required": false; }; "unreadLabel": { "alias": "unreadLabel"; "required": false; }; "totalLabel": { "alias": "totalLabel"; "required": false; }; "markAsReadLabel": { "alias": "markAsReadLabel"; "required": false; }; "markAsUnReadLabel": { "alias": "markAsUnReadLabel"; "required": false; }; "markAllAsReadLabel": { "alias": "markAllAsReadLabel"; "required": false; }; "settingsLabel": { "alias": "settingsLabel"; "required": false; }; "refreshLabel": { "alias": "refreshLabel"; "required": false; }; "viewAllNotificationsLabel": { "alias": "viewAllNotificationsLabel"; "required": false; }; "headerTitleLabel": { "alias": "headerTitleLabel"; "required": false; }; "headerHideLabel": { "alias": "headerHideLabel"; "required": false; }; "headerUnreadSinceLastCheckCountLabel": { "alias": "headerUnreadSinceLastCheckCountLabel"; "required": false; }; "headerUnreadCountLabel": { "alias": "headerUnreadCountLabel"; "required": false; }; "noNotificationFoundLabel": { "alias": "noNotificationFoundLabel"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "noNotificationFoundLink": { "alias": "noNotificationFoundLink"; "required": false; }; "isShowMarkAsRead": { "alias": "isShowMarkAsRead"; "required": false; }; "isShowViewAllAction": { "alias": "isShowViewAllAction"; "required": false; }; "isHidePanelOnViewAllAction": { "alias": "isHidePanelOnViewAllAction"; "required": false; }; "isShowMarkAllAsReadButton": { "alias": "isShowMarkAllAsReadButton"; "required": false; }; "isShowSettingsButton": { "alias": "isShowSettingsButton"; "required": false; }; "isShowRefreshButton": { "alias": "isShowRefreshButton"; "required": false; }; }, { "refreshClick": "refreshClick"; "notificationsClick": "notificationsClick"; "viewAllClick": "viewAllClick"; "markAllAsReadClick": "markAllAsReadClick"; "noNotificationFoundClick": "noNotificationFoundClick"; "itemClick": "itemClick"; "itemMarkAsReadClick": "itemMarkAsReadClick"; }, never, never, true, never>;
    static ngAcceptInputType_noNotificationFoundLink: unknown;
    static ngAcceptInputType_isShowMarkAsRead: unknown;
    static ngAcceptInputType_isShowViewAllAction: unknown;
    static ngAcceptInputType_isHidePanelOnViewAllAction: unknown;
    static ngAcceptInputType_isShowMarkAllAsReadButton: unknown;
    static ngAcceptInputType_isShowSettingsButton: unknown;
    static ngAcceptInputType_isShowRefreshButton: unknown;
}

declare class EuiSidebarToggleComponent {
    e2eAttr: string;
    name: string;
    iconSvgFillColor: any;
    asService: EuiAppShellService;
    onToggleSidebar(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiSidebarToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiSidebarToggleComponent, "eui-sidebar-toggle", never, { "e2eAttr": { "alias": "e2eAttr"; "required": false; }; "iconSvgFillColor": { "alias": "iconSvgFillColor"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuiToolbarMegaMenuComponent<Items = EuiMenuItem$1> implements OnInit, OnDestroy, OnChanges {
    string: string;
    role: string;
    items: Items[];
    protected megaMenuItems: Items[];
    protected megaMenuItemsGrouped: {
        [parentIndex: number]: {
            [colIndex: string]: {
                [colLabel: string]: Items[];
            };
        };
    };
    protected activeMenu: number;
    private asService;
    private document;
    private subs;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    closeMenu(): void;
    openMenu(menuIndex: number): void;
    groupByColIdPerParent(items: Items[]): {
        [parentIndex: number]: {
            [colIndex: string]: {
                [colLabel: string]: Items[];
            };
        };
    };
    private filterMegaMenuItems;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarMegaMenuComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarMegaMenuComponent<any>, "eui-toolbar-mega-menu", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuiToolbarComponent implements OnInit, AfterViewInit {
    get cssClasses(): string;
    hasMegaMenu: EuiToolbarMegaMenuComponent;
    asService: EuiAppShellService;
    euiSecondary: i0.InputSignalWithTransform<boolean, unknown>;
    euiPrimary: i0.InputSignalWithTransform<boolean, unknown>;
    private euiSecondarySignal;
    private euiPrimarySignal;
    private elRef;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarComponent, "eui-toolbar", never, { "euiSecondary": { "alias": "euiSecondary"; "required": false; "isSignal": true; }; "euiPrimary": { "alias": "euiPrimary"; "required": false; "isSignal": true; }; }, {}, ["hasMegaMenu"], ["eui-toolbar-logo", "eui-toolbar-app", "eui-toolbar-environment", "eui-toolbar-center", "eui-toolbar-items", "eui-toolbar-navbar", "eui-toolbar-mega-menu", "eui-language-selector"], true, never>;
}

declare class EuiToolbarAppComponent {
    class: string;
    appName: string;
    appSubTitle: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarAppComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarAppComponent, "eui-toolbar-app", never, { "appName": { "alias": "appName"; "required": false; }; "appSubTitle": { "alias": "appSubTitle"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuiToolbarLogoComponent implements OnInit {
    class: string;
    homeUrl: string;
    logoUrl: string;
    logoHeight: string;
    logoWidth: string;
    protected logoUrlGenerated: any;
    protected logoStyle: any;
    private router;
    private config;
    onClick(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarLogoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarLogoComponent, "eui-toolbar-logo", never, { "homeUrl": { "alias": "homeUrl"; "required": false; }; "logoUrl": { "alias": "logoUrl"; "required": false; }; "logoHeight": { "alias": "logoHeight"; "required": false; }; "logoWidth": { "alias": "logoWidth"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuiToolbarEnvironmentComponent {
    class: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarEnvironmentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarEnvironmentComponent, "eui-toolbar-environment", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiToolbarItemComponent {
    string: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarItemComponent, "eui-toolbar-item", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiToolbarItemsComponent {
    get cssClasses(): string;
    euiEnd: boolean;
    euiPositionRight: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarItemsComponent, "eui-toolbar-items", never, { "euiEnd": { "alias": "euiEnd"; "required": false; }; "euiPositionRight": { "alias": "euiPositionRight"; "required": false; }; }, {}, never, ["*"], true, never>;
    static ngAcceptInputType_euiEnd: unknown;
    static ngAcceptInputType_euiPositionRight: unknown;
}

declare class EuiToolbarCenterComponent {
    string: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarCenterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarCenterComponent, "eui-toolbar-center", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiToolbarNavbarItemComponent {
    get cssClasses(): string;
    tabindex: number;
    id: string;
    label: string;
    isActive: boolean;
    navBarComponentParent: EuiToolbarNavbarComponent;
    constructor();
    protected onClick(): void;
    protected onKeydown(event: KeyboardEvent): void;
    private _click;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarNavbarItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarNavbarItemComponent, "eui-toolbar-navbar-item", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_isActive: unknown;
}

declare class EuiToolbarNavbarComponent implements AfterContentInit, AfterViewInit {
    class: string;
    itemClick: EventEmitter<string>;
    items: QueryList<EuiToolbarNavbarItemComponent>;
    asService: EuiAppShellService;
    baseItemSelected: EuiToolbarNavbarItemComponent;
    isDropdownView: boolean;
    private elementRef;
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    itemSelected(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarNavbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarNavbarComponent, "eui-toolbar-navbar", never, {}, { "itemClick": "itemClick"; }, ["items"], ["*"], true, never>;
}

declare class EuiToolbarSelectorComponent {
    class: string;
    label: string;
    iconSvgName: string;
    euiDisabled: boolean;
    selectorClick: EventEmitter<boolean>;
    protected asService: EuiAppShellService;
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarSelectorComponent, "eui-toolbar-selector", never, { "label": { "alias": "label"; "required": false; }; "iconSvgName": { "alias": "iconSvgName"; "required": false; }; "euiDisabled": { "alias": "euiDisabled"; "required": false; }; }, { "selectorClick": "selectorClick"; }, never, never, true, never>;
    static ngAcceptInputType_euiDisabled: unknown;
}

declare class EuiToolbarSearchComponent implements AfterViewInit, AfterContentInit {
    get cssClasses(): string;
    isInputFocus: boolean;
    searchTerm: string;
    searchInput: string;
    resultItemTemplate: TemplateRef<{
        $implicit: EuiAutoCompleteItem;
    }>;
    placeholderLabel: string;
    panelWidth: string;
    searchResults: EuiAutoCompleteItem[];
    isAutocomplete: boolean;
    isInputText: boolean;
    hasSearchButton: boolean;
    hasExpandAnimation: boolean;
    search: EventEmitter<string>;
    selectionChange: EventEmitter<EuiAutoCompleteItem[]>;
    searchClick: EventEmitter<string>;
    inputFocus: EventEmitter<Event>;
    inputBlur: EventEmitter<Event>;
    templates: QueryList<EuiTemplateDirective>;
    protected asService: EuiAppShellService;
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    onSelectionChange(items: EuiAutoCompleteItem[]): void;
    onInputFocus(): void;
    onInputBlur(): void;
    onSearch(e: string): void;
    onSearchInput(e: KeyboardEvent): void;
    onSearchClick(isIconOnly: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiToolbarSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiToolbarSearchComponent, "eui-toolbar-search", never, { "placeholderLabel": { "alias": "placeholderLabel"; "required": false; }; "panelWidth": { "alias": "panelWidth"; "required": false; }; "searchResults": { "alias": "searchResults"; "required": false; }; "isAutocomplete": { "alias": "isAutocomplete"; "required": false; }; "isInputText": { "alias": "isInputText"; "required": false; }; "hasSearchButton": { "alias": "hasSearchButton"; "required": false; }; "hasExpandAnimation": { "alias": "hasExpandAnimation"; "required": false; }; }, { "search": "search"; "selectionChange": "selectionChange"; "searchClick": "searchClick"; "inputFocus": "inputFocus"; "inputBlur": "inputBlur"; }, ["templates"], never, true, never>;
    static ngAcceptInputType_isAutocomplete: unknown;
    static ngAcceptInputType_isInputText: unknown;
    static ngAcceptInputType_hasSearchButton: unknown;
    static ngAcceptInputType_hasExpandAnimation: unknown;
}

declare const EUI_LAYOUT: readonly [typeof EuiAppComponent, typeof EuiAppBreadcrumbComponent, typeof EuiAppFooterComponent, typeof EuiAppHeaderComponent, typeof EuiAppPageWrapperDirective, typeof EuiAppSidebarBodyComponent, typeof EuiAppSidebarComponent, typeof EuiAppSidebarDrawerComponent, typeof EuiAppSidebarFooterComponent, typeof EuiAppSidebarHeaderComponent, typeof EuiAppSidebarHeaderUserProfileComponent, typeof EuiAppSidebarMenuComponent, typeof EuiAppToolbarComponent, typeof EuiAppToolbarItemsMobileComponent, typeof EuiAppTopMessageComponent, typeof EuiFooterComponent, typeof EuiHeaderAppComponent, typeof EuiHeaderAppNameComponent, typeof EuiHeaderAppNameLogoComponent, typeof EuiHeaderAppSubtitleComponent, typeof EuiHeaderComponent, typeof EuiHeaderEnvironmentComponent, typeof EuiHeaderLogoComponent, typeof EuiHeaderRightContentComponent, typeof EuiHeaderSearchComponent, typeof EuiHeaderUserProfileComponent, typeof EuiNotificationItemComponent, typeof EuiNotificationsComponent, typeof EuiNotificationItemV2Component, typeof EuiNotificationsV2Component, typeof EuiSidebarToggleComponent, typeof EuiToolbarAppComponent, typeof EuiToolbarCenterComponent, typeof EuiToolbarComponent, typeof EuiToolbarEnvironmentComponent, typeof EuiToolbarItemComponent, typeof EuiToolbarItemsComponent, typeof EuiToolbarLogoComponent, typeof EuiToolbarMegaMenuComponent, typeof EuiToolbarNavbarComponent, typeof EuiToolbarNavbarItemComponent, typeof EuiToolbarSearchComponent, typeof EuiToolbarSelectorComponent];

export { EUI_LAYOUT, EuiAppBreadcrumbComponent, EuiAppComponent, EuiAppFooterComponent, EuiAppHeaderComponent, EuiAppPageWrapperDirective, EuiAppSidebarBodyComponent, EuiAppSidebarComponent, EuiAppSidebarDrawerComponent, EuiAppSidebarFooterComponent, EuiAppSidebarHeaderComponent, EuiAppSidebarHeaderUserProfileComponent, EuiAppSidebarMenuComponent, EuiAppToolbarComponent, EuiAppToolbarItemsMobileComponent, EuiAppTopMessageComponent, EuiFooterComponent, EuiHeaderAppComponent, EuiHeaderAppNameComponent, EuiHeaderAppNameLogoComponent, EuiHeaderAppSubtitleComponent, EuiHeaderComponent, EuiHeaderEnvironmentComponent, EuiHeaderLogoComponent, EuiHeaderRightContentComponent, EuiHeaderSearchComponent, EuiHeaderUserProfileComponent, EuiNotificationItemComponent, EuiNotificationItemV2Component, EuiNotificationsComponent, EuiNotificationsV2Component, EuiSidebarToggleComponent, EuiToolbarAppComponent, EuiToolbarCenterComponent, EuiToolbarComponent, EuiToolbarEnvironmentComponent, EuiToolbarItemComponent, EuiToolbarItemsComponent, EuiToolbarLogoComponent, EuiToolbarMegaMenuComponent, EuiToolbarNavbarComponent, EuiToolbarNavbarItemComponent, EuiToolbarSearchComponent, EuiToolbarSelectorComponent };
export type { NotificationMetadata };
//# sourceMappingURL=eui-components-layout.d.ts.map
