@koobiq/components 20.4.2 → 21.0.0

package/types/koobiq-components-tabs.d.ts

@@ -0,0 +1,888 @@
+import * as _angular_core from '@angular/core';
+import { OnChanges, AfterContentChecked, AfterContentInit, AfterViewInit, OnDestroy, QueryList, ElementRef, EventEmitter, DestroyRef, ChangeDetectorRef, SimpleChanges, OnInit, TemplateRef, InjectionToken } from '@angular/core';
+import * as i2 from '@angular/cdk/a11y';
+import { FocusableOption } from '@angular/cdk/a11y';
+import { Direction } from '@angular/cdk/bidi';
+import { KbqScrollbarViewport, KbqScrollbarMode } from '@koobiq/components/scrollbar';
+import * as i1$1 from '@angular/cdk/portal';
+import { CdkPortalOutlet, TemplatePortal, CdkPortal } from '@angular/cdk/portal';
+import { Subject } from 'rxjs';
+import * as i1 from '@koobiq/components/core';
+import * as i3 from '@angular/cdk/scrolling';
+import * as i4 from '@koobiq/components/icon';
+import * as i5 from '@koobiq/components/tooltip';
+import * as i6 from '@angular/cdk/observers';
+
+/**
+ * The directions that scrolling can go in when the header's tabs exceed the header width. 'After'
+ * will scroll the header towards the end of the tabs list and 'before' will scroll towards the
+ * beginning of the list.
+ */
+type ScrollDirection = 'after' | 'before';
+/** Item inside a paginated tab header. */
+type KbqPaginatedTabHeaderItem = FocusableOption & {
+    elementRef: ElementRef;
+};
+/**
+ * Base class for a tab header that supported pagination.
+ *
+ * @docs-private
+ */
+declare abstract class KbqPaginatedTabHeader implements OnChanges, AfterContentChecked, AfterContentInit, AfterViewInit, OnDestroy {
+    /** @docs-private */
+    readonly selectedIndexInput: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /** @docs-private */
+    readonly disablePaginationInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly verticalInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** The index of the active tab. */
+    get selectedIndex(): number;
+    set selectedIndex(value: number);
+    private readonly selectedIndexState;
+    /** Tracks which element has focus; used for keyboard navigation */
+    get focusIndex(): number;
+    /** When the focus index is set, we must manually send focus to the correct label */
+    set focusIndex(value: number);
+    abstract get items(): QueryList<KbqPaginatedTabHeaderItem>;
+    abstract get tabListContainer(): ElementRef<HTMLElement>;
+    /** The strip's scroll viewport — the same element as {@link tabListContainer}. */
+    protected abstract get scrollbarViewport(): KbqScrollbarViewport;
+    abstract get tabList(): ElementRef<HTMLElement>;
+    abstract get nextPaginator(): ElementRef<HTMLElement>;
+    abstract get previousPaginator(): ElementRef<HTMLElement>;
+    /** Event emitted when the option is selected. */
+    readonly selectFocusedIndex: EventEmitter<number>;
+    /** Event emitted when a label is focused. */
+    readonly indexFocused: EventEmitter<number>;
+    /** Whether the controls for pagination should be displayed */
+    showPaginationControls: boolean;
+    /** Whether the tab list can be scrolled more towards the end of the tab label list. */
+    disableScrollAfter: boolean;
+    /** Whether the tab list can be scrolled more towards the beginning of the tab label list. */
+    disableScrollBefore: boolean;
+    /**
+     * Whether pagination should be disabled. This can be used to avoid unnecessary
+     * layout recalculations if it's known that pagination won't be required.
+     *
+     * A vertical header never paginates, so `vertical` forces this on without overwriting the value
+     * the consumer set — turning `vertical` back off restores it.
+     */
+    get disablePagination(): boolean;
+    set disablePagination(value: boolean);
+    private _disablePagination;
+    /** Whether the tabs should be displayed vertically. */
+    set vertical(value: boolean);
+    get vertical(): boolean;
+    private _vertical;
+    /** `disablePagination` as of the last content check — see `ngAfterContentChecked`. */
+    private previousDisablePagination;
+    /**
+     * The number of tab labels that are displayed on the header. When this changes, the header
+     * should re-evaluate the scroll position.
+     */
+    private tabLabelCount;
+    /** Used to manage focus between the tabs. */
+    private keyManager;
+    /** Cached text content of the header. */
+    private currentTextContent;
+    /** Stream that will stop the automated scrolling. */
+    private stopScrolling;
+    /** Whether the header should scroll to the selected index after the view has been checked. */
+    private selectedIndexChanged;
+    /** Whether DOM focus currently sits on one of the items. */
+    private focusWasInside;
+    /**
+     * Index of the item that last took DOM focus, or `-1`. Recorded from the `focusin` target rather
+     * than read back from `keyManager.activeItemIndex`, because the `selectedIndex` setter writes that
+     * field too — and on an `items.changes` tick a subscriber registered earlier (`KbqTabNavBar`'s
+     * `updateActiveLink`) repoints it at the *active* item before focus restoration gets to run.
+     */
+    private focusedItemIndex;
+    /** State of the in-progress mouse/pen drag gesture, if any. */
+    private dragState;
+    /** `requestAnimationFrame` handle for an in-progress inertia coast, if any. */
+    private inertiaFrameId;
+    /** Set after a drag gesture so the click it would otherwise trigger on a tab is suppressed. */
+    private suppressNextClick;
+    /** Handle of the timer that clears {@link suppressNextClick}, so it can be cancelled on destroy. */
+    private suppressClickTimeoutId;
+    private readonly documentPointerMoveListener;
+    private readonly documentPointerUpListener;
+    private readonly documentPointerCancelListener;
+    /** Emits on every native `scroll` event and drag/inertia frame; throttled to limit change detection. */
+    private readonly scrollProgress;
+    /**
+     * Emits scroll-correction requests (from focus or selection changes); debounced so a burst
+     * settles once. `ReplaySubject(1)`, not `Subject`: content hooks (where the very first request,
+     * from `ngAfterContentChecked`, is sent) run before view hooks in the same initial change-
+     * detection pass, so a plain `Subject` would drop it — the `ngAfterViewInit` subscription below
+     * doesn't exist yet when it's emitted.
+     */
+    private readonly scrollCorrectionRequest;
+    /**
+     * The latest scroll-correction request, repeated once webfonts finish loading: a label measured in the
+     * fallback face moves when the real one swaps in. Dropped once a correction has measured with no font
+     * loading, and as soon as the user moves the strip, so the repeat never pulls it back from where they took it.
+     */
+    private lastScrollCorrection;
+    protected readonly destroyRef: DestroyRef;
+    readonly elementRef: ElementRef<HTMLElement>;
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    private readonly ngZone;
+    private readonly platform;
+    private readonly dir;
+    private readonly window;
+    private readonly sharedResizeObserver;
+    private readonly document;
+    private readonly scrollbarOptions;
+    private readonly injector;
+    /** Whether the underline of the active tab moves without motion. */
+    protected readonly animationsDisabled: boolean;
+    /**
+     * Scrollbar mode for the tab strip. Only a vertical header scrolls in a direction the user is meant
+     * to see, so a horizontal one asks for `hidden`: the native scrollbar stays suppressed and no custom
+     * track is built for a strip that is paginated and dragged instead of scrolled by hand.
+     *
+     * Follows `vertical` itself: the `kbq-tab-group_vertical` class the stylesheet keys `overflow-y: auto`
+     * on is bound to the same value. The class of a nav bar is its own host binding, applied only after
+     * its content hooks, so reading the class from here would miss it on the first check.
+     */
+    protected get scrollbarMode(): KbqScrollbarMode;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Called when the user has selected an item via the keyboard. */
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
+    ngOnDestroy(): void;
+    handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Callback for when the MutationObserver detects that the content has changed.
+     */
+    onContentChanges(): void;
+    /**
+     * Updates the view whether pagination should be enabled or not.
+     *
+     * WARNING: Calling this method can be very costly in terms of performance. It should be called
+     * as infrequently as possible from outside of the Tabs component as it causes a reflow of the
+     * page.
+     */
+    updatePagination(): void;
+    /**
+     * Determines if an index is valid.  If the tabs are not ready yet, we assume that the user is
+     * providing a valid index and return true.
+     */
+    isValidIndex(index: number): boolean;
+    /**
+     * Sets focus on the HTML element for the label wrapper and scrolls it into the view if
+     * scrolling is enabled.
+     */
+    setTabFocus(tabIndex: number): void;
+    /** The layout direction of the containing app. */
+    getLayoutDirection(): Direction;
+    /**
+     * Moves the tab list in the 'before' or 'after' direction (towards the beginning of the list or
+     * the end of the list, respectively).
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    scrollHeader(direction: ScrollDirection): void;
+    /** Handles click events on the pagination arrows. */
+    handlePaginatorClick(direction: ScrollDirection): void;
+    /**
+     * Evaluate whether the pagination controls should be displayed. If the scroll width of the
+     * tab list is wider than the size of the header container, then the pagination controls should
+     * be shown.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    checkPaginationEnabled(): void;
+    /** Stops the currently-running paginator interval.  */
+    stopInterval(): void;
+    /**
+     * Handles the user pressing down on one of the paginators.
+     * Starts scrolling the header after a certain amount of time.
+     *
+     * @param direction In which direction the paginator should be scrolled.
+     */
+    handlePaginatorPress(direction: ScrollDirection, mouseEvent?: MouseEvent): void;
+    protected abstract itemSelected(event: KeyboardEvent): void;
+    /** Index of the item owning `target`, or `-1` — `target` is the item itself or something inside it. */
+    private indexOfItemContaining;
+    /**
+     * Moves focus onto the neighbouring item when the one that held it was removed. Without this the
+     * destroyed element takes focus down to `<body>` and a keyboard user has to tab in from the top of
+     * the document again (WCAG 2.4.3).
+     */
+    private restoreFocusAfterItemsChange;
+    /**
+     * The tab list's scroll position expressed independently of reading direction: `0` at the
+     * start of the tab list, growing towards the end — mirrors native `scrollLeft`'s RTL-dependent
+     * sign so callers can reason about "before"/"after" without checking direction themselves.
+     */
+    private get logicalScrollPosition();
+    /**
+     * Scrolls the header to a given logical position (see {@link logicalScrollPosition}).
+     *
+     * @param value Logical position to scroll to.
+     * @param behavior Scroll animation behavior; `'auto'` jumps instantly, `'smooth'` animates.
+     */
+    private scroll;
+    /** Queues a {@link scrollCorrection} behind the debounce, and keeps it to repeat once webfonts load. */
+    private requestScrollCorrection;
+    /**
+     * Moves the tab list such that the desired tab label (marked by index) is moved into view.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    private scrollCorrection;
+    /**
+     * Recomputes the pagination arrow-enabled state from the container's real scroll metrics.
+     * Bound to the native `scroll` event — this is the sole source of truth, no imperative call
+     * is needed after drag/inertia/arrow-click scroll writes.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    private updateScrollState;
+    private handlePointerDown;
+    private handlePointerMove;
+    private cancelDrag;
+    private endDrag;
+    private finishDrag;
+    private attachDocumentDragListeners;
+    private detachDocumentDragListeners;
+    private startInertia;
+    private cancelInertia;
+    private clampVelocity;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPaginatedTabHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqPaginatedTabHeader, never, never, { "selectedIndexInput": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "disablePaginationInput": { "alias": "disablePagination"; "required": false; "isSignal": true; }; "verticalInput": { "alias": "vertical"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * These position states are used internally as the translation states of the tab body. Setting the
+ * position state to left, right, or center will transition the tab body from its current
+ * position to its respective state. If there is not current position (void, in the case of a new
+ * tab body), then there will be no transition to its state.
+ *
+ * In the case of a new tab body that should immediately be centered with an animating transition,
+ * then left-origin-center or right-origin-center can be used, which will use left or right as its
+ * pseudo-prior state.
+ */
+type KbqTabBodyPositionState = 'left' | 'center' | 'right' | 'left-origin-center' | 'right-origin-center';
+/**
+ * Wrapper for the contents of a tab.
+ *
+ * @docs-private
+ */
+declare class KbqTabBody implements OnChanges, OnInit, OnDestroy {
+    private readonly elementRef;
+    private readonly dir;
+    private readonly destroyRef;
+    private readonly injector;
+    /** Whether the tab body translates without motion. */
+    protected readonly animationsDisabled: boolean;
+    /** @docs-private */
+    readonly positionInput: _angular_core.InputSignal<number | undefined>;
+    /** @docs-private */
+    readonly originInput: _angular_core.InputSignal<number | undefined>;
+    /** The shifted index position of the tab body, where zero represents the active center tab. */
+    set position(position: number);
+    /** Tab body position state, rendered as a modifier class of the content. */
+    bodyPosition: KbqTabBodyPositionState;
+    /** Event emitted when the tab begins to animate towards the center as the active tab. */
+    readonly onCentering: _angular_core.OutputEmitterRef<number>;
+    /** Event emitted before the centering of the tab begins. */
+    readonly beforeCentering: EventEmitter<boolean>;
+    /** @docs-private */
+    readonly beforeCenteringOutput: _angular_core.OutputRef<boolean>;
+    /** Event emitted once the tab has finished moving away from the center. Carries no payload. */
+    readonly afterLeavingCenter: EventEmitter<void>;
+    /** @docs-private */
+    readonly afterLeavingCenterOutput: _angular_core.OutputRef<void>;
+    /** Event emitted when the tab completes its animation towards the center. */
+    readonly onCentered: _angular_core.OutputEmitterRef<void>;
+    /** The portal host inside of this container into which the tab body content will be loaded. */
+    readonly portalHost: _angular_core.Signal<CdkPortalOutlet>;
+    /** The tab body content to display. */
+    readonly content: _angular_core.InputSignal<TemplatePortal<any>>;
+    /** Position that will be used when the tab is immediately becoming visible after creation. */
+    origin: number;
+    /** Duration for the tab's animation. */
+    readonly animationDuration: _angular_core.InputSignal<string>;
+    /** The duration as CSS time: a bare number, which CSS rejects, is taken as milliseconds. */
+    protected readonly cssAnimationDuration: _angular_core.Signal<string>;
+    /** Current position of the tab-body in the tab-group. Zero means that the tab is visible. */
+    private positionIndex;
+    /** Subscription to the directionality change observable. */
+    private readonly dirChangeSubscription;
+    private readonly contentElement;
+    /** The position the last translation went to, see `translateOnRender`. */
+    private renderedPosition?;
+    /** The position the body is created at, see `translateOnRender`. */
+    private initialPosition?;
+    private translationRender?;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * After initialized, check if the content is centered and has an origin. If so, set the
+     * special position states that transition the tab from the left or right before centering.
+     */
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** The text direction of the containing app. */
+    getLayoutDirection(): Direction;
+    /** Whether the provided position state is considered center, regardless of origin. */
+    isCenterPosition(position: KbqTabBodyPositionState | string): boolean;
+    /** Computes the position state that the tab body translates to. */
+    private computePositionAnimationState;
+    /**
+     * Starts the translation to the current position once it has rendered, and ends it once its transition
+     * has: the content is attached as the body starts centering and detached once it has left the center.
+     * Positions set within one frame translate once, from the last rendered one. The first frame starts from the
+     * position the body was created at when it has moved on from it: the content of a body created centered is
+     * attached at once, rendered or not.
+     */
+    private translateOnRender;
+    private translationStarted;
+    private translationDone;
+    /**
+     * Computes the position state based on the specified origin position. This is used if the
+     * tab is becoming visible immediately after creation.
+     */
+    private computePositionFromOrigin;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabBody, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTabBody, "kbq-tab-body", never, { "positionInput": { "alias": "position"; "required": false; "isSignal": true; }; "originInput": { "alias": "origin"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; }, { "onCentering": "onCentering"; "beforeCenteringOutput": "beforeCentering"; "afterLeavingCenterOutput": "afterLeavingCenter"; "onCentered": "onCentered"; }, never, never, true, never>;
+}
+/**
+ * The portal host directive for the contents of the tab.
+ *
+ * @docs-private
+ */
+declare class KbqTabBodyPortal extends CdkPortalOutlet implements OnInit, OnDestroy {
+    private readonly host;
+    /** Subscription to events for when the tab body begins centering. */
+    private centeringSub;
+    /** Subscription to events for when the tab body finishes leaving from center position. */
+    private leavingSub;
+    /** Set initial visibility or set up subscription for changing visibility. */
+    ngOnInit(): void;
+    /** Clean up centering subscription. */
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabBodyPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTabBodyPortal, "[kbqTabBodyHost]", never, {}, {}, never, never, true, never>;
+}
+
+/** Decorates the `ng-template` tags and reads out the template from it. */
+declare class KbqTabContent {
+    template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTabContent, "[kbqTabContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare const KBQ_TAB_LABEL: InjectionToken<KbqTabLabel>;
+/** Used to flag tab labels for use with the portal directive */
+declare class KbqTabLabel extends CdkPortal {
+    /** Whether the tab contains only an icon without a label. */
+    readonly iconOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTabLabel, "[kbq-tab-label], [kbqTabLabel]", never, { "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqTab implements OnInit, OnChanges, OnDestroy {
+    private readonly viewContainerRef;
+    /** @docs-private */
+    get content(): TemplatePortal | null;
+    private readonly templateLabelQuery;
+    /** The label template of the tab: the `kbqTabLabel` in its content, or else the one assigned in code. */
+    get templateLabel(): KbqTabLabel;
+    set templateLabel(value: KbqTabLabel);
+    private _templateLabel;
+    /**
+     * Template provided in the tab content that will be used if present, used to enable lazy-loading
+     */
+    readonly explicitContent: _angular_core.Signal<TemplateRef<any> | undefined>;
+    /** Template inside the KbqTab view that contains an `<ng-content>`. */
+    readonly implicitContent: _angular_core.Signal<TemplateRef<any>>;
+    /** @docs-private */
+    readonly tooltipTitleInput: _angular_core.InputSignal<string | undefined>;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    get tooltipTitle(): string;
+    set tooltipTitle(value: string);
+    private _tooltipTitle;
+    /** Whether the tab is disabled: it cannot be selected and has no interactive states. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Placement of the tooltip shown for a truncated or empty label. */
+    readonly tooltipPlacement: _angular_core.InputSignal<"left" | "right" | "top" | "topLeft" | "topRight" | "rightTop" | "rightBottom" | "leftTop" | "leftBottom" | "bottom" | "bottomLeft" | "bottomRight">;
+    /** Plain text label for the tab, used when there is no template label. */
+    readonly textLabel: _angular_core.InputSignal<string>;
+    readonly empty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly tabId: _angular_core.InputSignal<string>;
+    /** Whether the tab label contains only an icon (no text). */
+    get iconOnlyLabel(): boolean;
+    /** Emits whenever the internal state of the tab changes. */
+    readonly stateChanges: Subject<void>;
+    /**
+     * The relatively indexed position where 0 represents the center, negative is left, and positive
+     * represents the right.
+     */
+    position: number | null;
+    /**
+     * The initial relatively index origin of the tab if it was created and selected after there
+     * was already a selected tab. Provides context of what position the tab should originate from.
+     */
+    origin: number | null;
+    /** Whether the tab is currently active. A template that reads it is updated when it changes. */
+    get isActive(): boolean;
+    set isActive(value: boolean);
+    private readonly activeState;
+    get isOverflown(): boolean;
+    get overflowTooltipTitle(): string;
+    set overflowTooltipTitle(value: string);
+    private _overflowTooltipTitle;
+    /** Portal that will be the hosted content of the tab */
+    private contentPortal;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Keeps a label template assigned in code, used while the content of the tab has none. A falsy value is
+     * ignored.
+     *
+     * @docs-private
+     */
+    protected setTemplateLabelInput(value: KbqTabLabel): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTab, "kbq-tab", ["kbqTab"], { "tooltipTitleInput": { "alias": "tooltipTitle"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; "isSignal": true; }; "textLabel": { "alias": "label"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "tabId": { "alias": "tabId"; "required": false; "isSignal": true; }; }, {}, ["templateLabelQuery", "explicitContent"], ["*"], true, never>;
+}
+
+/**
+ * Used in the `kbq-tab-group` view to display tab labels.
+ *
+ * @docs-private
+ */
+declare class KbqTabLabelWrapper implements OnChanges, AfterViewInit {
+    elementRef: ElementRef<HTMLElement>;
+    private renderer;
+    private readonly labelContentQuery;
+    /** The element of the label content, measured to tell whether the label overflows. */
+    get labelContent(): ElementRef<HTMLElement>;
+    /** @docs-private */
+    readonly tabInput: _angular_core.InputSignal<KbqTab | undefined>;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    tab: KbqTab;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    /**
+     * Sets focus on the wrapper element.
+     *
+     * `preventScroll: true`: `FocusKeyManager.setActiveItem` calls this itself, right after (and
+     * unconditionally on) the `change` emission that runs `KbqPaginatedTabHeader.setTabFocus` — so
+     * without the guard here too, that call's own `preventScroll: true` is immediately undone by
+     * this one, and an overflowing header double-jumps (native scroll-into-view, then the
+     * paginator-aware `scrollCorrection`) on every arrow-key press.
+     */
+    focus(): void;
+    getOffsetLeft(): number;
+    getOffsetWidth(): number;
+    checkOverflow(): void;
+    isOverflown(): boolean;
+    getInnerText(): string;
+    private addClassModifierForIcons;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabLabelWrapper, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTabLabelWrapper, "[kbqTabLabelWrapper]", never, { "tabInput": { "alias": "tab"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["labelContentQuery"], never, true, never>;
+}
+
+/**
+ * The header of the tab group which displays a list of all the tabs in the tab group.
+ * When the tabs list's width exceeds the width of the header container,
+ * then arrows will be displayed to allow the user to scroll
+ * left and right across the header.
+ *
+ * @docs-private
+ */
+declare class KbqTabHeader extends KbqPaginatedTabHeader {
+    /** Whether the tabs are underlined. */
+    readonly underlined: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly itemsQuery;
+    private readonly itemsList;
+    private readonly tabListContainerQuery;
+    private readonly scrollbarViewportQuery;
+    private readonly tabListQuery;
+    private readonly nextPaginatorQuery;
+    private readonly previousPaginatorQuery;
+    /** The label wrappers of the tabs. */
+    get items(): QueryList<KbqTabLabelWrapper>;
+    /** The scroll container of the tab labels. */
+    get tabListContainer(): ElementRef;
+    protected get scrollbarViewport(): KbqScrollbarViewport;
+    /** The element that holds the tab labels. */
+    get tabList(): ElementRef;
+    /** The pagination arrow towards the end of the tab list. */
+    get nextPaginator(): ElementRef<HTMLElement>;
+    /** The pagination arrow towards the beginning of the tab list. */
+    get previousPaginator(): ElementRef<HTMLElement>;
+    private readonly isBrowser;
+    /** The underline as the last check of the tab group measured it, see `ngAfterContentChecked`. */
+    private checkedUnderline?;
+    protected get activeTabOffsetWidth(): number | undefined;
+    protected get activeTabOffsetLeft(): number | undefined;
+    protected get activeTabDisabled(): boolean;
+    ngAfterContentChecked(): void;
+    protected itemSelected(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTabHeader, "kbq-tab-header", never, { "underlined": { "alias": "underlined"; "required": false; "isSignal": true; }; }, { "selectFocusedIndex": "selectFocusedIndex"; "indexFocused": "indexFocused"; }, ["itemsQuery"], ["*"], true, never>;
+}
+
+declare class KbqAlignTabsCenterCssStyler {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqAlignTabsCenterCssStyler, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqAlignTabsCenterCssStyler, "kbq-tab-group[kbq-align-tabs-center], [kbq-tab-nav-bar][kbq-align-tabs-center], [kbqTabNavBar][kbq-align-tabs-center]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqAlignTabsEndCssStyler {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqAlignTabsEndCssStyler, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqAlignTabsEndCssStyler, "kbq-tab-group[kbq-align-tabs-end], [kbq-tab-nav-bar][kbq-align-tabs-end], [kbqTabNavBar][kbq-align-tabs-end]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqStretchTabsCssStyler {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqStretchTabsCssStyler, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqStretchTabsCssStyler, "kbq-tab-group[kbq-stretch-tabs], [kbq-tab-nav-bar][kbq-stretch-tabs], [kbqTabNavBar][kbq-stretch-tabs]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * @deprecated No-op. The vertical layout class is bound from `KbqTabGroup`/`KbqTabNavBar` themselves,
+ *  so it follows the `vertical` value instead of merely the presence of the attribute. Will be removed
+ *  in a future major version — stop importing it.
+ */
+declare class KbqVerticalTabsCssStyler {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqVerticalTabsCssStyler, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqVerticalTabsCssStyler, "kbq-tab-group[vertical], [kbq-tab-nav-bar][vertical], [kbqTabNavBar][vertical]", never, {}, {}, never, never, true, never>;
+}
+/** A simple change event emitted on focus or selection changes. */
+declare class KbqTabChangeEvent {
+    /** Index of the currently-selected tab. */
+    index: number;
+    /** Reference to the currently-selected tab. */
+    tab: KbqTab;
+}
+/** Possible positions for the tab header. */
+type KbqTabHeaderPosition = 'above' | 'below';
+/** Object that can be used to configure the default options for the tabs module. */
+interface KbqTabsConfig {
+    /** Duration for the tab animation. Must be a valid CSS value (e.g. 600ms). */
+    animationDuration?: string;
+}
+/** Injection token that can be used to provide the default options the tabs module. */
+declare const KBQ_TABS_CONFIG: InjectionToken<KbqTabsConfig>;
+type KbqTabSelectBy = string | number | ((tabs: KbqTab[]) => KbqTab | null);
+/**
+ * The persisted state of a tab group — which tab was selected.
+ *
+ * Both are stored: `tabId` is the only identifier that survives a reordering, and `index` is all there is
+ * when the tabs carry no `tabId`.
+ */
+interface KbqTabsState {
+    tabId: string | null;
+    index: number;
+}
+/**
+ * Tab-group component.  Supports basic tab pairs (label + content) and includes keyboard navigation.
+ */
+declare class KbqTabGroup implements OnChanges, AfterContentInit, AfterViewInit, AfterContentChecked, OnDestroy {
+    private readonly changeDetectorRef;
+    private readonly destroyRef;
+    private readonly resizeObserver;
+    private readonly platform;
+    /**
+     * Persistence of the selected tab, applied as a host directive. `useStateSaving` and `stateSavingKey`
+     * are its inputs, forwarded onto the tab group.
+     */
+    private readonly stateSaving;
+    private readonly tabsQuery;
+    private readonly tabsList;
+    /** The tabs of the group. */
+    get tabs(): QueryList<KbqTab>;
+    readonly tabBodyWrapper: _angular_core.Signal<ElementRef<any>>;
+    readonly tabHeader: _angular_core.Signal<KbqTabHeader>;
+    /** Whether the tab strip background should be transparent. */
+    readonly transparent: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the group is rendered on a surface rather than on the page background. */
+    readonly onSurface: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the selected tab is marked with an underline instead of a filled background. */
+    readonly underlined: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the tab strip is laid out vertically, alongside the content instead of above it. */
+    readonly vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the tab group should grow to the size of the active tab. */
+    readonly dynamicHeight: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** @docs-private */
+    readonly selectedIndexInput: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /** @docs-private */
+    readonly activeTabInput: _angular_core.InputSignal<KbqTabSelectBy | null | undefined>;
+    /** @docs-private */
+    readonly headerPositionInput: _angular_core.InputSignal<KbqTabHeaderPosition | undefined>;
+    /** @docs-private */
+    readonly animationDurationInput: _angular_core.InputSignal<string | undefined>;
+    /** The index of the active tab. */
+    get selectedIndex(): number;
+    set selectedIndex(value: number);
+    private readonly selectedIndexState;
+    get activeTab(): KbqTab | null;
+    set activeTab(value: KbqTabSelectBy | null);
+    /** Position of the tab header. */
+    headerPosition: KbqTabHeaderPosition;
+    /** Duration for the tab animation. Must be a valid CSS value (e.g. 600ms). */
+    animationDuration: string;
+    /** Output to enable support for two-way binding on `[(selectedIndex)]` */
+    readonly selectedIndexChange: _angular_core.OutputEmitterRef<number>;
+    /** Event emitted when the tab selection has changed. */
+    readonly activeTabChange: _angular_core.OutputEmitterRef<string | number | KbqTab>;
+    /** Event emitted when focus has changed within a tab group. */
+    readonly focusChange: _angular_core.OutputEmitterRef<KbqTabChangeEvent>;
+    /** Event emitted when the body animation has completed */
+    readonly animationDone: _angular_core.OutputEmitterRef<void>;
+    /** Event emitted when the tab selection has changed. */
+    readonly selectedTabChange: _angular_core.OutputEmitterRef<KbqTabChangeEvent>;
+    private attributeToSelectBy;
+    /**
+     * Whether anything has assigned `activeTab` or `selectedIndex`. Snapshotted while initializing, where
+     * only an input binding can have done so, and read from then on as "the application drives the
+     * selection" — which suppresses persistence.
+     */
+    private attributeWritten;
+    private controlled;
+    /** Whether the dev-mode warning about a tab with no `tabId` has already been logged. */
+    private warnedAboutTabId;
+    /** Snapshot of the height of the tab body wrapper before another tab is activated. */
+    private tabBodyWrapperHeight;
+    /** Subscription to tabs being added/removed. */
+    private tabsSubscription;
+    /** Subscription to changes in the tab labels. */
+    private tabLabelSubscription;
+    private readonly groupId;
+    private readonly defaultAnimationDuration;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    /**
+     * After the content is checked, this component knows what tabs have been defined
+     * and what the selected index should be. This is where we can know exactly what position
+     * each tab should be in according to the new selected index, and additionally we know how
+     * a new selected tab should transition in (from the left or right).
+     */
+    ngAfterContentChecked(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focusChanged(index: number): void;
+    /** Returns a unique id for each tab label element */
+    getTabLabelId(i: number): string;
+    /** Returns a unique id for each tab content element */
+    getTabContentId(i: number): string;
+    /**
+     * Sets the height of the body wrapper to the height of the activating tab if dynamic
+     * height property is true.
+     */
+    setTabBodyWrapperHeight(tabHeight: number): void;
+    /** Removes the height of the tab body wrapper. */
+    removeTabBodyWrapperHeight(): void;
+    /** Handle click events, setting new selected index if appropriate. */
+    handleClick(tab: KbqTab, tabHeader: KbqTabHeader, index: number): void;
+    /**
+     * Retrieves the tabindex for the tab. The single `0` follows the header's focus position rather
+     * than the selection, so that a disabled selected tab cannot take the whole strip out of the tab
+     * order — a disabled tab is `-1`, never absent, so it stays a roving-tabindex participant.
+     */
+    getTabIndex(tab: KbqTab, tabHeader: KbqTabHeader, index: number): number;
+    onSelectFocusedIndex($event: number): void;
+    /**
+     * Persists which tab is selected.
+     *
+     * Called for every selection a user makes. Both the tab's `tabId` and its position are stored: the
+     * `tabId` is the only one that survives the tabs being reordered, and the position is all there is
+     * when the tabs carry none.
+     */
+    saveState(): void;
+    /**
+     * Removes the state persisted for this tab group.
+     *
+     * Persistence itself stays on — the next selection is written again. Unset `useStateSaving` to stop
+     * it.
+     */
+    clearSavedState(): void;
+    /**
+     * Whether state is currently persisted for this tab group — restored on init, or written since.
+     * Always `false` while `useStateSaving` is unset, and `false` again after `clearSavedState()`.
+     */
+    get hasSavedState(): boolean;
+    /** Whether this tab group reads and writes its selection at all. */
+    private get persists();
+    /** Restores the persisted selection, unless the application drives it. */
+    private restoreState;
+    /** Reads the persisted selection and applies it. Runs while initializing, and again on a key change. */
+    private applySavedState;
+    /** The whole selection, by id and by position. */
+    private snapshot;
+    private checkOverflow;
+    private createChangeEvent;
+    /**
+     * Subscribes to changes in the tab labels. This is needed, because the `@Input` for the label is
+     * on the KbqTab component, whereas the data binding is inside the KbqTabGroup. In order for the
+     * binding to be updated, we need to subscribe to changes in it and trigger change detection
+     * manually.
+     */
+    private subscribeToTabLabels;
+    /**
+     * Index that owns `tabindex="0"`, falling back to the first enabled tab when focus sits on a
+     * disabled one.
+     *
+     * The template calls this once per tab, so the common path stays allocation-free: `QueryList.get`
+     * indexes the backing array, where `toArray()` would copy it N times per check.
+     */
+    private getRovingTabIndex;
+    /** First tab that can actually be selected, so that a leading disabled tab is not the default. */
+    private getDefaultTab;
+    /** Clamps the given index to the bounds of 0 and the tabs length. */
+    private clampTabIndex;
+    private getTabIndexToSelect;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTabGroup, "kbq-tab-group", ["kbqTabGroup"], { "transparent": { "alias": "transparent"; "required": false; "isSignal": true; }; "onSurface": { "alias": "onSurface"; "required": false; "isSignal": true; }; "underlined": { "alias": "underlined"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "dynamicHeight": { "alias": "dynamicHeight"; "required": false; "isSignal": true; }; "selectedIndexInput": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "activeTabInput": { "alias": "activeTab"; "required": false; "isSignal": true; }; "headerPositionInput": { "alias": "headerPosition"; "required": false; "isSignal": true; }; "animationDurationInput": { "alias": "animationDuration"; "required": false; "isSignal": true; }; }, { "selectedIndexChange": "selectedIndexChange"; "activeTabChange": "activeTabChange"; "focusChange": "focusChange"; "animationDone": "animationDone"; "selectedTabChange": "selectedTabChange"; }, ["tabsQuery"], never, true, [{ directive: typeof i1.KbqStateSaving; inputs: { "useStateSaving": "useStateSaving"; "stateSavingKey": "stateSavingKey"; }; outputs: {}; }]>;
+}
+
+/**
+ * Navigation component matching the styles of the tab group header.
+ */
+declare class KbqTabNavBar extends KbqPaginatedTabHeader implements AfterContentInit {
+    private readonly tabListContainerQuery;
+    private readonly scrollbarViewportQuery;
+    private readonly tabListQuery;
+    private readonly nextPaginatorQuery;
+    private readonly previousPaginatorQuery;
+    private readonly itemsQuery;
+    private readonly itemsList;
+    /** The scroll container of the tab links. */
+    get tabListContainer(): ElementRef;
+    protected get scrollbarViewport(): KbqScrollbarViewport;
+    /** The element that holds the tab links. */
+    get tabList(): ElementRef;
+    /** The pagination arrow towards the end of the tab list. */
+    get nextPaginator(): ElementRef<HTMLElement>;
+    /** The pagination arrow towards the beginning of the tab list. */
+    get previousPaginator(): ElementRef<HTMLElement>;
+    /** The tab links of the nav bar. */
+    get items(): QueryList<KbqTabLink>;
+    private readonly isBrowser;
+    /** Whether the nav bar background should be transparent. */
+    readonly transparent: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly onSurface: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the nav bar should be underlined. */
+    readonly underlined: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Associated tab panel controlled by the nav bar.
+     */
+    readonly tabNavPanel: _angular_core.InputSignal<KbqTabNavPanel | undefined>;
+    get role(): string | null;
+    /**
+     * Vertical tablists are walked with ↑/↓ — ←/→ do nothing — so the orientation has to be announced.
+     * `aria-orientation` is only meaningful on a role that supports it, hence nothing without a panel.
+     */
+    protected get ariaOrientation(): string | null;
+    protected get activeTabOffsetWidth(): number | undefined;
+    protected get activeTabOffsetLeft(): number | undefined;
+    protected get activeTabDisabled(): boolean;
+    /** `activeTabDisabled` as this view last rendered it: a link's `disabled` input gives this view no notice. */
+    private checkedActiveTabDisabled;
+    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
+    protected itemSelected(): void;
+    /** Notifies the component that the active link has been changed. */
+    updateActiveLink(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabNavBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTabNavBar, "[kbqTabNavBar], [kbq-tab-nav-bar]", ["kbqTabNavBar"], { "transparent": { "alias": "transparent"; "required": false; "isSignal": true; }; "onSurface": { "alias": "onSurface"; "required": false; "isSignal": true; }; "underlined": { "alias": "underlined"; "required": false; "isSignal": true; }; "tabNavPanel": { "alias": "tabNavPanel"; "required": false; "isSignal": true; }; }, {}, ["itemsQuery"], ["*"], true, never>;
+}
+/**
+ * Link inside of a KbqTabNavBar.
+ */
+declare class KbqTabLink implements OnChanges, OnDestroy, AfterViewInit {
+    /** @docs-private */
+    readonly idInput: _angular_core.InputSignal<string | undefined>;
+    /** @docs-private */
+    readonly activeInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly tabIndexInput: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    private readonly uniqueId;
+    /** Unique id for the link. */
+    id: string;
+    /** Whether the link is active. */
+    get active(): boolean;
+    set active(value: boolean);
+    /** Whether the tab link is active or not. */
+    private _active;
+    get vertical(): boolean;
+    get underlined(): boolean;
+    /** Whether the tab link is disabled. */
+    disabled: boolean;
+    /** Link tab index. */
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    private _tabIndex;
+    /** Link aria-selected attribute value. */
+    protected get ariaSelected(): string | null;
+    /** Link role attribute value. */
+    protected get role(): string | null;
+    /** Link aria-controls attribute value. */
+    protected get ariaControls(): string | null;
+    /** Link aria-current attribute value. */
+    protected get ariaCurrent(): string | null;
+    readonly elementRef: ElementRef<HTMLElement>;
+    private readonly focusMonitor;
+    private readonly renderer;
+    private readonly tabNavBar;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private addClassModifierForIcons;
+    /**
+     * Focuses the tab link.
+     *
+     * `preventScroll: true`: `FocusKeyManager.setActiveItem` calls this itself, right after (and
+     * unconditionally on) the `change` emission that runs `KbqPaginatedTabHeader.setTabFocus` — so
+     * without the guard here too, that call's own `preventScroll: true` is immediately undone by
+     * this one, and an overflowing nav bar double-jumps (native scroll-into-view, then the
+     * paginator-aware `scrollCorrection`) on every arrow-key press.
+     */
+    focus(): void;
+    /** Handles the focus event. */
+    protected handleFocus(): void;
+    /** Handles the keydown event. */
+    protected handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabLink, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTabLink, "[kbqTabLink], [kbq-tab-link]", ["kbqTabLink"], { "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "activeInput": { "alias": "active"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "tabIndexInput": { "alias": "tabIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Tab panel component associated with KbqTabNav.
+ */
+declare class KbqTabNavPanel {
+    /** Unique id for the tab panel. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Id of the active tab in the nav bar. */
+    activeTabId?: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabNavPanel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTabNavPanel, "[kbqTabNavPanel]", ["kbqTabNavPanel"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqTabsModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTabsModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqTabsModule, never, [typeof i1$1.PortalModule, typeof i2.A11yModule, typeof i3.CdkScrollableModule, typeof i4.KbqIconModule, typeof i5.KbqToolTipModule, typeof i6.CdkObserveContent, typeof KbqTabNavBar, typeof KbqTabLink, typeof KbqTabNavPanel, typeof KbqTabGroup, typeof KbqTabLabel, typeof KbqTab, typeof KbqTabLabelWrapper, typeof KbqTabBody, typeof KbqTabBodyPortal, typeof KbqTabHeader, typeof KbqTabContent, typeof KbqAlignTabsCenterCssStyler, typeof KbqAlignTabsEndCssStyler, typeof KbqStretchTabsCssStyler, typeof KbqVerticalTabsCssStyler], [typeof KbqTabGroup, typeof KbqTabLabel, typeof KbqTab, typeof KbqTabLabelWrapper, typeof KbqTabBody, typeof KbqTabBodyPortal, typeof KbqTabHeader, typeof KbqTabContent, typeof KbqAlignTabsCenterCssStyler, typeof KbqAlignTabsEndCssStyler, typeof KbqStretchTabsCssStyler, typeof KbqVerticalTabsCssStyler, typeof KbqTabNavBar, typeof KbqTabLink, typeof KbqTabNavPanel]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqTabsModule>;
+}
+
+export { KBQ_TABS_CONFIG, KBQ_TAB_LABEL, KbqAlignTabsCenterCssStyler, KbqAlignTabsEndCssStyler, KbqPaginatedTabHeader, KbqStretchTabsCssStyler, KbqTab, KbqTabBody, KbqTabBodyPortal, KbqTabChangeEvent, KbqTabContent, KbqTabGroup, KbqTabHeader, KbqTabLabel, KbqTabLabelWrapper, KbqTabLink, KbqTabNavBar, KbqTabNavPanel, KbqTabsModule, KbqVerticalTabsCssStyler };
+export type { KbqPaginatedTabHeaderItem, KbqTabBodyPositionState, KbqTabHeaderPosition, KbqTabSelectBy, KbqTabsConfig, KbqTabsState, ScrollDirection };