import * as i0 from '@angular/core';
import { EventEmitter, OnChanges, OnInit, ElementRef, TemplateRef, ChangeDetectorRef, AfterContentInit, AfterViewInit, OnDestroy, QueryList, DestroyRef, InjectionToken } from '@angular/core';
import { AbstractFdNgxClass, CssClassBuilder, Nullable } from '@fundamental-ngx/cdk/utils';
import { FocusableOption } from '@angular/cdk/a11y';
import { Subject } from 'rxjs';
import { ContentDensityObserver } from '@fundamental-ngx/core/content-density';
import { MenuComponent } from '@fundamental-ngx/core/menu';
import { ScrollbarDirective } from '@fundamental-ngx/core/scrollbar';
import { TabList } from '@fundamental-ngx/core/shared';
import { IconFont } from '@fundamental-ngx/core/icon';

/**
 * Represents a list of tab-panels.
 */
declare class TabItemExpandComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabItemExpandComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabItemExpandComponent, "fd-item-expand", never, {}, {}, never, never, true, never>;
}

/**
 * Tab link for nav mode
 *
 * ```html
 * <a fd-tab-link>
 *    link
 * </a>
 * ```
 */
declare class TabLinkDirective extends AbstractFdNgxClass implements FocusableOption {
    /** Whether the link is active */
    active: boolean;
    /**
     * Only visual / accessibility thing on tab-nav mode
     * RouterLink does not respect preventDefault/stopPropagation
     */
    disabled: boolean;
    /** Event Emitted always when, any keyboard event is dispatched on this element */
    readonly keyDown: EventEmitter<KeyboardEvent>;
    /** Event Emitted when item has been focused. */
    readonly focused: EventEmitter<void>;
    /** @hidden */
    protected _onFocus(): void;
    /** @hidden */
    protected _onKeyUp(event: KeyboardEvent): void;
    /** @hidden */
    _setProperties(): void;
    /** @hidden */
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabLinkDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabLinkDirective, "[fd-tab-link]", never, { "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "keyDown": "keyDown"; "focused": "focused"; }, never, never, true, never>;
}

type TabItemState = 'success' | 'error' | 'warning' | 'information' | 'neutral';
/**
 * Tab Item is optional wrapper for Tab link
 *
 * ```html
 * <div fd-tab-item>
 *    <a fd-tab-link>
 *        link
 *    </a>
 * </div>
 * ```
 */
declare class TabItemDirective implements CssClassBuilder, OnChanges, OnInit {
    readonly elementRef: ElementRef;
    /** Apply user custom styles */
    class: string;
    /** Semantic type of the tab item */
    tabItemState: Nullable<TabItemState>;
    /** This should be used only on `filterMode`. Flag should be enable for first item */
    header: boolean;
    /** Disabled state for tab item */
    disabled: boolean;
    /** Defines if there will be added fd-tabs__item class. Enabled by default. */
    fdTabItemClass: boolean;
    /** @hidden */
    linkItem: TabLinkDirective;
    /** @hidden */
    constructor(elementRef: ElementRef);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnChanges(): void;
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabItemDirective, "[fd-tab-item]", never, { "class": { "alias": "class"; "required": false; }; "tabItemState": { "alias": "tabItemState"; "required": false; }; "header": { "alias": "header"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fdTabItemClass": { "alias": "fdTabItemClass"; "required": false; }; }, {}, ["linkItem"], never, true, never>;
}

interface TabListComponentInterface {
    tabPanelPropertyChanged: Subject<void>;
}

declare class TabPanelStateChange {
    target: TabPanelComponent;
    state: boolean;
    /**
     * Tab panel state change event
     * @param target Tab panel that is being changed
     * @param state New state of the tab panel
     */
    constructor(target: TabPanelComponent, state: boolean);
}
/**
 * Represents the body of a tab element. It also contains elements pertaining to the associated tab header.
 */
declare class TabPanelComponent implements OnChanges {
    elementRef: ElementRef;
    private _changeDetRef;
    private readonly _tabsComponent;
    /** Id of the tab. If none is provided, one will be generated. */
    id: string;
    /** Aria-label of the tab. */
    ariaLabel: Nullable<string>;
    /** Id of the element that labels the tab. */
    ariaLabelledBy: Nullable<string>;
    /** The title of tab, depending on mode used, it will be placed in different position */
    title: Nullable<string>;
    /** The count of tab, depending on mode used, it will be placed in different position */
    count: Nullable<string>;
    /** Glyph icon, it can be used only on  */
    glyph: string;
    /** Glyph icon, it can be used only on  */
    header: boolean;
    /** Disabled state for tab item */
    disabled: boolean;
    /** Semantic type of the tab item */
    tabState: Nullable<TabItemState>;
    /** Event that is emitted when the tab panel has been opened. */
    opened: EventEmitter<void>;
    /** Event that is emitted when the tab panel has been closed. */
    closed: EventEmitter<void>;
    /** @hidden */
    titleTemplate: TemplateRef<any>;
    /** @hidden Event that is emitted when the tab panel . */
    _expandedStateChange: Subject<TabPanelStateChange>;
    /** @hidden */
    _expandedClass: boolean;
    /** @hidden */
    _forcedVisibility: boolean;
    /** @hidden Whether to display tab panel content */
    private _expanded;
    /** @hidden */
    get _panelId(): string;
    /** @hidden */
    constructor(elementRef: ElementRef, _changeDetRef: ChangeDetectorRef, _tabsComponent: TabListComponentInterface | null);
    /** @hidden
     * Thanks to OnPush change strategy detection on tab-list parent component,
     * every change of any property should be reported. */
    ngOnChanges(): void;
    /** Whether tab panel content is expanded */
    get expanded(): boolean;
    /** Whether to expand tab panel content */
    open(open: boolean): void;
    /** @hidden Set new expand state */
    _expand(expanded: boolean): void;
    /** @hidden */
    _focusFirstFocusableElement(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelComponent, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanelComponent, "fd-tab", never, { "id": { "alias": "id"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "title": { "alias": "title"; "required": false; }; "count": { "alias": "count"; "required": false; }; "glyph": { "alias": "glyph"; "required": false; }; "header": { "alias": "header"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabState": { "alias": "tabState"; "required": false; }; }, { "opened": "opened"; "closed": "closed"; }, ["titleTemplate"], ["*"], true, never>;
}

/** @hidden */
declare class TabInfo {
    /** Whether the tab is active */
    active: boolean;
    /** @hidden Width of the tab header */
    headerWidth: number;
    /** Corresponding tab panel */
    panel: TabPanelComponent;
    /** @hidden */
    constructor(tabPanel: TabPanelComponent);
    /** Tab header title */
    get title(): Nullable<string>;
    /** Whether the tab is disabled */
    get disabled(): boolean;
    /** Whether the tab is tab header */
    get isHeader(): boolean;
    /** @hidden */
    get id(): Nullable<string>;
    /** @hidden */
    get ariaLabel(): Nullable<string>;
    /** @hidden */
    get ariaLabelledBy(): Nullable<string>;
    /** @hidden */
    get tabState(): Nullable<TabItemState>;
    /** @hidden */
    get titleTemplate(): TemplateRef<any>;
    /** @hidden */
    get count(): Nullable<string>;
    /** @hidden */
    get glyph(): string;
    /** @hidden */
    get forcedVisibility(): boolean;
    /** @hidden */
    get panelId(): string;
}

type TabModes = 'icon-only' | 'process' | 'filter';
type TabSizes = 's' | 'm' | 'l' | 'xl' | 'xxl';
/**
 * Represents a list of tab-panels.
 * @deprecated
 * Use `@fundamental-ngx/platform/icon-tab-bar` instead
 */
declare class TabListComponent implements TabListComponentInterface, AfterContentInit, AfterViewInit, OnDestroy, TabList {
    private readonly _changeDetectorRef;
    readonly _contentDensityObserver: ContentDensityObserver;
    private readonly _destroyRef;
    /** Size of tab, it's mostly about adding spacing on tab container, available sizes 's' | 'm' | 'l' | 'xl' | 'xxl' */
    size: TabSizes;
    /**
     * Whether user wants to use tab component in certain mode. Modes available:
     * 'icon-only' | 'process' | 'filter'
     */
    mode: TabModes;
    /** Whether to move tabs overflowing in the tab bar to the dropdown */
    collapseOverflow: boolean;
    /** Limits the maximum number of tabs visible in the tab bar in collapseOverflow mode.
     * Other tabs will be moved to the collapsed tabs dropdown */
    maxVisibleTabs: number;
    /** Whether to open tab content one under another without collapsing */
    stackContent: boolean;
    /** Maximum height of the content */
    maxContentHeight: string;
    /** Whether to enable collapsing expanded tab on expanded tab click */
    collapsibleTabs: boolean;
    /** Initially selected tab (by id). First not disabled one if not specified. */
    defaultTab: Nullable<string>;
    /** Whether to try to keep selected tab (default value) on tabs change or to select default one (first if not specified). */
    selectDefaultOnTabsChange: boolean;
    /** Whether to focus the first focusable element in a tab panel when using stacked tabs. */
    focusFirstFocusableElement: boolean;
    /** Event emitted when the selected panel changes. */
    selectedTabChange: EventEmitter<TabPanelComponent>;
    /** Event emitted when the selected panel index changes. */
    selectedTabIndexChange: EventEmitter<number>;
    /** Event emitted when visible items count has been changed. */
    visibleItemsCount: EventEmitter<number>;
    /** Event emitted when hidden items count has been changed. */
    hiddenItemsCount: EventEmitter<number>;
    /** @hidden */
    tabPanels: QueryList<TabPanelComponent>;
    /** @hidden */
    tabHeaderLinks: QueryList<TabLinkDirective>;
    /** @hidden */
    tabHeaders: QueryList<TabItemDirective>;
    /** @hidden */
    overflowTrigger: ElementRef;
    /** @hidden */
    headerContainer: ElementRef;
    /** @hidden */
    _scrollbar: ScrollbarDirective;
    /** @hidden */
    menu: MenuComponent;
    /** @hidden */
    private _overflowLayout;
    /** @hidden */
    private readonly _scrollSpy;
    /** @hidden */
    get contentContainer(): ElementRef<HTMLElement>;
    /** @hidden Collection of tabs in original order */
    _tabArray: TabInfo[];
    /** @hidden Whether to disable scroll spy */
    _disableScrollSpy: boolean;
    /** @hidden */
    _init: boolean;
    /** @hidden */
    _currentNumberOfTabs: number;
    /** Scrollable element reference. */
    get scrollableElement(): Nullable<ElementRef>;
    /** Event is thrown always when tab is selected by keyboard actions */
    readonly tabSelected: Subject<number>;
    /** Event is thrown always, when some property is changed */
    readonly tabPanelPropertyChanged: Subject<void>;
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    constructor(_changeDetectorRef: ChangeDetectorRef, _contentDensityObserver: ContentDensityObserver, _destroyRef: DestroyRef);
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    _tabHeaderClickHandler(tabPanel: TabPanelComponent): void;
    /** @hidden */
    _tabHeaderKeydownHandler(event: KeyboardEvent, tabPanel: TabPanelComponent): void;
    /** @hidden */
    _overflowingTabHeaderClickHandler(tabPanel: TabPanelComponent): void;
    /** @hidden */
    selectTab(id: Nullable<string>): void;
    /** @hidden */
    highlightActiveTab(id: Nullable<string>): void;
    /** @hidden */
    _onTriggerKeydown(event: KeyboardEvent, menuRef: MenuComponent): void;
    /** @hidden */
    private get _tabPanelsChange$();
    /** @hidden */
    private _detectChanges;
    /** @hidden */
    private _setupTabPanelsChangeListeners;
    /** @hidden Setup mechanisms required for handling the stacked content behavior */
    private _initStackContentSubscription;
    /** @hidden */
    private _listenOnTabPanelsAndUpdateStorageStructures;
    /** @hidden */
    private _listenOnTabPanelsExpandedChange;
    /** @hidden */
    private _listenOnTabPanelsAndInitiallyExpandTabPanel;
    /** @hidden */
    private _listenOnPropertiesChange;
    /** @hidden */
    private _activateStackedTab;
    /** @hidden */
    private _activateExpandableTab;
    /** @hidden */
    private _expandTab;
    /** @hidden */
    private _scrollToPanel;
    /** @hidden Whether tab can be expanded/collapsed */
    private _canChangeExpandState;
    /** @hidden */
    private _selectedTabChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabListComponent, "fd-tab-list", never, { "size": { "alias": "size"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "collapseOverflow": { "alias": "collapseOverflow"; "required": false; }; "maxVisibleTabs": { "alias": "maxVisibleTabs"; "required": false; }; "stackContent": { "alias": "stackContent"; "required": false; }; "maxContentHeight": { "alias": "maxContentHeight"; "required": false; }; "collapsibleTabs": { "alias": "collapsibleTabs"; "required": false; }; "defaultTab": { "alias": "defaultTab"; "required": false; }; "selectDefaultOnTabsChange": { "alias": "selectDefaultOnTabsChange"; "required": false; }; "focusFirstFocusableElement": { "alias": "focusFirstFocusableElement"; "required": false; }; }, { "selectedTabChange": "selectedTabChange"; "selectedTabIndexChange": "selectedTabIndexChange"; "visibleItemsCount": "visibleItemsCount"; "hiddenItemsCount": "hiddenItemsCount"; }, ["tabPanels"], ["*"], true, never>;
}

declare const LIST_COMPONENT: InjectionToken<TabListComponentInterface>;

declare class TabNavComponent implements AfterContentInit, OnChanges, OnInit, OnDestroy, CssClassBuilder {
    readonly elementRef: ElementRef;
    /** Apply user custom styles */
    class: string;
    /**
     * Whether user wants to use tab component in certain mode. Modes available:
     * 'icon-only' | 'process' | 'filter'
     */
    mode: TabModes;
    /** Size of tab, it's mostly about adding spacing on tab container, available sizes 's' | 'm' | 'l' | 'xl' | 'xxl' */
    size: TabSizes;
    /** @hidden */
    links: QueryList<TabLinkDirective>;
    /** @hidden */
    items: QueryList<TabItemDirective>;
    /** @hidden */
    protected readonly _dir: i0.Signal<"rtl" | "ltr">;
    /** @hidden */
    private _subscriptions;
    /** An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)  */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    private readonly _contentDensityObserver;
    /** @hidden */
    private _keyboardEventsManager;
    /** @hidden */
    constructor(elementRef: ElementRef);
    /** @hidden
     * CssClassBuilder interface implementation
     * function must return single string
     * function is responsible for order which css classes are applied
     */
    buildComponentCssClass(): string[];
    /** @hidden */
    protected _keyUpHandler(event: KeyboardEvent): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngOnChanges(): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Function that gives possibility to get all the link directives, with and without nav__item wrapper */
    get tabLinks(): TabLinkDirective[];
    /**
     * Function to select a new tab from an index.
     * @param tabIndex Index of the tab to select.
     */
    selectTab(tabIndex: number): void;
    /**
     * @hidden
     * Every time any of query is changed, ex. tab is removed or added
     * reference to keydown subscriptions handler is renewed
     */
    private _listenOnContentQueryListChange;
    /** Whether any QueryList detects any changes */
    private _refreshSubscription;
    /** @hidden */
    private _listenToFocusedLinks;
    /** @hidden */
    private _setupKeyManager;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabNavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabNavComponent, "[fd-tab-nav]", never, { "class": { "alias": "class"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, ["links", "items"], ["*"], true, never>;
}

/**
 * Directive used to identify the template which will populate the tab header.
 * Used to achieve complex headers that require more than a string.
 *
 * ```html
 * <fd-tab>
 *      <ng-template fd-tab-title>
 *          <fd-icon [glyph]="'delete'"></fd-icon>
 *          <span>Tab Label</span>
 *      </ng-template>
 * </fd-tab>
 * ```
 */
declare class TabTitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabTitleDirective, "[fdTabTitleTemplate], [fd-tab-title-template]", never, {}, {}, never, never, true, never>;
}
/**
 * Directive for counter element, available in most of the modes on `tab` component
 */
declare class TabCountDirective {
    /** @hidden */
    fdTabsCountClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabCountDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabCountDirective, "[fdTabCount], [fd-tab-count]", never, {}, {}, never, never, true, never>;
}
/**
 * Directive for icon element, available in most of the modes on `tab` component
 */
declare class TabIconComponent implements CssClassBuilder, OnChanges {
    readonly elementRef: ElementRef;
    /** Apply user custom styles */
    class: string;
    /**
     * The icon to include inside the element
     * See the icon page for the list of icons.
     */
    icon: string;
    /** Icon font family */
    iconFont: IconFont;
    /** @hidden */
    constructor(elementRef: ElementRef);
    /** @hidden CssClassBuilder interface implementation
     * function must return single string
     * function is responsible for order which css classes are applied
     */
    buildComponentCssClass(): string[];
    /** @hidden
     * Function runs when component is initialized
     * function should build component css class
     * function should build css style
     */
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabIconComponent, "[fd-tab-icon]", never, { "class": { "alias": "class"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconFont": { "alias": "iconFont"; "required": false; }; }, {}, never, ["*"], true, never>;
}
declare class TabTagDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabTagDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabTagDirective, "[fdTabTag], [fd-tab-tag]", never, {}, {}, never, never, true, never>;
}
declare class TabLabelDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabLabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabLabelDirective, "[fdTabLabel], [fd-tab-label]", never, {}, {}, never, never, true, never>;
}
declare class TabProcessDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabProcessDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabProcessDirective, "[fdTabProcess], [fd-tab-process]", never, {}, {}, never, never, true, never>;
}
declare class TabHeaderDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabHeaderDirective, "[fdTabHeader], [fd-tab-header]", never, {}, {}, never, never, true, never>;
}
declare class TabCounterHeaderDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabCounterHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabCounterHeaderDirective, "[fdTabCounterHeader], [fd-tab-counter-header]", never, {}, {}, never, never, true, never>;
}
declare class TabProcessIconDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabProcessIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabProcessIconDirective, "[fdTabProcessIcon], [fd-tab-process-icon]", never, {}, {}, never, never, true, never>;
}
declare class TabSeparatorDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabSeparatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabSeparatorDirective, "[fdTabSeparator], [fd-tab-separator]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use `@fundamental-ngx/platform/icon-tab-bar` instead
 */
declare class TabsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TabsModule, never, [typeof TabListComponent, typeof TabPanelComponent, typeof TabTitleDirective, typeof TabNavComponent, typeof TabItemDirective, typeof TabLinkDirective, typeof TabTagDirective, typeof TabIconComponent, typeof TabCountDirective, typeof TabLabelDirective, typeof TabProcessDirective, typeof TabHeaderDirective, typeof TabCounterHeaderDirective, typeof TabProcessIconDirective, typeof TabSeparatorDirective], [typeof TabListComponent, typeof TabPanelComponent, typeof TabTitleDirective, typeof TabNavComponent, typeof TabItemDirective, typeof TabLinkDirective, typeof TabTagDirective, typeof TabIconComponent, typeof TabCountDirective, typeof TabLabelDirective, typeof TabProcessDirective, typeof TabHeaderDirective, typeof TabCounterHeaderDirective, typeof TabProcessIconDirective, typeof TabSeparatorDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TabsModule>;
}

export { LIST_COMPONENT, TabCountDirective, TabCounterHeaderDirective, TabHeaderDirective, TabIconComponent, TabItemDirective, TabItemExpandComponent, TabLabelDirective, TabLinkDirective, TabListComponent, TabNavComponent, TabPanelComponent, TabPanelStateChange, TabProcessDirective, TabProcessIconDirective, TabSeparatorDirective, TabTagDirective, TabTitleDirective, TabsModule };
export type { TabItemState, TabListComponentInterface, TabModes, TabSizes };
