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

package/accordion/accordion-item/accordion-item.component.d.ts

@@ -0,0 +1,22 @@
+import { CdkAccordionItem } from '@angular/cdk/accordion';
+import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
+import { AfterContentInit, ChangeDetectorRef, TemplateRef } from '@angular/core';
+import { AccordionComponent } from '../accordion.component';
+import * as i0 from "@angular/core";
+export declare class AccordionItemHeaderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionItemHeaderDirective, "[auiAccordionItemHeader]", never, {}, {}, never, never, true, never>;
+}
+export declare class AccordionItemContentDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionItemContentDirective, "[auiAccordionContent]", never, {}, {}, never, never, true, never>;
+}
+export 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>;
+}

package/accordion/accordion.component.d.ts

@@ -0,0 +1,10 @@
+import { CdkAccordion } from '@angular/cdk/accordion';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/accordion/accordion.module.d.ts

@@ -0,0 +1,15 @@
+import { AccordionItemComponent, AccordionItemContentDirective, AccordionItemHeaderDirective } from './accordion-item/accordion-item.component';
+import { AccordionComponent } from './accordion.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/accordion";
+import * as i3 from "../icon/icon.module";
+import * as i4 from "../button/button.module";
+import * as i5 from "./accordion.component";
+import * as i6 from "./accordion-item/accordion-item.component";
+export declare class AccordionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AccordionModule, never, [typeof i1.CommonModule, typeof i2.CdkAccordionModule, typeof i3.IconModule, typeof i4.ButtonModule, typeof i5.AccordionComponent, typeof i6.AccordionItemComponent, typeof i6.AccordionItemHeaderDirective, typeof i6.AccordionItemContentDirective], [typeof i5.AccordionComponent, typeof i6.AccordionItemComponent, typeof i6.AccordionItemHeaderDirective, typeof i6.AccordionItemContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AccordionModule>;
+}
+export declare const ACCORDION_MODULE: readonly [typeof AccordionComponent, typeof AccordionItemComponent, typeof AccordionItemHeaderDirective, typeof AccordionItemContentDirective];

package/accordion/index.d.ts

@@ -0,0 +1,3 @@
+export * from './accordion.component';
+export * from './accordion.module';
+export * from './accordion-item/accordion-item.component';

package/anchor/anchor.component.d.ts

@@ -0,0 +1,37 @@
+import { AfterViewInit, ChangeDetectorRef, EventEmitter, Injector, OnDestroy } from '@angular/core';
+import { AnchorDirectiveChild } from './anchor.directive';
+import { AnchorItem, AnchorTreeItem } from './types';
+import * as i0 from "@angular/core";
+export declare class AnchorTreeComponent extends AnchorDirectiveChild implements OnDestroy {
+    set treeItems(treeItems: AnchorTreeItem[]);
+    get treeItems(): AnchorTreeItem[];
+    private _treeItems;
+    activeId: string;
+    activeIdChange: EventEmitter<string>;
+    bem: import("../internal/utils").Bem;
+    isTemplateRef: (label: any) => label is import("@angular/core").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>;
+}
+export 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: import("../internal/utils").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>;
+}

package/anchor/anchor.directive.d.ts

@@ -0,0 +1,57 @@
+import { ComponentPortal } from '@angular/cdk/portal';
+import { CdkScrollable } from '@angular/cdk/scrolling';
+import { AfterContentChecked, AfterContentInit, ApplicationRef, ComponentFactoryResolver, ElementRef, EventEmitter, Injector, OnDestroy, OnInit, QueryList, TemplateRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { AnchorComponent } from './anchor.component';
+import * as i0 from "@angular/core";
+export 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>;
+}
+export 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>;
+}
+export declare class AnchorDirective implements AfterContentInit, OnDestroy {
+    private readonly cfr;
+    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(cfr: ComponentFactoryResolver, 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, 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>;
+}

package/anchor/anchor.module.d.ts

@@ -0,0 +1,12 @@
+import { AnchorComponent, AnchorTreeComponent } from './anchor.component';
+import { AnchorDirective, AnchorLabelDirective } from './anchor.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./anchor.component";
+import * as i3 from "./anchor.directive";
+export declare class AnchorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AnchorModule, never, [typeof i1.CommonModule, typeof i2.AnchorComponent, typeof i2.AnchorTreeComponent, typeof i3.AnchorDirective, typeof i3.AnchorLabelDirective], [typeof i2.AnchorComponent, typeof i2.AnchorTreeComponent, typeof i3.AnchorDirective, typeof i3.AnchorLabelDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AnchorModule>;
+}
+export declare const ANCHOR_MODULE: readonly [typeof AnchorComponent, typeof AnchorTreeComponent, typeof AnchorDirective, typeof AnchorLabelDirective];

package/anchor/index.d.ts

@@ -0,0 +1,5 @@
+export * from './anchor.component';
+export * from './anchor.directive';
+export * from './anchor.module';
+export * from './types';
+export * from './utils';

package/anchor/types.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+export interface AnchorItemBase {
+    readonly id?: string;
+    readonly target?: HTMLElement;
+    readonly label: TemplateRef<unknown> | string;
+    readonly labelContext?: unknown;
+    readonly labelChange?: EventEmitter<TemplateRef<unknown> | string>;
+}
+export interface AnchorItem extends AnchorItemBase {
+    readonly level: number;
+}
+export interface AnchorTreeItem extends AnchorItemBase {
+    children?: AnchorTreeItem[];
+}

package/anchor/utils.d.ts

@@ -0,0 +1,2 @@
+import { AnchorItem, AnchorTreeItem } from './types';
+export declare const getAnchorTreeItems: (items: AnchorItem[], level?: number) => AnchorTreeItem[];

package/autocomplete/autocomplete-placeholder.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class AutocompletePlaceholderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompletePlaceholderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AutocompletePlaceholderComponent, "aui-autocomplete-placeholder", never, {}, {}, never, ["*"], true, never>;
+}

package/autocomplete/autocomplete.component.d.ts

@@ -0,0 +1,21 @@
+import { AfterContentInit, ChangeDetectorRef, ElementRef, QueryList, TemplateRef } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { AutocompletePlaceholderComponent } from './autocomplete-placeholder.component';
+import { AutoCompleteDirective } from './autocomplete.directive';
+import { SuggestionComponent } from './suggestion/suggestion.component';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/autocomplete/autocomplete.directive.d.ts

@@ -0,0 +1,54 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, NgZone, OnDestroy, OnInit, Renderer2, ViewContainerRef } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { BaseTooltip } from '../tooltip';
+import { AnimationType } from '../tooltip/animations';
+import { AutocompleteComponent } from './autocomplete.component';
+import { AutoCompleteContext, SuggestionFilterFn } from './autocomplete.types';
+import * as i0 from "@angular/core";
+export 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>;
+}
+export 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>;
+}

package/autocomplete/autocomplete.module.d.ts

@@ -0,0 +1,22 @@
+import { AutocompletePlaceholderComponent } from './autocomplete-placeholder.component';
+import { AutocompleteComponent } from './autocomplete.component';
+import { AutoCompleteDirective, CustomAutoCompleteDirective } from './autocomplete.directive';
+import { SuggestionGroupTitleDirective } from './helper-directives';
+import { SuggestionComponent } from './suggestion/suggestion.component';
+import { SuggestionGroupComponent } from './suggestion-group/suggestion-group.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/overlay";
+import * as i3 from "../tooltip/tooltip.module";
+import * as i4 from "./autocomplete.directive";
+import * as i5 from "./autocomplete.component";
+import * as i6 from "./suggestion/suggestion.component";
+import * as i7 from "./autocomplete-placeholder.component";
+import * as i8 from "./suggestion-group/suggestion-group.component";
+import * as i9 from "./helper-directives";
+export declare class AutocompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AutocompleteModule, never, [typeof i1.CommonModule, typeof i2.OverlayModule, typeof i3.TooltipModule, typeof i4.AutoCompleteDirective, typeof i4.CustomAutoCompleteDirective, typeof i5.AutocompleteComponent, typeof i6.SuggestionComponent, typeof i7.AutocompletePlaceholderComponent, typeof i8.SuggestionGroupComponent, typeof i9.SuggestionGroupTitleDirective], [typeof i4.AutoCompleteDirective, typeof i4.CustomAutoCompleteDirective, typeof i5.AutocompleteComponent, typeof i6.SuggestionComponent, typeof i7.AutocompletePlaceholderComponent, typeof i8.SuggestionGroupComponent, typeof i9.SuggestionGroupTitleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AutocompleteModule>;
+}
+export declare const AUTOCOMPLETE_MODULE: readonly [typeof AutoCompleteDirective, typeof CustomAutoCompleteDirective, typeof AutocompleteComponent, typeof SuggestionComponent, typeof AutocompletePlaceholderComponent, typeof SuggestionGroupComponent, typeof SuggestionGroupTitleDirective];

package/autocomplete/autocomplete.types.d.ts

@@ -0,0 +1,4 @@
+export interface AutoCompleteContext {
+    width: string;
+}
+export type SuggestionFilterFn = (inputValue: string, suggestion: string) => boolean;

package/autocomplete/helper-directives.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class SuggestionGroupTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionGroupTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SuggestionGroupTitleDirective, "[auiSuggestionGroupTitle]", ["auiSuggestionGroupTitle"], {}, {}, never, never, true, never>;
+}

package/autocomplete/index.d.ts

@@ -0,0 +1,8 @@
+export * from './autocomplete.component';
+export * from './autocomplete.directive';
+export * from './autocomplete.module';
+export * from './autocomplete.types';
+export * from './autocomplete-placeholder.component';
+export * from './helper-directives';
+export * from './suggestion/suggestion.component';
+export * from './suggestion-group/suggestion-group.component';

package/autocomplete/suggestion/suggestion.component.d.ts

@@ -0,0 +1,28 @@
+import { ChangeDetectorRef, ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Bem } from '../../internal/utils';
+import { AutocompleteComponent } from '../autocomplete.component';
+import * as i0 from "@angular/core";
+export 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;
+}

package/autocomplete/suggestion-group/suggestion-group.component.d.ts

@@ -0,0 +1,11 @@
+import { AfterContentInit, QueryList } from '@angular/core';
+import { Observable } from 'rxjs';
+import { SuggestionComponent } from '../suggestion/suggestion.component';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/back-top/back-top.component.d.ts

@@ -0,0 +1,32 @@
+import { CdkScrollable } from '@angular/cdk/overlay';
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+type TargetType = Element | Window | string;
+export 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);
+    display$: import("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>;
+}
+export {};

package/back-top/back-top.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../icon/icon.module";
+import * as i3 from "../button/button.module";
+import * as i4 from "./back-top.component";
+export declare class BackTopModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackTopModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BackTopModule, never, [typeof i1.CommonModule, typeof i2.IconModule, typeof i3.ButtonModule, typeof i4.BackTopComponent], [typeof i4.BackTopComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BackTopModule>;
+}

package/back-top/index.d.ts

@@ -0,0 +1,2 @@
+export * from './back-top.component';
+export * from './back-top.module';

package/breadcrumb/breadcrumb-item.component.d.ts

@@ -0,0 +1,14 @@
+import { ChangeDetectorRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/breadcrumb/breadcrumb.component.d.ts

@@ -0,0 +1,15 @@
+import { AfterContentInit, QueryList } from '@angular/core';
+import { BreadcrumbItemComponent } from './breadcrumb-item.component';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/breadcrumb/breadcrumb.module.d.ts

@@ -0,0 +1,13 @@
+import { BreadcrumbItemComponent } from './breadcrumb-item.component';
+import { BreadcrumbComponent } from './breadcrumb.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../icon/icon.module";
+import * as i3 from "./breadcrumb.component";
+import * as i4 from "./breadcrumb-item.component";
+export declare class BreadcrumbModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BreadcrumbModule, never, [typeof i1.CommonModule, typeof i2.IconModule, typeof i3.BreadcrumbComponent, typeof i4.BreadcrumbItemComponent], [typeof i3.BreadcrumbComponent, typeof i4.BreadcrumbItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BreadcrumbModule>;
+}
+export declare const BREADCRUMB_MODULE: readonly [typeof BreadcrumbComponent, typeof BreadcrumbItemComponent];

package/breadcrumb/index.d.ts

@@ -0,0 +1,3 @@
+export * from './breadcrumb.component';
+export * from './breadcrumb.module';
+export * from './breadcrumb-item.component';

package/button/button-group/button-group.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class ButtonGroupComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonGroupComponent, "aui-button-group", never, {}, {}, never, ["*"], true, never>;
+}

package/button/button.component.d.ts

@@ -0,0 +1,33 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { ElementRef, OnDestroy, Renderer2 } from '@angular/core';
+import { ComponentSize } from '../internal/types';
+import { ButtonType } from './button.types';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/button/button.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../icon/icon.module";
+import * as i3 from "./button.component";
+import * as i4 from "./button-group/button-group.component";
+export declare class ButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonModule, never, [typeof i1.CommonModule, typeof i2.IconModule, typeof i3.ButtonComponent, typeof i4.ButtonGroupComponent], [typeof i3.ButtonComponent, typeof i4.ButtonGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonModule>;
+}

package/button/button.types.d.ts

@@ -0,0 +1,15 @@
+import { ValueOf } from '../internal/types';
+export 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: "";
+};
+export type ButtonType = ValueOf<typeof ButtonType>;

package/button/index.d.ts

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

package/card/card.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export 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>;
+}

package/card/card.module.d.ts

@@ -0,0 +1,14 @@
+import { CardComponent } from './card.component';
+import { CardFooterDirective, CardHeaderDirective, SectionTitleDirective } from './helper-directives';
+import { SectionComponent } from './section.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./card.component";
+import * as i3 from "./helper-directives";
+import * as i4 from "./section.component";
+export declare class CardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CardModule, never, [typeof i1.CommonModule, typeof i2.CardComponent, typeof i3.CardHeaderDirective, typeof i3.CardFooterDirective, typeof i4.SectionComponent, typeof i3.SectionTitleDirective], [typeof i2.CardComponent, typeof i3.CardHeaderDirective, typeof i3.CardFooterDirective, typeof i4.SectionComponent, typeof i3.SectionTitleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CardModule>;
+}
+export declare const CARD_MODULE: readonly [typeof CardComponent, typeof CardHeaderDirective, typeof CardFooterDirective, typeof SectionComponent, typeof SectionTitleDirective];

package/card/helper-directives.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+export declare class CardHeaderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CardHeaderDirective, "[auiCardHeader]", never, {}, {}, never, never, true, never>;
+}
+export declare class CardFooterDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CardFooterDirective, "[auiCardFooter]", never, {}, {}, never, never, true, never>;
+}
+export declare class SectionTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SectionTitleDirective, "[auiSectionTitle]", never, {}, {}, never, never, true, never>;
+}

package/card/index.d.ts

@@ -0,0 +1,4 @@
+export * from './card.component';
+export * from './card.module';
+export * from './helper-directives';
+export * from './section.component';

package/card/section.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class SectionComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionComponent, "aui-section", never, {}, {}, never, ["[auiSectionTitle]", "*"], true, never>;
+}

package/checkbox/checkbox-group/checkbox-group.component.d.ts

@@ -0,0 +1,16 @@
+import { QueryList } from '@angular/core';
+import { CommonFormControl } from '../../form';
+import { TrackFn } from '../../select';
+import { CheckboxComponent } from '../checkbox.component';
+import * as i0 from "@angular/core";
+export 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>;
+}