@acorex/components 5.0.5 → 5.0.9

package/lib/base/mixin/textbox-mixin.class.d.ts

@@ -0,0 +1,59 @@
+import { EventEmitter } from '@angular/core';
+import { AXHtmlEvent } from '../events.class';
+import { AXBaseComponent } from './base-components.class';
+import { Constructor } from './constratctor';
+export declare function _TextboxComponenetMixin<TBase extends Constructor<AXBaseComponent>>(Base: TBase): {
+    new (...args: any[]): {
+        /**
+        *  A string value that specifies the placeholder of text box.
+        */
+        placeholder: string;
+        /**
+        *  A number value that specifies the maximum characters of text box.
+        */
+        maxLength: number;
+        /**
+        *  Specifies that autocomplete is on or off.
+        */
+        autoComplete: boolean;
+        /**
+        *  Fires each time the user press a key.
+        *  @event
+        */
+        onKeyDown: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
+        _emitOnKeydownEvent(e: KeyboardEvent): void;
+        id: string; /**
+        *  A string value that specifies the placeholder of text box.
+        */
+        rtl: boolean;
+        cssClass: string;
+        cssStyle: string;
+        "__#1@#elementRef": import("@angular/core").ElementRef<any>;
+        _cdr: import("@angular/core").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: {
+            name: string;
+            value?: any;
+        }): any;
+        onOptionChanged(option: {
+            name: string;
+            oldValue?: any;
+            newValue?: any;
+        }): void;
+    };
+} & TBase;
+export declare const TEXTBOX_INPUTS: string[];
+export declare const TEXTBOX_OUTPUT: string[];

package/lib/base/mixin/value-mixin.class.d.ts

@@ -0,0 +1,71 @@
+import { EventEmitter } from '@angular/core';
+import { AXBaseComponent } from './base-components.class';
+import { Constructor } from './constratctor';
+import { AXValueChangedEvent } from '../events.class';
+import { AXValidationRuleResult } from '../../validation/validation.class';
+import { Subject, Subscription } from 'rxjs';
+export declare function _ValueComponenetMixin<TBase extends Constructor<AXBaseComponent>>(Base: TBase): {
+    new (...args: any[]): {
+        /**
+        *  Fires each time the user press a key.
+        *  @event
+        */
+        onValueChanged: EventEmitter<AXValueChangedEvent<any>>;
+        valueChange: EventEmitter<any>;
+        "__#6@#readonly": boolean;
+        /**
+        *  If set to true, user cannot change the value of component.
+        */
+        readonly: boolean;
+        "__#6@#allowNull": boolean;
+        allowNull: boolean;
+        "__#6@#name": string;
+        name: string;
+        "__#6@#debounceTime": number;
+        debounceTime: number;
+        "__#6@#valueSubscription": Subscription;
+        "__#6@#valueSubject": Subject<unknown>;
+        "__#6@#value": any;
+        value: any;
+        _emitOnValueChangedEvent(oldValue?: any, newValue?: any): void;
+        _onValueChanging(value: any): any;
+        _onValueChanged(oldValue: any, newValue: any): void;
+        _onInternalInit(): void;
+        _onInternalDestroy(): void;
+        _setValue(v: any): void;
+        clear(): void;
+        validate(): Promise<AXValidationRuleResult>;
+        _setErrorState(state: 'clear' | 'success' | 'error', ...args: any[]): void;
+        id: string;
+        rtl: boolean;
+        cssClass: string;
+        cssStyle: string;
+        "__#1@#elementRef": import("@angular/core").ElementRef<any>;
+        _cdr: import("@angular/core").ChangeDetectorRef;
+        _isInited: boolean;
+        _isRendered: boolean;
+        ngOnInit(): void; /**
+        *  If set to true, user cannot change the value of component.
+        */
+        ngAfterViewInit(): void;
+        ngOnDestroy(): void;
+        _getHostElement<T = HTMLElement>(): T;
+        _getInnerElement<T_1 = HTMLElement>(): T_1;
+        _onInternalViewInit(): void;
+        onInit(): void;
+        onRenderCssClass(): void;
+        onViewInit(): void;
+        onDestroy(): void;
+        onOptionChanging(option: {
+            name: string;
+            value?: any;
+        }): any;
+        onOptionChanged(option: {
+            name: string;
+            oldValue?: any;
+            newValue?: any;
+        }): void;
+    };
+} & TBase;
+export declare const VALUE_INPUTS: string[];
+export declare const VALUE_OUTPUT: string[];

package/lib/base/overlay.service.d.ts

@@ -0,0 +1,31 @@
+import { ApplicationRef } from '@angular/core';
+import { Overlay } from '@angular/cdk/overlay';
+import { AXConnectedPosition } from '.';
+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/lib/base/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>;
+}

package/lib/base/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 AXStyleButtonLook = '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/lib/button/button-group.component.d.ts

@@ -0,0 +1,36 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, NgZone, QueryList } from "@angular/core";
+import { AXButtonComponent } from "./button.component";
+import { AXClickEvent, AXInteractiveComponenetMixin, AXItemClickEvent, AXSelectionMode, AXSelectionValueChangedEvent, AXStyleButtonLook, AXStyleColorType } from "../base";
+import * as i0 from "@angular/core";
+export declare class AXButtonGroupComponent extends AXInteractiveComponenetMixin {
+    private zone;
+    selectionChange: EventEmitter<AXSelectionMode>;
+    private _selection;
+    get selection(): AXSelectionMode;
+    set selection(value: AXSelectionMode);
+    colorChange: EventEmitter<AXStyleColorType>;
+    private _color;
+    /**
+    *  Predefined color schemes
+    */
+    get color(): AXStyleColorType;
+    set color(value: AXStyleColorType);
+    lookChange: EventEmitter<AXStyleButtonLook>;
+    private _look?;
+    /**
+    *  Predefined look schemes
+    */
+    get look(): AXStyleButtonLook;
+    set look(value: AXStyleButtonLook);
+    onItemClick: EventEmitter<AXItemClickEvent<AXButtonComponent>>;
+    onValueChanged: EventEmitter<AXSelectionValueChangedEvent>;
+    _contentButtons: QueryList<AXButtonComponent>;
+    constructor(elementRef: ElementRef, zone: NgZone, cdr: ChangeDetectorRef);
+    ngAfterContentInit(): void;
+    private _bindEvents;
+    private _bindProps;
+    onOptionChanged(options: any): void;
+    _handleClickEvent(e: AXClickEvent, button: AXButtonComponent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXButtonGroupComponent, "ax-button-group", never, { "cssClass": "cssClass"; "size": "size"; "cssStyle": "cssStyle"; "rtl": "rtl"; "disabled": "disabled"; "selection": "selection"; "color": "color"; "look": "look"; }, { "selectionChange": "selectionChange"; "colorChange": "colorChange"; "lookChange": "lookChange"; "onItemClick": "onItemClick"; }, ["_contentButtons"], ["ax-button"]>;
+}

package/{src/lib/button/button-item.class.ts → lib/button/button-item.class.d.ts}

@@ -1,5 +1,4 @@
 import { AXStyleButtonLook, AXStyleColorType } from "../base";
-
 export interface AXClickItemBase {
     cssClass?: string;
     color?: AXStyleColorType;
@@ -13,12 +12,11 @@ export interface AXClickItemBase {
     seperated?: boolean;
     name?: string;
     data?: any;
-    onClick?: (...args) => void;
+    onClick?: (...args: any[]) => void;
 }
-export interface AXButtonItem extends  AXClickItemBase{
+export interface AXButtonItem extends AXClickItemBase {
     submitBehavior?: Boolean;
     cancelBehavior?: boolean;
 }
-
-export interface AXMenuItem extends  AXClickItemBase{
-}
+export interface AXMenuItem extends AXClickItemBase {
+}

package/lib/button/button-item.component.d.ts

@@ -0,0 +1,94 @@
+import { ChangeDetectorRef, ElementRef } from '@angular/core';
+import { AXBaseComponent, AXStyleColorType } from '../base';
+import * as i0 from "@angular/core";
+export declare const AXBaseItemButtonMixin: (abstract new (...args: any[]) => {
+    "__#5@#disabled": boolean;
+    disabled: boolean;
+    "__#5@#tabIndex": number;
+    tabIndex: number;
+    onFocus: import("@angular/core").EventEmitter<import("../base").AXFocusEvent>;
+    _emitOnFocusEvent(e: FocusEvent): void;
+    onBlur: import("@angular/core").EventEmitter<import("../base").AXFocusEvent>;
+    _emitOnBlurEvent(e: FocusEvent): void;
+    focus(): void;
+    id: string;
+    rtl: boolean;
+    cssClass: string;
+    cssStyle: string;
+    "__#1@#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: {
+        name: string;
+        value?: any;
+    }): any;
+    onOptionChanged(option: {
+        name: string;
+        oldValue?: any;
+        newValue?: any;
+    }): void;
+}) & {
+    new (...args: any[]): {
+        onClick: import("@angular/core").EventEmitter<import("../base").AXClickEvent>;
+        _emitOnClickEvent(e: MouseEvent): void;
+        id: string;
+        rtl: boolean;
+        cssClass: string;
+        cssStyle: string;
+        "__#1@#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: {
+            name: string;
+            value?: any;
+        }): any;
+        onOptionChanged(option: {
+            name: string;
+            oldValue?: any;
+            newValue?: any;
+        }): void;
+    };
+} & typeof AXBaseComponent;
+export declare class AXButtonItemComponent extends AXBaseItemButtonMixin {
+    /**
+    *  @ignore
+    */
+    constructor(elementRef: ElementRef, cdr: ChangeDetectorRef);
+    text: string;
+    tooltip: string;
+    selected: boolean;
+    seperated: boolean;
+    name: string;
+    data: any;
+    color: AXStyleColorType;
+    private __hostClick;
+    private get __hostClass();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXButtonItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXButtonItemComponent, "ax-button-item", never, { "text": "text"; "tooltip": "tooltip"; "selected": "selected"; "seperated": "seperated"; "name": "name"; "data": "data"; "color": "color"; }, {}, never, ["ax-prefix", "ax-icon", "ax-suffix"]>;
+}

package/lib/button/button.component.d.ts

@@ -0,0 +1,21 @@
+import { ChangeDetectorRef, ElementRef } from '@angular/core';
+import { AXBaseButtonMixin } from '../base/mixin/mixin.class';
+import * as i0 from "@angular/core";
+/**
+ * The Button is a component which detects user interaction and triggers a corresponding event
+ *
+ * @category Components
+ */
+export declare class AXButtonComponent extends AXBaseButtonMixin {
+    /**
+    *  @ignore
+    */
+    constructor(elementRef: ElementRef, cdr: ChangeDetectorRef);
+    onKeydownHandler(e: KeyboardEvent): boolean;
+    _emitOnClickEvent(e: MouseEvent): void;
+    _emitOnFocusEvent(e: MouseEvent): void;
+    _emitOnBlurEvent(e: MouseEvent): void;
+    private get __hostClass();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXButtonComponent, "ax-button", never, { "disabled": "disabled"; "tabIndex": "tabIndex"; "size": "size"; "text": "text"; "submitBehavior": "submitBehavior"; "cancelBehavior": "cancelBehavior"; "color": "color"; "look": "look"; "toggleable": "toggleable"; "selected": "selected"; }, { "onBlur": "onBlur"; "onFocus": "onFocus"; "onClick": "onClick"; "selectedChange": "selectedChange"; "toggleableChange": "toggleableChange"; }, never, ["ax-prefix,ax-loading,ax-icon", "ax-suffix", "ax-dropdown-panel"]>;
+}

package/lib/button/button.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./button.component";
+import * as i2 from "./button-item.component";
+import * as i3 from "./button-group.component";
+import * as i4 from "@angular/common";
+import * as i5 from "../icon/icon.module";
+import * as i6 from "../decorators/decorators.module";
+export declare class AXButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXButtonModule, [typeof i1.AXButtonComponent, typeof i2.AXButtonItemComponent, typeof i3.AXButtonGroupComponent], [typeof i4.CommonModule, typeof i5.AXIconModule, typeof i6.AXEditorDecoratorModule], [typeof i1.AXButtonComponent, typeof i2.AXButtonItemComponent, typeof i3.AXButtonGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXButtonModule>;
+}

package/{src/lib/button/index.ts → lib/button/index.d.ts}

@@ -2,4 +2,4 @@ export * from './button.component';
 export * from './button-group.component';
 export * from './button-item.component';
 export * from './button.module';
-export * from './button-item.class';
+export * from './button-item.class';

package/lib/calendar/calendar.component.d.ts

@@ -0,0 +1,56 @@
+import { AXDateTime } from '@acorex/core';
+import { ElementRef, ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { AXCalendarComponentMixin, AXClickEvent } from '../base';
+import * as i0 from "@angular/core";
+export declare type AXCalendarViewType = 'years' | 'months' | 'days';
+export declare type AXCalendarViewDepth = AXCalendarViewType;
+export declare type AXCalendarDisabledDates = Date[] | ((date: Date) => boolean);
+export declare type AXCalendarHolidayDates = Date[] | ((date: Date) => boolean);
+export declare class AXCalendarComponent extends AXCalendarComponentMixin {
+    private cdr;
+    private get _viewRange();
+    _today: AXDateTime;
+    private _viewStartDate;
+    _navText: string;
+    _todayText: string;
+    _slots: any[];
+    private _activeView;
+    get activeView(): AXCalendarViewType;
+    set activeView(v: AXCalendarViewType);
+    depthChange: EventEmitter<AXCalendarViewDepth>;
+    private _depth;
+    get depth(): AXCalendarViewDepth;
+    set depth(v: AXCalendarViewDepth);
+    private _min;
+    get min(): Date;
+    set min(v: Date);
+    private _max;
+    get max(): Date;
+    set max(v: Date);
+    private _disabledDates;
+    get disabledDates(): AXCalendarDisabledDates;
+    set disabledDates(v: AXCalendarDisabledDates);
+    private _holidayDates;
+    get holidayDates(): AXCalendarHolidayDates;
+    set holidayDates(v: AXCalendarHolidayDates);
+    constructor(elementRef: ElementRef, cdr: ChangeDetectorRef);
+    onInit(): void;
+    private _genearteSlots;
+    _handlePrevClick(e: AXClickEvent): void;
+    _handleNextClick(e: AXClickEvent): void;
+    _handleSlotClick(slot: any): void;
+    _handleNavClick(e: AXClickEvent): void;
+    _onValueChanged(oldValue: any, newValue: any): void;
+    _handleGoToday(): void;
+    next(): void;
+    prev(): void;
+    private _navNextPrev;
+    goToday(): void;
+    navTo(date: Date | AXDateTime): void;
+    private get __hostClass();
+    private isDisabled;
+    private isHoliday;
+    private isWeekend;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXCalendarComponent, "ax-calendar", never, { "readonly": "readonly"; "allowNull": "allowNull"; "value": "value"; "debounceTime": "debounceTime"; "name": "name"; "disabled": "disabled"; "tabIndex": "tabIndex"; "activeView": "activeView"; "depth": "depth"; "min": "min"; "max": "max"; "disabledDates": "disabledDates"; "holidayDates": "holidayDates"; }, { "valueChange": "valueChange"; "onValueChanged": "onValueChanged"; "onBlur": "onBlur"; "onFocus": "onFocus"; "depthChange": "depthChange"; }, never, never>;
+}

package/lib/calendar/calendar.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./calendar.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../button/button.module";
+import * as i4 from "../icon/icon.module";
+import * as i5 from "../decorators/decorators.module";
+import * as i6 from "@acorex/core";
+export declare class AXCalendarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCalendarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXCalendarModule, [typeof i1.AXCalendarComponent], [typeof i2.CommonModule, typeof i3.AXButtonModule, typeof i4.AXIconModule, typeof i5.AXEditorDecoratorModule, typeof i6.AXDateTimeModule], [typeof i1.AXCalendarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXCalendarModule>;
+}

package/lib/carousel/carousel-arrows.component.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef, ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { AXBaseComponentMixin, AXClickEvent } from '../base';
+import { AXCarouselComponent } from './carousel.component';
+import * as i0 from "@angular/core";
+export declare class AXCarouselArrowsComponent extends AXBaseComponentMixin {
+    private parent;
+    onNextClick: EventEmitter<AXClickEvent>;
+    onPrevClick: EventEmitter<AXClickEvent>;
+    constructor(elementRef: ElementRef, cdr: ChangeDetectorRef, parent: AXCarouselComponent);
+    _handlePrevClick(e: MouseEvent): void;
+    _handleNextClick(e: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCarouselArrowsComponent, [null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXCarouselArrowsComponent, "ax-carousel-arrows", never, {}, { "onNextClick": "onNextClick"; "onPrevClick": "onPrevClick"; }, never, never>;
+}

package/lib/carousel/carousel-item.component.d.ts

@@ -0,0 +1,8 @@
+import { ElementRef, ChangeDetectorRef } from '@angular/core';
+import { AXBaseComponentMixin } from '../base';
+import * as i0 from "@angular/core";
+export declare class AXCarouselItemComponent extends AXBaseComponentMixin {
+    constructor(elementRef: ElementRef, cdr: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCarouselItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXCarouselItemComponent, "ax-carousel-item", never, {}, {}, never, ["*"]>;
+}

package/lib/carousel/carousel-pager.component.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef, ChangeDetectorRef } from '@angular/core';
+import { AXBaseComponentMixin } from '../base';
+import { AXCarouselComponent } from './carousel.component';
+import * as i0 from "@angular/core";
+export declare class AXCarouselPagerComponent extends AXBaseComponentMixin {
+    private cdr;
+    private _parent;
+    _visibleIndex: number;
+    _pageIndex: number;
+    private _size;
+    _dots: any[];
+    private _subs;
+    constructor(elementRef: ElementRef, cdr: ChangeDetectorRef, _parent: AXCarouselComponent);
+    onViewInit(): void;
+    private _generateDots;
+    _handleClick(e: MouseEvent, index: number): void;
+    private _setPageIndex;
+    private _findPageIndex;
+    onDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCarouselPagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXCarouselPagerComponent, "ax-carousel-pager", never, {}, {}, never, never>;
+}

package/lib/carousel/carousel-splidejs.class.d.ts

@@ -0,0 +1,18 @@
+import { AXCarousel, AXCarouselCore } from "./carousel.class";
+import { Splide as SS } from '@splidejs/splide';
+export declare class AXCarouselSplideJS implements AXCarouselCore {
+    constructor();
+    _ref: SS;
+    _instance: AXCarousel;
+    mount(instance: AXCarousel): void;
+    private _emitOnSlideChanged;
+    private _getConfig;
+    next(): void;
+    last(): void;
+    prev(): void;
+    first(): void;
+    goToSlide(index: number): void;
+    goToPage(index: number): void;
+    destroy(): void;
+    rebuild(): void;
+}

package/{src/lib/carousel/carousel.class.ts → lib/carousel/carousel.class.d.ts}

@@ -1,9 +1,7 @@
-import { EventEmitter, Injectable } from "@angular/core";
+import { EventEmitter } from "@angular/core";
 import { AXValueChangedEvent } from "../base";
-
-
-@Injectable()
-export abstract class AXCarouselCore {
+import * as i0 from "@angular/core";
+export declare abstract class AXCarouselCore {
     abstract next(): void;
     abstract last(): void;
     abstract prev(): void;
@@ -13,55 +11,38 @@ export abstract class AXCarouselCore {
     abstract goToPage(index: number): void;
     abstract mount(instance: AXCarousel): void;
     abstract rebuild(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCarouselCore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXCarouselCore>;
 }
-
-
-
 export interface AXCarousel {
-
     onSlideChanged: EventEmitter<AXValueChangedEvent<number>>;
     onOptionsChanged: EventEmitter<void>;
-    //
-    pageSizeChange: EventEmitter<number>
+    pageSizeChange: EventEmitter<number>;
     pageSize: number;
-    //
     gap: number;
-    //
     autoplayChange: EventEmitter<boolean>;
     autoplay: boolean;
-    //
-    intervalChange: EventEmitter<number>
+    intervalChange: EventEmitter<number>;
     interval: number;
-    //
-    centeredChange: EventEmitter<boolean>
+    centeredChange: EventEmitter<boolean>;
     centered: boolean;
-    //
-    verticalChange: EventEmitter<boolean>
+    verticalChange: EventEmitter<boolean>;
     vertical: boolean;
-    //
-    paddingChange: EventEmitter<string | number>
+    paddingChange: EventEmitter<string | number>;
     padding: string | number;
-    //
-    loopChange: EventEmitter<boolean>
+    loopChange: EventEmitter<boolean>;
     loop: boolean;
-    //
-    rewindChange: EventEmitter<boolean>
+    rewindChange: EventEmitter<boolean>;
     rewind: boolean;
-    //
     visibleIndex: number;
-    //
-    onItemsChanged: EventEmitter<AXValueChangedEvent<HTMLDivElement[]>>
+    onItemsChanged: EventEmitter<AXValueChangedEvent<HTMLDivElement[]>>;
     items: HTMLDivElement[];
-
     rtl: boolean;
-
     next(): void;
     last(): void;
     prev(): void;
     first(): void;
     goToSlide(index: number): void;
     goToPage(index: number): void;
-
     host: HTMLDivElement;
 }
-