import * as i0 from '@angular/core';
import { OnInit, OnDestroy, AfterContentInit, EventEmitter, AfterViewInit, TemplateRef, QueryList, OnChanges, SimpleChanges } from '@angular/core';
import { EuiAppShellService, EuiGrowlService, EuiMenuItem, EuiThemeService } from '@eui/core';
import * as i1 from '@eui/components/shared';
import { BaseStatesDirective } from '@eui/components/shared';
import { EuiAutoCompleteItem } from '@eui/components/eui-autocomplete';
import { EuiTemplateDirective } from '@eui/components/directives';
import { EuiMenuItem as EuiMenuItem$1, EuiMenuComponent } from '@eui/components/eui-menu';

declare class EuiApp implements OnInit, OnDestroy, AfterContentInit {
    cssClasses: string;
    appSubTitle: string;
    themeClass: string;
    hasNoPageWrapper: boolean;
    isViewLoaded: boolean;
    asService: EuiAppShellService;
    euiGrowlService: EuiGrowlService;
    private destroy$;
    private cdRef;
    private platformId;
    private document;
    ngAfterContentInit(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiApp, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiApp, "eui-app", never, { "appSubTitle": { "alias": "appSubTitle"; "required": false; }; "themeClass": { "alias": "themeClass"; "required": false; }; }, {}, never, ["eui-app-top-message", "eui-app-header", "eui-app-toolbar", "eui-app-sidebar", "*", "eui-app-footer"], true, never>;
}

declare class EuiAppToolbar implements OnInit {
    protected baseStatesDirective: BaseStatesDirective;
    protected asService: EuiAppShellService;
    get cssClasses(): string;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppToolbar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbar, "eui-app-toolbar", never, {}, {}, never, ["eui-app-toolbar-logo", "eui-app-toolbar-appname", "eui-app-toolbar-environment", "eui-app-toolbar-mega-menu", "eui-app-toolbar-navbar", "eui-app-toolbar-search", "eui-app-toolbar-selector", "eui-app-toolbar-items", "eui-user-profile", "eui-language-selector"], true, [{ directive: typeof i1.BaseStatesDirective; inputs: { "euiPrimary": "euiPrimary"; "euiSecondary": "euiSecondary"; }; outputs: {}; }]>;
}

declare class EuiAppToolbarAppname {
    string: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppToolbarAppname, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarAppname, "eui-app-toolbar-appname", never, {}, {}, never, ["eui-app-toolbar-appname-label", "eui-app-toolbar-appname-sub-label"], true, never>;
}

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

declare class EuiAppToolbarAppNameSublabel {
    string: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppToolbarAppNameSublabel, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarAppNameSublabel, "eui-app-toolbar-appname-sub-label", never, {}, {}, never, ["*"], true, never>;
}

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

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

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

declare class EuiAppToolbarLogo implements OnInit {
    string: 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<EuiAppToolbarLogo, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarLogo, "eui-app-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 EuiAppToolbarSelector {
    class: string;
    label: string;
    iconSvgName: string;
    euiDisabled: boolean;
    selectorClick: EventEmitter<boolean>;
    protected asService: EuiAppShellService;
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppToolbarSelector, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarSelector, "eui-app-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 EuiAppToolbarSearch 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<EuiAppToolbarSearch, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarSearch, "eui-app-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 class EuiAppToolbarSidebarToggle {
    e2eAttr: string;
    name: string;
    iconSvgFillColor: any;
    asService: EuiAppShellService;
    onToggleSidebar(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppToolbarSidebarToggle, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarSidebarToggle, "eui-app-toolbar-sidebar-toggle", never, { "e2eAttr": { "alias": "e2eAttr"; "required": false; }; "iconSvgFillColor": { "alias": "iconSvgFillColor"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuiAppToolbarNavbarItem {
    get cssClasses(): string;
    tabindex: number;
    id: string;
    label: string;
    isActive: boolean;
    navBarComponentParent: EuiAppToolbarNavbar;
    constructor();
    protected onClick(): void;
    protected onKeydown(event: KeyboardEvent): void;
    private _click;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppToolbarNavbarItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarNavbarItem, "eui-app-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 EuiAppToolbarNavbar implements AfterContentInit, AfterViewInit {
    class: string;
    itemClick: EventEmitter<string>;
    items: QueryList<EuiAppToolbarNavbarItem>;
    asService: EuiAppShellService;
    baseItemSelected: EuiAppToolbarNavbarItem;
    isDropdownView: boolean;
    private elementRef;
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    itemSelected(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppToolbarNavbar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarNavbar, "eui-app-toolbar-navbar", never, {}, { "itemClick": "itemClick"; }, ["items"], ["*"], true, never>;
}

declare class EuiAppToolbarMegaMenu<Items = EuiMenuItem> implements OnInit, 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;
    closeMenu(): void;
    openMenu(menuIndex: number): void;
    groupByColIdPerParent(items: Items[]): {
        [parentIndex: number]: {
            [colIndex: string]: {
                [colLabel: string]: Items[];
            };
        };
    };
    private filterMegaMenuItems;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppToolbarMegaMenu<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppToolbarMegaMenu<any>, "eui-app-toolbar-mega-menu", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuiAppTopMessage implements OnInit {
    get cssClasses(): string;
    role: string;
    isCloseable: boolean;
    hasCustomContent: boolean;
    isVisible: boolean;
    topMessageClose: EventEmitter<null>;
    /** @description Instance of BaseStatesDirective for managing component states */
    protected baseStatesDirective: BaseStatesDirective;
    ngOnInit(): void;
    onCloseClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppTopMessage, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppTopMessage, "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;
    static ngAcceptInputType_isVisible: unknown;
}

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

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

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

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

declare class EuiAppSidebarMenu<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$1<unknown>>;
    sidebarItemToggle: EventEmitter<EuiMenuItem$1<unknown>>;
    menu?: EuiMenuComponent;
    private subs;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onMenuItemClicked(event: EuiMenuItem$1): void;
    onSidebarItemToggled(event: EuiMenuItem$1): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppSidebarMenu<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppSidebarMenu<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 EuiAppHeader {
    string: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppHeader, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppHeader, "eui-app-header", never, {}, {}, never, ["eui-app-header-logo", "eui-app-header-environment", "eui-app-header-appname", "eui-app-header-right-content", "eui-user-profile", "eui-language-selector", "eui-app-header-search"], true, never>;
}

declare class EuiAppHeaderAppName {
    string: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppHeaderAppName, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppHeaderAppName, "eui-app-header-appname", never, {}, {}, never, ["eui-app-header-appname-label", "eui-app-header-appname-sub-label"], true, never>;
}

declare class EuiAppHeaderAppNameLabel {
    string: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppHeaderAppNameLabel, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppHeaderAppNameLabel, "eui-app-header-appname-label", never, {}, {}, never, ["*"], true, never>;
}

declare class EuiAppHeaderAppNameSublabel {
    string: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppHeaderAppNameSublabel, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppHeaderAppNameSublabel, "eui-app-header-appname-sub-label", never, {}, {}, never, ["*"], true, never>;
}

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

declare class EuiAppHeaderLogo 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<EuiAppHeaderLogo, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppHeaderLogo, "eui-app-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 EuiAppHeaderRightContent {
    cssClass: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppHeaderRightContent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiAppHeaderRightContent, "eui-app-header-right-content", never, {}, {}, never, ["*"], true, never>;
}

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

declare const EUI_APP: readonly [typeof EuiApp, typeof EuiAppSidebar, typeof EuiAppSidebarHeader, typeof EuiAppSidebarBody, typeof EuiAppSidebarFooter, typeof EuiAppSidebarMenu, typeof EuiAppToolbar, typeof EuiAppToolbarAppname, typeof EuiAppToolbarAppNameLabel, typeof EuiAppToolbarAppNameSublabel, typeof EuiAppToolbarEnvironment, typeof EuiAppToolbarLogo, typeof EuiAppToolbarItems, typeof EuiAppToolbarItem, typeof EuiAppToolbarSelector, typeof EuiAppToolbarSearch, typeof EuiAppToolbarSidebarToggle, typeof EuiAppToolbarNavbar, typeof EuiAppToolbarNavbarItem, typeof EuiAppToolbarMegaMenu, typeof EuiAppHeader, typeof EuiAppHeaderAppName, typeof EuiAppHeaderAppNameLabel, typeof EuiAppHeaderAppNameSublabel, typeof EuiAppHeaderEnvironment, typeof EuiAppHeaderLogo, typeof EuiAppHeaderRightContent, typeof EuiAppHeaderSearch, typeof EuiAppTopMessage];

export { EUI_APP, EuiApp, EuiAppHeader, EuiAppHeaderAppName, EuiAppHeaderAppNameLabel, EuiAppHeaderAppNameSublabel, EuiAppHeaderEnvironment, EuiAppHeaderLogo, EuiAppHeaderRightContent, EuiAppHeaderSearch, EuiAppSidebar, EuiAppSidebarBody, EuiAppSidebarFooter, EuiAppSidebarHeader, EuiAppSidebarMenu, EuiAppToolbar, EuiAppToolbarAppNameLabel, EuiAppToolbarAppNameSublabel, EuiAppToolbarAppname, EuiAppToolbarEnvironment, EuiAppToolbarItem, EuiAppToolbarItems, EuiAppToolbarLogo, EuiAppToolbarMegaMenu, EuiAppToolbarNavbar, EuiAppToolbarNavbarItem, EuiAppToolbarSearch, EuiAppToolbarSelector, EuiAppToolbarSidebarToggle, EuiAppTopMessage };
//# sourceMappingURL=eui-components-layout-eui-app-v2.d.ts.map
