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

package/notification/notification.component.d.ts

@@ -0,0 +1,34 @@
+import { TemplatePortal } from '@angular/cdk/portal';
+import { AfterViewInit } from '@angular/core';
+import { Bem } from '../internal/utils';
+import { MessageComponent } from '../message/message.component';
+import { NotificationConfig } from './notification.config';
+import * as i0 from "@angular/core";
+export 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 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>;
+}

package/notification/notification.config.d.ts

@@ -0,0 +1,16 @@
+import { ComponentType } from '@angular/cdk/portal';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { MessageConfig, MessageGlobalConfig } from '../message';
+export interface NotificationConfig extends MessageConfig {
+    title?: string;
+    contentRef?: ComponentType<void> | TemplateRef<any>;
+    footerRef?: TemplateRef<any>;
+    context?: unknown;
+    customClass?: string;
+}
+export type NotificationGlobalConfig = MessageGlobalConfig;
+export declare const NOTIFICATION_CONFIG: InjectionToken<MessageGlobalConfig>;
+export declare const NOTIFICATION_DEFAULT_CONFIG: {
+    duration: number;
+    maxStack: number;
+};

package/notification/notification.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/overlay";
+import * as i3 from "@angular/cdk/portal";
+import * as i4 from "../icon/icon.module";
+import * as i5 from "./notification-wrapper.component";
+import * as i6 from "./notification.component";
+export declare class NotificationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NotificationModule, never, [typeof i1.CommonModule, typeof i2.OverlayModule, typeof i3.PortalModule, typeof i4.IconModule, typeof i5.NotificationWrapperComponent, typeof i6.NotificationComponent], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NotificationModule>;
+}

package/notification/notification.service.d.ts

@@ -0,0 +1,12 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { ApplicationRef, ComponentFactoryResolver, Injector } from '@angular/core';
+import { BaseMessage } from '../message/base-message';
+import { NotificationWrapperComponent } from './notification-wrapper.component';
+import { NotificationComponent } from './notification.component';
+import { NotificationConfig, NotificationGlobalConfig } from './notification.config';
+import * as i0 from "@angular/core";
+export declare class NotificationService extends BaseMessage<NotificationWrapperComponent, NotificationComponent, NotificationConfig> {
+    constructor(overlay: Overlay, injector: Injector, applicationRef: ApplicationRef, cfr: ComponentFactoryResolver, globalConfig: NotificationGlobalConfig);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, [null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alauda/ui",
-  "version": "9.1.1-beta.3",
+  "version": "9.1.1-beta.4",
   "description": "Angular UI components by Alauda Frontend Team.",
   "repository": "git+https://github.com/alauda/alauda-ui.git",
   "author": "Alauda Frontend",
@@ -9,7 +9,7 @@
     "JounQin <admin@1stG.me> (https://www.1stG.me)"
   ],
   "license": "MIT",
-  "packageManager": "yarn@4.0.1",
+  "packageManager": "yarn@1.22.21",
   "keywords": [
     "alauda",
     "angular",
@@ -17,7 +17,7 @@
     "ui"
   ],
   "peerDependencies": {
-    "@angular/cdk": ">=20.0.0",
+    "@angular/cdk": ">=19.0.0",
     "dayjs": "^1.0.0",
     "rxjs": "^7.0.0"
   },

package/paginator/index.d.ts

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

package/paginator/paginator-intl.d.ts

@@ -0,0 +1,20 @@
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * To modify the labels and text displayed, create a new instance of MatPaginatorIntl and
+ * include it in a custom provider
+ */
+export 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>;
+}

package/paginator/paginator.component.d.ts

@@ -0,0 +1,37 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy } from '@angular/core';
+import { Bem } from '../internal/utils';
+import { PaginatorIntl } from './paginator-intl';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/paginator/paginator.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../button/button.module";
+import * as i3 from "../icon/icon.module";
+import * as i4 from "../select/select.module";
+import * as i5 from "../input/input.module";
+import * as i6 from "./paginator.component";
+export declare class PaginatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PaginatorModule, never, [typeof i1.CommonModule, typeof i2.ButtonModule, typeof i3.IconModule, typeof i4.SelectModule, typeof i5.InputModule, typeof i6.PaginatorComponent], [typeof i6.PaginatorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PaginatorModule>;
+}

package/radio/base-radio.d.ts

@@ -0,0 +1,28 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { AfterViewInit, ChangeDetectorRef, ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { RadioGroupComponent } from './radio-group/radio-group.component';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/radio/index.d.ts

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

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

@@ -0,0 +1,17 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { ChangeDetectorRef, OnInit } from '@angular/core';
+import { Bem } from '../../internal/utils';
+import { BaseRadio } from '../base-radio';
+import { RadioGroupComponent } from '../radio-group/radio-group.component';
+import { RadioSize } from '../radio.types';
+import * as i0 from "@angular/core";
+export 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>;
+}

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

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { CommonFormControl } from '../../form';
+import { RadioSize } from '../radio.types';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/radio/radio.component.d.ts

@@ -0,0 +1,13 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { ChangeDetectorRef } from '@angular/core';
+import { Bem } from '../internal/utils';
+import { BaseRadio } from './base-radio';
+import { RadioGroupComponent } from './radio-group/radio-group.component';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/radio/radio.module.d.ts

@@ -0,0 +1,15 @@
+import { RadioButtonComponent } from './radio-button/radio-button.component';
+import { RadioGroupComponent } from './radio-group/radio-group.component';
+import { RadioComponent } from './radio.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../icon/icon.module";
+import * as i3 from "./radio.component";
+import * as i4 from "./radio-group/radio-group.component";
+import * as i5 from "./radio-button/radio-button.component";
+export declare class RadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RadioModule, never, [typeof i1.CommonModule, typeof i2.IconModule, typeof i3.RadioComponent, typeof i4.RadioGroupComponent, typeof i5.RadioButtonComponent], [typeof i3.RadioComponent, typeof i4.RadioGroupComponent, typeof i5.RadioButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RadioModule>;
+}
+export declare const RADIO_MODULE: readonly [typeof RadioComponent, typeof RadioGroupComponent, typeof RadioButtonComponent];

package/radio/radio.types.d.ts

@@ -0,0 +1,7 @@
+import { ValueOf } from '../internal/types';
+export declare const RadioSize: {
+    readonly Medium: "medium";
+    readonly Small: "small";
+    readonly Mini: "mini";
+};
+export type RadioSize = ValueOf<typeof RadioSize>;

package/scrolling/fixed-size-table-virtual-scroll-strategy.d.ts

@@ -0,0 +1,28 @@
+import { ListRange } from '@angular/cdk/collections';
+import { CdkVirtualScrollViewport, VirtualScrollStrategy } from '@angular/cdk/scrolling';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FixedSizeTableVirtualScrollStrategy implements VirtualScrollStrategy {
+    private _rowHeight;
+    private _headerHeight;
+    private _bufferSize;
+    private readonly _indexChange;
+    viewport: CdkVirtualScrollViewport;
+    scrolledIndexChange: import("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>;
+}

package/scrolling/fixed-size-table-virtual-scroll.directive.d.ts

@@ -0,0 +1,24 @@
+import { AfterContentInit, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { TableComponent } from '../table';
+import { FixedSizeTableVirtualScrollStrategy } from './fixed-size-table-virtual-scroll-strategy';
+import * as i0 from "@angular/core";
+export declare function _tableVirtualScrollDirectiveStrategyFactory(tableDir: FixedSizeTableVirtualScrollDirective): FixedSizeTableVirtualScrollStrategy;
+export 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>;
+}

package/scrolling/fixed-size-virtual-scroll.directive.d.ts

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

package/scrolling/index.d.ts

@@ -0,0 +1,6 @@
+export * from './fixed-size-table-virtual-scroll.directive';
+export * from './fixed-size-table-virtual-scroll-strategy';
+export * from './fixed-size-virtual-scroll.directive';
+export * from './scrolling.module';
+export * from './virtual-for-of.directive';
+export * from './virtual-scroll-viewport.component';

package/scrolling/scrolling.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./virtual-scroll-viewport.component";
+import * as i2 from "./fixed-size-table-virtual-scroll.directive";
+import * as i3 from "./fixed-size-virtual-scroll.directive";
+import * as i4 from "./virtual-for-of.directive";
+export declare class ScrollingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ScrollingModule, never, [typeof i1.VirtualScrollViewportComponent, typeof i2.FixedSizeTableVirtualScrollDirective, typeof i3.FixedSizeVirtualScrollDirective, typeof i4.VirtualForOfDirective], [typeof i1.VirtualScrollViewportComponent, typeof i2.FixedSizeTableVirtualScrollDirective, typeof i3.FixedSizeVirtualScrollDirective, typeof i4.VirtualForOfDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ScrollingModule>;
+}

package/scrolling/virtual-for-of.directive.d.ts

@@ -0,0 +1,13 @@
+import { DataSource } from '@angular/cdk/collections';
+import { CdkVirtualForOf, CdkVirtualForOfContext } from '@angular/cdk/scrolling';
+import { NgIterable, TemplateRef, TrackByFunction } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/scrolling/virtual-scroll-viewport.component.d.ts

@@ -0,0 +1,6 @@
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import * as i0 from "@angular/core";
+export declare class VirtualScrollViewportComponent extends CdkVirtualScrollViewport {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualScrollViewportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VirtualScrollViewportComponent, "aui-virtual-scroll-viewport", never, {}, {}, never, ["*"], true, never>;
+}

package/select/base-select.d.ts

@@ -0,0 +1,83 @@
+import { AfterContentInit, AfterViewInit, ElementRef, EventEmitter, OnDestroy, QueryList } from '@angular/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { CommonFormControl } from '../form';
+import { ComponentSize } from '../internal/types';
+import { TooltipDirective } from '../tooltip';
+import { OptionContentDirective } from './helper-directives';
+import { OptionComponent } from './option/option.component';
+import { OptionFilterFn, SelectFilterOption, TrackFn } from './select.types';
+import * as i0 from "@angular/core";
+export 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 import("@angular/core").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;
+}

package/select/helper-directives.d.ts

@@ -0,0 +1,22 @@
+import { ApplicationRef, ComponentFactoryResolver, Injector, OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class OptionGroupTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionGroupTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OptionGroupTitleDirective, "[auiOptionGroupTitle]", ["auiOptionGroupTitle"], {}, {}, never, never, true, never>;
+}
+export declare class OptionContentDirective implements OnDestroy {
+    private readonly templateRef;
+    private readonly appRef;
+    private readonly viewContainerRef;
+    private readonly componentFactoryResolver;
+    private readonly injector;
+    private portal;
+    private outlet;
+    private readonly doc;
+    constructor(templateRef: TemplateRef<unknown>, appRef: ApplicationRef, viewContainerRef: ViewContainerRef, componentFactoryResolver: ComponentFactoryResolver, 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>;
+}

package/select/index.d.ts

@@ -0,0 +1,9 @@
+export * from './helper-directives';
+export * from './multi-select/multi-select.component';
+export * from './option/option.component';
+export * from './option-group/option-group.component';
+export * from './option-placeholder.component';
+export * from './select.component';
+export * from './select.module';
+export * from './select.types';
+export * from './validators';

package/select/multi-select/multi-select.component.d.ts

@@ -0,0 +1,57 @@
+import { AfterContentInit, AfterViewInit, ChangeDetectorRef, ElementRef, Renderer2 } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Bem } from '../../internal/utils';
+import { BaseSelect } from '../base-select';
+import { OptionComponent } from '../option/option.component';
+import { SelectAllStatus, SelectFilterOption, TagClassFn } from '../select.types';
+import * as i0 from "@angular/core";
+export 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$: import("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;
+}

package/select/option/option.component.d.ts

@@ -0,0 +1,46 @@
+import { ChangeDetectorRef, ElementRef, TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ComponentSize } from '../../internal/types';
+import { Bem } from '../../internal/utils';
+import { BaseSelect } from '../base-select';
+import * as i0 from "@angular/core";
+export 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>;
+}