@acorex/components 6.0.1 → 6.0.2

package/color-palette/src/color-palette.module.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./color-palette.component";
+import * as i2 from "./color-palette-preview.component";
+import * as i3 from "./color-palette-swatches.component";
+import * as i4 from "./color-palette-input.component";
+import * as i5 from "./color-palette-picker.component";
+import * as i6 from "@angular/common";
+import * as i7 from "@acorex/components/textbox";
+import * as i8 from "@acorex/components/label";
+import * as i9 from "@acorex/components/button";
+import * as i10 from "@acorex/components/decorators";
+import * as i11 from "@acorex/components/number-box";
+import * as i12 from "@acorex/components/range-slider";
+export declare class AXColorPaletteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXColorPaletteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXColorPaletteModule, [typeof i1.AXColorPalleteComponent, typeof i2.AXColorPalettePreviewComponent, typeof i3.AXColorPaletteSwatchesComponent, typeof i4.AXColorPaletteInputComponent, typeof i5.AXColorPalettePickerComponent], [typeof i6.CommonModule, typeof i7.AXTextBoxModule, typeof i8.AXLabelModule, typeof i9.AXButtonModule, typeof i10.AXDecoratorModule, typeof i11.AXNumberBoxModule, typeof i12.AXRangeSliderModule], [typeof i1.AXColorPalleteComponent, typeof i2.AXColorPalettePreviewComponent, typeof i3.AXColorPaletteSwatchesComponent, typeof i4.AXColorPaletteInputComponent, typeof i5.AXColorPalettePickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXColorPaletteModule>;
+}

package/color-picker/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@acorex/components/color-picker" />
+export * from './public-api';

package/color-picker/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './src/color-picker.component';
+export * from './src/color-picker.module';

package/color-picker/src/color-picker.component.d.ts

@@ -0,0 +1,191 @@
+import { AXColorMode } from '@acorex/core/utils';
+import { AXPlatform } from '@acorex/core/platform';
+import { ChangeDetectorRef, ElementRef, NgZone } from '@angular/core';
+import { AXClickEvent, AXValueChangedEvent } from '@acorex/components/common';
+import { AXPopoverComponent } from '@acorex/components/popover';
+import { AXBaseComponent } from '@acorex/components/mixin';
+import * as i0 from "@angular/core";
+export declare const AXBaseColorPickerMixin: (abstract new (...args: any[]) => {
+    "__#32616@#disabled": boolean;
+    disabled: boolean;
+    "__#32616@#tabIndex": number;
+    tabIndex: number;
+    onFocus: import("@angular/core").EventEmitter<import("@acorex/components/common").AXFocusEvent>;
+    _emitOnFocusEvent(e: FocusEvent): void;
+    onBlur: import("@angular/core").EventEmitter<import("@acorex/components/common").AXFocusEvent>;
+    _emitOnBlurEvent(e: FocusEvent): void;
+    focus(): void;
+    hasFocus(): boolean;
+    id: string;
+    rtl: boolean;
+    "__#32613@#elementRef": ElementRef<any>;
+    _cdr: ChangeDetectorRef;
+    _isInited: boolean;
+    _isRendered: boolean;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    _getHostElement<T = HTMLElement>(): T;
+    _getInnerElement<T_1 = HTMLElement>(): T_1;
+    _onInternalInit(): void;
+    _onInternalViewInit(): void;
+    _onInternalDestroy(): void;
+    onInit(): void;
+    onRenderCssClass(): void;
+    onViewInit(): void;
+    onDestroy(): void;
+    _onOptionChanging(option: import("@acorex/components/mixin").AXComponentOptionChanging): any;
+    _onOptionChanged(option: import("@acorex/components/mixin").AXComponentOptionChanged): void;
+    _setOption(option: import("@acorex/components/mixin").AXComponentSetOption): void;
+}) & (abstract new (...args: any[]) => {
+    readonly: boolean;
+    onOpened: import("@angular/core").EventEmitter<import("@acorex/components/common").AXEvent>;
+    onClosed: import("@angular/core").EventEmitter<import("@acorex/components/common").AXEvent>;
+    popover: any;
+    position: import("@acorex/components/common").AXConnectedPosition[];
+    _emitOnOpenedEvent(): void;
+    _emitOnClosedEvent(): void;
+    onInit(): void;
+    onViewInit(): void;
+    toggle(): void;
+    close(): void;
+    open(): void;
+    readonly isOpen: boolean;
+    id: string;
+    rtl: boolean;
+    "__#32613@#elementRef": ElementRef<any>;
+    _cdr: ChangeDetectorRef;
+    _isInited: boolean;
+    _isRendered: boolean;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    _getHostElement<T_2 = HTMLElement>(): T_2;
+    _getInnerElement<T_1_1 = HTMLElement>(): T_1_1;
+    _onInternalInit(): void;
+    _onInternalViewInit(): void;
+    _onInternalDestroy(): void;
+    onRenderCssClass(): void;
+    onDestroy(): void;
+    _onOptionChanging(option: import("@acorex/components/mixin").AXComponentOptionChanging): any;
+    _onOptionChanged(option: import("@acorex/components/mixin").AXComponentOptionChanged): void;
+    _setOption(option: import("@acorex/components/mixin").AXComponentSetOption): void;
+}) & (new (...args: any[]) => {
+    onValueChanged: import("@angular/core").EventEmitter<AXValueChangedEvent<any>>;
+    valueChange: import("@angular/core").EventEmitter<any>;
+    "__#32617@#readonly": boolean;
+    readonly: boolean;
+    "__#32617@#allowNull": boolean;
+    allowNull: boolean;
+    "__#32617@#name": string;
+    name: string;
+    "__#32617@#isUserInteraction": boolean;
+    readonly isUserInteraction: boolean;
+    "__#32617@#value": any;
+    value: any;
+    "__#32617@#state": "error" | "clear" | "success";
+    readonly state: "error" | "clear" | "success";
+    _emitOnValueChangedEvent(oldValue?: any, newValue?: any): void;
+    _internalSetValue(value: any): any;
+    _internalGetValue(): any;
+    _setValue(value: any): any;
+    _getValue(value: any): any;
+    _setUserInteraction(): void;
+    _onValueChanged(oldValue: any, newValue: any): void;
+    _onInternalInit(): void;
+    _onInternalDestroy(): void;
+    clear(): void;
+    validate(): Promise<any>;
+    _setState(state: "error" | "clear" | "success", ...args: any[]): void;
+    id: string;
+    rtl: boolean;
+    "__#32613@#elementRef": ElementRef<any>;
+    _cdr: ChangeDetectorRef;
+    _isInited: boolean;
+    _isRendered: boolean;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    _getHostElement<T_3 = HTMLElement>(): T_3;
+    _getInnerElement<T_1_2 = HTMLElement>(): T_1_2;
+    _onInternalViewInit(): void;
+    onInit(): void;
+    onRenderCssClass(): void;
+    onViewInit(): void;
+    onDestroy(): void;
+    _onOptionChanging(option: import("@acorex/components/mixin").AXComponentOptionChanging): any;
+    _onOptionChanged(option: import("@acorex/components/mixin").AXComponentOptionChanged): void;
+    _setOption(option: import("@acorex/components/mixin").AXComponentSetOption): void;
+}) & (new (...args: any[]) => {
+    type: string;
+    placeholder: string;
+    maxLength: number;
+    autoComplete: string;
+    debounceTime: number;
+    "__#32618@#valueSubscription": import("rxjs").Subscription;
+    "__#32618@#valueSubject": import("rxjs").Subject<unknown>;
+    onKeyDown: import("@angular/core").EventEmitter<import("@acorex/components/common").AXHtmlEvent<KeyboardEvent>>;
+    onKeyUp: import("@angular/core").EventEmitter<import("@acorex/components/common").AXHtmlEvent<KeyboardEvent>>;
+    onKeyPress: import("@angular/core").EventEmitter<import("@acorex/components/common").AXHtmlEvent<KeyboardEvent>>;
+    _emitOnKeydownEvent(e: KeyboardEvent): void;
+    _emitOnKeyupEvent(e: KeyboardEvent): void;
+    _emitOnKeypressEvent(e: KeyboardEvent): void;
+    _handleModleChange(value: any): void;
+    _settleValue(value: any): void;
+    onInit(): void;
+    onDestroy(): void;
+    id: string;
+    rtl: boolean;
+    "__#32613@#elementRef": ElementRef<any>;
+    _cdr: ChangeDetectorRef;
+    /**
+     *  @ignore
+     */
+    _isInited: boolean;
+    _isRendered: boolean;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    _getHostElement<T_4 = HTMLElement>(): T_4;
+    _getInnerElement<T_1_3 = HTMLElement>(): T_1_3;
+    _onInternalInit(): void;
+    _onInternalViewInit(): void;
+    _onInternalDestroy(): void;
+    onRenderCssClass(): void;
+    onViewInit(): void;
+    _onOptionChanging(option: import("@acorex/components/mixin").AXComponentOptionChanging): any;
+    _onOptionChanged(option: import("@acorex/components/mixin").AXComponentOptionChanged): void;
+    _setOption(option: import("@acorex/components/mixin").AXComponentSetOption): void;
+}) & typeof AXBaseComponent;
+/**
+ * The Button is a component which detects user interaction and triggers a corresponding event
+ *
+ * @category Components
+ */
+export declare class AXColorPickerComponent extends AXBaseColorPickerMixin {
+    protected _elementRef: ElementRef<HTMLDivElement>;
+    private _zone;
+    private _platform;
+    popover: AXPopoverComponent;
+    _target: HTMLDivElement;
+    _popoverTitle: string;
+    _popoverWidth: number;
+    _colorCode: string;
+    _mode: AXColorMode;
+    _isMobile: boolean;
+    /**
+     *  @ignore
+     */
+    constructor(_elementRef: ElementRef<HTMLDivElement>, _cdr: ChangeDetectorRef, _zone: NgZone, _platform: AXPlatform);
+    _handleArrowClickEvent(e: AXClickEvent): void;
+    _handleInputClickEvent(e: MouseEvent): void;
+    _handleClearClickEvent(): void;
+    onInit(): void;
+    onViewInit(): void;
+    _onValueChanged(oldValue: any, newValue: any): void;
+    _handleValueChangedEvent(e: AXValueChangedEvent<any>): void;
+    _handlePopupOnOpened(e: any): Promise<void>;
+    _handlePopupOnClosed(e: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXColorPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXColorPickerComponent, "ax-color-picker", never, { "isOpen": "isOpen"; "fitParent": "fitParent"; "dropdownWidth": "dropdownWidth"; "position": "position"; "disabled": "disabled"; "tabIndex": "tabIndex"; "readonly": "readonly"; "allowNull": "allowNull"; "value": "value"; "name": "name"; "checked": "checked"; "placeholder": "placeholder"; "maxLength": "maxLength"; "debounceTime": "debounceTime"; "type": "type"; "autoComplete": "autoComplete"; }, { "onOpened": "onOpened"; "onClosed": "onClosed"; "onBlur": "onBlur"; "onFocus": "onFocus"; "valueChange": "valueChange"; "onValueChanged": "onValueChanged"; }, never, ["ax-prefix", "ax-validation-rule", "ax-suffix"], false>;
+}

package/color-picker/src/color-picker.module.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./color-picker.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@acorex/components/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "@acorex/components/decorators";
+import * as i6 from "@acorex/components/popover";
+import * as i7 from "@acorex/components/button";
+import * as i8 from "@angular/cdk/a11y";
+import * as i9 from "@acorex/components/loading";
+import * as i10 from "@acorex/core/translation";
+import * as i11 from "@acorex/components/textbox";
+import * as i12 from "@acorex/components/color-palette";
+export declare class AXColorPickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXColorPickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXColorPickerModule, [typeof i1.AXColorPickerComponent], [typeof i2.CommonModule, typeof i3.AXCommonModule, typeof i4.FormsModule, typeof i5.AXDecoratorModule, typeof i6.AXPopoverModule, typeof i7.AXButtonModule, typeof i8.A11yModule, typeof i9.AXLoadingModule, typeof i10.AXTranslationModule, typeof i11.AXTextBoxModule, typeof i12.AXColorPaletteModule], [typeof i1.AXColorPickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXColorPickerModule>;
+}

package/common/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@acorex/components/common" />
+export * from './public-api';

package/common/src/auto-focus.directive.d.ts

@@ -0,0 +1,12 @@
+import { AfterContentInit, ElementRef } from '@angular/core';
+import { AXFocusableComponent } from './components.class';
+import * as i0 from "@angular/core";
+export declare class AXAutoFocusDirective implements AfterContentInit {
+    private el;
+    _host: AXFocusableComponent;
+    autoFocus?: boolean;
+    constructor(el: ElementRef<HTMLElement>, _host: AXFocusableComponent);
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXAutoFocusDirective, [null, { optional: true; host: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXAutoFocusDirective, "[axAutoFocus]", never, { "autoFocus": "axAutoFocus"; }, {}, never, never, false>;
+}

package/common/src/common.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./responsive.directive";
+import * as i2 from "./infinite-scroll.directive";
+import * as i3 from "./auto-focus.directive";
+import * as i4 from "./hotkey.directive";
+export declare class AXCommonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXCommonModule, [typeof i1.AXResponsiveDirective, typeof i2.AXInfiniteScrollerDirective, typeof i3.AXAutoFocusDirective, typeof i4.AXHotkeyDirective], never, [typeof i1.AXResponsiveDirective, typeof i2.AXInfiniteScrollerDirective, typeof i3.AXAutoFocusDirective, typeof i4.AXHotkeyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXCommonModule>;
+}

package/common/src/components.class.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from '@angular/core';
+import { AXValueChangedEvent } from './events.class';
+import * as i0 from "@angular/core";
+export declare abstract class AXComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXComponent>;
+}
+export declare abstract class AXClosbaleComponent extends AXComponent {
+    abstract close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXClosbaleComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXClosbaleComponent>;
+}
+export declare abstract class AXSearchableComponent extends AXComponent {
+    abstract search(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXSearchableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXSearchableComponent>;
+}
+export declare abstract class AXValuableComponent extends AXComponent {
+    abstract onValueChanged: EventEmitter<AXValueChangedEvent<any>>;
+    abstract value: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXValuableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXValuableComponent>;
+}
+export declare abstract class AXFocusableComponent extends AXComponent {
+    abstract focus(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXFocusableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXFocusableComponent>;
+}
+export interface AXPagedComponentInterface {
+    goToPage(page: number): any;
+    get totalCount(): number;
+    get pageSize(): number;
+    onPageChanged: EventEmitter<AXValueChangedEvent<number>>;
+}
+export declare abstract class AXPagedComponent extends AXComponent implements AXPagedComponentInterface {
+    abstract goToPage(page: number): any;
+    abstract get totalCount(): number;
+    abstract get pageSize(): number;
+    abstract onPageChanged: EventEmitter<AXValueChangedEvent<number>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPagedComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPagedComponent>;
+}

package/common/src/custom-cdk-overlay.service.d.ts

@@ -0,0 +1,19 @@
+import { Overlay, OverlayKeyboardDispatcher, OverlayPositionBuilder, ScrollStrategyOptions, OverlayContainer, OverlayRef, OverlayConfig, OverlayOutsideClickDispatcher } from '@angular/cdk/overlay';
+import { ComponentFactoryResolver, Injector, NgZone, RendererFactory2 } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { Location } from '@angular/common';
+import * as i0 from "@angular/core";
+export declare class DynamicOverlayContainer extends OverlayContainer {
+    setContainerElement(containerElement: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicOverlayContainer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicOverlayContainer>;
+}
+export declare class DynamicOverlay extends Overlay {
+    private readonly _dynamicOverlayContainer;
+    private renderer;
+    constructor(scrollStrategies: ScrollStrategyOptions, _overlayContainer: DynamicOverlayContainer, _componentFactoryResolver: ComponentFactoryResolver, _positionBuilder: OverlayPositionBuilder, _keyboardDispatcher: OverlayKeyboardDispatcher, _injector: Injector, _ngZone: NgZone, _document: any, _directionality: Directionality, rendererFactory: RendererFactory2, _location: Location, _outsideClickDispatcher: OverlayOutsideClickDispatcher);
+    private setContainerElement;
+    createOn(containerElement: HTMLElement, config?: OverlayConfig): OverlayRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicOverlay, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicOverlay>;
+}

package/common/src/drawing.class.d.ts

@@ -0,0 +1,9 @@
+export interface AXConnectedPosition {
+    originX: 'start' | 'center' | 'end';
+    originY: 'top' | 'center' | 'bottom';
+    overlayX: 'start' | 'center' | 'end';
+    overlayY: 'top' | 'center' | 'bottom';
+    weight?: number;
+    offsetX?: number;
+    offsetY?: number;
+}

package/common/src/events.class.d.ts

@@ -0,0 +1,86 @@
+/**
+ *  Contains native event
+ * @category Events
+ */
+export declare class AXEvent {
+    /**
+     *  The sender component
+     */
+    component: any;
+    /**
+     *  The root native element
+     */
+    htmlElement?: HTMLElement;
+    isUserInteraction?: boolean;
+}
+/**
+ *  Contains native event
+ * @category Events
+ */
+export declare class AXHtmlEvent<E extends Event> extends AXEvent {
+    nativeEvent?: E;
+}
+/**
+ *  Contains native event
+ * @category Events
+ */
+export declare class AXValueChangedEvent<T> extends AXEvent {
+    name?: string;
+    value?: T;
+    oldValue?: T;
+}
+/**
+ *  Fires each time the user click the element.
+ * @category Events
+ */
+export declare class AXClickEvent extends AXHtmlEvent<MouseEvent> {
+    /**
+     *  uses for extra data
+     */
+    data?: any;
+    nativeEvent?: any;
+}
+/**
+ *  Fires each time the user click the element.
+ * @category Events
+ */
+export declare class AXButtonClickEvent extends AXClickEvent {
+    name: string;
+}
+/**
+ *  Fires each time the user click the element.
+ * @category Events
+ */
+export declare class AXItemClickEvent<T> extends AXHtmlEvent<MouseEvent> {
+    item: T;
+}
+/**
+ *  Fires each time the component gets focused.
+ * @category Events
+ */
+export declare class AXFocusEvent extends AXHtmlEvent<FocusEvent> {
+}
+/**
+ *  Fires each time an item or multiple items selected by the user or value.
+ * @category Events
+ */
+export declare class AXSelectionValueChangedEvent extends AXValueChangedEvent<any | any[]> {
+    value?: any;
+    oldValue?: any;
+    selectedKeys?: any[];
+    selectedItems?: any[];
+}
+/**
+ *  Contains range start & end values
+ * @category Events
+ */
+export declare class AXRangeChangedEvent<T> extends AXEvent {
+    /**
+     *  The range start value
+     */
+    start?: T;
+    /**
+     *  The range end value
+     */
+    end?: T;
+}

package/common/src/hotkey.directive.d.ts

@@ -0,0 +1,22 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import { AXComponent } from './components.class';
+import { AXHotkeysService } from './hotkey.service';
+import * as i0 from "@angular/core";
+export declare type AXHotKeyAction = {
+    [key: string]: string | Function;
+    parmas?: any;
+};
+export declare class AXHotkeyDirective implements AfterViewInit {
+    private el;
+    _host: AXComponent;
+    private hs;
+    hotkey: string | AXHotKeyAction | AXHotKeyAction[];
+    private _subs;
+    constructor(el: ElementRef<HTMLElement>, _host: AXComponent, hs: AXHotkeysService);
+    ngAfterViewInit(): void;
+    private _addDefaultAction;
+    private _addHotKeyAction;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXHotkeyDirective, [null, { optional: true; host: true; self: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXHotkeyDirective, "[hotkey]", never, { "hotkey": "hotkey"; }, {}, never, never, false>;
+}

package/common/src/hotkey.service.d.ts

@@ -0,0 +1,17 @@
+import { EventManager } from '@angular/platform-browser';
+import { Observable } from 'rxjs/internal/Observable';
+import * as i0 from "@angular/core";
+declare type Options = {
+    element: any;
+    keys: string;
+};
+export declare class AXHotkeysService {
+    private eventManager;
+    private document;
+    defaults: Partial<Options>;
+    constructor(eventManager: EventManager, document: Document);
+    addShortcut(options: Partial<Options>): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXHotkeysService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXHotkeysService>;
+}
+export {};

package/common/src/infinite-scroll.directive.d.ts

@@ -0,0 +1,25 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface AXScrollPosition {
+    scrollHeight: number;
+    scrollTop: number;
+    clientHeight: number;
+}
+export declare class AXInfiniteScrollerDirective implements AfterViewInit {
+    private elm;
+    private scrollEvent$;
+    private userScrolledDown$;
+    private requestOnScroll$;
+    scrollCallback: Function;
+    immediateCallback: any;
+    scrollPercent: number;
+    constructor(elm: ElementRef);
+    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": "scrollCallback"; "immediateCallback": "immediateCallback"; "scrollPercent": "scrollPercent"; }, {}, never, never, false>;
+}

package/common/src/overlay.service.d.ts

@@ -0,0 +1,31 @@
+import { ApplicationRef } from '@angular/core';
+import { Overlay } from '@angular/cdk/overlay';
+import { AXConnectedPosition } from './drawing.class';
+import { DynamicOverlay } from './custom-cdk-overlay.service';
+import * as i0 from "@angular/core";
+export interface AXOverlayViewRef {
+    instance: any;
+    dispose: () => void;
+    isOpen: () => boolean;
+}
+export interface AXOverlayConfigs {
+    position?: AXConnectedPosition | AXConnectedPosition[];
+    hasBackdrop?: boolean;
+    transparentBackdrop?: boolean;
+    closeOnClickOutside?: boolean;
+    targetElement?: HTMLElement;
+    containerElement?: HTMLElement;
+    onBackdropClick?: () => void;
+    panelClass?: string[] | string;
+    backdropClass?: string[] | string;
+    scroll?: 'auto' | 'block' | 'close';
+}
+export declare class AXOverlayService {
+    private overlayService;
+    private overlayService2;
+    private appRef;
+    constructor(overlayService: DynamicOverlay, overlayService2: Overlay, appRef: ApplicationRef);
+    show(content: any, context?: any, configs?: AXOverlayConfigs): AXOverlayViewRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXOverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXOverlayService>;
+}

package/common/src/responsive.directive.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AXResponsiveDirective implements OnDestroy {
+    private _elementRef;
+    private _observer;
+    constructor(_elementRef: ElementRef<HTMLDivElement>);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXResponsiveDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXResponsiveDirective, "[ax-responsive]", never, {}, {}, never, never, false>;
+}

package/common/src/styles.class.d.ts

@@ -0,0 +1,17 @@
+export declare const AX_STYLE_TYPES: string[];
+/**
+ * A token that specifies the  color style of component.
+ */
+export declare type AXStyleColorType = 'primary' | 'secondary' | 'info' | 'danger' | 'success' | 'warning' | 'light' | 'dark';
+export declare type AXStyleLookType = 'default' | 'blank' | 'outline' | 'twotone' | 'link';
+export declare const AX_LOCATIONS: string[];
+export declare type AXLocation = 'bottom-start' | 'bottom-center' | 'bottom-end' | 'top-start' | 'top-center' | 'top-end';
+export declare const AX_DIRECTIONS: string[];
+/**
+ * A token that specifies the  direction of component.
+ */
+export declare type AXDirection = 'vertical' | 'horizontal';
+/**
+ * A token that specifies the  selection mode of component.
+ */
+export declare type AXSelectionMode = 'single' | 'multiple';

package/data-pager/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@acorex/components/data-pager" />
+export * from './public-api';

package/data-pager/src/data-pager-base.component.d.ts

@@ -0,0 +1,49 @@
+import { EventEmitter } from '@angular/core';
+import { AXEvent } from '@acorex/components/common';
+import { AXInteractiveComponenetMixin } from '@acorex/components/mixin';
+import * as i0 from "@angular/core";
+/**
+ * A token that specifies the  display mode of datapager component.
+ */
+export declare type AXDataPagerDisplayMode = 'full' | 'compact' | 'custom';
+export interface AXDataPagerInfoData {
+    range: {
+        from: number;
+        to: number;
+    };
+    page: number;
+    skip: number;
+    take: number;
+    totalPages: number;
+    totalItems: number;
+}
+export declare class AXPagerPageChangedEvent extends AXEvent implements AXDataPagerInfoData {
+    range: {
+        from: number;
+        to: number;
+    };
+    page: number;
+    skip: number;
+    take: number;
+    totalPages: number;
+    totalItems: number;
+}
+export declare class AXPagerStateChangedEvent extends AXPagerPageChangedEvent {
+}
+export declare abstract class AXPagerComponent {
+    abstract onStateChanged: EventEmitter<AXPagerStateChangedEvent>;
+    abstract get state(): AXDataPagerInfoData;
+    abstract size: number;
+    abstract goNextPage(): void;
+    abstract goLastPage(): void;
+    abstract goFirstPage(): void;
+    abstract goPrevPage(): void;
+    abstract goToPage(page: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPagerComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPagerComponent>;
+}
+export declare abstract class AXDataPagerChild extends AXInteractiveComponenetMixin {
+    constructor(...args: any[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerChild, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXDataPagerChild>;
+}

package/data-pager/src/data-pager-info.component.d.ts

@@ -0,0 +1,15 @@
+import { ElementRef, ChangeDetectorRef } from '@angular/core';
+import { AXDataPagerChild, AXPagerComponent } from './data-pager-base.component';
+import * as i0 from "@angular/core";
+export declare class AXDataPagerInfoComponent extends AXDataPagerChild {
+    private elementRef;
+    private cdr;
+    private _parent;
+    constructor(elementRef: ElementRef<HTMLDivElement>, cdr: ChangeDetectorRef, _parent: AXPagerComponent);
+    text: string;
+    _textFormatted: string;
+    onViewInit(): void;
+    private _updateText;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerInfoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXDataPagerInfoComponent, "ax-data-pager-info", never, { "text": "text"; }, {}, never, never, false>;
+}

package/data-pager/src/data-pager-input-selector.component.d.ts

@@ -0,0 +1,15 @@
+import { ElementRef, ChangeDetectorRef } from "@angular/core";
+import { AXValueChangedEvent } from "@acorex/components/common";
+import { AXDataPagerChild, AXPagerComponent } from "./data-pager-base.component";
+import * as i0 from "@angular/core";
+export declare class AXDataPagerInputSelectorComponent extends AXDataPagerChild {
+    private _parent;
+    private cdr;
+    constructor(elementRef: ElementRef, _parent: AXPagerComponent, cdr: ChangeDetectorRef);
+    _totalPages: number;
+    _currentPage: number;
+    onViewInit(): void;
+    _handleValueChanged(e: AXValueChangedEvent<number>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerInputSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXDataPagerInputSelectorComponent, "ax-data-pager-input-selector", never, {}, {}, never, never, false>;
+}