@acorex/cdk 19.15.0-next.8 → 20.0.0

package/common/index.d.ts

@@ -1,33 +1,930 @@
-export * from './lib/types/animation';
-export * from './lib/types/base';
-export * from './lib/types/direction';
-export * from './lib/types/orientation';
-export * from './lib/types/placement';
-export * from './lib/types/range';
-export * from './lib/types/selection-mode';
-export * from './lib/classes/components.class';
-export * from './lib/classes/datalist.class';
-export * from './lib/classes/datasource.class';
-export * from './lib/classes/events.class';
-export * from './lib/classes/styles.class';
-export * from './lib/interfaces/component.interface';
-export * from './lib/common.module';
-export * from './lib/components/base-component.class';
-export * from './lib/components/button-base-component.class';
-export * from './lib/components/color-component.class';
-export * from './lib/components/colorlook-component.class';
-export * from './lib/components/input-base-value-component.class';
-export * from './lib/components/interactive-component.class';
-export * from './lib/components/look-component.class';
-export * from './lib/components/selection-base.component.class';
-export * from './lib/components/value-component.class';
-export * from './lib/directives/auto-focus.directive';
-export * from './lib/directives/copy-clipboard.directive';
-export * from './lib/directives/delayed-value-changed.directive';
-export * from './lib/directives/hotkey.directive';
-export * from './lib/directives/infinite-scroll.directive';
-export * from './lib/directives/inverted-color.directive';
-export * from './lib/directives/responsive.directive';
-export * from './lib/directives/ripple.directive';
-export * from './lib/services/dom.service';
-export * from './lib/services/hotkey.service';
+import * as i0 from '@angular/core';
+import { ChangeDetectorRef, ViewContainerRef, EventEmitter, OnDestroy, AfterViewInit, InjectionToken } from '@angular/core';
+import { AXUnsubscriber } from '@acorex/core/utils';
+import { AXValidationSummary, AXValidationRuleOptions } from '@acorex/core/validation';
+import { ControlValueAccessor } from '@angular/forms';
+import { DataSource, CollectionViewer } from '@angular/cdk/collections';
+import { Subject, Observable } from 'rxjs';
+import * as polytype from 'polytype';
+import { Observable as Observable$1 } from 'rxjs/internal/Observable';
+
+type AXAnimationEasing = 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'cubic' | 'cubic-in' | 'cubic-out' | 'cubic-in-out';
+
+declare abstract class NXButtonComponent {
+    text: i0.ModelSignal<string>;
+    toggleableChange: i0.OutputEmitterRef<boolean>;
+    selectedChange: i0.OutputEmitterRef<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NXButtonComponent, "ng-component", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "text": "textChange"; "toggleableChange": "toggleableChange"; "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+
+/**
+ * A token that specifies the  color style of component.
+ */
+type AXStyleColorType = 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'default';
+declare const AX_STYLE_COLOR_TYPES: AXStyleColorType[];
+type AXStyleLookType = 'solid' | 'blank' | 'outline' | 'twotone' | 'flat' | 'fill' | 'link' | 'none';
+declare const AX_STYLE_LOOK_TYPES: AXStyleLookType[];
+type AXSizeType = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type AXStyleSizeType = `ax-${AXSizeType}`;
+type AXLocation = 'bottom-start' | 'bottom-center' | 'bottom-end' | 'top-start' | 'top-center' | 'top-end' | 'center-end' | 'center-start';
+declare const AX_LOCATIONS: AXLocation[];
+type AXSurfaceType = 'lightest' | 'lighter' | 'light' | 'surface' | 'dark' | 'darker' | 'darkest';
+
+declare abstract class NXColorComponent {
+    color: i0.ModelSignal<AXStyleColorType>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXColorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NXColorComponent, "ng-component", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "color": "colorChange"; }, never, never, true, never>;
+}
+
+declare abstract class NXComponent {
+    #private;
+    protected isRendered: i0.Signal<boolean>;
+    get nativeElement(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NXComponent>;
+}
+
+/**
+ *  Base event class
+ * @category Events
+ */
+declare class NXEvent<T extends NXComponent = NXComponent> {
+    sender: T;
+}
+/**
+ *  Contains native event
+ * @category Events
+ */
+declare class NXNativeEvent<T extends NXComponent = NXComponent, E extends Event = Event> extends NXEvent<T> {
+    nativeEvent: E;
+}
+/**
+ *  Fires each time the user click the element.
+ * @category Events
+ */
+declare class NXClickEvent<T extends NXComponent = NXComponent> extends NXNativeEvent<T, MouseEvent> {
+}
+
+declare abstract class NXInteractiveComponent extends NXComponent {
+    disabled: i0.ModelSignal<boolean>;
+    tabIndex: i0.ModelSignal<number>;
+    onFocus: i0.OutputEmitterRef<void>;
+    onBlur: i0.OutputEmitterRef<void>;
+    focus(): void;
+    blur(): void;
+    hasFocus(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXInteractiveComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NXInteractiveComponent, "ng-component", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "tabIndex": "tabIndexChange"; "onFocus": "onFocus"; "onBlur": "onBlur"; }, never, never, true, never>;
+}
+
+declare abstract class NXLookComponent {
+    look: i0.ModelSignal<AXStyleLookType>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXLookComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NXLookComponent, "ng-component", never, { "look": { "alias": "look"; "required": false; "isSignal": true; }; }, { "look": "lookChange"; }, never, never, true, never>;
+}
+
+declare abstract class NXValueComponent {
+    readonly: i0.ModelSignal<boolean>;
+    name: i0.ModelSignal<string>;
+    value: i0.ModelSignal<unknown>;
+    onValueChanged: i0.OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXValueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NXValueComponent, "ng-component", never, { "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "readonly": "readonlyChange"; "name": "nameChange"; "value": "valueChange"; "onValueChanged": "onValueChanged"; }, never, never, true, never>;
+}
+
+/**
+ * A token that specifies the direction of component.
+ */
+type AXDirection = 'vertical' | 'horizontal';
+
+/**
+ * A token that specifies the orientation of component.
+ */
+type AXOrientation = 'vertical' | 'horizontal';
+
+type AXPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'end' | 'end-top' | 'end-bottom' | 'start' | 'start-top' | 'start-bottom';
+type AXPlacementType = AXConnectedPosition | AXConnectedPosition[] | AXPlacement | AXPlacement[];
+declare function convertToPlacement(value: AXPlacementType): AXConnectedPosition[];
+interface AXConnectedPosition {
+    originX: 'start' | 'center' | 'end';
+    originY: 'top' | 'center' | 'bottom';
+    overlayX: 'start' | 'center' | 'end';
+    overlayY: 'top' | 'center' | 'bottom';
+    weight?: number;
+    offsetX?: number;
+    offsetY?: number;
+}
+declare const AX_PLACEMENT_TOP: AXConnectedPosition;
+declare const AX_PLACEMENT_TOP_START: AXConnectedPosition;
+declare const AX_PLACEMENT_TOP_END: AXConnectedPosition;
+declare const AX_PLACEMENT_BOTTOM: AXConnectedPosition;
+declare const AX_PLACEMENT_BOTTOM_START: AXConnectedPosition;
+declare const AX_PLACEMENT_BOTTOM_END: AXConnectedPosition;
+declare const AX_PLACEMENT_START: AXConnectedPosition;
+declare const AX_PLACEMENT_START_TOP: AXConnectedPosition;
+declare const AX_PLACEMENT_START_BOTTOM: AXConnectedPosition;
+declare const AX_PLACEMENT_END: AXConnectedPosition;
+declare const AX_PLACEMENT_END_TOP: AXConnectedPosition;
+declare const AX_PLACEMENT_END_BOTTOM: AXConnectedPosition;
+declare const AX_PLACEMENT_MAP: {
+    [key: string]: {
+        origin: AXConnectedPosition;
+        alts?: AXConnectedPosition[];
+    };
+};
+
+interface AXRange<T> {
+    from: T;
+    end: T;
+}
+
+/**
+ * A token that specifies the  selection mode of component.
+ */
+type AXSelectionMode = 'single' | 'multiple' | 'none';
+
+/**
+ *  Contains native event
+ * @category Events
+ */
+declare class AXEvent {
+    /**
+     *  The sender component
+     */
+    component: any;
+    /**
+     *  The root native element
+     */
+    htmlElement?: HTMLElement;
+    isUserInteraction?: boolean;
+}
+/**
+ *  Contains native event
+ * @category Events
+ */
+declare class AXHtmlEvent<E extends Event = Event> extends AXEvent {
+    nativeEvent?: E;
+}
+/**
+ *  Contains native event
+ * @category Events
+ */
+declare class AXValueChangedEvent<T = any> extends AXEvent {
+    name?: string;
+    value?: T;
+    oldValue?: T;
+}
+/**
+ *  Contains native event
+ * @category Events
+ */
+declare class AXOptionChangedEvent<T = any> extends AXEvent {
+    name?: string;
+    newValue?: T;
+    oldValue?: T;
+}
+/**
+ *  Fires each time the user click the element.
+ * @category Events
+ */
+declare class AXClickEvent extends AXHtmlEvent<MouseEvent> {
+    /**
+     *  uses for extra data
+     */
+    data?: any;
+    nativeEvent?: any;
+}
+/**
+ *  Fires each time the user click the element.
+ * @category Events
+ */
+declare class AXButtonClickEvent extends AXClickEvent {
+    name: string;
+}
+/**
+ *  Fires each time the user click the element.
+ * @category Events
+ */
+declare class AXItemClickEvent<T = any> extends AXClickEvent {
+    name?: string;
+    item: T;
+}
+/**
+ *  Fires each time the component gets focused.
+ * @category Events
+ */
+declare class AXFocusEvent extends AXHtmlEvent<FocusEvent> {
+}
+/**
+ *  Fires each time an item or multiple items selected by the user or value.
+ * @category Events
+ */
+declare class AXSelectionValueChangedEvent extends AXValueChangedEvent<any | any[]> {
+    value?: any;
+    oldValue?: any;
+    selectedKeys?: any[];
+    selectedItems?: any[];
+}
+/**
+ *  Contains range start & end values
+ * @category Events
+ */
+declare class AXRangeChangedEvent<T> extends AXEvent {
+    /**
+     *  The range start value
+     */
+    start?: T;
+    /**
+     *  The range end value
+     */
+    end?: T;
+}
+
+type MXComponentOptionChanging<T = any> = {
+    name: string;
+    value?: T;
+};
+type MXComponentOptionChanged<T = any> = MXComponentOptionChanging<T>;
+type MXComponentSetOption<T> = {
+    name: string;
+    value?: T;
+    afterCallback?: (oldValue?: T, newValue?: T) => void;
+    beforeCallback?: (oldValue?: T, newValue?: T) => void;
+};
+type AXComponentState = 'clear' | 'success' | 'error';
+declare abstract class MXBaseComponent {
+    private _cdr;
+    private _elementRef;
+    private _viewRef;
+    private _domService;
+    private _id;
+    get id(): string;
+    set id(v: string);
+    protected get cdr(): ChangeDetectorRef;
+    getHostElement<T = HTMLElement>(): T;
+    protected getViewContainer(): ViewContainerRef;
+    protected internalOptionChanging(option: MXComponentOptionChanging): any;
+    protected internalOptionChanged(option: MXComponentOptionChanged): void;
+    /**
+     *  @ignore
+     */
+    protected ngOnInit(): void;
+    /**
+     * Fired when an option related to the component changes.
+     *
+     * @event
+     */
+    onOptionChanged: EventEmitter<AXOptionChangedEvent>;
+    setOption<T = any>(option: MXComponentSetOption<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXBaseComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXBaseComponent>;
+}
+
+declare class MXInteractiveComponent extends MXBaseComponent {
+    /**
+     *  @ignore
+     */
+    protected onTouchedCallback: () => void;
+    registerOnTouched(fn: () => void): void;
+    private _touched;
+    /**
+     * Indicates whether the component has been touched.
+     *
+     */
+    get touched(): boolean;
+    /**
+     *  @ignore
+     */
+    protected markAsTouched(): void;
+    /**
+     * Emits an event whenever the disabled state of the component changes.
+     *
+     * @event
+     */
+    disabledChange: EventEmitter<boolean>;
+    private _disabled;
+    /**
+     *  If set to true, it disables the component.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    setDisabledState(isDisabled: boolean): void;
+    _tabIndex: number;
+    /**
+     *  Specifies the tabindex of the component.
+     */
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    /**
+     *  Fires each time the component gets focused.
+     *  @event
+     */
+    onFocus: EventEmitter<AXFocusEvent>;
+    protected emitOnFocusEvent(e?: FocusEvent): void;
+    /**
+     *  Fires each time the component gets blurred.
+     *  @event
+     */
+    onBlur: EventEmitter<AXFocusEvent>;
+    protected emitOnBlurEvent(e?: FocusEvent): void;
+    focus(): void;
+    blur(): void;
+    /**
+     *  Check component is focused or has any focused element.
+     */
+    hasFocus(): boolean;
+}
+
+declare class MXValueComponent<T = any> extends MXInteractiveComponent implements ControlValueAccessor {
+    /**
+     *  Fires each time the user press a key.
+     *  @event
+     */
+    onValueChanged: EventEmitter<AXValueChangedEvent<any>>;
+    /**
+     * @deprecated The event should not be used, use ngModelChange instead
+     */
+    valueChange: EventEmitter<any>;
+    readonlyChange: EventEmitter<boolean>;
+    private _readonly;
+    /**
+     *  If set to true, user cannot change the value of component.
+     */
+    get readonly(): boolean;
+    set readonly(value: boolean);
+    private _name;
+    get name(): string;
+    set name(value: string);
+    private _dirty;
+    get dirty(): boolean;
+    markAsDirty(): void;
+    private _isUserInteraction;
+    initValue: T;
+    defaultValue: T;
+    private _value;
+    /**
+     * @deprecated The property should not be used, use ngModel instead
+     */
+    get value(): T;
+    set value(v: T);
+    stateChange: EventEmitter<AXComponentState>;
+    private _state;
+    get state(): AXComponentState;
+    set state(value: AXComponentState);
+    protected emitOnValueChangedEvent(oldValue?: any, newValue?: any): void;
+    protected internalSetValue(value: any): T;
+    protected internalGetValue(value: any): T;
+    protected internalValueChanged(value: any): void;
+    protected ngOnInit(): void;
+    protected ngOnDestroy(): void;
+    protected registerValidation(): void;
+    protected document: Document;
+    protected platformID: Object;
+    private validationService;
+    validationRulesChange: EventEmitter<AXFormValidationRule[]>;
+    private validationRules;
+    get isRequired(): boolean;
+    addValidationRule(rule: AXFormValidationRule): void;
+    removeValidationRule(ruleToRemove: AXFormValidationRule): void;
+    validate(): Promise<AXValidationSummary>;
+    protected setState(state: AXComponentState, ...args: any[]): void;
+    protected onChangeCallback: (value: T) => void;
+    registerOnChange(fn: (value: T) => void): void;
+    writeValue(value: T): void;
+    commitValue(value: T, u?: boolean): void;
+    reset(e?: boolean): void;
+    resetErrors(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXValueComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXValueComponent<any>>;
+}
+
+declare const TAB_META_KEY = "__meta__";
+declare class AXComponentCloseEvent extends AXEvent {
+    data?: any;
+}
+declare class AXComponentClosing {
+    cancel: boolean;
+    data?: any;
+}
+declare class AXComponentResult {
+    sender: any;
+    data?: any;
+}
+interface AXFormValidationRule {
+    rule: string;
+    disabled: boolean;
+    options?: AXValidationRuleOptions;
+}
+/**
+ *  Defines a CSS class—or multiple classes separated by spaces— which are applied to a span element inside the Button. Allows the usage of custom icons after the primary text.
+ */
+declare class AXComponentClosedPromise extends Promise<AXComponentResult> {
+    private closeMethod;
+    constructor(executor: (resolve: (value?: AXComponentResult | PromiseLike<AXComponentResult>) => void, reject: (reason?: any) => void) => void);
+    close(): void;
+}
+declare abstract class AXComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXComponent>;
+}
+declare abstract class AXClosableComponent extends AXComponent {
+    abstract close(): void;
+    abstract closeAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXClosableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXClosableComponent>;
+}
+declare abstract class AXClearableComponent extends AXComponent {
+    abstract reset(u: boolean): void;
+    abstract get readonly(): boolean;
+    abstract get disabled(): boolean;
+    abstract get value(): unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXClearableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXClearableComponent>;
+}
+declare abstract class AXSearchableComponent extends AXComponent {
+    abstract search(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXSearchableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXSearchableComponent>;
+}
+declare abstract class AXValuableComponent extends AXComponent {
+    abstract get isRequired(): boolean;
+    validationRulesChange: EventEmitter<AXFormValidationRule[]>;
+    abstract get name(): string;
+    abstract get value(): unknown;
+    abstract onValueChanged: EventEmitter<AXValueChangedEvent<unknown>>;
+    abstract commitValue(value: unknown, u: boolean): any;
+    abstract addValidationRule(rule: AXFormValidationRule): any;
+    abstract removeValidationRule(rule: AXFormValidationRule): any;
+    abstract validate(): Promise<AXValidationSummary>;
+    abstract reset(e: boolean): void;
+    abstract resetErrors(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXValuableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXValuableComponent>;
+}
+declare abstract class AXFocusableComponent extends AXComponent {
+    abstract focus(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXFocusableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXFocusableComponent>;
+}
+interface AXPagedComponentInterface {
+    goToPage(page: number): any;
+    get totalCount(): number;
+    get pageSize(): number;
+    onPageChanged: EventEmitter<AXValueChangedEvent<number>>;
+}
+declare abstract class AXPagedComponent extends AXComponent implements AXPagedComponentInterface {
+    abstract goToPage(page: number): any;
+    abstract get totalCount(): number;
+    abstract pageSize: number;
+    abstract onPageChanged: EventEmitter<AXValueChangedEvent<number>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPagedComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPagedComponent>;
+}
+declare abstract class AXAutocompleteParentComponent<T> extends MXValueComponent<T> {
+    oldInputEmitValue: T;
+    abstract unsubscriber: AXUnsubscriber;
+    onKeyDown: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
+    onItemSelected: EventEmitter<AXValueChangedEvent<T>>;
+    emitOnItemSelected(value: T, isUserInteraction?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXAutocompleteParentComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXAutocompleteParentComponent<any>>;
+}
+
+type AXDataSourceOperator = {
+    type: 'equal' | 'isNull' | 'isEmpty' | 'lt' | 'lte' | 'gt' | 'gte' | 'startsWith' | 'endsWith' | 'contains';
+    negative?: boolean;
+};
+type AXFilterLogic = 'and' | 'or';
+type AXSortOrder = 'asc' | 'desc';
+type AXDataSourceFilterOption = {
+    field?: string;
+    value?: unknown;
+    operator?: AXDataSourceOperator;
+    logic?: AXFilterLogic;
+    filters?: AXDataSourceFilterOption[];
+};
+type AXDataSourceSortOption = {
+    field: string;
+    dir: 'asc' | 'desc';
+};
+interface AXDataSourceQuery {
+    take: number;
+    skip: number;
+    filter?: AXDataSourceFilterOption;
+    sort: AXDataSourceSortOption[];
+}
+interface AXDataSourceCallbackResult<T> {
+    items: Array<T>;
+    total: number;
+}
+type AXDataSourceLoadCallback<T> = (e: AXDataSourceQuery) => Promise<AXDataSourceCallbackResult<T>>;
+type AXDataSourceByKeyCallback<T> = (key: unknown) => Promise<T>;
+interface AXDataSourceConfig<T = unknown> {
+    key?: string;
+    pageSize: number;
+    load: AXDataSourceLoadCallback<T>;
+    byKey?: AXDataSourceByKeyCallback<T>;
+}
+interface AXDataSourceChangedEvent<T = unknown> {
+    cachedItems: Array<T>;
+    items: Array<T>;
+    totalCount: number;
+    totalPages: number;
+    page: number;
+}
+interface AXDataSourceItemExpandedEvent<T = unknown> {
+    expandedItem: T;
+    children: Array<T>;
+}
+declare class AXDataSource<T = unknown> {
+    config: AXDataSourceConfig<T>;
+    useCache: boolean;
+    private _totalCount;
+    get totalCount(): number;
+    get totalPages(): number;
+    get pageSize(): number;
+    private _cachedItems;
+    get cachedItems(): T[];
+    private _items;
+    get items(): T[];
+    private fetchedPages;
+    private _page;
+    private _query;
+    get query(): AXDataSourceQuery;
+    onChanged: Subject<AXDataSourceChangedEvent<T>>;
+    onItemExpanded: Subject<AXDataSourceItemExpandedEvent<T>>;
+    onItemRefreshChildren: Subject<{
+        id: string;
+    }>;
+    onLoadingChanged: Subject<boolean>;
+    private _isLoading;
+    get isLoading(): boolean;
+    constructor(config: AXDataSourceConfig<T>);
+    private load;
+    getItemsByFilter(filter: AXDataSourceFilterOption): Promise<AXDataSourceCallbackResult<T>>;
+    private setLoadingState;
+    setPage(page: number): void;
+    setPageSize(pageSize: number): void;
+    filter(value: AXDataSourceFilterOption): void;
+    sort(...value: AXDataSourceSortOption[]): void;
+    clearFilter(): void;
+    reset(): void;
+    refresh(): void;
+    find(key: unknown): T | Promise<T>;
+}
+declare function convertArrayToDataSource<T>(items: T[], options?: {
+    key: string;
+    pageSize: number;
+}): AXDataSource;
+
+interface AXDataListQuery {
+    take?: number;
+    skip?: number;
+    searchQuery?: string;
+}
+interface AXDataListFetchCallbackResult {
+    items: Array<any>;
+    total: number;
+}
+type AXDataListFetchDataCallback = (e: AXDataListQuery) => Promise<AXDataListFetchCallbackResult>;
+type AXDataListItems = Array<any> | AXDataListFetchDataCallback;
+declare class AXListDataSource<T = unknown> extends DataSource<T> {
+    private config;
+    private debounceTime;
+    private subscription;
+    source: AXDataSource<T>;
+    private dataStream;
+    private _range;
+    get range(): {
+        start: number;
+        end: number;
+    };
+    /**
+     * @ignore
+     */
+    constructor(config: {
+        source: AXDataSource<T>;
+        debounceTime?: number;
+    });
+    connect(collectionViewer: CollectionViewer): Observable<T[]>;
+    disconnect(): void;
+    private getPageForIndex;
+    refresh(): void;
+}
+
+interface AXExpandToggleIcons {
+    expanded: string;
+    collapsed: string;
+}
+
+declare class AXResponsiveDirective implements OnDestroy {
+    private _elementRef;
+    private _observer;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXResponsiveDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXResponsiveDirective, "[axResponsive]", never, {}, {}, never, never, true, never>;
+}
+
+interface AXScrollPosition {
+    scrollHeight: number;
+    scrollTop: number;
+    clientHeight: number;
+}
+declare class AXInfiniteScrollerDirective implements AfterViewInit {
+    private elm;
+    private scrollEvent$;
+    private userScrolledDown$;
+    private requestOnScroll$;
+    scrollCallback: Function;
+    immediateCallback: any;
+    scrollPercent: number;
+    ngAfterViewInit(): void;
+    private registerScrollEvent;
+    private streamScrollEvents;
+    private requestCallbackOnScroll;
+    private isUserScrollingDown;
+    private isScrollExpectedPercent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXInfiniteScrollerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXInfiniteScrollerDirective, "[axInfiniteScroller]", never, { "scrollCallback": { "alias": "scrollCallback"; "required": false; }; "immediateCallback": { "alias": "immediateCallback"; "required": false; }; "scrollPercent": { "alias": "scrollPercent"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AXAutoFocusDirective implements AfterViewInit {
+    private renderer;
+    private el;
+    _host: AXFocusableComponent;
+    autoFocus?: boolean;
+    time: number;
+    private document;
+    private platformID;
+    ngAfterViewInit(): void;
+    protected doFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXAutoFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXAutoFocusDirective, "[axAutoFocus]", never, { "autoFocus": { "alias": "axAutoFocus"; "required": false; }; "time": { "alias": "axAutoFocusTime"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type AXHotKeyAction = {
+    [key: string]: string | Function;
+    parmas?: any;
+};
+declare class AXHotkeyDirective implements AfterViewInit {
+    private el;
+    _host: AXComponent;
+    private hs;
+    axHotkey: string | AXHotKeyAction | AXHotKeyAction[];
+    private _subs;
+    ngAfterViewInit(): void;
+    private _addDefaultAction;
+    private _addHotKeyAction;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXHotkeyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXHotkeyDirective, "[axHotkey]", never, { "axHotkey": { "alias": "axHotkey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AXCommonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXCommonModule, never, [typeof AXResponsiveDirective, typeof AXInfiniteScrollerDirective, typeof AXAutoFocusDirective, typeof AXHotkeyDirective], [typeof AXResponsiveDirective, typeof AXInfiniteScrollerDirective, typeof AXAutoFocusDirective, typeof AXHotkeyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXCommonModule>;
+}
+
+declare class MXColorComponent extends MXBaseComponent {
+    colorChange: EventEmitter<AXStyleColorType>;
+    private _color;
+    /**
+     *  Predefined color schemes
+     */
+    get color(): AXStyleColorType;
+    set color(value: AXStyleColorType);
+}
+
+declare abstract class MXLookableComponent {
+    look: AXStyleLookType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXLookableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXLookableComponent>;
+}
+declare class MXLookComponent extends MXBaseComponent {
+    lookChange: EventEmitter<AXStyleLookType>;
+    private _look?;
+    /**
+     *  Predefined look schemes
+     */
+    get look(): AXStyleLookType;
+    set look(value: AXStyleLookType);
+}
+
+declare const MXColorLookComponent_base: polytype.Polytype.ClusteredConstructor<[typeof MXColorComponent, typeof MXLookComponent]>;
+declare class MXColorLookComponent extends MXColorLookComponent_base {
+}
+
+declare const MXButtonBaseComponent_base: polytype.Polytype.ClusteredConstructor<[typeof MXInteractiveComponent, typeof MXColorLookComponent]>;
+declare class MXButtonBaseComponent extends MXButtonBaseComponent_base {
+    /**
+     * Emits an event when the text associated with the button changes.
+     *
+     * @event
+     */
+    textChange: EventEmitter<string>;
+    private _text;
+    /**
+     *  Defines the primary text to show inside the button.
+     */
+    get text(): string;
+    set text(v: string);
+    /**
+     * Emits an event when the toggleable state of the action sheet changes.
+     *
+     * @event
+     */
+    toggleableChange: EventEmitter<boolean>;
+    private _toggleable?;
+    /**
+     *  Provides visual styling that indicates if the Button is active
+     */
+    get toggleable(): boolean;
+    set toggleable(value: boolean);
+    /**
+     * Emits an event whenever the selection state of the component changes.
+     *
+     * @event
+     */
+    selectedChange: EventEmitter<boolean>;
+    private _selected?;
+    /**
+     *  Indicates if the Button is selected or not
+     */
+    get selected(): boolean;
+    set selected(value: boolean);
+    /**
+     *  @ignore
+     */
+    constructor();
+    /**
+     *  @ignore
+     */
+    protected get cssClasses(): {
+        'ax-button-icon': boolean;
+        'ax-state-disabled': boolean;
+        'ax-state-selected': boolean;
+    };
+}
+
+declare class MXInputBaseValueComponent<T = string> extends MXValueComponent<T> {
+    oldText: string;
+    placeholder: string;
+    /**
+     *  Fires each time the user press a key.
+     *  @event
+     */
+    onKeyDown: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
+    /**
+     *  Fires each time the user press a key.
+     *  @event
+     */
+    onKeyUp: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
+    /**
+     *  Fires each time the user press a key.
+     *  @event
+     */
+    onKeyPress: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
+    /**
+     *  Fires each time the user change the text.
+     *  @event
+     */
+    onTextChanged: EventEmitter<AXValueChangedEvent<string>>;
+    protected emitOnKeydownEvent(e: KeyboardEvent): void;
+    protected emitOnKeyupEvent(e: KeyboardEvent): void;
+    protected emitOnKeypressEvent(e: KeyboardEvent): void;
+    protected emitOnTextChanged(value: string, isUserInteraction?: boolean): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXInputBaseValueComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXInputBaseValueComponent<any>>;
+}
+
+declare class MXSelectionBridgeService {
+    selectedItems: unknown[];
+    cacheList: {
+        [key: string | number]: unknown;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXSelectionBridgeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXSelectionBridgeService>;
+}
+declare const AX_SELECTION_DATA_TOKEN: InjectionToken<MXSelectionBridgeService>;
+declare abstract class MXSelectionValueComponent<T = any> extends MXValueComponent<any> {
+    private formatService;
+    private dataService;
+    disabledCallback: (e: {
+        item: T;
+        index: number;
+    }) => boolean;
+    private _valueField;
+    get valueField(): string;
+    set valueField(v: string);
+    private _textTemplate;
+    get textTemplate(): string;
+    set textTemplate(v: string);
+    private _textField;
+    get textField(): string;
+    set textField(v: string);
+    private _disabledField;
+    get disabledField(): string;
+    set disabledField(v: string);
+    private _multiple;
+    get multiple(): boolean;
+    set multiple(v: boolean);
+    get selectedItems(): unknown[];
+    internalSetValue(value: unknown): any;
+    emitOnValueChangedEvent(oldValue?: unknown, newValue?: unknown): void;
+    abstract getItemByKey(key: unknown): unknown | Promise<unknown>;
+    protected normalizeItemsList(items: unknown[], findBykey?: boolean): unknown[];
+    private normalizeItem;
+    private _normalizeSelectedItems;
+    unselectItems(...items: T[]): void;
+    selectItems(...items: T[]): void;
+    toggleSelect(...items: T[]): void;
+    isItemSelected(item: T): boolean;
+    isItemDisabled(item: T): boolean;
+    protected getDisplayText(item: T): any;
+    protected getValue(item: T): any;
+    protected clearSelectionCache(): void;
+    protected softClearSelectionCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXSelectionValueComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXSelectionValueComponent<any>>;
+}
+
+declare class AXNgModelDelayedValueChangedDirective implements OnDestroy {
+    private ngModel;
+    axDelayedValueChanged: EventEmitter<any>;
+    axDelayTimeChange: EventEmitter<number>;
+    private _delayTime;
+    get delayTime(): number;
+    set delayTime(v: number);
+    private subscription;
+    ngOnDestroy(): void;
+    constructor();
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXNgModelDelayedValueChangedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXNgModelDelayedValueChangedDirective, "[axDelayedValueChanged]", never, { "delayTime": { "alias": "delayTime"; "required": false; }; }, { "axDelayedValueChanged": "axDelayedValueChanged"; "axDelayTimeChange": "axDelayTimeChange"; }, never, never, true, never>;
+}
+
+declare class AXInvertedColorDirective {
+    color: i0.InputSignal<AXStyleColorType>;
+    ref: ViewContainerRef;
+    private platformID;
+    constructor();
+    protected invertColor(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXInvertedColorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXInvertedColorDirective, "[axInvertedColor]", never, { "color": { "alias": "color"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXRippleDirective implements OnDestroy {
+    private el;
+    private cdr;
+    enabled?: boolean;
+    axRippleColor: string;
+    ripple: HTMLSpanElement | null;
+    private document;
+    private platformID;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private onElementClick;
+    private createRipple;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXRippleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXRippleDirective, "[axRipple]", never, { "enabled": { "alias": "axRipple"; "required": false; }; "axRippleColor": { "alias": "axRippleColor"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AXDomService {
+    generateElementId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDomService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXDomService>;
+}
+
+type Options = {
+    /**
+     * element - An html element
+     */
+    element: any;
+    /**
+     * keys - string of keys like (Control.f)
+     */
+    keys: string;
+};
+declare class AXHotkeysService {
+    private eventManager;
+    private document;
+    defaults: Partial<Options>;
+    /**
+     * Add shortcut
+     *
+     *
+     * @param options
+     * @returns Observable
+     *
+     */
+    addShortcut(options: Partial<Options>): Observable$1<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXHotkeysService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXHotkeysService>;
+}
+
+export { AXAutoFocusDirective, AXAutocompleteParentComponent, AXButtonClickEvent, AXClearableComponent, AXClickEvent, AXClosableComponent, AXCommonModule, AXComponent, AXComponentCloseEvent, AXComponentClosedPromise, AXComponentClosing, AXComponentResult, AXDataSource, AXDomService, AXEvent, AXFocusEvent, AXFocusableComponent, AXHotkeyDirective, AXHotkeysService, AXHtmlEvent, AXInfiniteScrollerDirective, AXInvertedColorDirective, AXItemClickEvent, AXListDataSource, AXNgModelDelayedValueChangedDirective, AXOptionChangedEvent, AXPagedComponent, AXRangeChangedEvent, AXResponsiveDirective, AXRippleDirective, AXSearchableComponent, AXSelectionValueChangedEvent, AXValuableComponent, AXValueChangedEvent, AX_LOCATIONS, AX_PLACEMENT_BOTTOM, AX_PLACEMENT_BOTTOM_END, AX_PLACEMENT_BOTTOM_START, AX_PLACEMENT_END, AX_PLACEMENT_END_BOTTOM, AX_PLACEMENT_END_TOP, AX_PLACEMENT_MAP, AX_PLACEMENT_START, AX_PLACEMENT_START_BOTTOM, AX_PLACEMENT_START_TOP, AX_PLACEMENT_TOP, AX_PLACEMENT_TOP_END, AX_PLACEMENT_TOP_START, AX_SELECTION_DATA_TOKEN, AX_STYLE_COLOR_TYPES, AX_STYLE_LOOK_TYPES, MXBaseComponent, MXButtonBaseComponent, MXColorComponent, MXColorLookComponent, MXInputBaseValueComponent, MXInteractiveComponent, MXLookComponent, MXLookableComponent, MXSelectionBridgeService, MXSelectionValueComponent, MXValueComponent, NXButtonComponent, NXClickEvent, NXColorComponent, NXComponent, NXEvent, NXInteractiveComponent, NXLookComponent, NXNativeEvent, NXValueComponent, TAB_META_KEY, convertArrayToDataSource, convertToPlacement };
+export type { AXAnimationEasing, AXComponentState, AXConnectedPosition, AXDataListFetchCallbackResult, AXDataListFetchDataCallback, AXDataListItems, AXDataListQuery, AXDataSourceByKeyCallback, AXDataSourceCallbackResult, AXDataSourceChangedEvent, AXDataSourceConfig, AXDataSourceFilterOption, AXDataSourceItemExpandedEvent, AXDataSourceLoadCallback, AXDataSourceOperator, AXDataSourceQuery, AXDataSourceSortOption, AXDirection, AXExpandToggleIcons, AXFilterLogic, AXFormValidationRule, AXHotKeyAction, AXLocation, AXOrientation, AXPagedComponentInterface, AXPlacement, AXPlacementType, AXRange, AXScrollPosition, AXSelectionMode, AXSizeType, AXSortOrder, AXStyleColorType, AXStyleLookType, AXStyleSizeType, AXSurfaceType, MXComponentOptionChanged, MXComponentOptionChanging, MXComponentSetOption };