@alauda/ui 9.1.1-beta.3 → 9.1.1-beta.4

package/table/table.component.d.ts

@@ -0,0 +1,20 @@
+import { CdkTable } from '@angular/cdk/table';
+import { AfterContentInit, ElementRef, OnDestroy } from '@angular/core';
+import { TablePlaceholderDefDirective, TablePlaceholderOutletDirective } from './table-placeholder.directive';
+import * as i0 from "@angular/core";
+export declare const tableBem: import("../internal/utils").Bem;
+export declare class TableComponent<T> extends CdkTable<T> implements AfterContentInit, OnDestroy {
+    enableScrollWrapper: boolean;
+    _placeholderOutlet: TablePlaceholderOutletDirective;
+    _placeholderDef: TablePlaceholderDefDirective;
+    className: string;
+    elementRef: ElementRef<any>;
+    protected get stickyCssClass(): string;
+    protected set stickyCssClass(_: string);
+    ngAfterContentInit(): void;
+    private _createPlaceholder;
+    private _clearPlaceholder;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "aui-table", ["auiTable"], { "enableScrollWrapper": { "alias": "enableScrollWrapper"; "required": false; }; }, {}, ["_placeholderDef"], ["caption", "colgroup, col", "*"], true, never>;
+}

package/table/table.module.d.ts

@@ -0,0 +1,35 @@
+import { TableCellDefDirective } from './table-cell-def.directive';
+import { TableExpandButtonCellComponent, TableExpandPanelCellComponent } from './table-cell.component';
+import { TableCellDirective } from './table-cell.directive';
+import { TableColumnDefDirective } from './table-column-def.directive';
+import { TableColumnResizableDirective } from './table-column-resizable.directive';
+import { TableHeaderCellDefDirective } from './table-header-cell-def.directive';
+import { TableHeaderCellDirective } from './table-header-cell.directive';
+import { TableHeaderRowDefDirective } from './table-header-row-def.directive';
+import { TableHeaderRowComponent } from './table-header-row.component';
+import { TablePlaceholderDefDirective, TablePlaceholderOutletDirective } from './table-placeholder.directive';
+import { TableRowDefDirective } from './table-row-def.directive';
+import { TableRowComponent } from './table-row.component';
+import { TableScrollableDirective, TableScrollWrapperDirective } from './table-scroll.directive';
+import { TableComponent } from './table.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./table.component";
+import * as i2 from "./table-row.component";
+import * as i3 from "./table-header-row.component";
+import * as i4 from "./table-cell.component";
+import * as i5 from "./table-cell.directive";
+import * as i6 from "./table-cell-def.directive";
+import * as i7 from "./table-header-cell.directive";
+import * as i8 from "./table-row-def.directive";
+import * as i9 from "./table-header-row-def.directive";
+import * as i10 from "./table-header-cell-def.directive";
+import * as i11 from "./table-column-def.directive";
+import * as i12 from "./table-column-resizable.directive";
+import * as i13 from "./table-placeholder.directive";
+import * as i14 from "./table-scroll.directive";
+export declare const TABLE_MODULE: readonly [typeof TableComponent, typeof TableRowComponent, typeof TableHeaderRowComponent, typeof TableExpandButtonCellComponent, typeof TableExpandPanelCellComponent, typeof TableCellDirective, typeof TableCellDefDirective, typeof TableHeaderCellDirective, typeof TableRowDefDirective, typeof TableHeaderRowDefDirective, typeof TableHeaderCellDefDirective, typeof TableColumnDefDirective, typeof TableColumnResizableDirective, typeof TablePlaceholderOutletDirective, typeof TablePlaceholderDefDirective, typeof TableScrollWrapperDirective, typeof TableScrollableDirective];
+export declare class TableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, never, [typeof i1.TableComponent, typeof i2.TableRowComponent, typeof i3.TableHeaderRowComponent, typeof i4.TableExpandButtonCellComponent, typeof i4.TableExpandPanelCellComponent, typeof i5.TableCellDirective, typeof i6.TableCellDefDirective, typeof i7.TableHeaderCellDirective, typeof i8.TableRowDefDirective, typeof i9.TableHeaderRowDefDirective, typeof i10.TableHeaderCellDefDirective, typeof i11.TableColumnDefDirective, typeof i12.TableColumnResizableDirective, typeof i13.TablePlaceholderOutletDirective, typeof i13.TablePlaceholderDefDirective, typeof i14.TableScrollWrapperDirective, typeof i14.TableScrollableDirective], [typeof i1.TableComponent, typeof i2.TableRowComponent, typeof i3.TableHeaderRowComponent, typeof i4.TableExpandButtonCellComponent, typeof i4.TableExpandPanelCellComponent, typeof i5.TableCellDirective, typeof i6.TableCellDefDirective, typeof i7.TableHeaderCellDirective, typeof i8.TableRowDefDirective, typeof i9.TableHeaderRowDefDirective, typeof i10.TableHeaderCellDefDirective, typeof i11.TableColumnDefDirective, typeof i12.TableColumnResizableDirective, typeof i13.TablePlaceholderOutletDirective, typeof i13.TablePlaceholderDefDirective, typeof i14.TableScrollWrapperDirective, typeof i14.TableScrollableDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
+}

package/table-of-contents/index.d.ts

@@ -0,0 +1,4 @@
+export * from './table-of-contents.module';
+export * from './toc-container.directive';
+export * from './toc-content.directive';
+export * from './toc-link.directive';

package/table-of-contents/table-of-contents.module.d.ts

@@ -0,0 +1,14 @@
+import { TocContainerDirective } from './toc-container.directive';
+import { TocContentDirective } from './toc-content.directive';
+import { TocLinkDirective } from './toc-link.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./toc-content.directive";
+import * as i3 from "./toc-container.directive";
+import * as i4 from "./toc-link.directive";
+export declare class TableOfContentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableOfContentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableOfContentsModule, never, [typeof i1.CommonModule, typeof i2.TocContentDirective, typeof i3.TocContainerDirective, typeof i4.TocLinkDirective], [typeof i2.TocContentDirective, typeof i3.TocContainerDirective, typeof i4.TocLinkDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableOfContentsModule>;
+}
+export declare const TABLE_OF_CONTENTS_MODULE: readonly [typeof TocContentDirective, typeof TocContainerDirective, typeof TocLinkDirective];

package/table-of-contents/toc-container.directive.d.ts

@@ -0,0 +1,28 @@
+import { AfterContentInit, ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { TocContentDirective } from './toc-content.directive';
+import * as i0 from "@angular/core";
+export declare class TocContainerDirective implements AfterContentInit, OnDestroy {
+    private readonly cdr;
+    activedChange: EventEmitter<string>;
+    private _contents;
+    private readonly _scrollTop$;
+    private readonly _scrollTo$;
+    private readonly _onDestroy$;
+    private readonly _subs;
+    private readonly _nativeElement;
+    get scrollTop(): number;
+    set scrollTop(value: number);
+    get isScrollEnd(): boolean;
+    constructor(elementRef: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
+    getOffsetTop(element: HTMLElement): number;
+    private getMinContent;
+    private getMaxContent;
+    onScroll(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    scrollTo(content: string[] | string): void;
+    registerContent(tocContent: TocContentDirective): void;
+    deregisterContent(tocContent: TocContentDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TocContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TocContainerDirective, "[auiTocContainer]", ["auiTocContainer"], {}, { "activedChange": "activedChange"; }, never, never, true, never>;
+}

package/table-of-contents/toc-content.directive.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { TocContainerDirective } from './toc-container.directive';
+import * as i0 from "@angular/core";
+export declare class TocContentDirective implements OnInit, OnDestroy {
+    private readonly containerDirective;
+    active: boolean;
+    auiTocContent: string;
+    nativeElement: HTMLElement;
+    constructor(elemRef: ElementRef<HTMLElement>, containerDirective: TocContainerDirective);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TocContentDirective, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TocContentDirective, "[auiTocContent]", never, { "auiTocContent": { "alias": "auiTocContent"; "required": false; }; }, {}, never, never, true, never>;
+}

package/table-of-contents/toc-link.directive.d.ts

@@ -0,0 +1,16 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { TocContainerDirective } from './toc-container.directive';
+import * as i0 from "@angular/core";
+export declare class TocLinkDirective implements OnInit, OnDestroy {
+    private readonly cdr;
+    active: boolean;
+    for: TocContainerDirective;
+    auiTocLink: string[] | string;
+    private readonly _subs;
+    onClick(): void;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TocLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TocLinkDirective, "[auiTocLink]", never, { "for": { "alias": "for"; "required": false; }; "auiTocLink": { "alias": "auiTocLink"; "required": false; }; }, {}, never, never, true, never>;
+}

package/tabs/index.d.ts

@@ -0,0 +1,8 @@
+export * from './tab.component';
+export * from './tab-body.component';
+export * from './tab-context.service';
+export * from './tab-group.component';
+export * from './tab-header.component';
+export * from './tab-header-active-indicator.component';
+export * from './tabs.module';
+export * from './tabs.types';

package/tabs/tab-body.component.d.ts

@@ -0,0 +1,71 @@
+import { CdkPortal, CdkPortalOutlet, TemplatePortal } from '@angular/cdk/portal';
+import { ComponentFactoryResolver, ElementRef, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class TabBodyComponent implements OnDestroy {
+    private _content;
+    content$: BehaviorSubject<TemplatePortal<any>>;
+    /** The portal host inside of this container into which the tab body content will be loaded. */
+    _portalOutlet: CdkPortalOutlet;
+    /** The tab body content to display. */
+    get content(): TemplatePortal;
+    set content(content: TemplatePortal);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabBodyComponent, "aui-tab-body", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
+}
+/** Used to flag tab labels for use with the portal directive */
+export declare class TabLabelDirective extends CdkPortal {
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabLabelDirective, "[auiTabLabel]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Lazy load the embedded template for a tab content.
+ */
+export declare class TabContentDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabContentDirective, "[auiTabContent]", never, {}, {}, never, never, true, never>;
+}
+/** Used to project additional template from host to the tab header. */
+export declare class TabHeaderAddonDirective extends CdkPortal {
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabHeaderAddonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabHeaderAddonDirective, "[auiTabHeaderAddon]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Used in the `aui-tab-group` view to display tab labels.
+ */
+export declare class TabLabelWrapperDirective {
+    elementRef: ElementRef<HTMLElement>;
+    /** Whether or not the tab is disabled  */
+    disabled: boolean;
+    getOffsetLeft(): number;
+    getOffsetWidth(): number;
+    /** Sets focus on the wrapper element */
+    focus(): void;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabLabelWrapperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabLabelWrapperDirective, "[auiTabLabelWrapper]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+export declare class TabTitleDirective extends CdkPortal {
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabTitleDirective, "[auiTabTitle]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The portal host directive for the contents of the tab.
+ */
+export declare class TabBodyPortalDirective extends CdkPortalOutlet implements OnInit, OnDestroy {
+    private readonly _host;
+    private _hostSubscription;
+    constructor(componentFactoryResolver: ComponentFactoryResolver, viewContainerRef: ViewContainerRef, _host: TabBodyComponent);
+    /** Set initial visibility or set up subscription for changing visibility. */
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabBodyPortalDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabBodyPortalDirective, "[auiTabBodyHost]", never, {}, {}, never, never, true, never>;
+}

package/tabs/tab-context.service.d.ts

@@ -0,0 +1,15 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class TabContextService {
+    readonly _parent: TabContextService;
+    private readonly active$$;
+    /**
+     * Whether the tab is currently active.
+     */
+    get isActive(): boolean;
+    set isActive(isActive: boolean);
+    readonly active$: Observable<boolean>;
+    constructor(_parent: TabContextService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabContextService, [{ optional: true; skipSelf: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TabContextService>;
+}

package/tabs/tab-group.component.d.ts

@@ -0,0 +1,92 @@
+import { AfterContentChecked, AfterContentInit, ChangeDetectorRef, EventEmitter, OnChanges, OnDestroy, QueryList, SimpleChanges, TemplateRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Bem } from '../internal/utils';
+import { TabHeaderAddonDirective, TabTitleDirective } from './tab-body.component';
+import { TabHeaderComponent } from './tab-header.component';
+import { TabComponent } from './tab.component';
+import { TabSize, TabType } from './tabs.types';
+import * as i0 from "@angular/core";
+/** A simple change event emitted on focus or selection changes. */
+export declare class TabChangeEvent {
+    /** Index of the currently-selected tab. */
+    index: number;
+    /** Reference to the currently-selected tab. */
+    tab: TabComponent;
+}
+export declare class TabGroupComponent implements OnChanges, AfterContentChecked, AfterContentInit, OnDestroy {
+    private readonly _changeDetectorRef;
+    bem: Bem;
+    _tabs: QueryList<TabComponent>;
+    _headerAddon: TabHeaderAddonDirective;
+    _tabHeader: TabHeaderComponent;
+    _tabTitle: TabTitleDirective;
+    /** The tab index that should be selected after the content has been checked. */
+    private _indexToSelect;
+    /** Subscription to tabs being added/removed. */
+    private _tabsSubscription;
+    /** Subscription to changes in the tab labels. */
+    private _tabLabelSubscription;
+    private _selectedIndex;
+    private _tab;
+    private _type;
+    private _size;
+    /** true lazy mode for template ref children */
+    private _lazy;
+    private _previousHeaderAddon;
+    /** Emits whenever the type changes */
+    readonly _typeChange: Subject<void>;
+    /** Emits whenever the size changes */
+    readonly _sizeChange: Subject<void>;
+    /** The index of the active tab. */
+    get selectedIndex(): number;
+    set selectedIndex(value: number);
+    get tab(): string;
+    set tab(value: string);
+    get type(): TabType;
+    set type(type: TabType);
+    title: TemplateRef<unknown> | string;
+    get size(): TabSize;
+    set size(val: TabSize);
+    get lazy(): boolean;
+    set lazy(lazy: boolean);
+    /** Output to enable support for two-way binding on `[(selectedIndex)]` */
+    readonly selectedIndexChange: EventEmitter<number>;
+    readonly tabChange: EventEmitter<string>;
+    /** Event emitted when the tab selection has changed. */
+    readonly selectedTabChange: EventEmitter<TabChangeEvent>;
+    /** Event emitted when focus has changed within a tab group. */
+    readonly focusChange: EventEmitter<TabChangeEvent>;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    activatedTabs: TabComponent[];
+    get activeTab(): TabComponent;
+    ngOnChanges(changes: SimpleChanges): 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.
+     */
+    ngAfterContentChecked(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Handle click events, setting new selected index if appropriate. */
+    _handleClick(tab: TabComponent, idx: number): void;
+    _focusChanged(index: number): void;
+    /** Re-aligns the ink bar to the selected tab element. */
+    realignActiveIndicator(): void;
+    private _changeActivatedTabs;
+    /** Clamps the given index to the bounds of 0 and the tabs length. */
+    private _clampTabIndex;
+    private _findIndexByTab;
+    private _createChangeEvent;
+    /**
+     * Subscribes to changes in the tab labels. This is needed, because the @Input for the label is
+     * on the Tab component, whereas the data binding is inside the TabGroup. In order for the
+     * binding to be updated, we need to subscribe to changes in it and trigger change detection
+     * manually.
+     */
+    private _subscribeToTabLabels;
+    /** Retrieves the tabindex for the tab. */
+    _getTabIndex(tab: TabComponent, idx: number): number | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabGroupComponent, "aui-tab-group", ["auiTabGroup"], { "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "tab": { "alias": "tab"; "required": false; }; "type": { "alias": "type"; "required": false; }; "title": { "alias": "title"; "required": false; }; "size": { "alias": "size"; "required": false; }; "lazy": { "alias": "lazy"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; "tabChange": "tabChange"; "selectedTabChange": "selectedTabChange"; "focusChange": "focusChange"; }, ["_headerAddon", "_tabTitle", "_tabs"], never, true, never>;
+}

package/tabs/tab-header-active-indicator.component.d.ts

@@ -0,0 +1,25 @@
+import { ElementRef, NgZone } from '@angular/core';
+import { Bem } from '../internal/utils';
+import { TabType } from './tabs.types';
+import * as i0 from "@angular/core";
+export declare class TabHeaderActiveIndicatorComponent {
+    private readonly _elementRef;
+    private readonly _ngZone;
+    type: TabType;
+    bem: Bem;
+    constructor(_elementRef: ElementRef<HTMLElement>, _ngZone: NgZone);
+    /**
+     * Calculates the styles from the provided element in order to align the indicator to that element.
+     * Shows the indicator if previously set as hidden.
+     * @param element
+     */
+    alignToElement(element: HTMLElement): void;
+    /**
+     * Sets the proper styles to the element.
+     * @param element
+     */
+    private _setStyles;
+    private _getElementPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabHeaderActiveIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabHeaderActiveIndicatorComponent, "aui-tab-header-active-indicator", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
+}

package/tabs/tab-header.component.d.ts

@@ -0,0 +1,137 @@
+import { AfterContentChecked, AfterContentInit, ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, QueryList } from '@angular/core';
+import { Bem } from '../internal/utils';
+import { TabHeaderAddonDirective, TabLabelWrapperDirective, TabTitleDirective } from './tab-body.component';
+import { TabHeaderActiveIndicatorComponent } from './tab-header-active-indicator.component';
+import { TabSize, TabType } from './tabs.types';
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
+export type ScrollDirection = 'after' | 'before';
+export declare class TabHeaderComponent implements OnDestroy, AfterContentChecked, AfterContentInit {
+    private readonly _changeDetectorRef;
+    bem: Bem;
+    _showAddon: boolean;
+    /** 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 the scroll distance has changed and should be applied after the view is checked. */
+    private _scrollDistanceChanged;
+    /** Whether the header should scroll to the selected index after the view has been checked. */
+    private _selectedIndexChanged;
+    /** The distance in pixels that the tab labels should be translated to the left. */
+    private _scrollDistance;
+    private _selectedIndex;
+    /** Emits when the component is destroyed. */
+    private readonly _destroyed;
+    /** Used to manage focus between the tabs. */
+    private _keyManager;
+    type: TabType;
+    size: TabSize;
+    /** The index of the active tab. */
+    get selectedIndex(): number;
+    set selectedIndex(value: number);
+    /** Event emitted when the option is selected. */
+    readonly selectFocusedIndex: EventEmitter<number>;
+    /** Event emitted when a label is focused. */
+    readonly indexFocused: EventEmitter<number>;
+    _headerAddon: TabHeaderAddonDirective;
+    _title: TabTitleDirective;
+    /**
+     * workaround for @link https://github.com/microsoft/TypeScript/pull/42425
+     */
+    _labelWrappers: QueryList<TabLabelWrapperDirective & {
+        disabled?: boolean;
+    }>;
+    _tabListContainer: ElementRef<HTMLElement>;
+    _tabList: ElementRef<HTMLElement>;
+    _paginationWrapper: ElementRef<HTMLElement>;
+    _activeIndicator: TabHeaderActiveIndicatorComponent;
+    ngOnDestroy(): void;
+    ngAfterContentChecked(): void;
+    /**
+     * Aligns the ink bar to the selected tab on load.
+     */
+    ngAfterContentInit(): void;
+    /** Sets the distance in pixels that the tab header should be transformed in the X-axis. */
+    get scrollDistance(): number;
+    set scrollDistance(v: number);
+    /** 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);
+    /**
+     * 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;
+    _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Sets focus on the HTML element for the label wrapper and scrolls it into the view if
+     * scrolling is enabled.
+     */
+    _setTabFocus(tabIndex: number): void;
+    /**
+     * 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.
+     */
+    _scrollToLabel(labelIndex: number): void;
+    /**
+     * Moves the tab list in the 'before' or 'after' direction (towards the beginning of the list or
+     * the end of the list, respectively). The distance to scroll is computed to be a third of the
+     * length of the tab list view window.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    _scrollHeader(scrollDir: ScrollDirection): void;
+    /**
+     * Callback for when the MutationObserver detects that the content has changed.
+     */
+    _onContentChanges(): void;
+    /**
+     * Updating the view whether pagination should be enabled or not
+     */
+    _updatePagination(): 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;
+    /**
+     * Evaluate whether the before and after controls should be enabled or disabled.
+     * If the header is at the beginning of the list (scroll distance is equal to 0) then disable the
+     * before button. If the header is at the end of the list (scroll distance is equal to the
+     * maximum distance we can scroll), then disable the after button.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    _checkScrollingControls(): void;
+    /**
+     * Determines what is the maximum length in pixels that can be set for the scroll distance. This
+     * is equal to the difference in width between the tab list container and tab header container.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    _getMaxScrollDistance(): number;
+    /** Performs the CSS transformation on the tab list that will cause the list to scroll. */
+    _updateTabScrollPosition(): void;
+    /** Tells the active indicator to align itself to the current label wrapper */
+    _alignActiveIndicatorToSelectedTab(): void;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabHeaderComponent, "aui-tab-header", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "selectFocusedIndex": "selectFocusedIndex"; "indexFocused": "indexFocused"; }, ["_headerAddon", "_title", "_labelWrappers"], ["*"], true, never>;
+}

package/tabs/tab.component.d.ts

@@ -0,0 +1,48 @@
+import { TemplatePortal } from '@angular/cdk/portal';
+import { AfterContentInit, EventEmitter, OnChanges, OnDestroy, SimpleChanges, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { TabLabelDirective } from './tab-body.component';
+import { TabContextService } from './tab-context.service';
+import * as i0 from "@angular/core";
+export declare class TabComponent implements AfterContentInit, OnDestroy, OnChanges {
+    private readonly _viewContainerRef;
+    readonly tabContext: TabContextService;
+    name: string;
+    /** Plain text label for the tab, used when there is no template label. */
+    textLabel: string;
+    /** Whether or not to show the close button in the header */
+    closeable: boolean;
+    /** Whether or not the tab is disabled  */
+    disabled: boolean;
+    close: EventEmitter<void>;
+    /** Content for the tab label given by `<ng-template [auiTabLabel]>`. */
+    templateLabel: TabLabelDirective;
+    /**
+     * Template provided in the tab content that will be used if present, used to enable lazy-loading
+     */
+    _explicitContent: TemplateRef<any>;
+    /** Template inside the AuiTab view that contains an `<ng-content>`. */
+    _implicitContent: TemplateRef<any>;
+    get content(): TemplatePortal | null;
+    /**
+     * 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;
+    /** Emits whenever the internal state of the tab changes. */
+    readonly _stateChanges: Subject<void>;
+    /** Portal that will be the hosted content of the tab */
+    private _contentPortal;
+    constructor(_viewContainerRef: ViewContainerRef, tabContext: TabContextService);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabComponent, "aui-tab", ["auiTab"], { "name": { "alias": "name"; "required": false; }; "textLabel": { "alias": "label"; "required": false; }; "closeable": { "alias": "closeable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "close": "close"; }, ["templateLabel", "_explicitContent"], ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}

package/tabs/tabs.module.d.ts

@@ -0,0 +1,23 @@
+import { TabContentDirective, TabHeaderAddonDirective, TabLabelDirective, TabLabelWrapperDirective, TabTitleDirective } from './tab-body.component';
+import { TabGroupComponent } from './tab-group.component';
+import { TabHeaderComponent } from './tab-header.component';
+import { TabComponent } from './tab.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/cdk/portal";
+import * as i4 from "../button/button.module";
+import * as i5 from "../icon/icon.module";
+import * as i6 from "@angular/cdk/a11y";
+import * as i7 from "@angular/cdk/observers";
+import * as i8 from "./tab-group.component";
+import * as i9 from "./tab.component";
+import * as i10 from "./tab-body.component";
+import * as i11 from "./tab-header.component";
+import * as i12 from "./tab-header-active-indicator.component";
+export declare class TabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TabsModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i3.PortalModule, typeof i4.ButtonModule, typeof i5.IconModule, typeof i6.A11yModule, typeof i7.ObserversModule, typeof i8.TabGroupComponent, typeof i9.TabComponent, typeof i10.TabLabelDirective, typeof i10.TabContentDirective, typeof i10.TabHeaderAddonDirective, typeof i10.TabTitleDirective, typeof i11.TabHeaderComponent, typeof i10.TabBodyComponent, typeof i10.TabBodyPortalDirective, typeof i10.TabLabelWrapperDirective, typeof i12.TabHeaderActiveIndicatorComponent], [typeof i8.TabGroupComponent, typeof i9.TabComponent, typeof i10.TabLabelDirective, typeof i10.TabContentDirective, typeof i10.TabHeaderAddonDirective, typeof i10.TabTitleDirective, typeof i10.TabLabelWrapperDirective, typeof i11.TabHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TabsModule>;
+}
+export declare const TABS_MODULE: readonly [typeof TabGroupComponent, typeof TabComponent, typeof TabLabelDirective, typeof TabContentDirective, typeof TabHeaderAddonDirective, typeof TabTitleDirective, typeof TabLabelWrapperDirective, typeof TabHeaderComponent];

package/tabs/tabs.types.d.ts

@@ -0,0 +1,15 @@
+import { ValueOf } from '../internal/types';
+export declare const TabSize: {
+    /** 卡片级尺寸 */
+    readonly Large: "large";
+    /** 页面级尺寸 */
+    readonly Medium: "medium";
+    /** 小尺寸 */
+    readonly Small: "small";
+};
+export type TabSize = ValueOf<typeof TabSize>;
+export declare const TabType: {
+    readonly Line: "line";
+    readonly Card: "card";
+};
+export type TabType = ValueOf<typeof TabType>;

package/tag/check-tag/check-tag.component.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from '@angular/core';
+import { ComponentSize } from '../../internal/types';
+import { Bem } from '../../internal/utils';
+import * as i0 from "@angular/core";
+export declare class CheckTagComponent {
+    bem: Bem;
+    hovered: boolean;
+    checked: boolean;
+    size: ComponentSize;
+    round: boolean;
+    checkedChange: EventEmitter<boolean>;
+    get rootClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckTagComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckTagComponent, "aui-check-tag", never, { "checked": { "alias": "checked"; "required": false; }; "size": { "alias": "size"; "required": false; }; "round": { "alias": "round"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, ["*"], true, never>;
+}

package/tag/index.d.ts

@@ -0,0 +1,4 @@
+export * from './check-tag/check-tag.component';
+export * from './tag.component';
+export * from './tag.module';
+export * from './tag.types';

package/tag/tag.component.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from '@angular/core';
+import { ComponentSize } from '../internal/types';
+import { Bem } from '../internal/utils';
+import { TagType } from './tag.types';
+import * as i0 from "@angular/core";
+export declare class TagComponent {
+    bem: Bem;
+    type: TagType;
+    size: ComponentSize;
+    closeable: boolean;
+    border: boolean;
+    solid: boolean;
+    invalid: boolean;
+    round: boolean;
+    color: string;
+    allowClick: boolean;
+    close: EventEmitter<void>;
+    get rootClass(): string;
+    get isNormalTag(): boolean;
+    get customStyle(): {
+        color: string;
+        'border-color': string;
+        'background-color': string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagComponent, "aui-tag", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "closeable": { "alias": "closeable"; "required": false; }; "border": { "alias": "border"; "required": false; }; "solid": { "alias": "solid"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "round": { "alias": "round"; "required": false; }; "color": { "alias": "color"; "required": false; }; "allowClick": { "alias": "allowClick"; "required": false; }; }, { "close": "close"; }, never, ["*"], true, never>;
+}