@alauda/ui 9.1.2-beta.1 → 9.1.2-beta.10

package/index.d.ts

@@ -1,38 +1,3673 @@
-export * from './accordion';
-export * from './anchor';
-export * from './autocomplete';
-export * from './back-top';
-export * from './breadcrumb';
-export * from './button';
-export * from './card';
-export * from './checkbox';
-export * from './color-picker';
-export * from './date-picker';
-export * from './dialog';
-export * from './drawer';
-export * from './dropdown';
-export * from './form';
-export * from './i18n';
-export * from './icon';
-export * from './inline-alert';
-export * from './input';
-export { ComponentSize } from './internal/types';
-export { AttrBoolean, Bem, buildBem, coerceAttrBoolean, coerceString, getCompatibleStylesRenderer, handlePixel, isTemplateRef, observeMutationOn, observeResizeOn, } from './internal/utils';
-export * from './message';
-export * from './notification';
-export * from './paginator';
-export * from './radio';
-export * from './scrolling';
-export * from './select';
-export * from './sort';
-export * from './status-bar';
-export * from './steps';
-export * from './switch';
-export * from './table';
-export * from './table-of-contents';
-export * from './tabs';
-export * from './tag';
-export * from './theme';
-export * from './time-picker';
-export * from './tooltip';
-export * from './tree-select';
+import * as i2 from '@angular/cdk/accordion';
+import { CdkAccordion, CdkAccordionItem } from '@angular/cdk/accordion';
+import * as i0 from '@angular/core';
+import { AfterContentInit, TemplateRef, ChangeDetectorRef, PipeTransform, OnDestroy, ElementRef, Renderer2, Injector, OnInit, AfterContentChecked, EventEmitter, QueryList, ApplicationRef, AfterViewInit, ViewContainerRef, NgZone, OnChanges, SimpleChanges, InjectionToken, Type, ComponentRef, EmbeddedViewRef, NgIterable, TrackByFunction, ComponentFactoryResolver } from '@angular/core';
+import { UniqueSelectionDispatcher, ListRange, DataSource } from '@angular/cdk/collections';
+import * as i1 from '@angular/common';
+import * as rxjs from 'rxjs';
+import { Observable, Subject, BehaviorSubject, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import * as i6 from '@angular/cdk/a11y';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import * as _alauda_ui from '@alauda/ui';
+import * as i3 from '@angular/cdk/portal';
+import { ComponentPortal, ComponentType, CdkPortalOutlet, TemplatePortal, CdkPortal } from '@angular/cdk/portal';
+import { CdkScrollable, ScrollDispatcher as ScrollDispatcher$1, VirtualScrollStrategy, CdkVirtualScrollViewport, CdkFixedSizeVirtualScroll, CdkVirtualForOf, CdkVirtualForOfContext } from '@angular/cdk/scrolling';
+import * as i2$1 from '@angular/cdk/overlay';
+import { Overlay, OverlayRef, CdkScrollable as CdkScrollable$1, ComponentType as ComponentType$1, ScrollDispatcher } from '@angular/cdk/overlay';
+import * as i2$2 from '@angular/forms';
+import { NgControl, ControlValueAccessor, ControlContainer, FormGroupDirective, NgForm, ValidatorFn, AsyncValidatorFn, UntypedFormControl, FormBuilder, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import { AnimationEvent } from '@angular/animations';
+import dayjs, { Dayjs, ConfigType } from 'dayjs';
+import { Directionality } from '@angular/cdk/bidi';
+import { RowOutlet, CdkTable, CdkCellDef, CdkCell, CdkColumnDef, CdkHeaderCellDef, CdkHeaderCell, CdkHeaderRowDef, CdkHeaderRow, CdkRowDef, CdkRow } from '@angular/cdk/table';
+import * as i7 from '@angular/cdk/observers';
+
+declare class AccordionComponent extends CdkAccordion {
+    parent: AccordionComponent;
+    background: boolean;
+    depth: number;
+    constructor(parent: AccordionComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, [{ optional: true; skipSelf: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionComponent, "aui-accordion", never, { "background": { "alias": "background"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class AccordionItemHeaderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionItemHeaderDirective, "[auiAccordionItemHeader]", never, {}, {}, never, never, true, never>;
+}
+declare class AccordionItemContentDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionItemContentDirective, "[auiAccordionContent]", never, {}, {}, never, never, true, never>;
+}
+declare class AccordionItemComponent extends CdkAccordionItem implements AfterContentInit {
+    background: boolean;
+    _lazyContentTpl: TemplateRef<unknown>;
+    lazyContentTpl: TemplateRef<unknown>;
+    constructor(accordion: AccordionComponent, cdr: ChangeDetectorRef, uniqueSelectionDispatcher: UniqueSelectionDispatcher);
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionItemComponent, "aui-accordion-item", never, { "background": { "alias": "background"; "required": false; }; }, {}, ["_lazyContentTpl"], ["[auiAccordionItemHeader]", "*"], true, never>;
+}
+
+type Theme = 'dark' | 'light';
+type ThemeMode = 'dark' | 'light' | 'system';
+type ThemeSet<T> = Record<Theme, T> | ((theme: Theme) => T) | [T, T];
+
+declare class ThemeService {
+    private readonly htmlEl;
+    private browserTheme;
+    private themeMode;
+    private readonly currentAppTheme$$;
+    readonly currentTheme$: rxjs.Observable<Theme>;
+    constructor();
+    setThemeMode(mode: ThemeMode): void;
+    currentTheme(): Theme;
+    private themeChanged;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+declare class RgbColorPipe implements PipeTransform {
+    transform: (color: string) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RgbColorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RgbColorPipe, "auiRgbColor", true>;
+}
+declare class RgbaColorPipe implements PipeTransform {
+    transform: ([color, opacity]: [string, number]) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RgbaColorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RgbaColorPipe, "auiRgbaColor", true>;
+}
+declare class CssVarPipe implements PipeTransform {
+    transform: (value: string) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CssVarPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CssVarPipe, "auiCssVar", true>;
+}
+declare class ThemePickerPipe<T> implements PipeTransform, OnDestroy {
+    private currentTheme;
+    private readonly destroy$$;
+    constructor(themeService: ThemeService, cdr: ChangeDetectorRef);
+    transform(v: ThemeSet<T>): T;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemePickerPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ThemePickerPipe<any>, "auiThemePicker", true>;
+}
+
+declare class ThemeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ThemeModule, never, [typeof i1.CommonModule, typeof ThemePickerPipe, typeof RgbColorPipe, typeof RgbaColorPipe, typeof CssVarPipe], [typeof ThemePickerPipe, typeof RgbColorPipe, typeof RgbaColorPipe, typeof CssVarPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ThemeModule>;
+}
+
+declare class Bem {
+    private readonly namespace;
+    constructor(namespace: string);
+    block(...modifiers: Array<string | {
+        [name: string]: boolean;
+    }>): string;
+    modifier(name: string): string;
+    element(name: string, ...modifiers: Array<string | {
+        [name: string]: boolean | '';
+    }>): string;
+}
+declare function buildBem(namespace: string): Bem;
+
+declare const coerceString: (val: unknown) => string;
+type AttrBoolean = boolean | '';
+declare const coerceAttrBoolean: (val: AttrBoolean) => boolean;
+
+declare const isTemplateRef: (label: any) => label is TemplateRef<unknown>;
+declare const handlePixel: (value: number | string) => string;
+
+declare const observeResizeOn: <T extends Element>(target: T, options?: ResizeObserverOptions) => Observable<T>;
+declare const observeMutationOn: <T extends Node>(target: T, options?: MutationObserverInit) => Observable<MutationRecord>;
+
+declare function getCompatibleStylesRenderer(): CSSStyleSheetRenderer | StylesRenderer;
+declare class StylesRenderer implements Renderer {
+    private styleElement;
+    render(styles: string): void;
+    cleanup(): void;
+}
+declare class CSSStyleSheetRenderer implements Renderer {
+    private readonly options?;
+    private styleSheet;
+    constructor(options?: CSSStyleSheetInit);
+    render(styles: string): void;
+    cleanup(): void;
+}
+interface Renderer {
+    render(styles: string): void;
+    cleanup(): void;
+}
+
+declare class IconRegisterService {
+    private readonly httpClient;
+    private defaultIconPrefix;
+    private readonly doc;
+    constructor(document: Document, httpClient: HttpClient);
+    getDefaultIconPrefix(): string;
+    replaceDefaultIconPrefix(prefix: string): void;
+    registerSvgSymbolsByUrl(url: string): void;
+    registerSvgSymbolsByString(str: string): void;
+    private appendSvg;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconRegisterService, [{ optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconRegisterService>;
+}
+
+declare class IconComponent {
+    private readonly iconRegisterService;
+    icon: string;
+    light: string;
+    dark: string;
+    link: string;
+    margin: 'left' | 'right';
+    size: string;
+    color: string;
+    background: 'circle' | 'triangle';
+    backgroundColor: string;
+    bem: Bem;
+    id: number;
+    constructor(iconRegisterService: IconRegisterService);
+    private parseIcon;
+    getWidth(): string | false;
+    getHeight(): string | false;
+    getIconId(icon: string): string;
+    getClass(id: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "aui-icon", never, { "icon": { "alias": "icon"; "required": false; }; "light": { "alias": "light"; "required": false; }; "dark": { "alias": "dark"; "required": false; }; "link": { "alias": "link"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "background": { "alias": "background"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IconModule, never, [typeof i1.CommonModule, typeof ThemeModule, typeof IconComponent], [typeof IconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IconModule>;
+}
+
+type ValueOf<T> = T[keyof T];
+declare const ComponentSize: {
+    readonly Large: "large";
+    readonly Medium: "medium";
+    readonly Small: "small";
+    readonly Mini: "mini";
+    /**
+     * represents default internally, @link https://github.com/angular/vscode-ng-language-service/issues/1147
+     */
+    readonly Empty: "";
+};
+type ComponentSize = ValueOf<typeof ComponentSize>;
+
+declare const ButtonType: {
+    readonly Default: "default";
+    readonly Primary: "primary";
+    readonly Success: "success";
+    readonly Warning: "warning";
+    readonly Danger: "danger";
+    readonly Text: "text";
+    readonly Inline: "inline";
+    /**
+     * represents default internally, @link https://github.com/angular/vscode-ng-language-service/issues/1147
+     */
+    readonly Empty: "";
+};
+type ButtonType = ValueOf<typeof ButtonType>;
+
+declare class ButtonComponent implements OnDestroy {
+    private readonly el;
+    private readonly renderer;
+    private readonly focusMonitor;
+    get type(): ButtonType;
+    set type(val: ButtonType);
+    get size(): ComponentSize;
+    set size(val: ComponentSize);
+    get plain(): boolean;
+    set plain(val: boolean);
+    get loading(): boolean;
+    set loading(val: boolean);
+    get round(): boolean;
+    set round(val: boolean);
+    get square(): boolean;
+    set square(val: boolean);
+    private _type;
+    private _size;
+    private _plain;
+    private _loading;
+    private _round;
+    private _square;
+    constructor(el: ElementRef, renderer: Renderer2, focusMonitor: FocusMonitor);
+    ngOnDestroy(): void;
+    private switchAssertClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "button[aui-button]", never, { "type": { "alias": "aui-button"; "required": false; }; "size": { "alias": "size"; "required": false; }; "plain": { "alias": "plain"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "round": { "alias": "round"; "required": false; }; "square": { "alias": "square"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ButtonGroupComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonGroupComponent, "aui-button-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonModule, never, [typeof i1.CommonModule, typeof IconModule, typeof ButtonComponent, typeof ButtonGroupComponent], [typeof ButtonComponent, typeof ButtonGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonModule>;
+}
+
+declare class AccordionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AccordionModule, never, [typeof i1.CommonModule, typeof i2.CdkAccordionModule, typeof IconModule, typeof ButtonModule, typeof AccordionComponent, typeof AccordionItemComponent, typeof AccordionItemHeaderDirective, typeof AccordionItemContentDirective], [typeof AccordionComponent, typeof AccordionItemComponent, typeof AccordionItemHeaderDirective, typeof AccordionItemContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AccordionModule>;
+}
+declare const ACCORDION_MODULE: readonly [typeof AccordionComponent, typeof AccordionItemComponent, typeof AccordionItemHeaderDirective, typeof AccordionItemContentDirective];
+
+declare class AnchorDirectiveChild {
+    protected injector: Injector;
+    readonly parent: AnchorDirective;
+    constructor(injector: Injector);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorDirectiveChild, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AnchorDirectiveChild, never, never, {}, {}, never, never, true, never>;
+}
+declare class AnchorLabelDirective extends AnchorDirectiveChild implements OnInit, AfterContentChecked {
+    protected injector: Injector;
+    readonly elRef: ElementRef<HTMLElement>;
+    get label(): string | TemplateRef<unknown>;
+    set label(value: string | TemplateRef<unknown>);
+    private _label;
+    labelContext: unknown;
+    get target(): HTMLElement;
+    set id(id: string);
+    get id(): string;
+    private _id;
+    set level(value: number | '');
+    get level(): number | "";
+    private _level;
+    labelChange: EventEmitter<string | TemplateRef<unknown>>;
+    constructor(injector: Injector, elRef: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    ngAfterContentChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AnchorLabelDirective, "[auiAnchorLabel]", never, { "label": { "alias": "auiAnchorLabel"; "required": false; }; "labelContext": { "alias": "auiAnchorLabelContext"; "required": false; }; "id": { "alias": "id"; "required": false; }; "level": { "alias": "level"; "required": false; }; }, { "labelChange": "labelChange"; }, never, never, true, never>;
+}
+declare class AnchorDirective implements AfterContentInit, OnDestroy {
+    private readonly appRef;
+    private readonly injector;
+    readonly elRef: ElementRef<HTMLElement>;
+    private readonly cdkScrollable;
+    auiAnchor: HTMLElement | '';
+    adaptPosition: boolean;
+    padding: number;
+    minTop: number;
+    injectId: boolean;
+    anchorLabels: QueryList<AnchorLabelDirective>;
+    get containerEl(): HTMLElement;
+    get scrollableEl(): HTMLElement | (Window & typeof globalThis);
+    anchorPortal: ComponentPortal<AnchorComponent>;
+    destroy$$: Subject<void>;
+    constructor(appRef: ApplicationRef, injector: Injector, elRef: ElementRef<HTMLElement>, cdkScrollable: CdkScrollable);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    adaptAnchorPosition(containerEl: HTMLElement, anchorEl: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorDirective, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AnchorDirective, "[auiAnchor]", never, { "auiAnchor": { "alias": "auiAnchor"; "required": false; }; "adaptPosition": { "alias": "adaptPosition"; "required": false; }; "padding": { "alias": "padding"; "required": false; }; "minTop": { "alias": "minTop"; "required": false; }; "injectId": { "alias": "injectId"; "required": false; }; }, {}, ["anchorLabels"], never, true, never>;
+}
+
+interface AnchorItemBase {
+    readonly id?: string;
+    readonly target?: HTMLElement;
+    readonly label: TemplateRef<unknown> | string;
+    readonly labelContext?: unknown;
+    readonly labelChange?: EventEmitter<TemplateRef<unknown> | string>;
+}
+interface AnchorItem extends AnchorItemBase {
+    readonly level: number;
+}
+interface AnchorTreeItem extends AnchorItemBase {
+    children?: AnchorTreeItem[];
+}
+
+declare class AnchorTreeComponent extends AnchorDirectiveChild implements OnDestroy {
+    set treeItems(treeItems: AnchorTreeItem[]);
+    get treeItems(): AnchorTreeItem[];
+    private _treeItems;
+    activeId: string;
+    activeIdChange: EventEmitter<string>;
+    bem: _alauda_ui.Bem;
+    isTemplateRef: (label: any) => label is i0.TemplateRef<unknown>;
+    private readonly depose$$;
+    watchLabelsChange(): void;
+    ngOnDestroy(): void;
+    isActive(item: AnchorTreeItem): boolean;
+    onItemClick(e: Event, item: AnchorTreeItem): void;
+    trackById(_index: number, item: AnchorTreeItem): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnchorTreeComponent, "aui-anchor-tree", never, { "treeItems": { "alias": "treeItems"; "required": false; }; "activeId": { "alias": "activeId"; "required": false; }; }, { "activeIdChange": "activeIdChange"; }, never, never, true, never>;
+}
+declare class AnchorComponent extends AnchorDirectiveChild implements AfterViewInit, OnDestroy {
+    protected injector: Injector;
+    private readonly cdr;
+    get items(): AnchorItem[];
+    set items(items: AnchorItem[]);
+    private _items;
+    treeItems: AnchorTreeItem[];
+    activeId: string;
+    bem: _alauda_ui.Bem;
+    private readonly destroy$$;
+    constructor(injector: Injector, cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnchorComponent, "aui-anchor", never, { "items": { "alias": "items"; "required": false; }; "treeItems": { "alias": "treeItems"; "required": false; }; "activeId": { "alias": "activeId"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AnchorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AnchorModule, never, [typeof i1.CommonModule, typeof AnchorComponent, typeof AnchorTreeComponent, typeof AnchorDirective, typeof AnchorLabelDirective], [typeof AnchorComponent, typeof AnchorTreeComponent, typeof AnchorDirective, typeof AnchorLabelDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AnchorModule>;
+}
+declare const ANCHOR_MODULE: readonly [typeof AnchorComponent, typeof AnchorTreeComponent, typeof AnchorDirective, typeof AnchorLabelDirective];
+
+declare const getAnchorTreeItems: (items: AnchorItem[], level?: number) => AnchorTreeItem[];
+
+declare class AutocompletePlaceholderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompletePlaceholderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AutocompletePlaceholderComponent, "aui-autocomplete-placeholder", never, {}, {}, never, ["*"], true, never>;
+}
+
+type AnimationType = 'none' | 'scale' | 'scaleY';
+
+declare enum TooltipType {
+    Default = "default",
+    Primary = "primary",
+    Success = "success",
+    Warning = "warning",
+    Error = "error",
+    Info = "info",
+    Plain = "plain",
+    Empty = "empty"
+}
+declare enum TooltipTrigger {
+    Hover = "hover",
+    Click = "click",
+    Focus = "focus",
+    Manual = "manual"
+}
+
+declare class TooltipComponent implements OnDestroy {
+    elRef: ElementRef<HTMLElement>;
+    cdr: ChangeDetectorRef;
+    text: string;
+    template: TemplateRef<any>;
+    bem: Bem;
+    showHide: string;
+    animationType: AnimationType;
+    inputContent$: Observable<TemplateRef<any> | string>;
+    inputType$: Observable<TooltipType>;
+    inputPosition$: Observable<string>;
+    inputClass$: Observable<string>;
+    inputContext$: Observable<any>;
+    text$: Observable<string>;
+    template$: Observable<TemplateRef<any>>;
+    class$: Observable<string>;
+    context$: Observable<any>;
+    hover$: Subject<boolean>;
+    destroy$: Subject<unknown>;
+    animating$$: BehaviorSubject<boolean>;
+    hide$: Subject<unknown>;
+    beforeHide$: Subject<unknown>;
+    beforeShow$: Subject<unknown>;
+    constructor(elRef: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    setupInputs(inputs: {
+        inputContent$: Observable<TemplateRef<any> | string>;
+        inputType$: Observable<TooltipType>;
+        inputPosition$: Observable<string>;
+        inputClass$: Observable<string>;
+        inputContext$: Observable<any>;
+        animationType?: string;
+    }): void;
+    onAnimation(event: AnimationEvent): void;
+    show(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "aui-tooltip", never, {}, {}, never, never, true, never>;
+}
+
+interface TooltipInterface {
+    content: TemplateRef<any> | string;
+    context: any;
+    class: string;
+    type: TooltipType;
+    position: string;
+    trigger: TooltipTrigger;
+    disabled: boolean;
+    hideOnClick: boolean;
+    visibleChange: EventEmitter<boolean>;
+}
+declare const DISPLAY_DELAY = 50;
+declare const HIDDEN_DELAY = 150;
+declare class BaseTooltip<T = any> implements TooltipInterface, AfterViewInit, OnDestroy {
+    protected overlay: Overlay;
+    protected viewContainerRef: ViewContainerRef;
+    protected elRef: ElementRef<HTMLInputElement>;
+    protected renderer: Renderer2;
+    protected cdr: ChangeDetectorRef;
+    protected ngZone: NgZone;
+    set content(value: TemplateRef<any> | string);
+    get content(): TemplateRef<any> | string;
+    set context(value: T);
+    get context(): T;
+    set class(value: string);
+    set type(value: TooltipType);
+    set position(value: string);
+    get position(): string;
+    set trigger(value: TooltipTrigger);
+    get trigger(): TooltipTrigger;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    hideOnClick: boolean;
+    animationType: AnimationType;
+    visibleChange: EventEmitter<boolean>;
+    overlayRef: OverlayRef;
+    protected componentClass: ComponentType<any>;
+    protected componentIns: TooltipComponent;
+    protected hostHovered: boolean;
+    protected tooltipHovered: boolean;
+    protected listeners: Array<() => void>;
+    protected unlistenBody: () => void;
+    protected inputContent$$: ReplaySubject<string | TemplateRef<any>>;
+    protected inputType$$: ReplaySubject<TooltipType>;
+    protected inputPosition$$: ReplaySubject<string>;
+    protected inputClass$$: ReplaySubject<string>;
+    protected inputContext$$: ReplaySubject<any>;
+    protected tooltipChanged$: rxjs.Observable<any>;
+    protected destroy$: Subject<unknown>;
+    protected _position: string;
+    protected _trigger: TooltipTrigger;
+    protected _disabled: boolean;
+    protected _context: T;
+    protected _content: TemplateRef<unknown> | string;
+    get isCreated(): boolean;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, elRef: ElementRef<HTMLInputElement>, renderer: Renderer2, cdr: ChangeDetectorRef, ngZone: NgZone);
+    private _updateTransformOrigin;
+    _createTooltip(): void;
+    _disposeTooltip(): void;
+    toggleTooltip(): void;
+    show(): void;
+    hide(): void;
+    updatePosition(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected updateListeners(): void;
+    protected clearListeners(): void;
+    protected createOverlay(): OverlayRef;
+    protected onMouseEnter(): Promise<void>;
+    protected onMouseLeave(): Promise<void>;
+    protected onTooltipHovered(hovered: boolean): Promise<void>;
+    protected onClick(): void;
+    protected onBodyClick(event: Event): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTooltip<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseTooltip<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class TooltipDirective extends BaseTooltip {
+    visibleChange: EventEmitter<boolean>;
+    animationType: AnimationType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[auiTooltip]", ["auiTooltip"], { "content": { "alias": "auiTooltip"; "required": false; }; "context": { "alias": "auiTooltipContext"; "required": false; }; "class": { "alias": "auiTooltipClass"; "required": false; }; "type": { "alias": "auiTooltipType"; "required": false; }; "position": { "alias": "auiTooltipPosition"; "required": false; }; "trigger": { "alias": "auiTooltipTrigger"; "required": false; }; "disabled": { "alias": "auiTooltipDisabled"; "required": false; }; "hideOnClick": { "alias": "auiTooltipHideOnClick"; "required": false; }; "animationType": { "alias": "auiTooltipAnimType"; "required": false; }; }, { "visibleChange": "auiTooltipVisibleChange"; }, never, never, true, never>;
+}
+
+declare class TooltipActiveDirective implements OnDestroy {
+    private readonly el;
+    private readonly renderer;
+    customClass: string[] | string;
+    destroy$: Subject<unknown>;
+    constructor(tooltipDirective: BaseTooltip, el: ElementRef, renderer: Renderer2);
+    ngOnDestroy(): void;
+    private addClass;
+    private removeClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipActiveDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipActiveDirective, "[auiTooltipActive]", never, { "customClass": { "alias": "auiTooltipActive"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Texts to render on the code editor.
+ */
+declare class TooltipCopyIntl {
+    copyTip: string;
+    copySuccessTip: string;
+    copyFailTip: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipCopyIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipCopyIntl>;
+}
+
+declare class TooltipCopyDirective extends BaseTooltip implements OnInit {
+    private readonly toolTipIntl;
+    className: boolean;
+    get auiTooltipCopy(): string;
+    set auiTooltipCopy(value: string);
+    get auiTooltipCopyTip(): string;
+    set auiTooltipCopyTip(value: string);
+    get auiTooltipCopySuccessTip(): string;
+    set auiTooltipCopySuccessTip(value: string);
+    get auiTooltipCopyFailTip(): string;
+    set auiTooltipCopyFailTip(value: string);
+    private _copyText;
+    private _copyTip;
+    private _copySuccessTip;
+    private _copyFailTip;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, elRef: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef, ngZone: NgZone, toolTipIntl: TooltipCopyIntl);
+    ngOnInit(): void;
+    onSourceClick(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipCopyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipCopyDirective, "[auiTooltipCopy]", never, { "position": { "alias": "auiTooltipPosition"; "required": false; }; "disabled": { "alias": "auiTooltipDisabled"; "required": false; }; "auiTooltipCopy": { "alias": "auiTooltipCopy"; "required": false; }; "auiTooltipCopyTip": { "alias": "auiTooltipCopyTip"; "required": false; }; "auiTooltipCopySuccessTip": { "alias": "auiTooltipCopySuccessTip"; "required": false; }; "auiTooltipCopyFailTip": { "alias": "auiTooltipCopyFailTip"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TooltipModule, never, [typeof i1.CommonModule, typeof i2$1.OverlayModule, typeof TooltipDirective, typeof TooltipComponent, typeof TooltipActiveDirective, typeof TooltipCopyDirective], [typeof TooltipDirective, typeof TooltipActiveDirective, typeof TooltipCopyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TooltipModule>;
+}
+declare const TOOLTIP_MODULE: readonly [typeof TooltipDirective, typeof TooltipActiveDirective, typeof TooltipCopyDirective];
+
+interface AutoCompleteContext {
+    width: string;
+}
+type SuggestionFilterFn = (inputValue: string, suggestion: string) => boolean;
+
+declare class AutoCompleteDirective extends BaseTooltip<AutoCompleteContext> implements OnInit, OnDestroy, AfterViewInit {
+    private readonly ngControl;
+    get autocomplete(): AutocompleteComponent;
+    set autocomplete(val: AutocompleteComponent);
+    get filterFn(): (inputValue: string, suggestion: string) => boolean;
+    set filterFn(val: (inputValue: string, suggestion: string) => boolean);
+    defaultFirstSuggestion: boolean;
+    suggestionTrigger: 'auto' | 'input';
+    innerSelector: string;
+    visibleChange: EventEmitter<boolean>;
+    selected: EventEmitter<string>;
+    autoPatch: boolean;
+    animationType: AnimationType;
+    private _autocomplete;
+    private focusedSuggestion;
+    private readonly inputValue$$;
+    private readonly filterFn$$;
+    private readonly unsubscribe$;
+    inputValue$: Observable<string>;
+    filterFn$: Observable<SuggestionFilterFn>;
+    get input(): HTMLInputElement;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, elRef: ElementRef<HTMLInputElement>, renderer: Renderer2, cdr: ChangeDetectorRef, ngZone: NgZone, ngControl: NgControl);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onFocus(): void;
+    onInput(event: Event): void;
+    onKeyDown(event: KeyboardEvent): void;
+    updateSuggestionsContext(): void;
+    onSuggestionClick(value: string): void;
+    show(): void;
+    autoFocusFirstSuggestion(): void;
+    private focusSuggestionDir;
+    private resetFocusedSuggestion;
+    private scrollToSuggestion;
+    protected selectFocusedOption(): void;
+    private _filterFn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoCompleteDirective, [null, null, null, null, null, null, { optional: true; host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoCompleteDirective, "input[auiAutocomplete],textarea[auiAutocomplete]", ["auiAutocomplete"], { "class": { "alias": "auiAutocompleteClass"; "required": false; }; "autocomplete": { "alias": "auiAutocomplete"; "required": false; }; "filterFn": { "alias": "auiAutocompleteFilterFn"; "required": false; }; "defaultFirstSuggestion": { "alias": "auiAutocompleteDefaultFirstSuggestion"; "required": false; }; "suggestionTrigger": { "alias": "auiAutocompleteTrigger"; "required": false; }; "autoPatch": { "alias": "auiAutocompleteAutoPatch"; "required": false; }; }, { "visibleChange": "auiAutocompleteVisibleChange"; "selected": "auiAutocompleteSelected"; }, never, never, true, never>;
+}
+declare class CustomAutoCompleteDirective extends AutoCompleteDirective {
+    innerSelector: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomAutoCompleteDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomAutoCompleteDirective, "[auiAutocomplete]:not(input):not(textarea)", ["auiAutocomplete"], { "class": { "alias": "auiAutocompleteClass"; "required": false; }; "innerSelector": { "alias": "auiAutocompleteInnerSelector"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SuggestionComponent {
+    private readonly cdr;
+    private readonly autocomplete;
+    bem: Bem;
+    private _value;
+    private readonly value$$;
+    get value(): string;
+    set value(val: string);
+    disabled: boolean;
+    elRef: ElementRef;
+    selected: boolean;
+    visible: boolean;
+    focused: boolean;
+    selected$: Observable<boolean>;
+    visible$: Observable<boolean>;
+    constructor(cdr: ChangeDetectorRef, autocomplete: AutocompleteComponent);
+    onClick(): void;
+    focus(): void;
+    blur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SuggestionComponent, "aui-suggestion", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class AutocompleteComponent implements AfterContentInit {
+    private readonly cdr;
+    suggestions: QueryList<SuggestionComponent>;
+    placeholder: QueryList<AutocompletePlaceholderComponent>;
+    template: TemplateRef<any>;
+    suggestionListRef: ElementRef;
+    hasVisibleSuggestion$: Observable<boolean>;
+    hasContent$: Observable<boolean>;
+    visibles$: Observable<boolean[]>;
+    directive$$: ReplaySubject<AutoCompleteDirective>;
+    constructor(cdr: ChangeDetectorRef);
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AutocompleteComponent, "aui-autocomplete", never, {}, {}, ["suggestions", "placeholder"], ["*", "aui-autocomplete-placeholder"], true, never>;
+}
+
+declare class SuggestionGroupTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionGroupTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SuggestionGroupTitleDirective, "[auiSuggestionGroupTitle]", ["auiSuggestionGroupTitle"], {}, {}, never, never, true, never>;
+}
+
+declare class SuggestionGroupComponent implements AfterContentInit {
+    suggestions: QueryList<SuggestionComponent>;
+    hasVisibleSuggestion$: Observable<boolean>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SuggestionGroupComponent, "aui-suggestion-group", never, {}, {}, ["suggestions"], ["[auiSuggestionGroupTitle]", "*"], true, never>;
+}
+
+declare class AutocompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AutocompleteModule, never, [typeof i1.CommonModule, typeof i2$1.OverlayModule, typeof TooltipModule, typeof AutoCompleteDirective, typeof CustomAutoCompleteDirective, typeof AutocompleteComponent, typeof SuggestionComponent, typeof AutocompletePlaceholderComponent, typeof SuggestionGroupComponent, typeof SuggestionGroupTitleDirective], [typeof AutoCompleteDirective, typeof CustomAutoCompleteDirective, typeof AutocompleteComponent, typeof SuggestionComponent, typeof AutocompletePlaceholderComponent, typeof SuggestionGroupComponent, typeof SuggestionGroupTitleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AutocompleteModule>;
+}
+declare const AUTOCOMPLETE_MODULE: readonly [typeof AutoCompleteDirective, typeof CustomAutoCompleteDirective, typeof AutocompleteComponent, typeof SuggestionComponent, typeof AutocompletePlaceholderComponent, typeof SuggestionGroupComponent, typeof SuggestionGroupTitleDirective];
+
+type TargetType = Element | Window | string;
+declare class BackTopComponent {
+    private readonly cdkScrollable;
+    set visibilityHeight(val: number);
+    get visibilityHeight(): number;
+    position: {
+        left?: string;
+        right?: string;
+        top?: string;
+        bottom?: string;
+    };
+    set target(val: TargetType);
+    get target(): TargetType;
+    click: EventEmitter<Event>;
+    private _visibilityHeight;
+    private readonly target$$;
+    private readonly visibilityHeight$$;
+    private _target;
+    private _scrollTarget;
+    constructor(cdkScrollable: CdkScrollable$1);
+    display$: rxjs.Observable<string>;
+    getTargetScrollTop(target: Element | Window): number;
+    handleClick(event: Event): void;
+    scrollToTop(duration: number): void;
+    getTarget(target: TargetType): Element | Window;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackTopComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BackTopComponent, "aui-back-top", never, { "visibilityHeight": { "alias": "visibilityHeight"; "required": false; }; "position": { "alias": "position"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, { "click": "click"; }, never, never, true, never>;
+}
+
+declare class BackTopModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackTopModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BackTopModule, never, [typeof i1.CommonModule, typeof IconModule, typeof ButtonModule, typeof BackTopComponent], [typeof BackTopComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BackTopModule>;
+}
+
+declare class BreadcrumbItemComponent {
+    private readonly cdr;
+    get separator(): string;
+    set separator(val: string);
+    get separatorIcon(): string;
+    set separatorIcon(val: string);
+    private _separator;
+    private _separatorIcon;
+    constructor(cdr: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbItemComponent, "aui-breadcrumb-item", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class BreadcrumbComponent implements AfterContentInit {
+    get separator(): string;
+    set separator(val: string);
+    get separatorIcon(): string;
+    set separatorIcon(val: string);
+    items: QueryList<BreadcrumbItemComponent>;
+    private _separator;
+    private _separatorIcon;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "aui-breadcrumb", never, { "separator": { "alias": "separator"; "required": false; }; "separatorIcon": { "alias": "separatorIcon"; "required": false; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+declare class BreadcrumbModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BreadcrumbModule, never, [typeof i1.CommonModule, typeof IconModule, typeof BreadcrumbComponent, typeof BreadcrumbItemComponent], [typeof BreadcrumbComponent, typeof BreadcrumbItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BreadcrumbModule>;
+}
+declare const BREADCRUMB_MODULE: readonly [typeof BreadcrumbComponent, typeof BreadcrumbItemComponent];
+
+declare class CardComponent {
+    divider: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "aui-card", never, { "divider": { "alias": "divider"; "required": false; }; }, {}, never, ["[auiCardHeader]", "*", "[auiCardFooter]"], true, never>;
+}
+
+declare class CardHeaderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CardHeaderDirective, "[auiCardHeader]", never, {}, {}, never, never, true, never>;
+}
+declare class CardFooterDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CardFooterDirective, "[auiCardFooter]", never, {}, {}, never, never, true, never>;
+}
+declare class SectionTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SectionTitleDirective, "[auiSectionTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SectionComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionComponent, "aui-section", never, {}, {}, never, ["[auiSectionTitle]", "*"], true, never>;
+}
+
+declare class CardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CardModule, never, [typeof i1.CommonModule, typeof CardComponent, typeof CardHeaderDirective, typeof CardFooterDirective, typeof SectionComponent, typeof SectionTitleDirective], [typeof CardComponent, typeof CardHeaderDirective, typeof CardFooterDirective, typeof SectionComponent, typeof SectionTitleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CardModule>;
+}
+declare const CARD_MODULE: readonly [typeof CardComponent, typeof CardHeaderDirective, typeof CardFooterDirective, typeof SectionComponent, typeof SectionTitleDirective];
+
+/**
+ * form control 内部不保持 value 属性，当不使用 ngModel 时可以通过 [(value)] 实现双向绑定；
+ * 也可以分别传入 value 和 监听 valueChange 事件以实现阻断用户操作的功能。
+ */
+declare class CommonFormControl<V, M = V> implements ControlValueAccessor {
+    protected cdr: ChangeDetectorRef;
+    get disabled(): boolean | "";
+    set disabled(val: boolean | '');
+    get readonly(): boolean;
+    set readonly(val: boolean);
+    get propValue(): V;
+    set propValue(val: V);
+    valueChange: EventEmitter<V>;
+    protected onChange: (_: V) => void;
+    protected onTouched: () => void;
+    private _propValue;
+    private _disabled;
+    private _readonly;
+    model: M;
+    model$: ReplaySubject<M>;
+    constructor(cdr: ChangeDetectorRef);
+    registerOnChange(fn: (_: V) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: V): void;
+    emitModel(model: M): void;
+    emitValue(value: V): void;
+    protected valueIn(value: V): M;
+    protected modelOut(model: M): V;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommonFormControl<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommonFormControl<any, any>, never, never, { "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "propValue": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare const LabelPosition: {
+    readonly Top: "top";
+    readonly Left: "left";
+    readonly Right: "right";
+};
+type LabelPosition = ValueOf<typeof LabelPosition>;
+declare const FormItemWidth: {
+    readonly Small: "small";
+    /**
+     * @deprecated Prefer to 'Large'
+     */
+    readonly Medium: "medium";
+    readonly Large: "large";
+};
+type FormItemWidth = ValueOf<typeof FormItemWidth>;
+
+declare class FormDirective {
+    controlContainer?: ControlContainer;
+    get ngClassSubmitted(): boolean;
+    private readonly labelWidth$$;
+    private readonly labelPosition$$;
+    private readonly emptyAddon$$;
+    set labelWidth(val: string);
+    set labelPosition(val: LabelPosition);
+    set emptyAddon(val: boolean);
+    inline: boolean;
+    labelWidth$: Observable<string>;
+    labelPosition$: Observable<LabelPosition>;
+    emptyAddon$: Observable<boolean>;
+    constructor(controlContainer?: ControlContainer);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormDirective, "form[auiForm]", ["auiForm"], { "labelWidth": { "alias": "auiFormLabelWidth"; "required": false; }; "labelPosition": { "alias": "auiFormLabelPosition"; "required": false; }; "emptyAddon": { "alias": "auiFormEmptyAddon"; "required": false; }; "inline": { "alias": "auiFormInline"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FormItemLabelDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormItemLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormItemLabelDirective, "label[auiFormItemLabel]", never, {}, {}, never, never, true, never>;
+}
+declare class FormItemHintDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormItemHintDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormItemHintDirective, "[auiFormItemHint]", never, {}, {}, never, never, true, never>;
+}
+declare class FormItemAddonDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormItemAddonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormItemAddonDirective, "[auiFormItemAddon]", never, {}, {}, never, never, true, never>;
+}
+declare class FormItemErrorDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormItemErrorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormItemErrorDirective, "[auiFormItemError]", never, {}, {}, never, never, true, never>;
+}
+declare class FormItemControlDirective {
+    required: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormItemControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormItemControlDirective, "[auiFormItemControl]", never, { "required": { "alias": "required"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+}
+
+declare class FormItemComponent implements AfterContentInit, OnDestroy {
+    private readonly cdr;
+    private readonly auiForm;
+    bem: Bem;
+    labelWidth: string;
+    width: FormItemWidth;
+    labelPosition: LabelPosition;
+    emptyAddon: boolean;
+    plain: boolean;
+    itemLabel: FormItemLabelDirective;
+    itemControl: FormItemControlDirective;
+    ngControls: QueryList<NgControl>;
+    addons: QueryList<FormItemAddonDirective>;
+    errors: QueryList<FormItemErrorDirective>;
+    hints: QueryList<FormItemHintDirective>;
+    hasError$: Observable<boolean>;
+    errorCount$: Observable<number>;
+    hintCount$: Observable<number>;
+    parentForm: FormGroupDirective | NgForm;
+    private readonly destroy$$;
+    get formItemWidthClass(): string;
+    constructor(cdr: ChangeDetectorRef, auiForm: FormDirective, ngForm: NgForm, formGroup: FormGroupDirective);
+    ngAfterContentInit(): void;
+    subscribeInputsFromParent(): void;
+    mapControlStatus(control: NgControl): Observable<boolean>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormItemComponent, [null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormItemComponent, "aui-form-item", never, { "labelWidth": { "alias": "labelWidth"; "required": false; }; "width": { "alias": "width"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "emptyAddon": { "alias": "emptyAddon"; "required": false; }; "plain": { "alias": "plain"; "required": false; }; }, {}, ["itemLabel", "itemControl", "ngControls", "addons", "errors", "hints"], ["label[auiFormItemLabel]", "*", "[auiFormItemAddon]", "[auiFormItemError]", "[auiFormItemHint]"], true, never>;
+}
+
+declare class FormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormModule, never, [typeof i1.CommonModule, typeof FormDirective, typeof FormItemComponent, typeof FormItemAddonDirective, typeof FormItemErrorDirective, typeof FormItemHintDirective, typeof FormItemLabelDirective, typeof FormItemControlDirective], [typeof FormDirective, typeof FormItemComponent, typeof FormItemAddonDirective, typeof FormItemErrorDirective, typeof FormItemHintDirective, typeof FormItemLabelDirective, typeof FormItemControlDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormModule>;
+}
+declare const FORM_MODULE: readonly [typeof FormDirective, typeof FormItemComponent, typeof FormItemAddonDirective, typeof FormItemErrorDirective, typeof FormItemHintDirective, typeof FormItemLabelDirective, typeof FormItemControlDirective];
+
+declare class OptionGroupTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionGroupTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OptionGroupTitleDirective, "[auiOptionGroupTitle]", ["auiOptionGroupTitle"], {}, {}, never, never, true, never>;
+}
+declare class OptionContentDirective implements OnDestroy {
+    private readonly templateRef;
+    private readonly appRef;
+    private readonly viewContainerRef;
+    private readonly injector;
+    private portal;
+    private outlet;
+    private readonly doc;
+    constructor(templateRef: TemplateRef<unknown>, appRef: ApplicationRef, viewContainerRef: ViewContainerRef, injector: Injector, document: any);
+    attach(context?: any): void;
+    detach(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OptionContentDirective, "*[auiOptionContent]", ["auiOptionContent"], {}, {}, never, never, true, never>;
+}
+
+declare class OptionComponent<T> {
+    private readonly cdr;
+    bem: Bem;
+    private _disabled;
+    private _label;
+    private _labelContext;
+    private _value;
+    private readonly label$$;
+    private readonly labelContext$$;
+    private readonly value$$;
+    private readonly disabled$$;
+    get label(): string | TemplateRef<unknown>;
+    set label(val: string | TemplateRef<unknown>);
+    get labelContext(): unknown;
+    set labelContext(val: unknown);
+    get value(): T;
+    set value(val: T);
+    get disabled(): boolean;
+    set disabled(val: boolean | '');
+    isMulti: boolean;
+    elRef: ElementRef<HTMLDivElement>;
+    private readonly select;
+    selected: boolean;
+    visible: boolean;
+    size: ComponentSize;
+    focused: boolean;
+    value$: Observable<T>;
+    label$: Observable<string | TemplateRef<unknown>>;
+    labelContext$: Observable<unknown>;
+    disabled$: Observable<boolean>;
+    selected$: Observable<boolean>;
+    size$: Observable<ComponentSize>;
+    visible$: Observable<boolean>;
+    constructor(cdr: ChangeDetectorRef, select: BaseSelect<T>);
+    onClick(): void;
+    focus(): void;
+    blur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OptionComponent<any>, "aui-option", never, { "label": { "alias": "label"; "required": false; }; "labelContext": { "alias": "labelContext"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface SelectOption {
+    label: TemplateRef<unknown> | string;
+    labelContext?: unknown;
+}
+interface SelectFilterOption<T> extends SelectOption {
+    disabled?: boolean;
+    value: T;
+}
+type OptionFilterFn<T> = (filter: string, option: SelectFilterOption<T>) => boolean;
+type TrackFn<T, R = unknown> = (value: T) => R;
+type TagClassFn<V, T extends TemplateRef<unknown> | string = TemplateRef<unknown> | string> = (label: T, value: V) => Set<string> | string[] | string | {
+    [className: string]: unknown;
+};
+declare enum SelectAllStatus {
+    Empty = "",
+    Checked = "checked",
+    Indeterminate = "indeterminate"
+}
+
+declare abstract class BaseSelect<T, V = T> extends CommonFormControl<V> implements AfterContentInit, AfterViewInit, OnDestroy {
+    get size(): ComponentSize;
+    set size(val: ComponentSize);
+    filterable: boolean;
+    clearable: boolean;
+    filterFn: OptionFilterFn<T>;
+    trackFn: TrackFn<T>;
+    labelFn?: (value: T) => string;
+    allowCreate: boolean;
+    get allOptions(): OptionComponent<T>[];
+    get opened(): boolean;
+    get inaction(): boolean;
+    get filterString(): string;
+    set filterString(val: string);
+    loading: boolean;
+    placeholder: string;
+    defaultFirstOption: boolean;
+    lazy: boolean;
+    filterChange: EventEmitter<string>;
+    show: EventEmitter<void>;
+    hide: EventEmitter<void>;
+    protected selectRef: ElementRef<HTMLElement>;
+    protected tooltipRef: TooltipDirective;
+    protected optionListRef: ElementRef<HTMLDivElement>;
+    protected inputtingOption: OptionComponent<T>;
+    protected optionContent?: OptionContentDirective;
+    customOptions: QueryList<OptionComponent<T>>;
+    contentOptions: QueryList<OptionComponent<T>>;
+    isTemplateRef: (label: any) => label is i0.TemplateRef<unknown>;
+    isMulti: boolean;
+    /**
+     * Utility field to make sure the users always see the value as type array
+     */
+    abstract readonly values$: Observable<T[]>;
+    allOptions$: Observable<Array<OptionComponent<T>>>;
+    protected focusedOption: OptionComponent<T>;
+    private _size;
+    private _filterString;
+    protected destroy$$: Subject<void>;
+    protected size$$: BehaviorSubject<ComponentSize>;
+    private readonly filterString$$;
+    size$: Observable<ComponentSize>;
+    filterString$: Observable<string>;
+    optionVisibles$: Observable<boolean[]>;
+    hasVisibleOption$: Observable<boolean>;
+    hasMatchedOption$: Observable<boolean>;
+    customCreatedOptions$: Observable<Array<SelectFilterOption<T>>>;
+    containerWidth: string;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    openOption(): void;
+    closeOption(): void;
+    onShowOptions(): void;
+    onHideOptions(): void;
+    onInput(event: Event): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onOptionClick(option: OptionComponent<T>): void;
+    protected autoFocusFirstOption(): void;
+    protected focusOptionDir(dir: 'down' | 'up'): void;
+    protected resetFocusedOption(focusedOption?: OptionComponent<T>): void;
+    protected scrollToOption(option: OptionComponent<T>): void;
+    protected selectFocusedOption(): void;
+    protected escSelect(): void;
+    private _trackFn;
+    private _filterFn;
+    abstract selectOption(option: OptionComponent<T>): void;
+    abstract clearValue(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSelect<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseSelect<any, any>, never, never, { "size": { "alias": "size"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "filterFn": { "alias": "filterFn"; "required": false; }; "trackFn": { "alias": "trackFn"; "required": false; }; "labelFn": { "alias": "labelFn"; "required": false; }; "allowCreate": { "alias": "allowCreate"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "defaultFirstOption": { "alias": "defaultFirstOption"; "required": false; }; "lazy": { "alias": "lazy"; "required": false; }; }, { "filterChange": "filterChange"; "show": "show"; "hide": "hide"; }, ["optionContent", "contentOptions"], never, true, never>;
+    static ngAcceptInputType_filterable: unknown;
+    static ngAcceptInputType_clearable: unknown;
+    static ngAcceptInputType_allowCreate: unknown;
+}
+
+declare class MultiSelectComponent<T = unknown> extends BaseSelect<T, T[]> implements AfterContentInit, AfterViewInit {
+    private readonly renderer;
+    bem: Bem;
+    bemSelectAll: Bem;
+    selectedOptions$: Observable<Array<SelectFilterOption<T>>>;
+    selectAllStatus$: Observable<SelectAllStatus>;
+    selectAllStatus: SelectAllStatus;
+    hasEnabledOptions$: Observable<boolean>;
+    isMulti: boolean;
+    model: T[];
+    values$: rxjs.ReplaySubject<T[]>;
+    tagClassFn: TagClassFn<T>;
+    maxRowCount: number;
+    customRowHeight: number;
+    allowSelectAll: boolean;
+    inputRef: ElementRef<HTMLInputElement>;
+    inputValueMirror: ElementRef<HTMLElement>;
+    get hostPosition(): string;
+    get hostDisplay(): string;
+    inputValue: string;
+    hasDisabledOption: boolean;
+    get rootClass(): string;
+    get tagSize(): "medium" | "mini";
+    get inputClass(): string;
+    get displayClearBtn(): number;
+    get maxHeight(): string;
+    private readonly withMaxRowCount;
+    focused: boolean;
+    trackByValue: (_: number, item: SelectFilterOption<T>) => unknown;
+    constructor(cdr: ChangeDetectorRef, renderer: Renderer2);
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    onVisibleOptions(visible: boolean): void;
+    onInput(event: Event): void;
+    onInputFocus(): void;
+    onInputBlur(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    selectOption(option: OptionComponent<T>): void;
+    addValue(value: T): void;
+    removeValue(value: T): void;
+    clearValue(event: Event): void;
+    onSelectAllClick(): void;
+    private includes;
+    protected valueIn(v: T[]): T[];
+    private resetInput;
+    private setInputWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSelectComponent<any>, "aui-multi-select", never, { "tagClassFn": { "alias": "tagClassFn"; "required": false; }; "maxRowCount": { "alias": "maxRowCount"; "required": false; }; "customRowHeight": { "alias": "customRowHeight"; "required": false; }; "allowSelectAll": { "alias": "allowSelectAll"; "required": false; }; }, {}, never, ["*", "aui-option-placeholder"], true, never>;
+    static ngAcceptInputType_allowSelectAll: unknown;
+}
+
+declare class OptionGroupComponent<T> implements AfterContentInit {
+    options: QueryList<OptionComponent<T>>;
+    hasVisibleOption$: Observable<boolean>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionGroupComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OptionGroupComponent<any>, "aui-option-group", never, {}, {}, ["options"], ["[auiOptionGroupTitle]", "*"], true, never>;
+}
+
+declare class OptionPlaceholderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionPlaceholderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OptionPlaceholderComponent, "aui-option-placeholder", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface AutoSizeValue {
+    minRows: number;
+    maxRows?: number;
+}
+/**
+ * Directive to automatically resize a textarea to fit its content.
+ */
+declare class AutosizeDirective implements AfterViewInit, OnDestroy {
+    private readonly elRef;
+    private readonly ngControl;
+    private _autoSize;
+    private readonly destroy$$;
+    get autoSize(): AutoSizeValue | "";
+    set autoSize(value: AutoSizeValue | '');
+    constructor(elRef: ElementRef<HTMLTextAreaElement>, ngControl: NgControl);
+    resizeTextarea(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutosizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutosizeDirective, "textarea[autosize][ngModel],textarea[autosize][formControl],textarea[autosize][formControlName]", ["TextareaAutosize"], { "autoSize": { "alias": "autosize"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InputAddonBeforeDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputAddonBeforeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputAddonBeforeDirective, "[auiInputAddonBefore]", never, {}, {}, never, never, true, never>;
+}
+declare class InputAddonAfterDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputAddonAfterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputAddonAfterDirective, "[auiInputAddonAfter]", never, {}, {}, never, never, true, never>;
+}
+declare class InputPrefixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputPrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputPrefixDirective, "[auiInputPrefix]", never, {}, {}, never, never, true, never>;
+}
+declare class InputSuffixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputSuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputSuffixDirective, "[auiInputSuffix]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InputComponent {
+    elementRef: ElementRef<HTMLInputElement>;
+    private readonly renderer;
+    get size(): ComponentSize;
+    set size(val: ComponentSize);
+    get disabled(): boolean;
+    set disabled(val: boolean | '');
+    private _size;
+    private _disabled;
+    size$: BehaviorSubject<ComponentSize>;
+    disabled$: BehaviorSubject<boolean>;
+    constructor(elementRef: ElementRef<HTMLInputElement>, renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "input[aui-input],textarea[aui-input]", never, { "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const TagType: {
+    readonly Primary: "primary";
+    readonly Success: "success";
+    readonly Warning: "warning";
+    readonly Error: "error";
+    readonly Info: "info";
+};
+type TagType = ValueOf<typeof TagType>;
+
+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>;
+}
+
+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>;
+}
+
+declare class TagModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TagModule, never, [typeof i1.CommonModule, typeof IconModule, typeof TagComponent, typeof CheckTagComponent], [typeof TagComponent, typeof CheckTagComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TagModule>;
+}
+
+declare class ClickOutsideDirective {
+    private readonly el;
+    auiClickOutside: EventEmitter<Event>;
+    onBodyClick(event: Event): void;
+    constructor(el: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[auiClickOutside]", ["auiClickOutside"], {}, { "auiClickOutside": "auiClickOutside"; }, never, never, true, never>;
+}
+
+declare class SharedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedModule, never, [typeof ClickOutsideDirective], [typeof ClickOutsideDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SharedModule>;
+}
+
+declare class InputGroupComponent implements AfterContentInit {
+    bem: Bem;
+    private readonly addonBeforeRefs;
+    private readonly addonAfterRefs;
+    private readonly prefixRefs;
+    private readonly suffixRefs;
+    inputRef: InputComponent;
+    hasAddonBefore$: Observable<boolean>;
+    hasAddonAfter$: Observable<boolean>;
+    hasPrefix$: Observable<boolean>;
+    hasSuffix$: Observable<boolean>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputGroupComponent, "aui-input-group", never, {}, {}, ["inputRef", "addonBeforeRefs", "addonAfterRefs", "prefixRefs", "suffixRefs"], ["[auiInputAddonBefore]", "[auiInputPrefix]", "*", "[auiInputSuffix]", "[auiInputAddonAfter]"], true, never>;
+}
+declare const INPUT_GROUP_MODULE: readonly [typeof InputGroupComponent, typeof InputAddonAfterDirective, typeof InputAddonBeforeDirective, typeof InputPrefixDirective, typeof InputSuffixDirective];
+
+declare class SearchComponent {
+    bem: Bem;
+    size: ComponentSize;
+    searchButton: boolean;
+    clearable: boolean;
+    searching: boolean;
+    placeholder: string;
+    disabled: boolean;
+    get keyword(): string;
+    set keyword(value: string);
+    keywordChange: EventEmitter<string>;
+    search: EventEmitter<string>;
+    clear: EventEmitter<void>;
+    inputRef: ElementRef<HTMLInputElement>;
+    value: string;
+    get showSpinner(): boolean;
+    get showClear(): boolean;
+    focus(): void;
+    emitChange(value: string): void;
+    emitSearch(): void;
+    emitClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SearchComponent, "aui-search", never, { "size": { "alias": "size"; "required": false; }; "searchButton": { "alias": "searchButton"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "searching": { "alias": "searching"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "keyword": { "alias": "keyword"; "required": false; }; }, { "keywordChange": "keywordChange"; "search": "search"; "clear": "clear"; }, never, never, true, never>;
+}
+
+declare const INPUT_ERROR_KEY = "input_data_error";
+declare class TagsInputComponent extends CommonFormControl<string[]> implements AfterViewInit, OnChanges {
+    private readonly fb;
+    private readonly renderer;
+    private readonly injector;
+    bem: Bem;
+    placeholder: string;
+    size: ComponentSize;
+    clearable: boolean | '';
+    allowRepeat: boolean | '';
+    allowEmpty: boolean | '';
+    readonlyTags: string[] | readonly string[];
+    maxRowCount: number;
+    customRowHeight: number;
+    _inputValidator: ValidatorFn;
+    _inputAsyncValidator: AsyncValidatorFn;
+    set inputValidator(fn: ValidatorFn | ValidatorFn[]);
+    get inputValidator(): ValidatorFn | ValidatorFn[];
+    set inputAsyncValidator(fn: AsyncValidatorFn | AsyncValidatorFn[]);
+    get inputAsyncValidator(): AsyncValidatorFn | AsyncValidatorFn[];
+    inputRef: ElementRef<HTMLInputElement>;
+    inputValueMirror: ElementRef<HTMLElement>;
+    get hostPosition(): string;
+    get hostDisplay(): string;
+    get maxHeight(): string;
+    private readonly withMaxRowCount;
+    focused: boolean;
+    model: string[];
+    readonly inputControl: UntypedFormControl;
+    controlContainer: NgControl;
+    get rootClass(): string;
+    get tagSize(): "medium" | "mini";
+    get inputClass(): string;
+    constructor(cdr: ChangeDetectorRef, fb: FormBuilder, renderer: Renderer2, injector: Injector);
+    ngOnChanges({ inputValidator, inputAsyncValidator, disabled, }: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    onRemove(index: number): void;
+    onInput(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onInputFocus(): void;
+    onInputBlur(event: Event): void;
+    trackByValue(_: number, value: string): string;
+    protected valueIn(v: string[]): string[];
+    private sortByReadonly;
+    private pushValue;
+    private syncControlStatus;
+    private removeInputControlError;
+    private clearInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagsInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagsInputComponent, "aui-tags-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "size": { "alias": "size"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "allowRepeat": { "alias": "allowRepeat"; "required": false; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; }; "readonlyTags": { "alias": "readonlyTags"; "required": false; }; "maxRowCount": { "alias": "maxRowCount"; "required": false; }; "customRowHeight": { "alias": "customRowHeight"; "required": false; }; "inputValidator": { "alias": "inputValidator"; "required": false; }; "inputAsyncValidator": { "alias": "inputAsyncValidator"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NumberInputComponent extends CommonFormControl<number> implements AfterContentInit, AfterViewInit {
+    bem: Bem;
+    size: ComponentSize;
+    min: number;
+    max: number;
+    step: number;
+    precision: number;
+    controls: boolean;
+    placeholder: string;
+    controlsPosition: string;
+    angleControls: boolean;
+    clearable: boolean;
+    inputRef: ElementRef<HTMLInputElement>;
+    private readonly addonBeforeRefs;
+    private readonly addonAfterRefs;
+    isFocus: boolean;
+    hasAddonBefore$: Observable<boolean>;
+    hasAddonAfter$: Observable<boolean>;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    valueIn(v: number): number;
+    modelOut(value: number): number;
+    inputChanged(value: string): void;
+    takeOneStep(positive: boolean): void;
+    private parsePrecision;
+    private getStepPrecision;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumberInputComponent, "aui-number-input", never, { "size": { "alias": "size"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "precision": { "alias": "precision"; "required": false; }; "controls": { "alias": "controls"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "controlsPosition": { "alias": "controlsPosition"; "required": false; }; "angleControls": { "alias": "angleControls"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; }, {}, ["addonBeforeRefs", "addonAfterRefs"], ["[auiInputAddonBefore]", "[auiInputAddonAfter]"], true, never>;
+    static ngAcceptInputType_min: number | string;
+    static ngAcceptInputType_max: number | string;
+}
+declare const NUMBER_INPUT_MODULE: readonly [typeof NumberInputComponent, typeof InputAddonBeforeDirective, typeof InputAddonAfterDirective];
+
+declare class InputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InputModule, never, [typeof i1.CommonModule, typeof i2$2.FormsModule, typeof i2$2.ReactiveFormsModule, typeof IconModule, typeof TagModule, typeof SharedModule, typeof AutosizeDirective, typeof InputComponent, typeof InputGroupComponent, typeof InputAddonBeforeDirective, typeof InputAddonAfterDirective, typeof InputPrefixDirective, typeof InputSuffixDirective, typeof SearchComponent, typeof TagsInputComponent, typeof NumberInputComponent], [typeof AutosizeDirective, typeof InputComponent, typeof InputGroupComponent, typeof InputAddonBeforeDirective, typeof InputAddonAfterDirective, typeof InputPrefixDirective, typeof InputSuffixDirective, typeof SearchComponent, typeof TagsInputComponent, typeof NumberInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InputModule>;
+}
+
+declare class SelectComponent<T = unknown> extends BaseSelect<T> implements AfterContentInit {
+    inputRef: InputComponent;
+    values$: Observable<T[]>;
+    selectedOption$: Observable<SelectOption>;
+    hasSelected$: Observable<boolean>;
+    get rootClass(): string;
+    get containerClass(): string;
+    isClearable: (hasSelected: boolean) => boolean;
+    ngAfterContentInit(): void;
+    onVisibleOptions(visible: boolean): void;
+    protected valueIn(v: T): T;
+    selectOption(option: OptionComponent<T>): void;
+    clearValue(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent<any>, "aui-select", never, {}, {}, never, ["*", "aui-option-placeholder"], true, never>;
+}
+
+declare class AuiSelectValidators {
+    static includes<T>(options: T[], trackFn?: TrackFn<T>): ValidatorFn;
+}
+declare class IncludesDirective<T> implements Validator, AfterContentInit {
+    private readonly selectRef;
+    get includes(): boolean | "";
+    set includes(val: boolean | '');
+    trackFn: TrackFn<T>;
+    private _includes;
+    onValidatorChange: () => void;
+    constructor(selectRef: SelectComponent<T>);
+    ngAfterContentInit(): void;
+    registerOnValidatorChange(fn: () => void): void;
+    validate(control: AbstractControl): ValidationErrors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncludesDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IncludesDirective<any>, "aui-select[ngModel][includes],aui-select[formControl][includes],aui-select[formControlName][includes]", never, { "includes": { "alias": "includes"; "required": false; }; "trackFn": { "alias": "trackFn"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface I18NInterface {
+    locale: string;
+    translation: Record<string, string>;
+}
+declare const I18NInterfaceToken: InjectionToken<I18NInterface>;
+
+declare class I18nService {
+    readonly $$i18n: i0.WritableSignal<I18NInterface>;
+    $locale: i0.Signal<string>;
+    $monthBeforeYear: i0.Signal<boolean>;
+    setI18n(i18n: I18NInterface): void;
+    translate(key: string, data?: Record<string, string>, ignoreNonExist?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<I18nService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<I18nService>;
+}
+
+declare class I18nPipe implements PipeTransform {
+    private readonly i18n;
+    constructor(i18n: I18nService);
+    transform(value: any, data?: Record<string, string>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<I18nPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<I18nPipe, "auiI18n", true>;
+}
+
+declare class I18nModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<I18nModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<I18nModule, never, [typeof I18nPipe], [typeof I18nPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<I18nModule>;
+}
+
+declare class SelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectModule, never, [typeof i1.CommonModule, typeof InputModule, typeof I18nModule, typeof IconModule, typeof TooltipModule, typeof TagModule, typeof SelectComponent, typeof OptionComponent, typeof OptionGroupComponent, typeof OptionPlaceholderComponent, typeof MultiSelectComponent, typeof IncludesDirective, typeof OptionGroupTitleDirective, typeof OptionContentDirective], [typeof SelectComponent, typeof OptionComponent, typeof OptionGroupComponent, typeof OptionPlaceholderComponent, typeof MultiSelectComponent, typeof IncludesDirective, typeof OptionGroupTitleDirective, typeof OptionContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectModule>;
+}
+declare const SELECT_MODULE: readonly [typeof SelectComponent, typeof OptionComponent, typeof OptionGroupComponent, typeof OptionPlaceholderComponent, typeof MultiSelectComponent, typeof IncludesDirective, typeof OptionGroupTitleDirective, typeof OptionContentDirective];
+
+declare class CheckboxGroupComponent<T> extends CommonFormControl<T[]> {
+    private _trackFn;
+    direction: 'column' | 'row';
+    get trackFn(): TrackFn<T>;
+    set trackFn(val: TrackFn<T>);
+    checkboxes: QueryList<CheckboxComponent<T>>;
+    onCheckboxChange(checkbox: CheckboxComponent<T>): void;
+    onCheckboxBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxGroupComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxGroupComponent<any>, "aui-checkbox-group", never, { "direction": { "alias": "direction"; "required": false; }; "trackFn": { "alias": "trackFn"; "required": false; }; }, {}, ["checkboxes"], ["*"], true, never>;
+}
+
+declare class CheckboxComponent<T> extends CommonFormControl<boolean> implements AfterViewInit, OnDestroy {
+    private readonly focusMonitor;
+    id: string;
+    name: string;
+    type: string;
+    get label(): T;
+    set label(val: T);
+    get indeterminate(): boolean;
+    set indeterminate(value: boolean);
+    elRef: ElementRef;
+    private readonly checkboxGroup;
+    private _label;
+    private readonly label$$;
+    private _indeterminate;
+    private readonly destroy$$;
+    constructor(cdr: ChangeDetectorRef, checkboxGroup: CheckboxGroupComponent<T>, focusMonitor: FocusMonitor);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onClick(): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent<any>, [null, { optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent<any>, "aui-checkbox", never, { "name": { "alias": "name"; "required": false; }; "type": { "alias": "type"; "required": false; }; "label": { "alias": "label"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class CheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CheckboxModule, never, [typeof i1.CommonModule, typeof IconModule, typeof CheckboxComponent, typeof CheckboxGroupComponent], [typeof CheckboxComponent, typeof CheckboxGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CheckboxModule>;
+}
+declare const CHECKBOX_MODULE: readonly [typeof CheckboxComponent, typeof CheckboxGroupComponent];
+
+declare class ColorPickerComponent extends CommonFormControl<string> {
+    onInput(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorPickerComponent, "aui-color-picker", never, {}, {}, never, never, true, never>;
+}
+
+declare class ColorPickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ColorPickerModule, never, [typeof i1.CommonModule, typeof i2$2.FormsModule, typeof ColorPickerComponent], [typeof ColorPickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ColorPickerModule>;
+}
+
+declare enum Side {
+    Left = "left",
+    Right = "right"
+}
+type DisabledTimeFn = (date?: Dayjs) => {
+    hours: () => number[];
+    minutes: (hour?: number) => number[];
+    seconds: (hour?: number, minute?: number) => number[];
+};
+interface CalendarHeaderRange {
+    start: Dayjs;
+    end?: Dayjs;
+}
+declare enum DateNavRange {
+    Decade = "decade",
+    Year = "year",
+    Month = "month"
+}
+type DisabledDateFn = (date: Dayjs, type: DateNavRange) => boolean;
+
+declare const DATE = "date";
+declare const DAY = "day";
+declare const MONTH = "month";
+declare const YEAR = "year";
+declare const HOUR = "hour";
+declare const MINUTE = "minute";
+declare const SECOND = "second";
+declare enum DatePickerType {
+    Day = "date",
+    Month = "month",
+    Year = "year"
+}
+declare const MONTH_PANEL_COLUMN_COUNT = 3;
+declare const MONTH_PANEL_ROW_COUNT = 4;
+declare const YEAR_PANEL_COLUMN_COUNT = 3;
+declare const YEAR_PANEL_ROW_COUNT = 4;
+declare const DAY_PANEL_COLUMN_COUNT = 7;
+declare const DAY_PANEL_ROW_COUNT = 6;
+declare const DATE_TYPES: DatePickerType[];
+declare const DATE_NAV_RANGES: DateNavRange[];
+
+declare enum TimePickerControlType {
+    Hour = "hour",
+    Minute = "minute",
+    Second = "second"
+}
+interface TimePickerModel {
+    hour?: number;
+    minute?: number;
+    second?: number;
+}
+type TimePickerDataLike = ConfigType | TimePickerModel;
+declare function isTimePickerModel(item: any): item is TimePickerModel;
+
+declare class TimePickerComponent extends CommonFormControl<TimePickerDataLike, TimePickerModel> {
+    format: string;
+    size: ComponentSize;
+    placeholder: string;
+    clearable: boolean;
+    showIcon: boolean;
+    disableHours: () => number[];
+    disableMinutes: (hour?: number) => number[];
+    disableSeconds: (hour?: number, minute?: number) => number[];
+    hourStep: number;
+    minuteStep: number;
+    secondStep: number;
+    footerTemplate: TemplateRef<void>;
+    readonly open: EventEmitter<void>;
+    readonly close: EventEmitter<void>;
+    tooltipRef: TooltipDirective;
+    timeValue: Dayjs;
+    timeFormatValue: string;
+    writeValue(value: TimePickerDataLike): void;
+    setValue(value: Dayjs): void;
+    changeFromPanel(value: Dayjs): void;
+    changeFromInput(source: string): void;
+    onKeyDown(event: KeyboardEvent): void;
+    handleTooltipVisible(visible: boolean): void;
+    openPanel(): void;
+    closePanel(): void;
+    clearValue(event: Event): void;
+    submit(close?: boolean, value?: Dayjs): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimePickerComponent, "aui-time-picker", never, { "format": { "alias": "format"; "required": false; }; "size": { "alias": "size"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "disableHours": { "alias": "disableHours"; "required": false; }; "disableMinutes": { "alias": "disableMinutes"; "required": false; }; "disableSeconds": { "alias": "disableSeconds"; "required": false; }; "hourStep": { "alias": "hourStep"; "required": false; }; "minuteStep": { "alias": "minuteStep"; "required": false; }; "secondStep": { "alias": "secondStep"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; }, { "open": "open"; "close": "close"; }, never, never, true, never>;
+}
+
+declare const HOUR_ITEMS: number[];
+declare const MINUTE_ITEMS: number[];
+declare const SECOND_ITEMS: number[];
+declare const CONTROL_ITEM_HEIGHT = 28;
+
+declare class TimePickerPanelComponent extends CommonFormControl<Dayjs> implements OnChanges {
+    protected cdr: ChangeDetectorRef;
+    set format(value: string);
+    get format(): string;
+    private _format;
+    get totalWidth(): number;
+    onMousedown(): boolean;
+    hourStep: number;
+    minuteStep: number;
+    secondStep: number;
+    footerTemplate: TemplateRef<void>;
+    confirm: EventEmitter<void>;
+    disableHours: () => number[];
+    disableMinutes: (hour?: number) => number[];
+    disableSeconds: (hour?: number, minute?: number) => number[];
+    hourEnabled: boolean;
+    minuteEnabled: boolean;
+    secondEnabled: boolean;
+    TimePickerControlType: typeof TimePickerControlType;
+    HOUR_ITEM_CONFIG: number[];
+    MINUTE_ITEM_CONFIG: number[];
+    SECOND_ITEM_CONFIG: number[];
+    CONTROL_ITEM_HEIGHT: number;
+    ComponentSize: {
+        readonly Large: "large";
+        readonly Medium: "medium";
+        readonly Small: "small";
+        readonly Mini: "mini";
+        readonly Empty: "";
+    };
+    bem: _alauda_ui.Bem;
+    hourRef: ElementRef<HTMLElement>;
+    minuteRef: ElementRef<HTMLElement>;
+    secondRef: ElementRef<HTMLElement>;
+    enabledColumns: number;
+    firstScrolled: boolean;
+    constructor(cdr: ChangeDetectorRef);
+    isDisabled(value: number, type: TimePickerControlType): boolean;
+    ngOnChanges({ hourStep, minuteStep, secondStep }: SimpleChanges): void;
+    writeValue(value: Dayjs): void;
+    selectValue(value: number, type: TimePickerControlType): void;
+    syncValue(value: number, type: TimePickerControlType, currentValue: Dayjs): dayjs.Dayjs;
+    syncScrollOffset(duration: number, value: Dayjs): void;
+    private scrollByValue;
+    matchValue(value: number, type: TimePickerControlType, currDate: Dayjs): boolean;
+    getControlTypeConfig(type: TimePickerControlType): number[];
+    selectNow(): void;
+    trackBy(_index: number, content: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimePickerPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimePickerPanelComponent, "aui-time-picker-panel", never, { "format": { "alias": "format"; "required": false; }; "hourStep": { "alias": "hourStep"; "required": false; }; "minuteStep": { "alias": "minuteStep"; "required": false; }; "secondStep": { "alias": "secondStep"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; "disableHours": { "alias": "disableHours"; "required": false; }; "disableMinutes": { "alias": "disableMinutes"; "required": false; }; "disableSeconds": { "alias": "disableSeconds"; "required": false; }; }, { "confirm": "confirm"; }, never, never, true, never>;
+}
+
+declare class TimePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TimePickerModule, never, [typeof i2$2.FormsModule, typeof i2$2.ReactiveFormsModule, typeof i3.PortalModule, typeof i2$1.OverlayModule, typeof i1.CommonModule, typeof InputModule, typeof TooltipModule, typeof IconModule, typeof ButtonModule, typeof I18nModule, typeof TimePickerComponent, typeof TimePickerPanelComponent], [typeof TimePickerComponent, typeof TimePickerPanelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TimePickerModule>;
+}
+declare const TIME_PICKER_MODULE: readonly [typeof TimePickerComponent, typeof TimePickerPanelComponent];
+
+declare class DatePickerPanelComponent extends CommonFormControl<Dayjs> {
+    clearable: boolean;
+    clearText: string;
+    set type(type: DatePickerType);
+    get type(): DatePickerType;
+    private _type;
+    showTime: boolean;
+    disabledDate: (date: Dayjs, type: DateNavRange) => boolean;
+    disabledTime: DisabledTimeFn;
+    weekStartDay: number;
+    showFooter: boolean;
+    footerTemplate: TemplateRef<unknown>;
+    extraFooter: TemplateRef<unknown>;
+    minDate: Dayjs;
+    maxDate: Dayjs;
+    confirm: EventEmitter<dayjs.Dayjs>;
+    clear: EventEmitter<void>;
+    private _cacheSelectedDate;
+    private _cacheDisabledTimeFn;
+    getDisabledTimeFn(selectedDate: Dayjs, type: keyof ReturnType<DisabledTimeFn>): (() => number[]) | ((hour?: number) => number[]) | ((hour?: number, minute?: number) => number[]);
+    navRange: DateNavRange;
+    get currentNavType(): DatePickerType;
+    anchor: Dayjs;
+    selectedDate: Dayjs;
+    selectedTime: TimePickerModel;
+    DateNavRange: typeof DateNavRange;
+    DatePickerType: typeof DatePickerType;
+    writeValue(obj: Dayjs): void;
+    panelValueChange(value: Dayjs): void;
+    confirmValue(value?: ConfigType, closeAfterConfirm?: boolean): void;
+    timeDateChange(time: TimePickerModel): void;
+    setToday(): void;
+    clearValue(): void;
+    private _disabledTimeFn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatePickerPanelComponent, "aui-date-picker-panel", never, { "clearable": { "alias": "clearable"; "required": false; }; "clearText": { "alias": "clearText"; "required": false; }; "type": { "alias": "type"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "disabledDate": { "alias": "disabledDate"; "required": false; }; "disabledTime": { "alias": "disabledTime"; "required": false; }; "weekStartDay": { "alias": "weekStartDay"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; "extraFooter": { "alias": "extraFooter"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "confirm": "confirm"; "clear": "clear"; }, never, never, true, never>;
+}
+
+declare class CalendarFooterComponent {
+    clearable: boolean;
+    clearText: string;
+    customAction: TemplateRef<any>;
+    confirm: EventEmitter<void>;
+    clear: EventEmitter<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarFooterComponent, "aui-calendar-footer", never, { "clearable": { "alias": "clearable"; "required": false; }; "clearText": { "alias": "clearText"; "required": false; }; "customAction": { "alias": "customAction"; "required": false; }; }, { "confirm": "confirm"; "clear": "clear"; }, never, ["*"], true, never>;
+}
+
+declare class CalendarHeaderComponent {
+    get dateNavRange(): DateNavRange;
+    set dateNavRange(val: DateNavRange);
+    get anchor(): dayjs.Dayjs;
+    set anchor(val: dayjs.Dayjs);
+    maxAvail?: ConfigType;
+    private get _maxAvail();
+    minAvail?: ConfigType;
+    private get _minAvail();
+    navRangeChange: EventEmitter<DateNavRange>;
+    anchorChange: EventEmitter<dayjs.Dayjs>;
+    private readonly $$dateNavRange;
+    private readonly $$anchor;
+    private readonly i18nService;
+    bem: _alauda_ui.Bem;
+    DateNavRange: typeof DateNavRange;
+    $monthBeforeYear: i0.Signal<boolean>;
+    $headerRange: i0.Signal<{
+        start: {
+            year: string;
+            month: string;
+        };
+        end: {
+            year: string;
+            month: string;
+        };
+    }>;
+    shouldShowNav(type: DateNavRange, side: Side): boolean;
+    compareNavValue(type: DateNavRange, constrain: Dayjs, anchor: Dayjs): 1 | 0 | -1;
+    navHead(range: DateNavRange, value: number): void;
+    clickNav: (range: DateNavRange) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarHeaderComponent, "aui-calendar-header", never, { "dateNavRange": { "alias": "dateNavRange"; "required": false; }; "anchor": { "alias": "anchor"; "required": false; }; "maxAvail": { "alias": "maxAvail"; "required": false; }; "minAvail": { "alias": "minAvail"; "required": false; }; }, { "navRangeChange": "navRangeChange"; "anchorChange": "anchorChange"; }, never, never, true, never>;
+}
+
+declare class DateCell {
+    value: Dayjs;
+    label: number | string;
+    isBackground?: boolean;
+    inRange?: boolean;
+    isRangeStart?: boolean;
+    isRangeEnd?: boolean;
+    isDisabled?: boolean;
+    constructor(value: Dayjs, label: number | string);
+}
+
+declare class PickerPanelComponent implements OnChanges {
+    private readonly cdr;
+    navRange: DateNavRange;
+    type: DatePickerType;
+    anchor: dayjs.Dayjs;
+    matchDates: Dayjs[];
+    disabledDate: (date: Dayjs, navRange: DateNavRange) => boolean;
+    set weekStartDay(day: number);
+    get weekStartDay(): number;
+    minDate: Dayjs;
+    maxDate: Dayjs;
+    get disabledDateFn(): (date: Dayjs, navRange: DateNavRange) => boolean;
+    private _weekStartDay;
+    panelData: DateCell[][];
+    select: EventEmitter<dayjs.Dayjs>;
+    hovered: EventEmitter<dayjs.Dayjs>;
+    bem: _alauda_ui.Bem;
+    DateNavRange: typeof DateNavRange;
+    weekDefs: string[];
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    renderPanelData(date: Dayjs, navRange: DateNavRange): void;
+    match(value: Dayjs): boolean;
+    matchToday(value: Dayjs): boolean;
+    selectValue(value: Dayjs): void;
+    trackByFn(): DateNavRange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PickerPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PickerPanelComponent, "aui-picker-panel", never, { "navRange": { "alias": "navRange"; "required": false; }; "type": { "alias": "type"; "required": false; }; "anchor": { "alias": "anchor"; "required": false; }; "matchDates": { "alias": "matchDates"; "required": false; }; "disabledDate": { "alias": "disabledDate"; "required": false; }; "weekStartDay": { "alias": "weekStartDay"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "select": "select"; "hovered": "hovered"; }, never, never, true, never>;
+}
+
+declare class DateRangePickerPanelComponent extends CommonFormControl<Dayjs[]> {
+    clearable: boolean;
+    clearText: string;
+    showTime: boolean;
+    showFooter: boolean;
+    disabledDate: (date: Dayjs, navRange: DateNavRange, startDate: Dayjs) => boolean;
+    disabledTime: {
+        left: DisabledTimeFn;
+        right: DisabledTimeFn;
+    };
+    weekStartDay: number;
+    minDate: Dayjs;
+    maxDate: Dayjs;
+    clear: EventEmitter<void>;
+    confirm: EventEmitter<void>;
+    bem: _alauda_ui.Bem;
+    Side: typeof Side;
+    DatePickerType: typeof DatePickerType;
+    leftDateRange: DateNavRange;
+    rightDateRange: DateNavRange;
+    FOOTER_DATE_FORMAT: string;
+    leftAnchor: dayjs.Dayjs;
+    rightAnchor: dayjs.Dayjs;
+    get maxHeaderAvail(): dayjs.Dayjs;
+    get minHeaderAvail(): dayjs.Dayjs;
+    rangeValue: Dayjs[];
+    matchValues: Dayjs[];
+    startTime: TimePickerModel;
+    endTime: TimePickerModel;
+    writeValue(obj: Dayjs[]): void;
+    calendarRangeChange(type: DateNavRange, side: Side): void;
+    getDateDisabledFn(side: Side, constrainValue: Dayjs): (date: Dayjs, navRange: DateNavRange) => boolean;
+    private getDisabledTimeCachedFn;
+    leftDisabledTimeFn: (value: Dayjs, key: keyof ReturnType<DisabledTimeFn>) => (() => number[]) | ((hour?: number) => number[]) | ((hour?: number, minute?: number) => number[]);
+    rightDisabledTimeFn: (value: Dayjs, key: keyof ReturnType<DisabledTimeFn>) => (() => number[]) | ((hour?: number) => number[]) | ((hour?: number, minute?: number) => number[]);
+    selectPickerPanel(value: Dayjs, side: Side): void;
+    reorder(sortedDate: Dayjs[]): void;
+    hoverItem(date: Dayjs): void;
+    confirmValue(value: Dayjs[], closeThen?: boolean): void;
+    timeChange(time: TimePickerModel): void;
+    syncTime(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangePickerPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangePickerPanelComponent, "aui-date-range-picker-panel", never, { "clearable": { "alias": "clearable"; "required": false; }; "clearText": { "alias": "clearText"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "disabledDate": { "alias": "disabledDate"; "required": false; }; "disabledTime": { "alias": "disabledTime"; "required": false; }; "weekStartDay": { "alias": "weekStartDay"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "clear": "clear"; "confirm": "confirm"; }, never, never, true, never>;
+}
+
+declare class RangePickerComponent extends CommonFormControl<ConfigType[], Dayjs[]> {
+    clearable: boolean;
+    clearText: string;
+    format: string;
+    showFooter: boolean;
+    showTime: boolean;
+    disabledDate: DisabledDateFn;
+    minDate: Dayjs;
+    maxDate: Dayjs;
+    disabledTime: {
+        left: DisabledTimeFn;
+        right: DisabledTimeFn;
+    };
+    weekStartDay: number;
+    size: ComponentSize;
+    visibleChange: EventEmitter<boolean>;
+    value: [Dayjs, Dayjs];
+    valueIn(obj: [ConfigType, ConfigType]): dayjs.Dayjs[];
+    writeValue(obj: [Dayjs, Dayjs]): void;
+    clearValue(): void;
+    tooltipVisibleChange(visible: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RangePickerComponent, "aui-range-picker", never, { "clearable": { "alias": "clearable"; "required": false; }; "clearText": { "alias": "clearText"; "required": false; }; "format": { "alias": "format"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "disabledDate": { "alias": "disabledDate"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabledTime": { "alias": "disabledTime"; "required": false; }; "weekStartDay": { "alias": "weekStartDay"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "visibleChange": "visibleChange"; }, never, never, true, never>;
+}
+
+declare class DatePickerComponent extends CommonFormControl<ConfigType, Dayjs> {
+    clearable: boolean;
+    clearText: string;
+    format: string;
+    showTime: boolean;
+    type: DatePickerType;
+    size: "medium";
+    disabledDate: (date: Dayjs, type: DateNavRange) => boolean;
+    disabledTime: DisabledTimeFn;
+    minDate: Dayjs;
+    maxDate: Dayjs;
+    weekStartDay: number;
+    showFooter: boolean;
+    footerTemplate: TemplateRef<unknown>;
+    extraFooter: TemplateRef<unknown>;
+    placeholder: string;
+    visibleChange: EventEmitter<boolean>;
+    value: Dayjs;
+    DatePickerType: typeof DatePickerType;
+    valueIn(obj: ConfigType): dayjs.Dayjs;
+    writeValue(obj: Dayjs): void;
+    clearValue(): void;
+    tooltipVisibleChange(visible: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatePickerComponent, "aui-date-picker", never, { "clearable": { "alias": "clearable"; "required": false; }; "clearText": { "alias": "clearText"; "required": false; }; "format": { "alias": "format"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabledDate": { "alias": "disabledDate"; "required": false; }; "disabledTime": { "alias": "disabledTime"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "weekStartDay": { "alias": "weekStartDay"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; "extraFooter": { "alias": "extraFooter"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "visibleChange": "visibleChange"; }, never, never, true, never>;
+}
+
+declare class DatePickerTriggerComponent {
+    get value(): Dayjs | Dayjs[];
+    set value(val: Dayjs | Dayjs[]);
+    get format(): string;
+    set format(val: string);
+    get isRange(): boolean;
+    set isRange(val: boolean);
+    size: ComponentSize;
+    clearable: boolean;
+    placeholder: string;
+    startPlaceholder: string;
+    endPlaceholder: string;
+    disabled: boolean;
+    blur: EventEmitter<void>;
+    clear: EventEmitter<void>;
+    focusInputRef: InputComponent;
+    centerFocus: boolean;
+    leftFocus: boolean;
+    rightFocus: boolean;
+    hovered: boolean;
+    bem: _alauda_ui.Bem;
+    get isFocus(): boolean;
+    get hasValue(): boolean | Dayjs;
+    get showClear(): boolean;
+    private readonly i18nService;
+    private readonly $$value;
+    private readonly $$format;
+    private readonly $$isRange;
+    $formatValue: i0.Signal<string | string[]>;
+    constructor();
+    focusInput(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerTriggerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatePickerTriggerComponent, "aui-date-picker-trigger", never, { "value": { "alias": "value"; "required": false; }; "format": { "alias": "format"; "required": false; }; "isRange": { "alias": "isRange"; "required": false; }; "size": { "alias": "size"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "startPlaceholder": { "alias": "startPlaceholder"; "required": false; }; "endPlaceholder": { "alias": "endPlaceholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "blur": "blur"; "clear": "clear"; }, never, never, true, never>;
+}
+
+declare class DatePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DatePickerModule, never, [typeof i1.CommonModule, typeof InputModule, typeof ButtonModule, typeof TooltipModule, typeof i2$2.ReactiveFormsModule, typeof i2$2.FormsModule, typeof TimePickerModule, typeof IconModule, typeof I18nModule, typeof CalendarHeaderComponent, typeof CalendarFooterComponent, typeof DateRangePickerPanelComponent, typeof PickerPanelComponent, typeof RangePickerComponent, typeof DatePickerPanelComponent, typeof DatePickerComponent, typeof DatePickerTriggerComponent], [typeof CalendarHeaderComponent, typeof CalendarFooterComponent, typeof DateRangePickerPanelComponent, typeof PickerPanelComponent, typeof RangePickerComponent, typeof DatePickerPanelComponent, typeof DatePickerComponent, typeof DatePickerTriggerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DatePickerModule>;
+}
+
+declare enum DialogSize {
+    Small = "small",
+    Medium = "medium",
+    Big = "big",
+    Large = "large",
+    Fullscreen = "fullscreen",
+    FitContent = "fit-content"
+}
+declare enum ConfirmType {
+    Primary = "primary",
+    Success = "success",
+    Warning = "warning",
+    Danger = "danger"
+}
+type PromiseExecutor<T> = (resolve: (result?: PromiseLike<T> | T) => void, reject: (reason?: unknown) => void) => void;
+type CustomBeforeAction<T> = () => Observable<T> | PromiseLike<T>;
+type BeforeAction<T> = CustomBeforeAction<T> | PromiseExecutor<T>;
+
+declare class BaseDialogConfig {
+    noAnimation?: boolean;
+}
+declare class DialogConfig<D = any> extends BaseDialogConfig {
+    id?: number;
+    viewContainerRef?: ViewContainerRef;
+    data?: D;
+    size?: DialogSize;
+    hasBackdrop?: boolean;
+    fitViewport?: boolean;
+    customClass?: string;
+}
+
+declare class ConfirmDialogConfig<T = unknown, R = unknown> extends BaseDialogConfig {
+    title: string;
+    content?: TemplateRef<any> | Type<any> | string;
+    cancelButton?: boolean;
+    confirmType?: ConfirmType;
+    confirmText?: string;
+    cancelText?: string;
+    beforeConfirm?: BeforeAction<T>;
+    beforeCancel?: BeforeAction<R>;
+}
+
+declare class DialogComponent {
+    private readonly elementRef;
+    private readonly render;
+    portalOutlet: CdkPortalOutlet;
+    bem: Bem;
+    config: DialogConfig;
+    state: 'enter' | 'exit' | 'void';
+    animationStateChanged: EventEmitter<AnimationEvent>;
+    elementFocusedBeforeModalWasOpened: HTMLElement;
+    overlayRef: OverlayRef;
+    get id(): string;
+    set id(value: string);
+    private readonly _id;
+    get rootClass(): string;
+    get zoomClassMap(): {
+        enter: string;
+        enterActive: string;
+        leave: string;
+        leaveActive: string;
+    };
+    get fadeClassMap(): {
+        enter: string;
+        enterActive: string;
+        leave: string;
+        leaveActive: string;
+    };
+    constructor(elementRef: ElementRef<HTMLElement>, render: Renderer2);
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attachTemplatePortal<T>(portal: TemplatePortal<T>): EmbeddedViewRef<T>;
+    onAnimationDone(event: AnimationEvent): void;
+    onAnimationStart(event: AnimationEvent): void;
+    startExitAnimation(): void;
+    private blurActiveElement;
+    private cleanAnimationClass;
+    private setEnterAnimationClass;
+    private setExitAnimationClass;
+    private setMaskExitAnimationClass;
+    private setModalTransformOrigin;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "aui-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class DialogRef<T = ComponentType$1<any>, R = any> {
+    private readonly overlayRef;
+    dialogInstance: DialogComponent;
+    componentInstance?: T;
+    readonly id: string;
+    private readonly afterOpen$;
+    private readonly afterClosed$;
+    constructor(overlayRef: OverlayRef, dialogInstance: DialogComponent);
+    close(result?: R): void;
+    afterOpen(): Observable<void>;
+    afterClosed(): Observable<R>;
+    updatePosition(): this;
+    updateSize(): this;
+    private getPositionStrategy;
+}
+
+declare const DIALOG_DATA: InjectionToken<any>;
+declare class DialogService {
+    private readonly overlay;
+    private readonly injector;
+    static readonly DIALOG_OVERLAY_PANE_CLASS = "aui-dialog-overlay-pane";
+    static readonly DIALOG_BACKDROP_CLASS = "aui-dialog-backdrop";
+    static readonly DIALOG_OVERLAY_PANE_FIT_VIEWPORT_CLASS = "aui-dialog-overlay-pane--fit-viewport";
+    openDialogs: Array<DialogRef<any>>;
+    constructor(overlay: Overlay, injector: Injector);
+    open<T, D = any, R = any>(compOrTempRef: ComponentType<T> | TemplateRef<T>, config?: DialogConfig<D>): DialogRef<T, R>;
+    confirm<T = unknown, R = unknown>(config: ConfirmDialogConfig<T, R>): Promise<T>;
+    closeAll(): void;
+    private createOverlay;
+    private getOverlayConfig;
+    private attachDialog;
+    private attachDialogContent;
+    private createInjector;
+    private removeDialog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}
+
+declare class DialogCloseDirective implements OnInit {
+    dialogRef: DialogRef<any>;
+    private readonly elementRef;
+    private readonly dialogService;
+    result: any;
+    constructor(dialogRef: DialogRef<any>, elementRef: ElementRef, dialogService: DialogService);
+    ngOnInit(): void;
+    closeDialog(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogCloseDirective, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogCloseDirective, "[auiDialogClose]", ["auiDialogClose"], { "result": { "alias": "auiDialogClose"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DialogContentComponent extends CdkScrollable$1 {
+    bem: Bem;
+    constructor(elementRef: ElementRef<HTMLElement>, scrollDispatcher: ScrollDispatcher, ngZone: NgZone, dir?: Directionality);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogContentComponent, "aui-dialog-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class DialogFooterComponent {
+    bem: Bem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogFooterComponent, "aui-dialog-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class DialogHeaderComponent implements OnInit {
+    dialogRef: DialogRef<any>;
+    private readonly elementRef;
+    private readonly dialogService;
+    bem: Bem;
+    divider: boolean;
+    closeable: boolean;
+    result: any;
+    constructor(dialogRef: DialogRef<any>, elementRef: ElementRef, dialogService: DialogService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderComponent, [{ optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogHeaderComponent, "aui-dialog-header", never, { "divider": { "alias": "divider"; "required": false; }; "closeable": { "alias": "closeable"; "required": false; }; "result": { "alias": "result"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ConfirmDialogComponent<T = unknown, R = unknown> {
+    private readonly dialogRef;
+    private readonly cdr;
+    bem: Bem;
+    config: ConfirmDialogConfig<T, R>;
+    waitConfirm: boolean;
+    waitCancel: boolean;
+    isTemplateRef: (label: any) => label is i0.TemplateRef<unknown>;
+    isString: (label: any) => label is string;
+    constructor(dialogRef: DialogRef<any>, cdr: ChangeDetectorRef);
+    setConfig(config: ConfirmDialogConfig<T, R>): void;
+    iconMap(type: ConfirmType): "check_circle_s" | "exclamation_triangle_s" | "exclamation_circle_s";
+    confirm(): Promise<void>;
+    cancel(): Promise<void>;
+    private toPromise;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDialogComponent<any, any>, "aui-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class DialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogModule, never, [typeof i1.CommonModule, typeof i2$1.OverlayModule, typeof i3.PortalModule, typeof IconModule, typeof ButtonModule, typeof DialogComponent, typeof DialogHeaderComponent, typeof DialogContentComponent, typeof DialogFooterComponent, typeof DialogCloseDirective, typeof ConfirmDialogComponent], [typeof DialogComponent, typeof DialogHeaderComponent, typeof DialogContentComponent, typeof DialogFooterComponent, typeof DialogCloseDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DialogModule>;
+}
+declare const DIALOG_MODULE: readonly [typeof DialogComponent, typeof DialogHeaderComponent, typeof DialogContentComponent, typeof DialogFooterComponent, typeof DialogCloseDirective];
+
+declare const DrawerSize: {
+    readonly Small: "small";
+    readonly Medium: "medium";
+    readonly Big: "big";
+};
+type DrawerSize = ValueOf<typeof DrawerSize>;
+interface DrawerOptions<T = unknown, C extends object = object> {
+    title?: TemplateRef<C> | string;
+    content?: ComponentType<T> | TemplateRef<C>;
+    footer?: TemplateRef<C> | string;
+    contentParams?: C;
+    width?: number;
+    size?: DrawerSize;
+    offsetY?: string;
+    divider?: boolean;
+    drawerClass?: string;
+    visible?: boolean;
+    showClose?: boolean;
+    mask?: boolean;
+    maskClosable?: boolean;
+    hideOnClickOutside?: boolean;
+    disposeWhenHide?: boolean;
+}
+
+type Step = 'hideDone' | 'hideStart' | 'showDone' | 'showStart';
+declare class DrawerInternalComponent<T = unknown, C extends object = object> implements AfterViewInit {
+    private readonly injector;
+    private readonly cdr;
+    bodyPortalOutlet: CdkPortalOutlet;
+    mask: ElementRef<HTMLDivElement>;
+    animationStep$: Subject<Step>;
+    options: DrawerOptions<T, C>;
+    showHide$$: BehaviorSubject<"show" | "hide">;
+    maskVisible$: Subject<boolean>;
+    get drawerClasses(): Record<string, boolean>;
+    get width(): string;
+    get context(): {
+        $implicit: C;
+    } & C;
+    isTemplateRef: (label: any) => label is i0.TemplateRef<unknown>;
+    constructor(injector: Injector, cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    private attachBodyContent;
+    onAnimation(event: AnimationEvent): void;
+    updateOptions(options: DrawerOptions<T, C>): void;
+    show(): void;
+    hide(): void;
+    maskClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerInternalComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DrawerInternalComponent<any, any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DrawerRef<T = unknown, C extends object = object, R = unknown> {
+    drawerInstance: DrawerInternalComponent<T, C>;
+    private result;
+    private readonly afterOpen$;
+    private readonly afterClosed$;
+    get afterOpen(): Observable<void>;
+    get afterClosed(): Observable<R>;
+    constructor(drawerInstance: DrawerInternalComponent<T, C>);
+    open(): void;
+    close(result?: R): void;
+}
+
+declare class DrawerService<T = unknown, C extends object = object, R = unknown> implements OnDestroy {
+    private readonly overlay;
+    private overlayRef;
+    options: DrawerOptions<T, C>;
+    drawerRef: DrawerRef<T, C, R>;
+    invisible$: Subject<void>;
+    private drawerInternalComponentRef;
+    constructor(overlay: Overlay);
+    open(options: DrawerOptions<T, C>): DrawerRef<T, C, R>;
+    updateOptions(options: DrawerOptions<T, C>): void;
+    private createOverlay;
+    private createDrawer;
+    private getOverlayConfig;
+    private dispose;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerService<any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DrawerService<any, any, any>>;
+}
+
+declare class DrawerComponent<T = unknown, C extends object = object, R = unknown> implements AfterViewInit, OnChanges, Required<DrawerOptions<T, C>> {
+    private readonly drawerService;
+    title: TemplateRef<C> | string;
+    footer: TemplateRef<C> | string;
+    size: DrawerSize;
+    offsetY: string;
+    visible: boolean;
+    content: ComponentType$1<T> | TemplateRef<C>;
+    hideOnClickOutside: boolean;
+    showClose: boolean;
+    drawerClass: string;
+    mask: boolean;
+    maskClosable: boolean;
+    divider: boolean;
+    width: number;
+    contentParams: C;
+    disposeWhenHide: boolean;
+    readonly close: EventEmitter<R>;
+    private readonly titleTemplate;
+    private readonly contentTemplateOrComponent;
+    private readonly footerTemplate;
+    private drawerRef;
+    constructor(drawerService: DrawerService<T, C, R>);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerComponent<any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DrawerComponent<any, any, any>, "aui-drawer", never, { "title": { "alias": "title"; "required": false; }; "footer": { "alias": "footer"; "required": false; }; "size": { "alias": "size"; "required": false; }; "offsetY": { "alias": "offsetY"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "content": { "alias": "content"; "required": false; }; "hideOnClickOutside": { "alias": "hideOnClickOutside"; "required": false; }; "showClose": { "alias": "showClose"; "required": false; }; "drawerClass": { "alias": "drawerClass"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; "maskClosable": { "alias": "maskClosable"; "required": false; }; "divider": { "alias": "divider"; "required": false; }; "width": { "alias": "width"; "required": false; }; "contentParams": { "alias": "contentParams"; "required": false; }; "disposeWhenHide": { "alias": "disposeWhenHide"; "required": false; }; }, { "close": "close"; }, ["titleTemplate", "contentTemplateOrComponent", "footerTemplate"], ["*"], true, never>;
+}
+
+declare class DrawerHeaderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DrawerHeaderDirective, "[auiDrawerHeader]", never, {}, {}, never, never, true, never>;
+}
+declare class DrawerContentDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DrawerContentDirective, "[auiDrawerContent]", never, {}, {}, never, never, true, never>;
+}
+declare class DrawerFooterDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DrawerFooterDirective, "[auiDrawerFooter]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DrawerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DrawerModule, never, [typeof i1.CommonModule, typeof IconModule, typeof i2$1.OverlayModule, typeof i3.PortalModule, typeof DrawerComponent, typeof DrawerHeaderDirective, typeof DrawerContentDirective, typeof DrawerFooterDirective], [typeof DrawerComponent, typeof DrawerHeaderDirective, typeof DrawerContentDirective, typeof DrawerFooterDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DrawerModule>;
+}
+declare const DRAWER_MODULE: readonly [typeof DrawerComponent, typeof DrawerHeaderDirective, typeof DrawerContentDirective, typeof DrawerFooterDirective];
+
+declare class DropdownDirective extends BaseTooltip {
+    hideOnClick: boolean;
+    visibleChange: EventEmitter<boolean>;
+    animationType: AnimationType;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, elRef: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef, ngZone: NgZone);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownDirective, "[auiDropdown]", ["auiDropdown"], { "class": { "alias": "auiDropdownClass"; "required": false; }; "disabled": { "alias": "auiDropdownDisabled"; "required": false; }; "position": { "alias": "auiDropdownPosition"; "required": false; }; "trigger": { "alias": "auiDropdownTrigger"; "required": false; }; "context": { "alias": "auiDropdownContext"; "required": false; }; "content": { "alias": "auiDropdown"; "required": false; }; "hideOnClick": { "alias": "auiDropdownHideOnClick"; "required": false; }; }, { "visibleChange": "auiDropdownVisibleChange"; }, never, never, true, never>;
+}
+
+declare class DropdownActiveDirective extends TooltipActiveDirective {
+    customClass: string[] | string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownActiveDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownActiveDirective, "[auiDropdownActive]", never, { "customClass": { "alias": "auiDropdownActive"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DropdownButtonComponent implements AfterContentInit {
+    bem: Bem;
+    type: ButtonType;
+    plain: boolean;
+    size: ComponentSize;
+    loading: boolean;
+    disabled: boolean;
+    buttonClick: EventEmitter<Event>;
+    private readonly menuItems;
+    disableTrigger$: Observable<boolean>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownButtonComponent, "aui-dropdown-button", never, { "type": { "alias": "type"; "required": false; }; "plain": { "alias": "plain"; "required": false; }; "size": { "alias": "size"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "buttonClick": "buttonClick"; }, ["menuItems"], ["*", "aui-menu"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class MenuGroupTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuGroupTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuGroupTitleDirective, "[auiMenuGroupTitle]", ["auiMenuGroupTitle"], {}, {}, never, never, true, never>;
+}
+
+declare class MenuComponent {
+    bem: Bem;
+    size: ComponentSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "aui-menu", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MenuGroupComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuGroupComponent, "aui-menu-group", never, {}, {}, never, ["[auiMenuGroupTitle]", "*"], true, never>;
+}
+
+declare const MenuItemType: {
+    readonly Default: "default";
+    readonly Primary: "primary";
+    readonly Success: "success";
+    readonly Warning: "warning";
+    readonly Danger: "danger";
+};
+type MenuItemType = ValueOf<typeof MenuItemType>;
+
+declare class MenuItemComponent {
+    bem: Bem;
+    protected _disabled: boolean;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    divide: boolean;
+    type: MenuItemType;
+    actived: boolean;
+    get className(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemComponent, "aui-menu-item", never, { "disabled": { "alias": "disabled"; "required": false; }; "divide": { "alias": "divide"; "required": false; }; "type": { "alias": "type"; "required": false; }; "actived": { "alias": "actived"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class SubmenuComponent extends MenuItemComponent {
+    bem: Bem;
+    trigger: TooltipTrigger;
+    size: ComponentSize;
+    get disabled(): boolean;
+    menuItems: QueryList<MenuItemComponent>;
+    get hasEnabledItem(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubmenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SubmenuComponent, "aui-submenu", never, { "trigger": { "alias": "trigger"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["menuItems"], ["*", "aui-menu-item"], true, never>;
+}
+
+declare class DropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DropdownModule, never, [typeof i1.CommonModule, typeof TooltipModule, typeof IconModule, typeof ButtonModule, typeof DropdownDirective, typeof DropdownActiveDirective, typeof DropdownButtonComponent, typeof MenuComponent, typeof MenuGroupComponent, typeof MenuGroupTitleDirective, typeof MenuItemComponent, typeof SubmenuComponent], [typeof DropdownDirective, typeof DropdownActiveDirective, typeof DropdownButtonComponent, typeof MenuComponent, typeof MenuGroupComponent, typeof MenuGroupTitleDirective, typeof MenuItemComponent, typeof SubmenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DropdownModule>;
+}
+declare const DROPDOWN_MODULE: readonly [typeof DropdownDirective, typeof DropdownActiveDirective, typeof DropdownButtonComponent, typeof MenuComponent, typeof MenuGroupComponent, typeof MenuGroupTitleDirective, typeof MenuItemComponent, typeof SubmenuComponent];
+
+declare const en: I18NInterface;
+
+declare const zh: I18NInterface;
+
+declare class InlineAlertTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineAlertTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InlineAlertTitleDirective, "[auiInlineAlertTitle]", ["auiInlineAlertTitle"], {}, {}, never, never, true, never>;
+}
+
+declare const InlineAlertType: {
+    readonly Primary: "primary";
+    readonly Success: "success";
+    readonly Warning: "warning";
+    readonly Danger: "danger";
+    readonly Error: "error";
+    readonly Info: "info";
+};
+type InlineAlertType = ValueOf<typeof InlineAlertType>;
+
+declare class InlineAlertComponent {
+    bem: Bem;
+    title: string;
+    content: string;
+    closable: boolean;
+    type: InlineAlertType;
+    close: EventEmitter<void>;
+    titleRef: InlineAlertTitleDirective;
+    visible: boolean;
+    iconMap(type: InlineAlertType): "check_circle_s" | "exclamation_triangle_s" | "exclamation_circle_s" | "info_circle_s";
+    closeSelf(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InlineAlertComponent, "aui-inline-alert", never, { "title": { "alias": "title"; "required": false; }; "content": { "alias": "content"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "close": "close"; }, ["titleRef"], ["[auiInlineAlertTitle]", "*"], true, never>;
+}
+
+declare class InlineAlertModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineAlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InlineAlertModule, never, [typeof i1.CommonModule, typeof IconModule, typeof InlineAlertComponent, typeof InlineAlertTitleDirective], [typeof InlineAlertComponent, typeof InlineAlertTitleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InlineAlertModule>;
+}
+declare const INLINE_ALERT_MODULE: readonly [typeof InlineAlertComponent, typeof InlineAlertTitleDirective];
+
+declare enum MessageType {
+    Error = "error",
+    Success = "success",
+    Warning = "warning",
+    Info = "info"
+}
+/**
+ * messageOptions: contains Basic configuration
+ * Just for some containers like Message-Container
+ * Detailed document： http://confluence.alaudatech.com/pages/viewpage.action?pageId=23383163
+ */
+declare class MessageConfig {
+    /**
+     * the message type
+     */
+    type?: MessageType;
+    /**
+     * The id of this message, The same ID can only have one at the same time
+     */
+    id?: number | string;
+    /**
+     * automatically shut down after a few seconds, if <= 0 ,non automatic closure
+     */
+    duration?: number;
+    /**
+     * message content
+     */
+    content?: string;
+}
+interface MessageGlobalConfig {
+    /**
+     * max instance in one time
+     */
+    maxStack: number;
+    duration: number | {
+        [key in MessageType]: number;
+    };
+}
+declare const MESSAGE_CONFIG: InjectionToken<MessageGlobalConfig>;
+declare const MESSAGE_DEFAULT_CONFIG: {
+    duration: number;
+    maxStack: number;
+};
+
+declare class MessageWrapperComponent {
+    elementRef: ElementRef;
+    constructor(elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageWrapperComponent, "aui-message-wrapper", never, {}, {}, never, never, true, never>;
+}
+
+declare class MessageComponent implements AfterViewInit {
+    protected viewContainerRef: ViewContainerRef;
+    protected cdr: ChangeDetectorRef;
+    protected readonly animateStartState: string;
+    protected readonly animateStartEnd: string;
+    bem: Bem;
+    animateState: string;
+    uniqueId: string;
+    beforeClosed: Subject<void>;
+    afterClosed: Subject<void>;
+    id: number | string;
+    type: MessageType;
+    content: string;
+    duration: number;
+    get icon(): string;
+    protected timerId: number;
+    constructor(viewContainerRef: ViewContainerRef, cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    setConfig(config: MessageConfig): void;
+    close(): void;
+    onAnimationEnd(event: AnimationEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageComponent, "aui-message", never, {}, {}, never, never, true, never>;
+}
+
+declare class MessageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MessageModule, never, [typeof i1.CommonModule, typeof i2$1.OverlayModule, typeof IconModule, typeof MessageWrapperComponent, typeof MessageComponent], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MessageModule>;
+}
+
+declare abstract class BaseMessage<Wrapper extends MessageWrapperComponent, Component extends MessageComponent, Config extends MessageConfig> {
+    protected overlay: Overlay;
+    protected injector: Injector;
+    protected applicationRef: ApplicationRef;
+    protected overlayPaneClassName: string;
+    protected wrapperClass: ComponentType<Wrapper>;
+    protected componentClass: ComponentType<Component>;
+    protected globalConfig: MessageGlobalConfig;
+    wrapperInstance: {
+        elementRef: ElementRef<HTMLElement>;
+    };
+    componentRefs: Array<ComponentRef<Component>>;
+    constructor(overlay: Overlay, injector: Injector, applicationRef: ApplicationRef, overlayPaneClassName: string, wrapperClass: ComponentType<Wrapper>, componentClass: ComponentType<Component>, globalConfig: MessageGlobalConfig);
+    create(config: Config): ComponentRef<Component>;
+    create(config: MessageType, content: string): ComponentRef<Component>;
+    createType(type: MessageType, option: Config | string): ComponentRef<Component>;
+    success(option: Config | string): ComponentRef<Component>;
+    warning(option: Config | string): ComponentRef<Component>;
+    error(option: Config | string): ComponentRef<Component>;
+    info(option: Config | string): ComponentRef<Component>;
+    remove(id: number | string): void;
+    removeAll(): void;
+    protected initWrapperContainer(): void;
+    protected initComponentRef(config: Config): ComponentRef<Component>;
+    protected removeNeedless(id: number | string): void;
+}
+
+declare class MessageService extends BaseMessage<MessageWrapperComponent, MessageComponent, MessageConfig> {
+    constructor(overlay: Overlay, injector: Injector, applicationRef: ApplicationRef, globalConfig: MessageGlobalConfig);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, [null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;
+}
+
+interface NotificationConfig extends MessageConfig {
+    title?: string;
+    contentRef?: ComponentType<void> | TemplateRef<any>;
+    footerRef?: TemplateRef<any>;
+    context?: unknown;
+    customClass?: string;
+}
+type NotificationGlobalConfig = MessageGlobalConfig;
+declare const NOTIFICATION_CONFIG: InjectionToken<MessageGlobalConfig>;
+declare const NOTIFICATION_DEFAULT_CONFIG: {
+    duration: number;
+    maxStack: number;
+};
+
+declare class NotificationComponent extends MessageComponent implements AfterViewInit {
+    protected readonly animateStartState = "flyLeft";
+    protected readonly animateStartEnd = "flyUp";
+    bem: Bem;
+    animateState: string;
+    uniqueId: string;
+    isHover: boolean;
+    title: string;
+    remains: number;
+    childComponentInstance: unknown;
+    customClass: string;
+    footerPortal: TemplatePortal<unknown>;
+    private pendingTemplatePortal;
+    private readonly portalOutlet;
+    private readonly modalEl;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    ngAfterViewInit(): void;
+    setConfig(config: NotificationConfig): void;
+    /**
+     * Attach a TemplatePortal as content to this modal container.
+     * @param portal Portal to be attached as the modal content.
+     */
+    private attachTemplatePortal;
+    private attachComponentRef;
+    private countDown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationComponent, "aui-notification", never, {}, {}, never, never, true, never>;
+}
+
+declare class NotificationWrapperComponent extends MessageWrapperComponent {
+    elementRef: ElementRef;
+    constructor(elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationWrapperComponent, "aui-notification-wrapper", never, {}, {}, never, never, true, never>;
+}
+
+declare class NotificationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NotificationModule, never, [typeof i1.CommonModule, typeof i2$1.OverlayModule, typeof i3.PortalModule, typeof IconModule, typeof NotificationWrapperComponent, typeof NotificationComponent], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NotificationModule>;
+}
+
+declare class NotificationService extends BaseMessage<NotificationWrapperComponent, NotificationComponent, NotificationConfig> {
+    constructor(overlay: Overlay, injector: Injector, applicationRef: ApplicationRef, globalConfig: NotificationGlobalConfig);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, [null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}
+
+/**
+ * To modify the labels and text displayed, create a new instance of MatPaginatorIntl and
+ * include it in a custom provider
+ */
+declare class PaginatorIntl {
+    /**
+     * Stream that emits whenever the labels here are changed. Use this to notify
+     * components if the labels have changed after initialization.
+     */
+    readonly changes: Subject<void>;
+    /** A label for the page size selector. */
+    itemsPerPageLabel: string;
+    jumperLabelPrefix: string;
+    jumperLabelSuffix: string;
+    getTotalLabel: (length: number) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginatorIntl>;
+}
+
+declare class PaginatorComponent implements OnDestroy {
+    intl: PaginatorIntl;
+    private readonly cdr;
+    bem: Bem;
+    get pageIndex(): number;
+    set pageIndex(val: number);
+    get currentPage(): number;
+    set currentPage(val: number);
+    get pageSize(): number;
+    set pageSize(val: number);
+    pageSizeOptions: number[];
+    total: number;
+    layout: string[] | string;
+    disabled: boolean;
+    readonly pageIndexChange: EventEmitter<number>;
+    readonly currentPageChange: EventEmitter<number>;
+    readonly pageSizeChange: EventEmitter<number>;
+    private _currentPage;
+    private _pageSize;
+    private readonly intlChangeSub;
+    get pageCount(): number;
+    constructor(intl: PaginatorIntl, cdr: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    getLayoutArr(): string[];
+    getCenterPages(): number[];
+    jumpTo(page: number): void;
+    navigate(step: number): void;
+    changePageSize(size: number): void;
+    onKeydown(event: KeyboardEvent): void;
+    trackByIndex(index: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginatorComponent, "aui-paginator", never, { "pageIndex": { "alias": "pageIndex"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "total": { "alias": "total"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "pageIndexChange": "pageIndexChange"; "currentPageChange": "currentPageChange"; "pageSizeChange": "pageSizeChange"; }, never, ["*"], true, never>;
+}
+
+declare class PaginatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PaginatorModule, never, [typeof i1.CommonModule, typeof ButtonModule, typeof IconModule, typeof SelectModule, typeof InputModule, typeof PaginatorComponent], [typeof PaginatorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PaginatorModule>;
+}
+
+declare const RadioSize: {
+    readonly Medium: "medium";
+    readonly Small: "small";
+    readonly Mini: "mini";
+};
+type RadioSize = ValueOf<typeof RadioSize>;
+
+declare class RadioGroupComponent extends CommonFormControl<any> {
+    private readonly size$$;
+    private readonly isPlain$$;
+    private readonly name$$;
+    set size(val: RadioSize);
+    direction: 'column' | 'row';
+    set plain(val: boolean);
+    set name(val: string);
+    size$: Observable<RadioSize>;
+    isPlain$: Observable<boolean>;
+    name$: Observable<string>;
+    onRadioChange(value: any): void;
+    onRadioBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "aui-radio-group", never, { "size": { "alias": "size"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "plain": { "alias": "plain"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class BaseRadio implements OnInit, AfterViewInit, OnDestroy {
+    protected radioGroup: RadioGroupComponent;
+    protected focusMonitor: FocusMonitor;
+    protected cdr: ChangeDetectorRef;
+    id: string;
+    disabled: boolean | '';
+    get value(): unknown;
+    set value(val: unknown);
+    elRef: ElementRef;
+    checked: boolean;
+    name: string;
+    protected _value: unknown;
+    protected readonly value$$: BehaviorSubject<unknown>;
+    protected destroy$$: Subject<void>;
+    constructor(radioGroup: RadioGroupComponent, focusMonitor: FocusMonitor, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onClick(): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseRadio, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseRadio, never, never, { "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RadioComponent extends BaseRadio {
+    bem: Bem;
+    get rootClass(): string;
+    constructor(radioGroup: RadioGroupComponent, focusMonitor: FocusMonitor, cdr: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioComponent, "aui-radio", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class RadioButtonComponent extends BaseRadio implements OnInit {
+    bem: Bem;
+    size: RadioSize;
+    isPlain: boolean;
+    get rootClass(): string;
+    constructor(radioGroup: RadioGroupComponent, focusMonitor: FocusMonitor, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonComponent, "aui-radio-button", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class RadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RadioModule, never, [typeof i1.CommonModule, typeof IconModule, typeof RadioComponent, typeof RadioGroupComponent, typeof RadioButtonComponent], [typeof RadioComponent, typeof RadioGroupComponent, typeof RadioButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RadioModule>;
+}
+declare const RADIO_MODULE: readonly [typeof RadioComponent, typeof RadioGroupComponent, typeof RadioButtonComponent];
+
+declare class TablePlaceholderDefDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TablePlaceholderDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TablePlaceholderDefDirective, "ng-template[auiTablePlaceholderDef]", never, {}, {}, never, never, true, never>;
+}
+declare class TablePlaceholderOutletDirective implements RowOutlet {
+    viewContainer: ViewContainerRef;
+    elementRef: ElementRef;
+    constructor(viewContainer: ViewContainerRef, elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TablePlaceholderOutletDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TablePlaceholderOutletDirective, "[auiTablePlaceholderOutlet]", never, {}, {}, never, never, true, never>;
+}
+
+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>;
+}
+
+/**
+ * Cell definition for the aui-table.
+ * Captures the template of a column's data row cell as well as cell-specific properties.
+ */
+declare class TableCellDefDirective extends CdkCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellDefDirective, "[auiTableCellDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TableExpandButtonCellComponent extends CdkCell {
+    expand: boolean;
+    disabled: boolean;
+    expandChange: EventEmitter<any>;
+    get expanded(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableExpandButtonCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableExpandButtonCellComponent, "aui-table-cell[auiExpandButton]", never, { "expand": { "alias": "expand"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "expandChange": "expandChange"; }, never, never, true, never>;
+}
+declare class TableExpandPanelCellComponent extends CdkCell {
+    expand: boolean;
+    background: boolean;
+    get expanded(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableExpandPanelCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableExpandPanelCellComponent, "aui-table-cell[auiExpandPanel]", never, { "expand": { "alias": "expand"; "required": false; }; "background": { "alias": "background"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Cell template container that adds the right classes and role. */
+declare class TableCellDirective extends CdkCell {
+    direction: 'column' | 'row';
+    constructor(columnDef: CdkColumnDef, elementRef: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellDirective, "aui-table-cell", never, { "direction": { "alias": "direction"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Column definition for the aui-table.
+ * Defines a set of cells available for a table column.
+ */
+declare class TableColumnDefDirective extends CdkColumnDef {
+    set auiTableColumnDef(value: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableColumnDefDirective, "[auiTableColumnDef]", never, { "sticky": { "alias": "sticky"; "required": false; }; "auiTableColumnDef": { "alias": "auiTableColumnDef"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TableColumnResizableDirective implements OnInit, AfterViewInit, OnDestroy {
+    minWidth: string;
+    maxWidth: string;
+    private readonly renderer2;
+    private readonly tableColumnDefDirective;
+    private readonly tableComponent;
+    private readonly columnElement;
+    private readonly containerElement;
+    private readonly hostAttr;
+    private readonly stylesRenderer;
+    private resizeSubscription;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private bindResizable;
+    private createResizeHandle;
+    private createResizeMarkLine;
+    private createResizeOverlay;
+    private getColumnWidth;
+    private getColumnOffset;
+    private getWidthInRange;
+    private getResizeRange;
+    private getActualWidth;
+    private isStickyLeftBorderColumn;
+    private renderWidthStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnResizableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableColumnResizableDirective, "[auiTableColumnResizable]", never, { "minWidth": { "alias": "minWidth"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Header cell definition for the aui-table.
+ * Captures the template of a column's header cell and as well as cell-specific properties.
+ */
+declare class TableHeaderCellDefDirective extends CdkHeaderCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderCellDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableHeaderCellDefDirective, "[auiTableHeaderCellDef]", never, {}, {}, never, never, true, never>;
+}
+
+/** Header cell template container that adds the right classes and role. */
+declare class TableHeaderCellDirective extends CdkHeaderCell {
+    constructor(columnDef: CdkColumnDef, elementRef: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableHeaderCellDirective, "aui-table-header-cell", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Header row definition for the aui-table.
+ * Captures the header row's template and other header properties such as the columns to display.
+ */
+declare class TableHeaderRowDefDirective extends CdkHeaderRowDef {
+    columns: Iterable<string>;
+    set auiTableHeaderRowDefSticky(val: boolean);
+    get auiTableHeaderRowDefSticky(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderRowDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableHeaderRowDefDirective, "[auiTableHeaderRowDef]", never, { "columns": { "alias": "auiTableHeaderRowDef"; "required": false; }; "auiTableHeaderRowDefSticky": { "alias": "auiTableHeaderRowDefSticky"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Header template container that contains the cell outlet. Adds the right class and role. */
+declare class TableHeaderRowComponent extends CdkHeaderRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableHeaderRowComponent, "aui-table-header-row", ["auiTableHeaderRow"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Data row definition for the aui-table.
+ * Captures the header row's template and other row properties such as the columns to display and
+ * a when predicate that describes when this row should be used.
+ */
+declare class TableRowDefDirective<T> extends CdkRowDef<T> {
+    columns: Iterable<string>;
+    set auiTableRowDefWhen(v: (index: number, rowData: T) => boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowDefDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableRowDefDirective<any>, "[auiTableRowDef]", never, { "columns": { "alias": "auiTableRowDefColumns"; "required": false; }; "auiTableRowDefWhen": { "alias": "auiTableRowDefWhen"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Data row template container that contains the cell outlet. Adds the right class and role. */
+declare class TableRowComponent extends CdkRow implements AfterContentInit {
+    private readonly elRef;
+    disabled: boolean;
+    hasPanel: boolean;
+    constructor(elRef: ElementRef<HTMLElement>);
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableRowComponent, "aui-table-row", ["auiTableRow"], { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TableScrollWrapperDirective {
+    auiTableScrollWrapper: string;
+    elementRef: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableScrollWrapperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableScrollWrapperDirective, "[auiTableScrollWrapper]", never, { "auiTableScrollWrapper": { "alias": "auiTableScrollWrapper"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class TableScrollableDirective extends CdkScrollable implements AfterViewInit, OnInit, OnDestroy {
+    private readonly el;
+    private readonly table;
+    set scrollable(scrollable: boolean | '');
+    get scrollable(): boolean | "";
+    private _scrollable;
+    scrollable$$: BehaviorSubject<boolean>;
+    destroy$$: Subject<void>;
+    constructor(el: ElementRef<HTMLElement>, scrollDispatcher: ScrollDispatcher$1, ngZone: NgZone, table: TableComponent<unknown>, dir?: Directionality);
+    className: string;
+    get containerEl(): HTMLElement;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    viewMutation(): void;
+    mutateVerticalScroll(): void;
+    mutateHorizontalScroll(): void;
+    placeClassList(classList: DOMTokenList, condition: boolean, className: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableScrollableDirective, [null, null, null, { host: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableScrollableDirective, "[auiTableScrollable]", never, { "scrollable": { "alias": "auiTableScrollable"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+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];
+declare class TableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, never, [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], [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]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
+}
+
+declare class FixedSizeTableVirtualScrollStrategy implements VirtualScrollStrategy {
+    private _rowHeight;
+    private _headerHeight;
+    private _bufferSize;
+    private readonly _indexChange;
+    viewport: CdkVirtualScrollViewport;
+    scrolledIndexChange: rxjs.Observable<number>;
+    stickyChange: Subject<number>;
+    renderedRangeStream: BehaviorSubject<ListRange>;
+    get dataLength(): number;
+    set dataLength(value: number);
+    private _dataLength;
+    attach(viewport: CdkVirtualScrollViewport): void;
+    detach(): void;
+    onContentScrolled(): void;
+    onDataLengthChanged(): void;
+    onContentRendered(): void;
+    onRenderedOffsetChanged(): void;
+    scrollToIndex(index: number, behavior: ScrollBehavior): void;
+    setConfig(rowHeight: number, headerHeight: number, bufferSize: number): void;
+    private _updateContent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixedSizeTableVirtualScrollStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FixedSizeTableVirtualScrollStrategy>;
+}
+
+declare function _tableVirtualScrollDirectiveStrategyFactory(tableDir: FixedSizeTableVirtualScrollDirective): FixedSizeTableVirtualScrollStrategy;
+declare class FixedSizeTableVirtualScrollDirective<T = unknown> implements AfterContentInit, OnChanges, OnDestroy {
+    private readonly onDestroy$;
+    private readonly _dataSource$$;
+    rowHeight: number;
+    headerHeight: number;
+    buffer: number;
+    set dataSource(dataSource: T[]);
+    table: TableComponent<any>;
+    scrollStrategy: FixedSizeTableVirtualScrollStrategy;
+    private stickyPositions;
+    ngAfterContentInit(): void;
+    ngOnChanges({ rowHeight, headerHeight, buffer }: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private isStickyEnabled;
+    private initStickyPositions;
+    private setSticky;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixedSizeTableVirtualScrollDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FixedSizeTableVirtualScrollDirective<any>, "aui-virtual-scroll-viewport[fixedSize]", ["viewPort"], { "rowHeight": { "alias": "rowHeight"; "required": false; }; "headerHeight": { "alias": "headerHeight"; "required": false; }; "buffer": { "alias": "buffer"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; }, {}, ["table"], never, true, never>;
+}
+
+declare class FixedSizeVirtualScrollDirective extends CdkFixedSizeVirtualScroll {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixedSizeVirtualScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FixedSizeVirtualScrollDirective, "aui-virtual-scroll-viewport[itemSize]", never, {}, {}, never, never, true, never>;
+}
+
+declare class VirtualScrollViewportComponent extends CdkVirtualScrollViewport {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualScrollViewportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VirtualScrollViewportComponent, "aui-virtual-scroll-viewport", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class VirtualForOfDirective<T> extends CdkVirtualForOf<T> {
+    set auiVirtualForOf(value: DataSource<T> | NgIterable<T> | Observable<T[]> | null | undefined);
+    set auiVirtualForTrackBy(fn: TrackByFunction<T> | undefined);
+    set auiVirtualForTemplate(value: TemplateRef<CdkVirtualForOfContext<T>>);
+    set auiVirtualForTemplateCacheSize(size: number);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualForOfDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VirtualForOfDirective<any>, "[auiVirtualFor][auiVirtualForOf]", never, { "auiVirtualForOf": { "alias": "auiVirtualForOf"; "required": false; }; "auiVirtualForTrackBy": { "alias": "auiVirtualForTrackBy"; "required": false; }; "auiVirtualForTemplate": { "alias": "auiVirtualForTemplate"; "required": false; }; "auiVirtualForTemplateCacheSize": { "alias": "auiVirtualForTemplateCacheSize"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ScrollingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ScrollingModule, never, [typeof VirtualScrollViewportComponent, typeof FixedSizeTableVirtualScrollDirective, typeof FixedSizeVirtualScrollDirective, typeof VirtualForOfDirective], [typeof VirtualScrollViewportComponent, typeof FixedSizeTableVirtualScrollDirective, typeof FixedSizeVirtualScrollDirective, typeof VirtualForOfDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ScrollingModule>;
+}
+
+type SortDirection = '' | 'asc' | 'desc';
+type ArrowViewState = SortDirection | 'active' | 'hint';
+interface Sortable {
+    id: string;
+    start: 'asc' | 'desc';
+}
+interface Sort {
+    active: string;
+    direction: SortDirection;
+}
+
+declare class SortDirective implements OnChanges, OnDestroy {
+    sortables: Map<string, Sortable>;
+    readonly _stateChanges: Subject<void>;
+    active: string;
+    start: 'asc' | 'desc';
+    get direction(): SortDirection;
+    set direction(direction: SortDirection);
+    private _direction;
+    readonly sortChange: EventEmitter<Sort>;
+    register(sortable: Sortable): void;
+    deregister(sortable: Sortable): void;
+    sort(sortable: Sortable): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SortDirective, "[auiSort]", ["auiSort"], { "active": { "alias": "active"; "required": false; }; "start": { "alias": "start"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; }, { "sortChange": "sortChange"; }, never, never, true, never>;
+}
+
+declare class SortHeaderComponent implements Sortable, OnInit, OnDestroy {
+    _sort: SortDirective;
+    _cdkColumnRef: CdkColumnDef;
+    private readonly _rerenderSubscription;
+    _viewState: ArrowViewState;
+    arrowDirection: SortDirection;
+    id: string;
+    start: 'asc' | 'desc';
+    bem: Bem;
+    constructor(cdr: ChangeDetectorRef, _sort: SortDirective, _cdkColumnRef: CdkColumnDef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    _handleClick(): void;
+    _isSorted(): boolean;
+    _updateArrowDirection(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortHeaderComponent, [null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SortHeaderComponent, "[aui-sort-header]", never, { "id": { "alias": "aui-sort-header"; "required": false; }; "start": { "alias": "start"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class SortModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SortModule, never, [typeof i1.CommonModule, typeof SortDirective, typeof SortHeaderComponent], [typeof SortDirective, typeof SortHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SortModule>;
+}
+declare const SORT_MODULE: readonly [typeof SortDirective, typeof SortHeaderComponent];
+
+/** @docs-private */
+declare function getSortDuplicateSortableIdError(id: string): Error;
+/** @docs-private */
+declare function getSortHeaderNotContainedWithinSortError(): Error;
+/** @docs-private */
+declare function getSortHeaderMissingIdError(): Error;
+/** @docs-private */
+declare function getSortInvalidDirectionError(direction: string): Error;
+
+interface Status {
+    type?: StatusType;
+    class?: string;
+    scale: number;
+    [key: string]: unknown;
+}
+declare const StatusType: {
+    readonly Primary: "primary";
+    readonly Success: "success";
+    readonly Warning: "warning";
+    readonly Error: "error";
+    readonly Info: "info";
+    readonly Pending: "pending";
+};
+type StatusType = ValueOf<typeof StatusType>;
+declare const StatusBarSize: {
+    readonly Medium: "medium";
+    readonly Small: "small";
+};
+type StatusBarSize = ValueOf<typeof StatusBarSize>;
+
+declare class StatusBarComponent {
+    bem: Bem;
+    status: Status[];
+    size: StatusBarSize;
+    template: TemplateRef<any>;
+    statusClick: EventEmitter<Status>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StatusBarComponent, "aui-status-bar", never, { "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, { "statusClick": "statusClick"; }, never, never, true, never>;
+}
+
+declare class StatusBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StatusBarModule, never, [typeof i1.CommonModule, typeof TooltipModule, typeof StatusBarComponent], [typeof StatusBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StatusBarModule>;
+}
+
+declare const StepState: {
+    readonly Default: "default";
+    readonly Done: "done";
+    readonly Error: "error";
+    readonly Pending: "pending";
+};
+type StepState = ValueOf<typeof StepState>;
+interface StepItem {
+    label: string;
+    description?: string;
+    state?: StepState;
+    optional?: boolean;
+}
+type StepsOrientation = 'horizontal' | 'vertical';
+type StepsType = 'progress' | 'step';
+
+declare class StepsComponent implements OnInit, OnDestroy {
+    _currentIndex: number;
+    private _steps;
+    get steps(): StepItem[];
+    set steps(val: StepItem[]);
+    get currentIndex(): number;
+    set currentIndex(index: number);
+    orientation: StepsOrientation;
+    type: StepsType;
+    selectable: boolean;
+    currentIndexChange: EventEmitter<number>;
+    selectedIndexChange: EventEmitter<number>;
+    currentIndexChange$$: BehaviorSubject<number>;
+    stepsChange$$: BehaviorSubject<StepItem[]>;
+    selectedIndex: number;
+    private readonly destroy$$;
+    ngOnInit(): void;
+    private setCurrentIndex;
+    private getProgressCurrentIndex;
+    get isVertical(): boolean;
+    get isProgress(): boolean;
+    get activeIndex(): number;
+    getIcon(i: number, state?: StepState): string;
+    select(i: number): void;
+    isSelectable(i: number): boolean;
+    getActiveIndex(): number;
+    isLastActive(i: number, steps: StepItem[]): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepsComponent, "aui-steps", ["auiSteps"], { "steps": { "alias": "steps"; "required": false; }; "currentIndex": { "alias": "currentIndex"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "type": { "alias": "type"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; }, { "currentIndexChange": "currentIndexChange"; "selectedIndexChange": "selectedIndexChange"; }, never, never, true, never>;
+}
+
+declare class StepsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StepsModule, never, [typeof i1.CommonModule, typeof IconModule, typeof StepsComponent], [typeof StepsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StepsModule>;
+}
+
+declare class SwitchComponent extends CommonFormControl<boolean> {
+    bem: Bem;
+    loading: boolean;
+    onSwitch(): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchComponent, "aui-switch", never, { "loading": { "alias": "loading"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SwitchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SwitchModule, never, [typeof i1.CommonModule, typeof SwitchComponent], [typeof SwitchComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SwitchModule>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+declare class TableOfContentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableOfContentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableOfContentsModule, never, [typeof i1.CommonModule, typeof TocContentDirective, typeof TocContainerDirective, typeof TocLinkDirective], [typeof TocContentDirective, typeof TocContainerDirective, typeof TocLinkDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableOfContentsModule>;
+}
+declare const TABLE_OF_CONTENTS_MODULE: readonly [typeof TocContentDirective, typeof TocContainerDirective, typeof TocLinkDirective];
+
+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 */
+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.
+ */
+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. */
+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.
+ */
+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;
+}
+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.
+ */
+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>;
+}
+
+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>;
+}
+
+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;
+}
+
+declare const TabSize: {
+    /** 卡片级尺寸 */
+    readonly Large: "large";
+    /** 页面级尺寸 */
+    readonly Medium: "medium";
+    /** 小尺寸 */
+    readonly Small: "small";
+};
+type TabSize = ValueOf<typeof TabSize>;
+declare const TabType: {
+    readonly Line: "line";
+    readonly Card: "card";
+};
+type TabType = ValueOf<typeof TabType>;
+
+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>;
+}
+
+/**
+ * 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';
+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>;
+}
+
+/** A simple change event emitted on focus or selection changes. */
+declare class TabChangeEvent {
+    /** Index of the currently-selected tab. */
+    index: number;
+    /** Reference to the currently-selected tab. */
+    tab: TabComponent;
+}
+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>;
+}
+
+declare class TabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TabsModule, never, [typeof i1.CommonModule, typeof i2$2.FormsModule, typeof i3.PortalModule, typeof ButtonModule, typeof IconModule, typeof i6.A11yModule, typeof i7.ObserversModule, typeof TabGroupComponent, typeof TabComponent, typeof TabLabelDirective, typeof TabContentDirective, typeof TabHeaderAddonDirective, typeof TabTitleDirective, typeof TabHeaderComponent, typeof TabBodyComponent, typeof TabBodyPortalDirective, typeof TabLabelWrapperDirective, typeof TabHeaderActiveIndicatorComponent], [typeof TabGroupComponent, typeof TabComponent, typeof TabLabelDirective, typeof TabContentDirective, typeof TabHeaderAddonDirective, typeof TabTitleDirective, typeof TabLabelWrapperDirective, typeof TabHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TabsModule>;
+}
+declare const TABS_MODULE: readonly [typeof TabGroupComponent, typeof TabComponent, typeof TabLabelDirective, typeof TabContentDirective, typeof TabHeaderAddonDirective, typeof TabTitleDirective, typeof TabLabelWrapperDirective, typeof TabHeaderComponent];
+
+declare function rgbColor(color: string): string;
+declare function rgbaColor([color, opacity]: [string, number]): string;
+declare function cssVar(value: string): string;
+
+declare class TreeNodePlaceholderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodePlaceholderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodePlaceholderComponent, "aui-tree-node-placeholder", never, {}, {}, never, ["*"], true, never>;
+}
+
+type NodeFilterFn<T> = (filter: string, node: TreeNode<T>) => boolean;
+interface TreeNode<T = unknown> {
+    label: string;
+    value: T;
+    children?: Array<TreeNode<T>>;
+    disabled?: boolean;
+    expanded?: boolean;
+    icon?: string;
+    expandedIcon?: string;
+    loading?: boolean;
+}
+
+declare class TreeSelectComponent<T = unknown> extends CommonFormControl<T> {
+    get nodesData(): TreeNode<T>[];
+    set nodesData(val: TreeNode<T>[]);
+    loading: boolean;
+    placeholder: string;
+    filterable: boolean;
+    clearable: boolean;
+    leafOnly: boolean;
+    filterFn: (filterString: string, node: TreeNode<T>) => boolean;
+    trackFn: TrackFn<T>;
+    labelFn?: (value: T) => string;
+    filterChange: EventEmitter<string>;
+    show: EventEmitter<void>;
+    hide: EventEmitter<void>;
+    protected selectRef: ElementRef<HTMLElement>;
+    protected tooltipRef: TooltipDirective;
+    nodeListRef: ElementRef<HTMLElement>;
+    inputRef: InputComponent;
+    private _nodesData;
+    private _filterString;
+    private readonly filterString$$;
+    filterString$: Observable<string>;
+    containerWidth: string;
+    displayText: string;
+    flattedNodes: Array<TreeNode<T>>;
+    get isClearable(): string;
+    get opened(): boolean;
+    get inputReadonly(): boolean;
+    get filterString(): string;
+    set filterString(val: string);
+    updatePosition(): void;
+    onVisibleNodes(visible: boolean): void;
+    onInput(event: Event): void;
+    onNodeClick(node: TreeNodeComponent<T>): void;
+    getVisibleNodeCount(): number;
+    selectNode(node: TreeNodeComponent<T>): void;
+    onKeyDown(event: KeyboardEvent): void;
+    openOption(): void;
+    closeOption(): void;
+    updateSelectDisplay(value: any): void;
+    clearValue(event: Event): void;
+    protected valueIn(v: T): T;
+    getPlaceholder(): string;
+    getInputValue(): string;
+    trackByLabel: (_: number, node: TreeNode<T>) => string;
+    private flatNodesData;
+    private getLabelFromNode;
+    private _filterFn;
+    private _trackFn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeSelectComponent<any>, "aui-tree-select", never, { "nodesData": { "alias": "nodesData"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "leafOnly": { "alias": "leafOnly"; "required": false; }; "filterFn": { "alias": "filterFn"; "required": false; }; "trackFn": { "alias": "trackFn"; "required": false; }; "labelFn": { "alias": "labelFn"; "required": false; }; }, { "filterChange": "filterChange"; "show": "show"; "hide": "hide"; }, never, ["aui-tree-node-placeholder"], true, never>;
+    static ngAcceptInputType_filterable: unknown;
+    static ngAcceptInputType_clearable: unknown;
+    static ngAcceptInputType_leafOnly: unknown;
+}
+declare class TreeNodeComponent<T> implements AfterViewInit, OnDestroy {
+    private readonly cdr;
+    bem: Bem;
+    private _nodeData;
+    private readonly nodeData$$;
+    private readonly destroy$$;
+    get nodeData(): TreeNode<T>;
+    set nodeData(val: TreeNode<T>);
+    leafOnly: boolean;
+    titleRef: ElementRef<HTMLElement>;
+    childNodes: QueryList<TreeNodeComponent<T>>;
+    selected: boolean;
+    visible: boolean;
+    isLeaf: boolean;
+    private readonly select;
+    selected$: Observable<boolean>;
+    selfVisible$: Observable<boolean>;
+    visible$: Observable<boolean>;
+    constructor(select: TreeSelectComponent<T>, cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onClick(): void;
+    switchExpanded(): void;
+    getIcon(): string;
+    trackByLabel(_: number, data: TreeNode<T>): string;
+    scrollToNode(node: TreeNodeComponent<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeComponent<any>, "aui-tree-node", never, { "nodeData": { "alias": "nodeData"; "required": false; }; "leafOnly": { "alias": "leafOnly"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_leafOnly: unknown;
+}
+
+declare class TreeSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeSelectModule, never, [typeof i1.CommonModule, typeof TooltipModule, typeof IconModule, typeof InputModule, typeof TreeSelectComponent, typeof TreeNodeComponent, typeof TreeNodePlaceholderComponent], [typeof TreeSelectComponent, typeof TreeNodeComponent, typeof TreeNodePlaceholderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TreeSelectModule>;
+}
+
+export { ACCORDION_MODULE, ANCHOR_MODULE, AUTOCOMPLETE_MODULE, AccordionComponent, AccordionItemComponent, AccordionItemContentDirective, AccordionItemHeaderDirective, AccordionModule, AnchorComponent, AnchorDirective, AnchorDirectiveChild, AnchorLabelDirective, AnchorModule, AnchorTreeComponent, AuiSelectValidators, AutoCompleteDirective, AutocompleteComponent, AutocompleteModule, AutocompletePlaceholderComponent, AutosizeDirective, BREADCRUMB_MODULE, BackTopComponent, BackTopModule, BaseDialogConfig, BaseTooltip, Bem, BreadcrumbComponent, BreadcrumbItemComponent, BreadcrumbModule, ButtonComponent, ButtonGroupComponent, ButtonModule, ButtonType, CARD_MODULE, CHECKBOX_MODULE, CONTROL_ITEM_HEIGHT, CalendarFooterComponent, CalendarHeaderComponent, CardComponent, CardFooterDirective, CardHeaderDirective, CardModule, CheckTagComponent, CheckboxComponent, CheckboxGroupComponent, CheckboxModule, ColorPickerComponent, ColorPickerModule, CommonFormControl, ComponentSize, ConfirmDialogConfig, ConfirmType, CssVarPipe, CustomAutoCompleteDirective, DATE, DATE_NAV_RANGES, DATE_TYPES, DAY, DAY_PANEL_COLUMN_COUNT, DAY_PANEL_ROW_COUNT, DIALOG_DATA, DIALOG_MODULE, DISPLAY_DELAY, DRAWER_MODULE, DROPDOWN_MODULE, DateNavRange, DatePickerComponent, DatePickerModule, DatePickerPanelComponent, DatePickerTriggerComponent, DatePickerType, DateRangePickerPanelComponent, DialogCloseDirective, DialogComponent, DialogConfig, DialogContentComponent, DialogFooterComponent, DialogHeaderComponent, DialogModule, DialogRef, DialogService, DialogSize, DrawerComponent, DrawerContentDirective, DrawerFooterDirective, DrawerHeaderDirective, DrawerModule, DrawerRef, DrawerService, DrawerSize, DropdownActiveDirective, DropdownButtonComponent, DropdownDirective, DropdownModule, FORM_MODULE, FixedSizeTableVirtualScrollDirective, FixedSizeTableVirtualScrollStrategy, FixedSizeVirtualScrollDirective, FormDirective, FormItemAddonDirective, FormItemComponent, FormItemControlDirective, FormItemErrorDirective, FormItemHintDirective, FormItemLabelDirective, FormItemWidth, FormModule, HIDDEN_DELAY, HOUR, HOUR_ITEMS, I18NInterfaceToken, I18nModule, I18nPipe, I18nService, INLINE_ALERT_MODULE, INPUT_ERROR_KEY, INPUT_GROUP_MODULE, IconComponent, IconModule, IconRegisterService, IncludesDirective, InlineAlertComponent, InlineAlertModule, InlineAlertTitleDirective, InlineAlertType, InputAddonAfterDirective, InputAddonBeforeDirective, InputComponent, InputGroupComponent, InputModule, InputPrefixDirective, InputSuffixDirective, LabelPosition, MESSAGE_CONFIG, MESSAGE_DEFAULT_CONFIG, MINUTE, MINUTE_ITEMS, MONTH, MONTH_PANEL_COLUMN_COUNT, MONTH_PANEL_ROW_COUNT, MenuComponent, MenuGroupComponent, MenuGroupTitleDirective, MenuItemComponent, MenuItemType, MessageConfig, MessageModule, MessageService, MessageType, MultiSelectComponent, NOTIFICATION_CONFIG, NOTIFICATION_DEFAULT_CONFIG, NUMBER_INPUT_MODULE, NotificationComponent, NotificationModule, NotificationService, NumberInputComponent, OptionComponent, OptionContentDirective, OptionGroupComponent, OptionGroupTitleDirective, OptionPlaceholderComponent, PaginatorComponent, PaginatorIntl, PaginatorModule, PickerPanelComponent, RADIO_MODULE, RadioButtonComponent, RadioComponent, RadioGroupComponent, RadioModule, RadioSize, RangePickerComponent, RgbColorPipe, RgbaColorPipe, SECOND, SECOND_ITEMS, SELECT_MODULE, SORT_MODULE, ScrollingModule, SearchComponent, SectionComponent, SectionTitleDirective, SelectAllStatus, SelectComponent, SelectModule, Side, SortDirective, SortHeaderComponent, SortModule, StatusBarComponent, StatusBarModule, StatusBarSize, StatusType, StepState, StepsComponent, StepsModule, SubmenuComponent, SuggestionComponent, SuggestionGroupComponent, SuggestionGroupTitleDirective, SwitchComponent, SwitchModule, TABLE_MODULE, TABLE_OF_CONTENTS_MODULE, TABS_MODULE, TIME_PICKER_MODULE, TOOLTIP_MODULE, TabBodyComponent, TabBodyPortalDirective, TabChangeEvent, TabComponent, TabContentDirective, TabContextService, TabGroupComponent, TabHeaderActiveIndicatorComponent, TabHeaderAddonDirective, TabHeaderComponent, TabLabelDirective, TabLabelWrapperDirective, TabSize, TabTitleDirective, TabType, TableCellDefDirective, TableCellDirective, TableColumnDefDirective, TableColumnResizableDirective, TableComponent, TableExpandButtonCellComponent, TableExpandPanelCellComponent, TableHeaderCellDefDirective, TableHeaderCellDirective, TableHeaderRowComponent, TableHeaderRowDefDirective, TableModule, TableOfContentsModule, TablePlaceholderDefDirective, TablePlaceholderOutletDirective, TableRowComponent, TableRowDefDirective, TableScrollWrapperDirective, TableScrollableDirective, TabsModule, TagComponent, TagModule, TagType, TagsInputComponent, ThemeModule, ThemePickerPipe, ThemeService, TimePickerComponent, TimePickerControlType, TimePickerModule, TimePickerPanelComponent, TocContainerDirective, TocContentDirective, TocLinkDirective, TooltipActiveDirective, TooltipComponent, TooltipCopyDirective, TooltipCopyIntl, TooltipDirective, TooltipModule, TooltipTrigger, TooltipType, TreeNodeComponent, TreeNodePlaceholderComponent, TreeSelectComponent, TreeSelectModule, VirtualForOfDirective, VirtualScrollViewportComponent, YEAR, YEAR_PANEL_COLUMN_COUNT, YEAR_PANEL_ROW_COUNT, _tableVirtualScrollDirectiveStrategyFactory, buildBem, coerceAttrBoolean, coerceString, cssVar, en, getAnchorTreeItems, getCompatibleStylesRenderer, getSortDuplicateSortableIdError, getSortHeaderMissingIdError, getSortHeaderNotContainedWithinSortError, getSortInvalidDirectionError, handlePixel, isTemplateRef, isTimePickerModel, observeMutationOn, observeResizeOn, rgbColor, rgbaColor, zh };
+export type { AnchorItem, AnchorItemBase, AnchorTreeItem, ArrowViewState, AttrBoolean, AutoCompleteContext, AutoSizeValue, BeforeAction, CalendarHeaderRange, CustomBeforeAction, DisabledDateFn, DisabledTimeFn, DrawerOptions, I18NInterface, MessageGlobalConfig, NodeFilterFn, NotificationConfig, NotificationGlobalConfig, OptionFilterFn, PromiseExecutor, ScrollDirection, SelectFilterOption, SelectOption, Sort, SortDirection, Sortable, Status, StepItem, StepsOrientation, StepsType, SuggestionFilterFn, TagClassFn, Theme, ThemeMode, ThemeSet, TimePickerDataLike, TimePickerModel, TooltipInterface, TrackFn, TreeNode };