import * as _fundamental_ngx_platform_icon_tab_bar from '@fundamental-ngx/platform/icon-tab-bar';
import * as _angular_core from '@angular/core';
import { TemplateRef, Signal, InputSignal, InputSignalWithTransform, OnChanges, ChangeDetectorRef, QueryList, ElementRef, EventEmitter, SimpleChanges, OnInit, AfterViewInit, OnDestroy, NgZone } from '@angular/core';
import * as _fundamental_ngx_cdk_utils from '@fundamental-ngx/cdk/utils';
import { NullableObject, FdkAsyncProperty, Nullable, OverflowListDirective, HasElementRef, ContentDensityService } from '@fundamental-ngx/cdk/utils';
import { Point, DragRef, DragDrop } from '@angular/cdk/drag-drop';
import { Subject } from 'rxjs';
import { IconFont } from '@fundamental-ngx/core/icon';
import { PopoverComponent, TriggerConfig } from '@fundamental-ngx/core/popover';
import { ScrollbarDirective } from '@fundamental-ngx/core/scrollbar';
import { TabList } from '@fundamental-ngx/core/shared';

type TabType = 'text' | 'icon' | 'icon-only' | 'filter' | 'process';
type TabDensityMode = 'cozy' | 'compact' | 'condensed' | 'inherit';
/** @deprecated Use TabDensityMode instead. Will be removed in future versions. */
type TabDestinyMode = TabDensityMode;
type SemanticColor = 'negative' | 'critical' | 'positive' | 'informative' | 'default';
type IconTabBarBackground = 'solid' | 'translucent' | 'transparent';
type IconTabBarSize = 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | 'responsive-paddings';

/** This is config that user should provide to input */
type TabConfig = NullableObject<{
    icon?: FdkAsyncProperty<string | undefined>;
    label: FdkAsyncProperty<string>;
    color: FdkAsyncProperty<SemanticColor | undefined>;
    counter: FdkAsyncProperty<number>;
    /** whether the tab is selected */
    active: boolean;
    /** if set to true, will show red circle in top-right corner of tab */
    badge: boolean;
    /** config for nested tabs */
    subItems: TabConfig[];
    /** Whether the tab can be closed. */
    closable: boolean;
    iconFont: IconFont;
    renderer?: TemplateRef<any>;
    titleTemplate?: TemplateRef<any>;
    id: string;
    /** ID of the template to use for tab content. When provided, the template with this ID will be used as the tab content.*/
    contentTemplateId?: string;
}>;
type ReactiveTabConfig = NullableObject<{
    icon?: InputSignal<string | undefined>;
    label: InputSignal<Nullable<string>>;
    color: InputSignal<SemanticColor>;
    counter: InputSignal<Nullable<number>>;
    /** whether the tab is selected */
    active: InputSignalWithTransform<boolean, unknown>;
    /** if set to true, will show red circle in top-right corner of tab */
    badge: InputSignalWithTransform<boolean, unknown>;
    /** config for nested tabs */
    subItems: ReactiveTabConfig[];
    /** Whether the tab can be closed. */
    closable: InputSignalWithTransform<boolean, unknown>;
    iconFont: InputSignal<IconFont>;
    renderer?: Signal<TemplateRef<any> | undefined>;
    titleTemplate?: Signal<TemplateRef<any> | undefined>;
    id: InputSignal<string>;
}>;
type ExtendedTabConfig = TabConfig & {
    isActive$: Signal<boolean>;
};

interface ElementChord {
    x: number;
    y: number;
    width: number;
    height: number;
}
/**
 * Extended TabConfig with special fields, that are calculated internally
 */
interface IconTabBarItem extends TabConfig {
    /** order in the array */
    index: number;
    uId: string;
    /**
     * Calculated index of tab, that takes into account the level of nesting.
     *
     * E.g. items `1, 1.1, 1.1.1, 2` will get indexes `0, 1, 2, 3` accordingly
     */
    flatIndex: number;
    cssClasses: string[];
    /** This field is used in overflow mode. Determines whether particular tab should be hidden */
    hidden?: boolean;
    subItems?: IconTabBarItem[];
    /** Unique id of the parent tab, if current item is a subItem */
    parentUId?: string;
}
interface IconTabBarDndItem {
    dndItemData: IconTabBarItem;
    previewClass: string[];
    dndHoveredClass: string[];
    dndSeparatorClass: string[];
    moved: Subject<Point>;
    released: Subject<void>;
    started: Subject<void>;
    dragRef: DragRef;
    isVertical: boolean;
    getElementCoordinates(): ElementChord;
    toggleHoveredStyles(force?: boolean): void;
    toggleSeparatorStyles(force?: boolean): void;
}
interface IconTabBarDndList {
    changeDraggableState(draggable: boolean): void;
}

declare abstract class IconTabBarPopoverBase implements OnChanges {
    protected _cd: ChangeDetectorRef;
    /** @hidden list of tab html elements, that can receive focus. Each item should have "data-flatIndex" attribute */
    abstract _tabExtraUIElements: QueryList<ElementRef<HTMLElement>>;
    /**
     * @description Flag representing rtl mode
     */
    isRtl: boolean;
    /**
     * @description Reference to PopoverComponent
     */
    popover: PopoverComponent;
    /**
     * @description Sub items array
     */
    extraTabs: IconTabBarItem[];
    /**
     * @description Should we show separator between subItems
     */
    isSeparators: boolean;
    /**
     * @description Emits when some tab is selected.
     */
    selectedExtraItem: EventEmitter<IconTabBarItem>;
    /** @description Emits when popover is closed and focus should be applied to first visible tab */
    focusFirstVisibleItem: EventEmitter<void>;
    /** @description Emits when popover is closed and focus should be applied to last visible tab */
    focusLastVisibleItem: EventEmitter<void>;
    /** Event emits when user clicks on x button in tab. */
    closeTab: EventEmitter<string>;
    /**
     * @description Associations for colors of the tabs.
     * If any of the color associations provided, they'll be read by screenreader instead of the actual color
     */
    colorAssociations: _angular_core.InputSignal<Partial<Record<_fundamental_ngx_platform_icon_tab_bar.SemanticColor, string>> | undefined>;
    /**
     * @hidden
     * @description state of popover
     */
    _isOpen: boolean;
    /** @hidden */
    constructor(_cd: ChangeDetectorRef);
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * @hidden
     * @param focusLast whether to focus first or last item in the popover
     */
    _openPopover(focusLast?: boolean): void;
    /** @hidden */
    _focusPreviousPopoverItem(currentIndex: number): void;
    /** @hidden */
    _focusNextPopoverItem(currentIndex: number): void;
    /** @hidden */
    _focusPopoverItem(index: number): void;
    /**
     * @hidden
     * @param selectedItem
     */
    _selectItem(selectedItem: IconTabBarItem): void;
    /** @hidden */
    _keyDownHandler(event: KeyboardEvent, tab: IconTabBarItem, currentIndex: number): void;
    /**
     * @hidden
     * @description Generate styles for subItems
     */
    protected _setStyles(items: IconTabBarItem[]): void;
    /** @hidden */
    private _getOrderedTabExtraUIElements;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarPopoverBase, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconTabBarPopoverBase, never, never, { "isRtl": { "alias": "isRtl"; "required": false; }; "extraTabs": { "alias": "extraTabs"; "required": false; }; "isSeparators": { "alias": "isSeparators"; "required": false; }; "colorAssociations": { "alias": "colorAssociations"; "required": false; "isSignal": true; }; }, { "selectedExtraItem": "selectedExtraItem"; "focusFirstVisibleItem": "focusFirstVisibleItem"; "focusLastVisibleItem": "focusLastVisibleItem"; "closeTab": "closeTab"; }, never, never, true, never>;
}

declare class TextTypePopoverComponent extends IconTabBarPopoverBase implements OnChanges {
    /** @hidden reference for html element, that opens dropdown and can receive focus */
    _dropdownTrigger: ElementRef<HTMLElement>;
    /** @hidden list of tab html elements, that can receive focus */
    _tabExtraUIElements: QueryList<ElementRef<HTMLElement>>;
    /** Whether to render item as a multi-click variant. */
    multiClick: boolean;
    /**
     * @description Layout type for tab.
     */
    layoutMode: 'row' | 'column';
    /**
     * @description Is extra items mode or subitems mode
     */
    isExtraItemsMode: boolean;
    /**
     * @description Parent tab need for subItems mode
     */
    parentTab: IconTabBarItem;
    /**
     * @description uId of selected subItem
     */
    selectedSubItemUid: Nullable<string>;
    /**
     * @description tabIndex of the particular item. Aplicable only for subitems mode
     */
    tabindex: number;
    /**
     * @description Emits when some subTab is selected and isExtraItemsMode is disabled
     */
    selectedSubItem: EventEmitter<any>;
    /** Emits when root item is being selected. Applicable for multi-click variant only. */
    selectedItem: EventEmitter<void>;
    /** @hidden */
    _containsSelected: boolean;
    /** @hidden */
    _popoverTriggers: TriggerConfig[];
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * @hidden
     * @param selectedItem
     */
    _selectItem(selectedItem: IconTabBarItem): void;
    /** @hidden */
    _textPopoverKeyDownHandler(event: KeyboardEvent, tab: IconTabBarItem): void;
    /** @hidden */
    private _calculateIfContainsSelected;
    /** @hidden */
    private _getChildren;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextTypePopoverComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextTypePopoverComponent, "fdp-text-type-popover", never, { "multiClick": { "alias": "multiClick"; "required": false; }; "layoutMode": { "alias": "layoutMode"; "required": false; }; "isExtraItemsMode": { "alias": "isExtraItemsMode"; "required": false; }; "parentTab": { "alias": "parentTab"; "required": false; }; "selectedSubItemUid": { "alias": "selectedSubItemUid"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; }, { "selectedSubItem": "selectedSubItem"; "selectedItem": "selectedItem"; }, never, never, true, never>;
}

declare abstract class IconTabBarBase implements OnInit, OnChanges, AfterViewInit, OnDestroy {
    /**
     * @hidden
     * List of tab elements, that can receive focus.
     * There's a separate mapping function to get actual html element: `_getTabUIElementFocusable`
     */
    abstract _tabUIElements: QueryList<unknown>;
    /** @hidden */
    abstract _tabBarPopover: IconTabBarPopoverBase;
    /**
     * @description A tab bar configuration that stores the state of each tab. Based on this configuration, a tab bar is representing.
     */
    set tabs(value: IconTabBarItem[]);
    /** @hidden */
    get tabs(): IconTabBarItem[];
    /**
     * @description Flag representing rtl mode
     */
    isRtl: boolean;
    /**
     * @description densityMode setter triggers tabs to re-calculation overflowed tabs
     */
    set densityMode(value: TabDensityMode);
    /** Currently selected tab Unique ID. */
    selectedUid: string | undefined;
    /**
     * @description Emits when some tab is selected.
     */
    selected: EventEmitter<IconTabBarItem>;
    /** Emits when selected tab Unique ID changes. */
    selectedUidChange: EventEmitter<string | undefined>;
    /**
     * @description Reference to OverflowListDirective
     */
    overflowDirective: OverflowListDirective;
    /** Header element reference. */
    headerElement: ElementRef<HTMLElement>;
    /** @hidden */
    _extraTabs$: _angular_core.WritableSignal<IconTabBarItem[]>;
    /** @hidden */
    _lastVisibleTabIndex: number;
    /** @hidden */
    _extraItems$: _angular_core.WritableSignal<boolean>;
    /** @hidden Heading level of the tab. */
    tabHeadingLevel: _angular_core.InputSignal<number | null>;
    /**
     * @description Associations for colors of the tabs.
     * If any of the color associations provided, they'll be read by screenreader instead of the actual color
     */
    colorAssociations: _angular_core.InputSignal<Partial<Record<_fundamental_ngx_platform_icon_tab_bar.SemanticColor, string>> | undefined>;
    /** @hidden */
    readonly _inDynamicPage: boolean;
    /** @hidden */
    protected readonly _cd: ChangeDetectorRef;
    /** @Hidden */
    protected readonly _ngZone: NgZone;
    /** @hidden */
    private _tabs;
    /** @hidden */
    private _densityMode;
    /** @hidden */
    private _destroyRef;
    /** @hidden */
    private _destroyed;
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /**
     * @hidden
     * @param selectedItem
     * @param event
     */
    _selectItem(selectedItem: IconTabBarItem | undefined, event?: Event): void;
    /** @hidden */
    _keyDownHandler(event: KeyboardEvent, tab: IconTabBarItem | undefined, currentIndex: number, popover?: TextTypePopoverComponent): void;
    /** @hidden focuses next tab */
    _focusNextItem(currentIndex: number): void;
    /** @hidden focuses previous tab */
    _focusPreviousItem(currentIndex: number): void;
    /**
     * @hidden
     * @param tabIndex index of the tab to apply focus
     * @param focusLast whether to focus first or last item in the popover
     */
    _focusItem(tabIndex: number, focusLast?: boolean): void;
    /**
     * @hidden
     * @param selectedItem
     * @description select extra item inside popover
     */
    _selectExtraItem(selectedItem: IconTabBarItem): void;
    /**
     * @hidden
     * @param extraItems
     * @description recalculate _nextSteps and _prevSteps array if we have extra items
     */
    _recalculateVisibleItems(extraItems: number): void;
    /**
     * @hidden
     * Mapping function to resolve UI tab element to it's focusable part/descendant
     */
    protected _getTabUIElementFocusable(tabUIElement: unknown): Nullable<HTMLElement>;
    /**
     * @hidden
     * @description trigger recalculation items, need to do it asynchronously after dom was rerendered
     */
    protected _triggerRecalculationVisibleItems(): void;
    /**
     * @hidden
     * @description initialize state of tabs
     */
    protected _initTabs(): void;
    /**
     * @hidden
     * Resets and hides extra tabs.
     * @param tabs - The list of tab items.
     * @param extraTabs - The list of extra tab items.
     */
    private _resetAndHideExtraTabs;
    /**
     * @hidden
     * Handles changes to the selected UID.
     */
    private _handleSelectedUidChange;
    /**
     * @hidden
     * Calculates the index of the last visible tab item.
     * @param totalTabs - The total number of tabs.
     * @param extraItems - The number of extra items.
     * @param selected - The currently selected tab item (optional).
     * @returns The index of the last visible tab item.
     */
    private _getLastVisibleTabIndex;
    /**
     * @hidden
     * Resets the visibility and CSS classes of a tab item.
     * @param tab - The tab item to reset.
     */
    private _resetTab;
    /**
     * @hidden
     * Hides extra tabs and updates the extraTabs array with the hidden tabs.
     * @param tabs - The array of all tab items.
     * @param extraTabs - The array to store the hidden tab items.
     */
    private _hideExtraTabs;
    /**
     * @hidden
     * Recursively finds the active tab item in a list of tabs.
     * @param tabs - The array of tab items.
     * @returns The active tab item, or undefined if no active tab is found.
     */
    private _findActiveTabId;
    /**
     * @hidden
     * Checks if a tab was removed from the list of tabs.
     * @param changes - SimpleChanges
     * @returns { boolean } - Returns true if a tab was removed, false otherwise.
     */
    private _tabWasRemoved;
    /**
     * @hidden
     * Updates the selected tab based on the changes in the tabs.
     * If the removed tab was before the selected tab or is the selected tab, it updates the selected tab.
     * If no previous selected tab can be found, it selects the first one.
     * If the removed tab is after the selected tab, no changes are needed.
     * @param changes - SimpleChanges
     */
    private _updateSelectedTab;
    /**
     * @hidden
     * Gets the index of the removed tab based on the changes in the tabs.
     * @param changes - SimpleChanges
     * @returns { number } - The index of the removed tab, or -1 if not found.
     */
    private _getRemovedTabIndex;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarBase, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconTabBarBase, never, never, { "tabs": { "alias": "tabs"; "required": false; }; "isRtl": { "alias": "isRtl"; "required": false; }; "densityMode": { "alias": "densityMode"; "required": false; }; "selectedUid": { "alias": "selectedUid"; "required": false; }; "tabHeadingLevel": { "alias": "tabHeadingLevel"; "required": false; "isSignal": true; }; "colorAssociations": { "alias": "colorAssociations"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "selectedUidChange": "selectedUidChange"; }, never, never, true, never>;
}

declare abstract class ClosableIconTabBar extends IconTabBarBase {
    abstract _tabBarPopover: IconTabBarPopoverBase;
    /**
     * Event emits when user clicks on x button in tab.
     */
    closeTab: EventEmitter<IconTabBarItem>;
    /** @hidden */
    _closeTab(itemIndex: string, checkPopover?: boolean): void;
    /** @hidden */
    _keyDownHandler(event: KeyboardEvent, tab: IconTabBarItem | undefined, currentIndex: number, popover?: TextTypePopoverComponent): void;
    /**
     * @hidden
     * @param arr
     * @param parentUid
     * @description Update indexes, uIds, styles.
     */
    protected _updateTabs(arr: IconTabBarItem[], parentUid?: string, flatIndexRef?: {
        value: number;
    }): IconTabBarItem[];
    /**
     * @hidden
     * @param uid
     * @param arr
     * @returns {parent, tab}
     * @description Get tab reference inside main tab array and  reference to parent array.
     */
    protected _getTabInfoFromMainList(uid: string, arr?: any[]): {
        parent: IconTabBarItem[];
        tab: IconTabBarItem;
    } | undefined;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClosableIconTabBar, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ClosableIconTabBar, never, never, {}, { "closeTab": "closeTab"; }, never, never, true, never>;
}

declare class IconTabBarPopoverComponent extends IconTabBarPopoverBase {
    /** @hidden list of tab html elements, that can receive focus */
    _tabExtraUIElements: QueryList<ElementRef<HTMLElement>>;
    /**
     * @description Flag representing position inside container left/right
     */
    leftSide: boolean;
    /**
     * @description Label for button
     */
    label: string;
    /** Whether to display labels for tab items */
    showItemLabel: boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarPopoverComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconTabBarPopoverComponent, "fdp-icon-tab-bar-popover", never, { "leftSide": { "alias": "leftSide"; "required": false; }; "label": { "alias": "label"; "required": false; }; "showItemLabel": { "alias": "showItemLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IconTabBarFilterTypeComponent extends ClosableIconTabBar {
    /** @hidden list of tab html elements, that can receive focus */
    _tabUIElements: QueryList<ElementRef<HTMLElement>>;
    /** @hidden */
    _tabBarPopover: IconTabBarPopoverComponent;
    /**
     * @description Boolean flag indicating to show total tab
     */
    showTotalTab: boolean;
    /** @hidden */
    _totalTab?: IconTabBarItem;
    /**
     * @hidden
     * @description initialize state of tabs
     */
    protected _initTabs(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarFilterTypeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconTabBarFilterTypeComponent, "fdp-icon-tab-bar-filter-type", never, { "showTotalTab": { "alias": "showTotalTab"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IconTabBarIconTypeComponent extends ClosableIconTabBar {
    /** @hidden list of tab html elements, that can receive focus */
    _tabUIElements: QueryList<ElementRef<HTMLElement>>;
    /** @hidden */
    _tabBarPopover: IconTabBarPopoverComponent;
    /** Whether to display labels for tab items */
    showLabel: boolean;
    /** @hidden */
    readonly _defaultFontFamily = "SAP-icons";
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarIconTypeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconTabBarIconTypeComponent, "fdp-icon-tab-bar-icon-type", never, { "showLabel": { "alias": "showLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IconTabBarProcessTypeComponent extends ClosableIconTabBar {
    /** @hidden list of tab html elements, that can receive focus */
    _tabUIElements: QueryList<ElementRef<HTMLElement>>;
    /** @hidden */
    _tabBarPopover: IconTabBarPopoverComponent;
    /** @hidden */
    _offsetOverflowDirective: number;
    /**
     * @hidden
     * An array containing extra tabs for the next steps
     */
    _nextSteps: IconTabBarItem[];
    /**
     * @hidden
     * An array containing extra tabs for the next steps
     */
    _prevSteps: IconTabBarItem[];
    /** @hidden */
    _showLeftBtn: boolean;
    /** @hidden */
    _showRightBtn: boolean;
    /** @hidden */
    _anchorIndexForExtraBtnDirective: number;
    /** @hidden */
    private _firstVisibleTabIndex;
    /** @hidden */
    private _currentStepIndex;
    /**
     * @hidden
     * @param selectedItem
     */
    _selectItem(selectedItem: IconTabBarItem): void;
    /**
     * @hidden
     * @param selectedItem
     * @description select extra item inside popover
     */
    _selectExtraItem(selectedItem: IconTabBarItem): Promise<void>;
    /**
     * @hidden
     * @param extraItems
     * @description recalculate _nextSteps and _prevSteps array if we have extra items
     */
    _recalculateVisibleItems(extraItems: number): void;
    /** @hidden */
    private _clearExtraList;
    /**
     * @hidden
     * @param extraItems
     * @param amountOfNextSteps
     * @description We fill the array of the next steps to the selected tab,
     * based on this we generate the array of the previous steps if it is necessary
     */
    private _recalculateItemsByNextArr;
    /**
     * @hidden
     * @param extraItems
     * @param amountOfPreviousSteps
     * @description We fill the array of the previous steps to the selected tab,
     * based on this we generate the array of the next steps if it is necessary
     */
    private recalculateItemsByPrevArr;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarProcessTypeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconTabBarProcessTypeComponent, "fdp-icon-tab-bar-process-type", never, {}, {}, never, never, true, never>;
}

interface FdDnDEvent {
    draggableItem: IconTabBarItem;
    targetItem: IconTabBarItem;
    action: 'replace' | 'insert';
}
declare class IconBarDndContainerDirective {
    elementRef: ElementRef;
    /**
     * @description Defines if drag and drop feature should be enabled for list items
     */
    set draggable(draggable: boolean);
    /**
     * @description Event that is thrown, when the item is dropped
     */
    dropped: EventEmitter<FdDnDEvent>;
    /** @hidden */
    private _dragRefItems;
    /** @hidden  */
    private dndItemDirectives;
    /** @hidden  */
    private _dndListDirectives;
    /** @hidden */
    private _elementsCoordinates;
    /** @hidden */
    private _virtualSeparatorsCoordinates;
    /** @hidden */
    private _closestItemIndex;
    /** @hidden */
    private _closestSeparatorIndex;
    /** @hidden */
    private _draggable;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    constructor(elementRef: ElementRef);
    /**
     * @description Method called, when element is started to be dragged
     */
    dragStart(): void;
    /**
     * @param mousePosition
     * @description Method called, when the item is being moved by 1 px
     */
    onMove(mousePosition: Point): void;
    /**
     * @param dragDir
     * @description Method called, when element is released
     */
    dragEnd(dragDir: IconTabBarDndItem): void;
    /**
     * @param dragItem
     * @description Register IconTabBarDndItem to current container
     */
    registerDragItem(dragItem: IconTabBarDndItem): void;
    /**
     * @param dragItem
     * @description Remove registered IconTabBarDndItem to current container
     */
    removeDragItem(dragItem: IconTabBarDndItem): void;
    /**
     * @param listDir
     * @description Register IconTabBarDndList to current container
     */
    registerDndList(listDir: IconTabBarDndList): void;
    /**
     * @param listDir
     * @description Remove registered IconTabBarDndList to current container
     */
    removeDndList(listDir: IconTabBarDndList): void;
    /**
     * @description Generate virtual elements as separator between tabs
     */
    private _generateVirtualSeparators;
    /** @hidden */
    private _changeDraggableState;
    /** @hidden */
    private _isMouseOnFlipper;
    /** @hidden */
    private _isMouseOnElement;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconBarDndContainerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconBarDndContainerDirective, "[fdpIconBarDndContainer], [fdp-icon-bar-dnd-container]", never, { "draggable": { "alias": "draggable"; "required": false; }; }, { "dropped": "dropped"; }, never, never, true, never>;
}

/** @hidden */
type TabItem = ElementRef<HTMLElement> | TextTypePopoverComponent;
declare class IconTabBarTextTypeComponent extends ClosableIconTabBar {
    /** @hidden list of tab html elements, that can receive focus */
    _tabUIElements: QueryList<TabItem>;
    /** @hidden */
    _tabBarPopover: TextTypePopoverComponent;
    /**
     * @description Disable or enable reordering(drag and drop) feature.
     */
    enableTabReordering: boolean;
    /**
     * @description Layout type for tab.
     */
    layoutMode: 'row' | 'column';
    /** Whether to render icon tab item as multi-click variant. */
    multiClick: boolean;
    /**
     * @description Emits when user drops the tab.
     */
    reordered: EventEmitter<IconTabBarItem[]>;
    /**
     * @hidden
     * @param selectedItem
     */
    _selectExtraItem(selectedItem: IconTabBarItem | undefined): void;
    /**
     * @hidden
     * @param draggableItem
     * @param targetItem
     * @param action
     */
    _onDropped(event: FdDnDEvent): void;
    /**
     * @hidden
     * @param uid
     * @description Get item id from sub item uid. Eg if sub item id is '6.2', then item id will be '6'. Defaults to '0'.
     */
    _getItemIdFromSubItemUid(uid: string | undefined): string;
    /** @hidden */
    protected _getTabUIElementFocusable(tabUIElement: Nullable<TabItem>): Nullable<HTMLElement>;
    /** @hidden */
    private _canDrop;
    /**
     * @hidden
     * @param data
     * @description Insert tab into another tab.
     */
    private _insertItemAsChild;
    /**
     * @hidden
     * @param data
     * @description Insert tab between tabs
     */
    private _replaceAsSibling;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarTextTypeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconTabBarTextTypeComponent, "fdp-icon-tab-bar-text-type", never, { "enableTabReordering": { "alias": "enableTabReordering"; "required": false; }; "layoutMode": { "alias": "layoutMode"; "required": false; }; "multiClick": { "alias": "multiClick"; "required": false; }; }, { "reordered": "reordered"; }, never, never, true, never>;
}

declare class IconTabBarTabContentDirective implements HasElementRef {
    /** Tab ID */
    id: _angular_core.InputSignal<Nullable<string>>;
    /** Tab Unique ID. */
    uId: _angular_core.InputSignal<Nullable<string>>;
    /** Element reference. */
    readonly elementRef: ElementRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarTabContentDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconTabBarTabContentDirective, "fdp-icon-tab-bar-tab-content", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "uId": { "alias": "uId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class IconTabBarTabComponent implements ReactiveTabConfig {
    /** Tab Label. */
    label: _angular_core.InputSignal<Nullable<string>>;
    /** Tab text color. */
    color: _angular_core.InputSignal<SemanticColor>;
    /** Tab icon. */
    icon: _angular_core.InputSignal<string | undefined>;
    /** Tab icon font family. */
    iconFont: _angular_core.InputSignal<IconFont>;
    /** Tab counter. */
    counter: _angular_core.InputSignal<Nullable<number>>;
    /** whether the tab is selected */
    active: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** if set to true, will show red circle in top-right corner of tab */
    badge: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether the tab can be closed. */
    closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Tab ID. */
    id: _angular_core.InputSignal<string>;
    /** Content renderer. */
    readonly renderer: _angular_core.Signal<TemplateRef<any> | undefined>;
    /** Title template. */
    readonly titleTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    /** @hidden */
    readonly children: _angular_core.Signal<readonly IconTabBarTabComponent[]>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarTabComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconTabBarTabComponent, "fdp-icon-tab-bar-tab", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconFont": { "alias": "iconFont"; "required": false; "isSignal": true; }; "counter": { "alias": "counter"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, ["titleTemplate", "children"], ["*"], true, never>;
}

declare const UNIQUE_KEY_SEPARATOR = ".";
declare const FLIPPER_SIZE: {
    width: number;
    height: number;
    verticalHeight: number;
};
declare const ICON_TAB_HIDDEN_CLASS_NAME = "fd-icon-tab-bar__item--hidden";

declare class IconBarDndListDirective implements IconTabBarDndList, AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private _dragDrop;
    private _dndContainer;
    /**
     * @description Direction in which the list is oriented.
     */
    dndOrientation: 'horizontal' | 'vertical';
    /**
     * @description Is disabled autoscroll inside draggable list
     */
    dndAutoScroll: boolean;
    /** @hidden */
    private _dropListRef;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private _dragRefItems;
    /** @hidden */
    private readonly _dndItems$;
    /** @hidden */
    constructor(elementRef: ElementRef, _dragDrop: DragDrop, _dndContainer: IconBarDndContainerDirective);
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /**
     * @param dragItem
     * @description Register IconTabBarDndItem to current list
     */
    registerDragItem(dragItem: IconTabBarDndItem): void;
    /**
     * @param dragItem
     * @description Remove registered IconTabBarDndItem to current list
     */
    removeDragItem(dragItem: IconTabBarDndItem): void;
    /**
     * @param draggable
     */
    changeDraggableState(draggable: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconBarDndListDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconBarDndListDirective, "[fdpIconBarDndList], [fdp-icon-bar-dnd-list]", never, { "dndOrientation": { "alias": "dndOrientation"; "required": false; }; "dndAutoScroll": { "alias": "dndAutoScroll"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IconBarDndItemDirective implements IconTabBarDndItem, AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    protected _dragDrop: DragDrop;
    private _dndListDir;
    private _dndContainerDir;
    /**
     * @description Tab info
     */
    dndItemData: IconTabBarItem;
    /**
     * @description Classes for draggable preview
     */
    previewClass: string[];
    /**
     * @description Classes for hovered state
     */
    dndHoveredClass: string[];
    /**
     * @description Classes for separator, when draggable element between two tabs
     */
    dndSeparatorClass: string[];
    /**
     * @description Event thrown when the element is moved by 1px
     */
    readonly moved: Subject<Point>;
    /**
     * @description Event thrown when the element is released
     */
    readonly released: Subject<void>;
    /**
     * @description Event thrown when the element is started to be dragged
     */
    readonly started: Subject<void>;
    /** @hidden */
    isVertical: boolean;
    /**
     * @hidden
     * @description Drag reference, object created from DND CDK Service
     */
    dragRef: DragRef;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    constructor(elementRef: ElementRef, _dragDrop: DragDrop, _dndListDir: IconBarDndListDirective, _dndContainerDir: IconBarDndContainerDirective);
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    onCdkDragStart(): void;
    /** @hidden */
    onCdkMove(position: Point): void;
    /** @hidden */
    onCdkDragReleased(): void;
    /** @hidden */
    getElementCoordinates(): ElementChord;
    /**
     * @description Add/delete separator classes
     */
    toggleSeparatorStyles(force?: boolean): void;
    /**
     * @description Add/delete hovered state classes
     */
    toggleHoveredStyles(force?: boolean): void;
    /** @hidden */
    private _setCDKDrag;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconBarDndItemDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconBarDndItemDirective, "[fdpIconBarDndItem], [fdp-icon-bar-dnd-item]", never, { "dndItemData": { "alias": "dndItemData"; "required": false; }; "previewClass": { "alias": "previewClass"; "required": false; }; "dndHoveredClass": { "alias": "dndHoveredClass"; "required": false; }; "dndSeparatorClass": { "alias": "dndSeparatorClass"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Directive to mark a template as a content template for icon tab bar.
 * This allows you to define templates with IDs that can be referenced in tab configurations.
 * Use this directive when you want to define tab content using templates with IDs instead of
 * projecting content directly into fdp-icon-tab-bar-tab components.
 *
 */
declare class IconTabBarContentTemplateDirective implements OnInit, OnDestroy {
    /**
     * The unique ID for this template. Used to reference the template in tab configurations.
     * This ID should be used in the `contentTemplateId` property of the `TabConfig`.
     */
    templateId: _angular_core.InputSignal<string>;
    /** Reference to the template element. @hidden */
    readonly templateRef: TemplateRef<any>;
    /** Service to manage templates. @hidden */
    private readonly templateService;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarContentTemplateDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconTabBarContentTemplateDirective, "[fdpIconTabBarContentTemplate]", never, { "templateId": { "alias": "templateId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class IconTabBarFreeContentDirective {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarFreeContentDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconTabBarFreeContentDirective, "[fdpIconTabBarFreeContent]", never, {}, {}, never, never, true, never>;
}

declare class IconTabTitleDirective {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabTitleDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconTabTitleDirective, "[fdpIconTabBarTitleTemplate], [fdp-icon-tab-bar-title-template]", never, {}, {}, never, never, true, never>;
}

declare class IconTabBarComponent implements OnInit, TabList {
    private _cd;
    private _contentDensityService;
    /**
     * Whether to open tab content one under another without collapsing.
     * Works only for content-projected tab content.
     */
    stackContent: boolean;
    /** Heading level of the tab. */
    tabHeadingLevel: _angular_core.InputSignal<number | null>;
    /** @description Type of tab bar view. */
    iconTabType: _angular_core.InputSignal<TabType>;
    /**
     * @description A tab bar configuration that stores the state of each tab. Based on this configuration, a tab bar is representing.
     */
    tabsConfig: _angular_core.ModelSignal<_fundamental_ngx_cdk_utils.NullableObject<{
        icon?: _fundamental_ngx_cdk_utils.FdkAsyncProperty<string | undefined>;
        label: _fundamental_ngx_cdk_utils.FdkAsyncProperty<string>;
        color: _fundamental_ngx_cdk_utils.FdkAsyncProperty<_fundamental_ngx_platform_icon_tab_bar.SemanticColor | undefined>;
        counter: _fundamental_ngx_cdk_utils.FdkAsyncProperty<number>;
        active: boolean;
        badge: boolean;
        subItems: TabConfig[];
        closable: boolean;
        iconFont: IconFont;
        renderer?: TemplateRef<any>;
        titleTemplate?: TemplateRef<any>;
        id: string;
        contentTemplateId?: string;
    }>[] | undefined>;
    /** @description Density mode. */
    densityMode: _angular_core.ModelSignal<TabDensityMode>;
    /** @description Icon font */
    iconTabFont: _angular_core.InputSignal<IconFont>;
    /** @description Disable or enable reordering(drag and drop) feature. (supported by text type only) */
    enableTabReordering: _angular_core.InputSignal<boolean>;
    /** @description Boolean flag indicating to show total tab.(supported by filter type only) */
    showTotalTab: _angular_core.InputSignal<boolean>;
    /** Whether to render icon tab item as multi-click variant. */
    multiClick: _angular_core.InputSignal<boolean>;
    /** @description Layout type for tab (supported by text type only) */
    layoutMode: _angular_core.InputSignal<"row" | "column">;
    /** @description Icon tab bar background type. */
    iconTabBackground: _angular_core.InputSignal<IconTabBarBackground>;
    /** @description Icon tab bar size. */
    iconTabSize: _angular_core.InputSignal<IconTabBarSize | undefined>;
    /**
     * @description Associations for colors of the tabs.
     * If any of the color associations provided, they'll be read by screenreader instead of the actual color
     */
    colorAssociations: _angular_core.InputSignal<Partial<Record<_fundamental_ngx_platform_icon_tab_bar.SemanticColor, string>> | undefined>;
    /** @description If Icon tab bar is used in Settings Dialog */
    settings: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Maximum height of the content.
     * Works only for content-projected tab content.
     */
    maxContentHeight: _angular_core.InputSignal<string>;
    /** @description Emits when some tab is selected. */
    iconTabSelected: _angular_core.OutputEmitterRef<IconTabBarItem>;
    /** @description Emits when user drop tab. */
    iconTabReordered: _angular_core.OutputEmitterRef<IconTabBarItem[]>;
    /** Event emitted when user clicks on x icon in tab. */
    closeTab: _angular_core.OutputEmitterRef<IconTabBarItem>;
    /** @hidden */
    children: _angular_core.Signal<readonly IconTabBarTabComponent[]>;
    /** @hidden */
    _scrollbar: _angular_core.Signal<ScrollbarDirective | undefined>;
    /** @hidden */
    tabDirectives: _angular_core.Signal<readonly IconTabBarTabContentDirective[]>;
    protected get _customTabs(): boolean;
    /** @hidden */
    get headerContainer(): Nullable<ElementRef>;
    /** @hidden */
    _cssClassForContainer: string[];
    /** @hidden */
    _disableScrollSpy: boolean;
    /** @hidden */
    _init: boolean;
    /** @hidden */
    activeTab: TabConfig | null;
    /** Scrollable element reference. */
    get scrollableElement(): Nullable<ElementRef>;
    /** @hidden */
    readonly _selectedUid: _angular_core.WritableSignal<string | undefined>;
    /** @hidden */
    readonly _flatTabs$: _angular_core.Signal<IconTabBarItem[]>;
    /** @hidden */
    readonly _tabRenderer$: _angular_core.WritableSignal<IconTabBarItem | null>;
    /** @hidden */
    readonly _templateMap$: _angular_core.Signal<Map<string, TemplateRef<any>>>;
    /** @hidden */
    readonly _tabs$: _angular_core.Signal<IconTabBarItem[]>;
    /** @hidden */
    readonly _tabsConfig$: _angular_core.Signal<_fundamental_ngx_cdk_utils.NullableObject<{
        icon?: _fundamental_ngx_cdk_utils.FdkAsyncProperty<string | undefined>;
        label: _fundamental_ngx_cdk_utils.FdkAsyncProperty<string>;
        color: _fundamental_ngx_cdk_utils.FdkAsyncProperty<_fundamental_ngx_platform_icon_tab_bar.SemanticColor | undefined>;
        counter: _fundamental_ngx_cdk_utils.FdkAsyncProperty<number>;
        active: boolean;
        badge: boolean;
        subItems: TabConfig[];
        closable: boolean;
        iconFont: IconFont;
        renderer?: TemplateRef<any>;
        titleTemplate?: TemplateRef<any>;
        id: string;
        contentTemplateId?: string;
    }>[]>;
    /** @hidden */
    protected readonly isRtl: _angular_core.Signal<boolean>;
    /** @hidden Initialize active tab when tabs change */
    private readonly _initActiveTabEffect;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _inDynamicPage;
    /** @hidden Template service */
    private readonly templateService;
    private readonly _iconTabBarCmp;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    constructor(_cd: ChangeDetectorRef, _contentDensityService: ContentDensityService);
    /** @hidden */
    ngOnInit(): void;
    /**
     * @hidden
     * @param event reordered array of IconTabBarItem
     */
    _onReorder(event: IconTabBarItem[]): void;
    /**
     * @hidden
     * @param selectedItem
     */
    _selectItem(selectedItem: IconTabBarItem): void;
    /** @hidden */
    _closeTab(item: IconTabBarItem): void;
    /** Programmatically select tab. */
    selectTab(id: Nullable<string>): void;
    /** @hidden */
    highlightActiveTab(id: Nullable<string>, scroll?: boolean): void;
    /**
     * @hidden
     * @returns array of css classes for icon-tab-bar container
     */
    private _generateContainerStyles;
    private _generateTabConfig;
    /** @hidden */
    private _scrollToPanel;
    /**
     * @hidden
     * @description generate IconTabItems from TabConfig array
     */
    private _generateTabBarItems;
    /** @hidden Apply template mapping to tab configurations */
    private _applyTemplateMapping;
    private _generateFlatTabs;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarComponent, [null, { optional: true; }]>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconTabBarComponent, "fdp-icon-tab-bar", never, { "stackContent": { "alias": "stackContent"; "required": false; }; "tabHeadingLevel": { "alias": "tabHeadingLevel"; "required": false; "isSignal": true; }; "iconTabType": { "alias": "iconTabType"; "required": false; "isSignal": true; }; "tabsConfig": { "alias": "tabsConfig"; "required": false; "isSignal": true; }; "densityMode": { "alias": "densityMode"; "required": false; "isSignal": true; }; "iconTabFont": { "alias": "iconTabFont"; "required": false; "isSignal": true; }; "enableTabReordering": { "alias": "enableTabReordering"; "required": false; "isSignal": true; }; "showTotalTab": { "alias": "showTotalTab"; "required": false; "isSignal": true; }; "multiClick": { "alias": "multiClick"; "required": false; "isSignal": true; }; "layoutMode": { "alias": "layoutMode"; "required": false; "isSignal": true; }; "iconTabBackground": { "alias": "iconTabBackground"; "required": false; "isSignal": true; }; "iconTabSize": { "alias": "iconTabSize"; "required": false; "isSignal": true; }; "colorAssociations": { "alias": "colorAssociations"; "required": false; "isSignal": true; }; "settings": { "alias": "settings"; "required": false; "isSignal": true; }; "maxContentHeight": { "alias": "maxContentHeight"; "required": false; "isSignal": true; }; }, { "tabsConfig": "tabsConfigChange"; "densityMode": "densityModeChange"; "iconTabSelected": "iconTabSelected"; "iconTabReordered": "iconTabReordered"; "closeTab": "closeTab"; }, ["children"], ["[fdpIconTabBarFreeContent]"], true, never>;
    static ngAcceptInputType_stackContent: unknown;
}

declare const FDP_ICON_TAB_BAR: readonly [typeof IconTabBarComponent, typeof IconTabBarTabComponent, typeof IconTabBarContentTemplateDirective, typeof IconTabBarFreeContentDirective];
/**
 * @deprecated
 * Import `IconTabBarComponent` directly instead.
 */
declare class PlatformIconTabBarModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformIconTabBarModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<PlatformIconTabBarModule, never, [typeof IconTabBarComponent, typeof IconTabBarTextTypeComponent, typeof IconTabBarIconTypeComponent, typeof IconTabBarProcessTypeComponent, typeof IconTabBarFilterTypeComponent, typeof IconTabBarPopoverComponent, typeof TextTypePopoverComponent, typeof IconBarDndListDirective, typeof IconBarDndItemDirective, typeof IconBarDndContainerDirective, typeof IconTabBarTabComponent, typeof IconTabBarContentTemplateDirective, typeof IconTabBarFreeContentDirective], [typeof IconTabBarComponent, typeof IconTabBarTextTypeComponent, typeof IconTabBarIconTypeComponent, typeof IconTabBarProcessTypeComponent, typeof IconTabBarFilterTypeComponent, typeof IconTabBarPopoverComponent, typeof TextTypePopoverComponent, typeof IconBarDndListDirective, typeof IconBarDndItemDirective, typeof IconBarDndContainerDirective, typeof IconTabBarTabComponent, typeof IconTabBarContentTemplateDirective, typeof IconTabBarFreeContentDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<PlatformIconTabBarModule>;
}

/**
 * Associations for colors of the tabs.
 * If any of the color associations provided, they'll be read by screenreader instead of the actual color
 */
type TabColorAssociations = Partial<Record<SemanticColor, string>>;

/**
 * Service to manage template registration across components
 */
declare class IconTabBarTemplateService {
    private templates;
    private templatesSignal;
    registerTemplate(id: string, template: TemplateRef<any>): void;
    unregisterTemplate(id: string): void;
    getTemplate(id: string): TemplateRef<any> | undefined;
    getAllTemplates(): Map<string, TemplateRef<any>>;
    getAllTemplatesSignal(): Signal<Map<string, TemplateRef<any>>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarTemplateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IconTabBarTemplateService>;
}

declare class IconTabBarTextTypeTabItemComponent {
    /** Tab item. */
    item: Nullable<IconTabBarItem>;
    /**
     * @description Layout type for tab.
     */
    layoutMode: 'row' | 'column';
    /**
     * @description Associations for colors of the tabs.
     * If any of the color associations provided, they'll be read by screenreader instead of the actual color
     */
    colorAssociations: _angular_core.InputSignal<Partial<Record<_fundamental_ngx_platform_icon_tab_bar.SemanticColor, string>> | undefined>;
    /** @hidden */
    get nativeElement(): HTMLElement;
    /** @hiddem */
    private readonly _elementRef;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconTabBarTextTypeTabItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconTabBarTextTypeTabItemComponent, "[fdp-icon-tab-bar-text-type-tab-item]", never, { "item": { "alias": "item"; "required": false; }; "layoutMode": { "alias": "layoutMode"; "required": false; }; "colorAssociations": { "alias": "colorAssociations"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

export { FDP_ICON_TAB_BAR, FLIPPER_SIZE, ICON_TAB_HIDDEN_CLASS_NAME, IconBarDndContainerDirective, IconBarDndItemDirective, IconBarDndListDirective, IconTabBarBase, IconTabBarComponent, IconTabBarContentTemplateDirective, IconTabBarFilterTypeComponent, IconTabBarFreeContentDirective, IconTabBarIconTypeComponent, IconTabBarPopoverBase, IconTabBarPopoverComponent, IconTabBarProcessTypeComponent, IconTabBarTabComponent, IconTabBarTabContentDirective, IconTabBarTemplateService, IconTabBarTextTypeComponent, IconTabBarTextTypeTabItemComponent, IconTabTitleDirective, PlatformIconTabBarModule, TextTypePopoverComponent, UNIQUE_KEY_SEPARATOR };
export type { ElementChord, ExtendedTabConfig, FdDnDEvent, IconTabBarBackground, IconTabBarDndItem, IconTabBarDndList, IconTabBarItem, IconTabBarSize, ReactiveTabConfig, SemanticColor, TabColorAssociations, TabConfig, TabDensityMode, TabDestinyMode, TabType };
