@alauda/ui/index.d.ts

Angular UI components by Alauda Frontend Team.

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 f