import * as i0 from '@angular/core';
import { AfterViewInit, TemplateRef, OnChanges, SimpleChanges, OnInit, OnDestroy, EventEmitter, QueryList, ElementRef } from '@angular/core';
import { BehaviorSubject } from 'rxjs';
import * as i1 from '@eui/components/shared';
import { BaseStatesDirective } from '@eui/components/shared';
import { TemplatePortal } from '@angular/cdk/portal';

declare class EuiTabHeaderComponent implements AfterViewInit {
    templateRef: TemplateRef<HTMLElement>;
    templatePortal: TemplatePortal;
    private viewContainerRef;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiTabHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiTabHeaderComponent, "eui-tab-header", never, {}, {}, never, ["eui-tab-header-left-content", "eui-tab-header-label", "eui-tab-header-sub-label", "*", "eui-tab-header-right-content"], true, never>;
}

declare class EuiTabBodyComponent implements AfterViewInit {
    hasNoContentPadding: boolean;
    templateRef: TemplateRef<HTMLElement>;
    templatePortal: TemplatePortal;
    tabIndex$: BehaviorSubject<number>;
    private viewContainerRef;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiTabBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiTabBodyComponent, "eui-tab-body", never, { "hasNoContentPadding": { "alias": "hasNoContentPadding"; "required": false; }; }, {}, never, ["*"], true, never>;
    static ngAcceptInputType_hasNoContentPadding: unknown;
}

declare class EuiTabComponent implements OnChanges {
    id: string;
    url: string;
    e2eAttr: string;
    tooltip: string;
    isClosable: boolean;
    isDisabled: boolean;
    isVisible: boolean;
    isHandleCloseOnClose: boolean;
    isHandleActivateTab: boolean;
    templateHeader: EuiTabHeaderComponent;
    templateBody: EuiTabBodyComponent;
    isActive: boolean;
    isVisible$: BehaviorSubject<boolean>;
    isClosable$: BehaviorSubject<boolean>;
    isDisabled$: BehaviorSubject<boolean>;
    baseStatesDirective: BaseStatesDirective;
    ngOnChanges(c: SimpleChanges): void;
    activateTab(): void;
    deactivateTab(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiTabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiTabComponent, "eui-tab", never, { "id": { "alias": "id"; "required": false; }; "url": { "alias": "url"; "required": false; }; "e2eAttr": { "alias": "e2eAttr"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "isClosable": { "alias": "isClosable"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; "isHandleCloseOnClose": { "alias": "isHandleCloseOnClose"; "required": false; }; "isHandleActivateTab": { "alias": "isHandleActivateTab"; "required": false; }; }, {}, ["templateHeader", "templateBody"], ["*"], true, [{ directive: typeof i1.BaseStatesDirective; inputs: { "euiPrimary": "euiPrimary"; "euiSecondary": "euiSecondary"; "euiInfo": "euiInfo"; "euiSuccess": "euiSuccess"; "euiWarning": "euiWarning"; "euiDanger": "euiDanger"; "euiVariant": "euiVariant"; }; outputs: {}; }]>;
    static ngAcceptInputType_isClosable: unknown;
    static ngAcceptInputType_isDisabled: unknown;
    static ngAcceptInputType_isVisible: unknown;
    static ngAcceptInputType_isHandleCloseOnClose: unknown;
    static ngAcceptInputType_isHandleActivateTab: unknown;
}

/**
 * @description
 * eUI Tabs component helps to organize content into separate views where only one view can be visible at a time.
 * Each tab's label is shown in the tab header and the active tab is designated with a primary ink bar visual.
 * The active tab may be set using the `activeTabIndex` input option or when the user selects one of the tab labels in the header.
 * When the list of tab labels exceeds the width of the header or its container, pagination controls appear to let the user scroll left and right across the tabs.
 */
declare class EuiTabsComponent implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    get elementClass(): string;
    e2eAttr: string;
    /**
     * Index of the active tab
     *
     * @default 0
     */
    activeTabIndex: number;
    /**
     * Sets the `aria-label` attribute for the host element.
     *
     * @default 'eUI Tabs'
     */
    ariaLabel: string;
    isMainNavigation: boolean;
    isFlat: boolean;
    /**
     * Event emitted when a tab is closed
     */
    tabClose: EventEmitter<{
        tab: EuiTabComponent;
        index: number;
    }>;
    /**
     * Event emitted when a tab is activated
     */
    tabActivate: EventEmitter<{
        tab: EuiTabComponent;
        index: number;
    }>;
    /**
     * Event emitted when a tab is clicked
     */
    tabClick: EventEmitter<{
        tab: EuiTabComponent;
        index: number;
    }>;
    _tabs: QueryList<EuiTabComponent>;
    euiTabsHeadersContainer: ElementRef;
    euiTabsHeaders: ElementRef;
    euiTabListItems: QueryList<ElementRef>;
    tabs: EuiTabComponent[];
    scrolling: boolean;
    navigationLeftButtonDisabled: boolean;
    navigationRightButtonDisabled: boolean;
    currentOffset: number;
    protected tabId: string;
    private destroy$;
    private player;
    private stepMove;
    private scrollOffset;
    private scrollingCount;
    private cd;
    private builder;
    private euiAppShellService;
    /**
     * Width of the tabs headers container
     */
    get euiTabsHeadersContainerWidth(): number;
    /**
     * Width of the tabs headers
     */
    get euiTabsHeadersWidth(): number;
    ngOnChanges(c: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Activate a tab having index passed in parameter if exists.
     *
     * @param index Index of the tab to close
     * @param isAnimated Whether the tab activation should be animated
     * @param options Object with emitEvent property to emit the event or not
     */
    activateTab(index: number, isAnimated?: boolean, options?: {
        emitEvent: boolean;
    }): void;
    /**
     * Close a tab having index passed in parameter if exists.
         * @param index Index of the tab to close
     */
    closeTab(index: number): void;
    /**
     * Scroll to the left handler
     */
    goToLeft(): void;
    /**
     * Scroll to the rihgt handler
     */
    goToRight(): void;
    /**
     * Actions applied upon a keydown event
     *
     * @param i Index of the tab for each pressed key
     * @param event The keyboard event
     */
    protected onKeydown(i: number, event: KeyboardEvent): void;
    /**
     * Click handler for tab list item
     *
     * @param index Index of the tab clicked
     */
    protected tabListItemClick(index: number): void;
    /**
     * Activates a tab
     *
     * @param index Index of the tab to activate
     * @param isAnimated Whether the activation should be animated
     * @param options Object with emitEvent property to emit the event or not
     */
    protected activate(index: number, isAnimated?: boolean, options?: {
        emitEvent: boolean;
    }): void;
    /**
     * Closes a tab
     *
     * @param index Index of the tab to close
     * @param e
     */
    protected close(index: number, e: Event): void;
    /**
     * Checks if there are html elements within the tab panel, in order to focus or not the tab panel
     * @param index The tab index
     */
    protected onAttached(index: number): void;
    /**
     * Checks the existence of focusable elements
     * @param origin The element to check
     */
    private isFocusableElement;
    /**
     * Checks if the tabs headers are scrolling and calculates the scrolling position
     */
    private tabsScrollingHandler;
    /**
     * Sets the scroll position oon the tab header specified by index
     *
     * @param index Index of the tab header to scroll to
     * @param isAnimated Whether the tab activation should be animated
     */
    private setScrollToTabIndex;
    /**
     * Sets the scroll position of the tabs headers
     *
     * @param scrollTo Number to set on the margin-left style property
     * @param isAnimated Whether the tab activation should be animated
     */
    private setScrollTo;
    /**
     * Checks if the active tab is fully visible
     *
     * @param activeTab Index of the tab to check
     * @returns true if fully visible, false otherwise
     */
    private isActiveTabFullyVisible;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiTabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiTabsComponent, "eui-tabs", never, { "e2eAttr": { "alias": "e2eAttr"; "required": false; }; "activeTabIndex": { "alias": "activeTabIndex"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "isMainNavigation": { "alias": "isMainNavigation"; "required": false; }; "isFlat": { "alias": "isFlat"; "required": false; }; }, { "tabClose": "tabClose"; "tabActivate": "tabActivate"; "tabClick": "tabClick"; }, ["_tabs"], ["eui-tabs-right-content"], true, never>;
    static ngAcceptInputType_isMainNavigation: unknown;
    static ngAcceptInputType_isFlat: unknown;
}

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

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

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

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

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

declare const EUI_TABS: readonly [typeof EuiTabsComponent, typeof EuiTabsRightContentComponent, typeof EuiTabBodyComponent, typeof EuiTabHeaderComponent, typeof EuiTabHeaderLabelComponent, typeof EuiTabHeaderSublabelComponent, typeof EuiTabHeaderRightContentComponent, typeof EuiTabHeaderLeftContentComponent, typeof EuiTabComponent];

export { EUI_TABS, EuiTabBodyComponent, EuiTabComponent, EuiTabHeaderComponent, EuiTabHeaderLabelComponent, EuiTabHeaderLeftContentComponent, EuiTabHeaderRightContentComponent, EuiTabHeaderSublabelComponent, EuiTabsComponent, EuiTabsRightContentComponent };
//# sourceMappingURL=eui-components-eui-tabs.d.ts.map
