cmat 0.0.27 → 0.0.29

package/components/transfer-picker/index.d.ts

@@ -1,5 +1,191 @@
+import { CdkOverlayOrigin, OverlayRef, Overlay } from '@angular/cdk/overlay';
+import { CdkPortal } from '@angular/cdk/portal';
+import * as i0 from '@angular/core';
+import { OnInit, AfterViewInit, OnDestroy, ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { FormControl } from '@angular/forms';
+import { SelectionModel } from '@angular/cdk/collections';
+import { CdkTree } from '@angular/cdk/tree';
+
 /**
- * Generated bundle index. Do not edit.
+ * Node for Transfer item
  */
-/// <amd-module name="cmat/components/transfer-picker" />
-export * from './public-api';
+declare class CmatTransferItemNode {
+    [key: string]: any;
+    children?: CmatTransferItemNode[];
+    label: string;
+    value: string | number;
+}
+/** Flat Transfer item node with expandable and level information */
+declare class CmatTransferItemFlatNode {
+    label: string;
+    value: string | number;
+    level: number;
+    disabled?: boolean;
+    expandable: boolean;
+}
+declare enum CmatTransferFilterCondition {
+    EQUALS = 0,
+    NOT_EQUALS = 1,
+    MORE_THAN = 2,
+    LESS_THAN = 3
+}
+interface CmatTransferFilterItem {
+    label: string;
+    value: number | string;
+    condition: CmatTransferFilterCondition[];
+    field: string;
+    selected?: boolean;
+}
+interface CmatTransferFilterData {
+    condition: 'or' | 'and';
+    filters: CmatTransferFilterItem[];
+}
+interface CmatSourceOptions {
+    title: string;
+    filterable: boolean;
+    searchable: boolean;
+    searchPlaceholder: string;
+    filters: CmatTransferFilterItem[];
+}
+
+declare class CmatTransferPickerService {
+    dataSourceChange: BehaviorSubject<CmatTransferItemNode[]>;
+    refreshDataSourceChange: BehaviorSubject<boolean>;
+    filtersChange: BehaviorSubject<CmatTransferFilterItem[]>;
+    sourceOptionsChange: BehaviorSubject<CmatSourceOptions | void>;
+    selectedValuesChange: BehaviorSubject<string[]>;
+    private _dataSource;
+    private _filterData;
+    private _keyword;
+    private _originalDataSource;
+    private _filteredDataSource;
+    private _compareMap;
+    private _conditionMap;
+    constructor();
+    get dataSource(): CmatTransferItemNode[];
+    set dataSource(data: CmatTransferItemNode[]);
+    set sourceOptions(value: CmatSourceOptions);
+    set selectedValues(value: string[]);
+    filterDataSource({ filterData, keyword }: {
+        filterData?: CmatTransferFilterData;
+        keyword?: string;
+    }): void;
+    resetDataSource(clear: boolean): void;
+    private _filterDataSourceByType;
+    private _setFilteredDataSourceByFilters;
+    private _setFilteredDataSourceByKeyword;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatTransferPickerService>;
+}
+
+declare class CmatTransferPickerFilterComponent implements OnInit {
+    private _overlay;
+    private _service;
+    filters: CmatTransferFilterItem[];
+    overlayOrigin: CdkOverlayOrigin;
+    filterTemplate: CdkPortal;
+    overlayRef: OverlayRef;
+    filterData: CmatTransferFilterData;
+    constructor(_overlay: Overlay, _service: CmatTransferPickerService);
+    ngOnInit(): void;
+    toggleFilter(): void;
+    onFilterClick(filter: CmatTransferFilterItem): void;
+    onConditionChange(event: any): void;
+    changeFilterData(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerFilterComponent, "cmat-transfer-picker-filter", ["cmatTransferPickerFilter"], { "filters": { "alias": "filters"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CmatTransferPickerSearchComponent implements OnInit {
+    private _service;
+    searchPlaceholder: string;
+    keyword: FormControl;
+    constructor(_service: CmatTransferPickerService);
+    ngOnInit(): void;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerSearchComponent, "cmat-transfer-picker-search", ["cmatTransferPickerSearch"], { "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CmatTransferPickerSourceComponent implements OnInit, AfterViewInit, OnDestroy {
+    private _service;
+    private _changeDetectorRef;
+    tree: CdkTree<CmatTransferItemNode>;
+    /** Map from nested node to flattened node. This helps us to keep the same object for selection */
+    nestedNodeMap: Map<CmatTransferItemNode, CmatTransferItemFlatNode>;
+    dataSource: CmatTransferItemNode[];
+    dataFlatNodes: CmatTransferItemFlatNode[];
+    /** The selection for checklist */
+    checklistSelection: SelectionModel<CmatTransferItemFlatNode>;
+    options: CmatSourceOptions;
+    selectedList: CmatTransferItemFlatNode[];
+    private _unsubscribeAll;
+    constructor(_service: CmatTransferPickerService, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    getSelectedList(): CmatTransferItemFlatNode[];
+    resetSelectedItem(item: CmatTransferItemFlatNode): void;
+    childrenAccessor: (node: CmatTransferItemNode) => CmatTransferItemNode[];
+    hasChild: (_: number, node: CmatTransferItemNode) => boolean;
+    /** Whether all the descendants of the node are selected */
+    descendantsAllSelected(node: CmatTransferItemFlatNode): boolean;
+    /** Whether part of the descendants are selected */
+    descendantsPartiallySelected(node: CmatTransferItemFlatNode): boolean;
+    /** Toggle the transfer item selection. Select/deselect all the descendants node */
+    transferItemSelectionToggle(node: CmatTransferItemFlatNode): void;
+    /** Toggle a leaf transfer item selection. Check all the parents to see if they changed */
+    transferLeafItemSelectionToggle(node: CmatTransferItemFlatNode): void;
+    private _getLevel;
+    private _isExpandable;
+    private _getChildren;
+    /**
+     * Transformer to convert nested node to flat node. Record the nodes in maps for later use.
+     */
+    private _transformer;
+    private _getDescendants;
+    private _getFlattenNodes;
+    private _checkAllParentsSelection;
+    /** Check root node checked state and change it accordingly */
+    private _checkRootNodeSelection;
+    private _getParentNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerSourceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerSourceComponent, "cmat-transfer-picker-source", ["cmatTransferPickerSource"], {}, {}, never, never, true, never>;
+}
+
+declare class CmatTransferPickerTargetComponent {
+    selectedList: CmatTransferItemFlatNode[];
+    clearItemChange: EventEmitter<CmatTransferItemFlatNode>;
+    constructor();
+    clearItem(item: CmatTransferItemFlatNode): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerTargetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerTargetComponent, "cmat-transfer-picker-target", ["cmatTransferPickerTarget"], { "selectedList": { "alias": "selectedList"; "required": false; }; }, { "clearItemChange": "clearItemChange"; }, never, never, true, never>;
+}
+
+declare class CmatTransferPickerComponent implements OnInit, AfterViewInit {
+    private _service;
+    private _changeDetectorRef;
+    title: string;
+    filterable: boolean;
+    searchable: boolean;
+    searchPlaceholder: string;
+    dataSource: CmatTransferItemNode[];
+    filters: CmatTransferFilterItem[];
+    selectedValues: string[];
+    selectChange: EventEmitter<CmatTransferItemFlatNode[]>;
+    source: CmatTransferPickerSourceComponent;
+    selectedList: CmatTransferItemFlatNode[];
+    constructor(_service: CmatTransferPickerService, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    pick(): void;
+    reset(): void;
+    onClearItemChange(item: CmatTransferItemFlatNode): void;
+    private _emitterChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerComponent, "cmat-transfer-picker", ["cmatTransferPicker"], { "title": { "alias": "title"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "selectedValues": { "alias": "selectedValues"; "required": false; }; }, { "selectChange": "selectChange"; }, never, never, true, never>;
+}
+
+export { CmatTransferFilterCondition, CmatTransferItemFlatNode, CmatTransferItemNode, CmatTransferPickerComponent, CmatTransferPickerFilterComponent, CmatTransferPickerSearchComponent, CmatTransferPickerService, CmatTransferPickerSourceComponent, CmatTransferPickerTargetComponent };
+export type { CmatSourceOptions, CmatTransferFilterData, CmatTransferFilterItem };

package/components/treetable/index.d.ts

@@ -1,5 +1,44 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/components/treetable" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnChanges, TemplateRef, ChangeDetectorRef, SimpleChanges } from '@angular/core';
+import { MatTableDataSource } from '@angular/material/table';
+import { Subject } from 'rxjs';
+
+declare class CmatTreeTableNode {
+    [propName: string]: any;
+    id: string | number;
+    children: CmatTreeTableNode[] | null;
+    name: string;
+    title: string;
+    showHeader?: string[];
+    level?: number;
+}
+
+declare class CmatTreeTableColumnDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTreeTableColumnDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatTreeTableColumnDirective, "ng-template[cmatTreeTableColumn]", never, {}, {}, never, never, true, never>;
+}
+declare class CmatTreeTableComponent implements OnChanges {
+    private _changeDetectorRef;
+    data: CmatTreeTableNode[];
+    verticalSeparator: boolean;
+    initExpand: boolean;
+    tableClass: string;
+    showControlColumn: boolean;
+    nodeClicked: Subject<CmatTreeTableNode>;
+    customColumnTpl?: TemplateRef<any>;
+    displayedColumns: string[];
+    dataSource: MatTableDataSource<CmatTreeTableNode>;
+    private _treeTable;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    formatIndentation(node: CmatTreeTableNode, step?: number): string;
+    onNodeClick(clickedNode: CmatTreeTableNode): void;
+    getDisplayedColumns(): string[];
+    private _switchNodeVisible;
+    private _generateDataSource;
+    private _getFlattenNodes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTreeTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTreeTableComponent, "cmat-treetable", ["cmatTreeTable"], { "data": { "alias": "data"; "required": false; }; "verticalSeparator": { "alias": "verticalSeparator"; "required": false; }; "initExpand": { "alias": "initExpand"; "required": false; }; "tableClass": { "alias": "tableClass"; "required": false; }; "showControlColumn": { "alias": "showControlColumn"; "required": false; }; }, { "nodeClicked": "nodeClicked"; }, ["customColumnTpl"], never, true, never>;
+}
+
+export { CmatTreeTableColumnDirective, CmatTreeTableComponent, CmatTreeTableNode };

package/components/upload/index.d.ts

@@ -1,5 +1,115 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/components/upload" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnDestroy, OnInit, EventEmitter, ChangeDetectorRef, AfterViewInit, QueryList, ElementRef } from '@angular/core';
+import { CmatMediaWatcherService } from 'cmat/services/media-watcher';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { CmatUrlStateConfigService } from 'cmat/services/config';
+
+declare class CmatFilesUtilService implements OnDestroy {
+    private _http;
+    private _urlStateConfigService;
+    private _config;
+    private _unsubscribeAll;
+    constructor(_http: HttpClient, _urlStateConfigService: CmatUrlStateConfigService);
+    ngOnDestroy(): void;
+    downloadFile(fileId: string, isStream?: boolean): Observable<any>;
+    downloadFileZip(fileIds?: string[]): Observable<any>;
+    uploadFile(file: FormData): Observable<any>;
+    deleteFile(fileId: string): Observable<any>;
+    getFileList(ids?: [], fileName?: string, fileCategory?: string, searchDate?: Date, pageIndex?: number, pageSize?: number): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatFilesUtilService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatFilesUtilService>;
+}
+
+declare class CmatUploadComponent implements OnInit, OnDestroy {
+    private _fileService;
+    private _changeDetectorRef;
+    fileAlias: string;
+    filePath: string;
+    fileCategory: string;
+    editMode: boolean;
+    autoUpload: boolean;
+    id: string;
+    removeEvent: EventEmitter<CmatUploadComponent>;
+    uploadEvent: EventEmitter<any>;
+    progressPercentage: number;
+    loaded: number;
+    total: number;
+    isUploading: boolean;
+    private _file;
+    private _unsubscribeAll;
+    constructor(_fileService: CmatFilesUtilService, _changeDetectorRef: ChangeDetectorRef);
+    get file(): any;
+    set file(file: any);
+    get fileType(): 'csv' | 'gif' | 'word' | 'excel' | 'jpg' | 'outlook' | 'pdf' | 'png' | 'ppt' | 'file' | 'text' | 'video' | 'zip';
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    upload(): void;
+    download(): void;
+    remove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatUploadComponent, "cmat-upload", ["cmatUpload"], { "fileAlias": { "alias": "fileAlias"; "required": false; }; "filePath": { "alias": "filePath"; "required": false; }; "fileCategory": { "alias": "fileCategory"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "autoUpload": { "alias": "autoUpload"; "required": false; }; "id": { "alias": "id"; "required": false; }; "file": { "alias": "file"; "required": false; }; }, { "removeEvent": "removeEvent"; "uploadEvent": "uploadEvent"; }, never, never, true, never>;
+}
+
+declare class CmatUploadQueueComponent implements OnDestroy, AfterViewInit {
+    private _changeDetectorRef;
+    private _cmatMediaWatcherService;
+    private _elementRef;
+    fileUploads: QueryList<CmatUploadComponent>;
+    fileAlias: string;
+    filePath: string;
+    fileCategory: string;
+    required: boolean;
+    autoUpload: boolean;
+    multiple: boolean;
+    accept: string;
+    title: string;
+    editMode: boolean;
+    filesData: any[];
+    outputRemoveIdEvent: EventEmitter<string>;
+    outputUploadIdEvent: EventEmitter<string>;
+    outputFilesDataEvent: EventEmitter<any>;
+    id: string;
+    isHandSet: boolean;
+    private _unsubscribeAll;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _cmatMediaWatcherService: CmatMediaWatcherService, _elementRef: ElementRef);
+    onDrop(event: any): void;
+    onDropOver(event: any): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    add(file: any): void;
+    upload(event: any): void;
+    remove(event: CmatUploadComponent): void;
+    uploadAll(): void;
+    removeAll(): void;
+    choose(): void;
+    getData(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatUploadQueueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatUploadQueueComponent, "cmat-upload-queue", ["cmatUploadQueue"], { "fileAlias": { "alias": "fileAlias"; "required": false; }; "filePath": { "alias": "filePath"; "required": false; }; "fileCategory": { "alias": "fileCategory"; "required": false; }; "required": { "alias": "required"; "required": false; }; "autoUpload": { "alias": "autoUpload"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "title": { "alias": "title"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "filesData": { "alias": "filesData"; "required": false; }; }, { "outputRemoveIdEvent": "outputRemoveIdEvent"; "outputUploadIdEvent": "outputUploadIdEvent"; "outputFilesDataEvent": "outputFilesDataEvent"; }, never, never, true, never>;
+}
+
+interface FileModel {
+    id?: string | null;
+    fileName: string;
+    filePath: string;
+    fileStatus?: 'Uploaded' | 'Processed';
+    length: number;
+    uploadUserId?: string;
+    uploadUserName?: string;
+    uploadDate: Date;
+    fileType: 'csv' | 'gif' | 'word' | 'excel' | 'jpg' | 'outlook' | 'pdf' | 'png' | 'ppt' | 'file' | 'text' | 'video' | 'zip';
+    fileCategory: string;
+    data?: any;
+}
+interface FileCategoryModel {
+    name: string;
+    value: number;
+}
+interface FileListModel {
+    data: FileModel[];
+    dataCount: number;
+    category: FileCategoryModel[];
+}
+
+export { CmatFilesUtilService, CmatUploadComponent, CmatUploadQueueComponent };
+export type { FileCategoryModel, FileListModel, FileModel };

package/components/x6-angular-shape/index.d.ts

@@ -1,5 +1,43 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/components/x6-angular-shape" />
-export * from './public-api';
+import { Node, NodeView, Dom } from '@antv/x6';
+import { TemplateRef, Type, Injector } from '@angular/core';
+
+declare class AngularShape<Properties extends AngularShape.Properties = AngularShape.Properties> extends Node<Properties> {
+}
+declare namespace AngularShape {
+    type Primer = 'rect' | 'circle' | 'path' | 'ellipse' | 'polygon' | 'polyline';
+    interface Properties extends Node.Properties {
+        primer?: Primer;
+    }
+}
+declare namespace AngularShape {
+}
+
+declare class AngularShapeView extends NodeView<AngularShape> {
+    getNodeContainer(): HTMLDivElement;
+    onMouseDown(e: Dom.MouseDownEvent, x: number, y: number): void;
+    unmount(): this;
+    confirmUpdate(flag: number): number;
+    protected renderAngularContent(): void;
+    protected unmountAngularContent(): HTMLDivElement;
+    private getNgArguments;
+    /** 当执行 node.setData() 时需要对实例设置新的输入值 */
+    private setInstanceInput;
+}
+declare namespace AngularShapeView {
+    const action: any;
+}
+
+type Content = TemplateRef<any> | Type<any>;
+type AngularShapeConfig = Node.Properties & {
+    shape: string;
+    injector: Injector;
+    content: Content;
+};
+declare const registerInfo: Map<string, {
+    injector: Injector;
+    content: Content;
+}>;
+declare function register(config: AngularShapeConfig): void;
+
+export { AngularShape, AngularShapeView, register, registerInfo };
+export type { AngularShapeConfig, Content };

package/directives/animate-on-scroll/index.d.ts

@@ -1,5 +1,45 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/animate-on-scroll" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnDestroy, OnInit, AfterViewInit, ElementRef, Renderer2 } from '@angular/core';
+import { Observable } from 'rxjs';
+
+declare class ScrollService implements OnDestroy {
+    scrollObs: Observable<any>;
+    resizeObs: Observable<any>;
+    pos: number;
+    private _scrollSub;
+    private _resizeSub;
+    constructor();
+    ngOnDestroy(): void;
+    private manageScrollPos;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollService>;
+}
+
+declare class CmatAnimationOnScrollDirective implements OnInit, OnDestroy, AfterViewInit {
+    private _elementRef;
+    private _renderer;
+    private _scroll;
+    animationName: string | null;
+    offset: number;
+    useScroll?: boolean;
+    threshold?: number;
+    private _offsetTop;
+    private _isVisible;
+    private _winHeight;
+    private _scrollSub;
+    private _resizeSub;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2, _scroll: ScrollService);
+    private get id();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private manageVisibility;
+    private addAnimationClass;
+    private setClass;
+    private getWinHeight;
+    private getOffsetTop;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatAnimationOnScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatAnimationOnScrollDirective, "[cmatAnimateOnScroll]", never, { "animationName": { "alias": "animationName"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "useScroll": { "alias": "useScroll"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { CmatAnimationOnScrollDirective };

package/directives/arrow-cursor/index.d.ts

@@ -1,5 +1,34 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/arrow-cursor" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, EventEmitter } from '@angular/core';
+import { CmatMediaWatcherService } from 'cmat/services/media-watcher';
+
+declare class CmatArrowCursorDirective implements AfterViewInit, OnDestroy {
+    private _document;
+    private _cmatMediaWatcherService;
+    animationDuration: number;
+    orientation: 'horizontal' | 'vertical';
+    enabled: boolean;
+    selector: string;
+    clickEvent: EventEmitter<string | null>;
+    cursorAnimationFrame: any;
+    isPhone: boolean;
+    arrowCursor: HTMLDivElement | null;
+    cursorClientX: number;
+    cursorClientY: number;
+    cursorIcon: SVGElement | null;
+    cursorSide: string | null;
+    oldCursorSide: string | null;
+    private _unsubscribeAll;
+    constructor(_document: Document, _cmatMediaWatcherService: CmatMediaWatcherService);
+    onMouseEnter(event: any): void;
+    onMouseLeave(event: any): void;
+    onMouseOver(event: any): void;
+    onClick(event: Event): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    moveCursor(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatArrowCursorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatArrowCursorDirective, "[cmatArrowCursor]", never, { "animationDuration": { "alias": "animationDuration"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; "selector": { "alias": "selector"; "required": false; }; }, { "clickEvent": "clickEvent"; }, never, never, true, never>;
+}
+
+export { CmatArrowCursorDirective };

package/directives/autofocus/index.d.ts

@@ -1,5 +1,11 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/autofocus" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+declare class CmatAutofocusDirective {
+    element: ElementRef;
+    constructor(element: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatAutofocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatAutofocusDirective, "[cmatAutofocus]", never, {}, {}, never, never, true, never>;
+}
+
+export { CmatAutofocusDirective };

package/directives/data-exporter/index.d.ts

@@ -1,5 +1,54 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/data-exporter" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { Injector, OnChanges, SimpleChanges } from '@angular/core';
+import { WritingOptions } from 'xlsx';
+
+interface ExporterListInfo {
+    code: string;
+    label: string;
+}
+declare enum ExportType {
+    XLS = "xls",
+    XLSX = "xlsx",
+    CSV = "csv",
+    TXT = "txt",
+    JSON = "json"
+}
+interface Options {
+    fileName?: string;
+}
+interface TxtOptions extends Options {
+    delimiter?: string;
+}
+interface ExcelOptions extends Options, Omit<WritingOptions, 'bookType'> {
+    columnWidths: number[];
+}
+
+interface Exporter<T extends Options> {
+    export(rows: any[], options?: T): void;
+}
+
+declare class ServiceLocatorService {
+    private _injector;
+    constructor(_injector: Injector);
+    getService(exportType: ExportType | 'xls' | 'xlsx' | 'csv' | 'txt' | 'json'): Exporter<Options>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceLocatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ServiceLocatorService>;
+}
+
+declare class CmatDataExporterDirective implements OnChanges {
+    private _serviceLocator;
+    dataSource: any[];
+    exportColumns: ExporterListInfo[];
+    options?: Options | ExcelOptions | TxtOptions;
+    exportType: ExportType | 'xls' | 'xlsx' | 'csv' | 'txt' | 'json';
+    private _data;
+    private _exporterService;
+    constructor(_serviceLocator: ServiceLocatorService);
+    ngOnChanges(changes: SimpleChanges): void;
+    private _loadExporter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDataExporterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDataExporterDirective, "button[cmatDataExporter]", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "exportColumns": { "alias": "exportColumns"; "required": false; }; "options": { "alias": "options"; "required": false; }; "exportType": { "alias": "exportType"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { CmatDataExporterDirective, ExportType };
+export type { ExcelOptions, ExporterListInfo, Options, TxtOptions };

package/directives/debounce/index.d.ts

@@ -1,5 +1,32 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/debounce" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter } from '@angular/core';
+import { Subject } from 'rxjs';
+
+declare abstract class AbstractDebounceDirective implements OnInit, OnDestroy {
+    debounceTime: number;
+    emitChanged: EventEmitter<any>;
+    emitEvent$: Subject<any>;
+    subscription$: Subject<void>;
+    constructor();
+    ngOnInit(): void;
+    emitChange(value: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDebounceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDebounceDirective, never, never, { "debounceTime": { "alias": "debounceTime"; "required": false; }; }, { "emitChanged": "emitChanged"; }, never, never, true, never>;
+}
+
+declare class CmatDebounceClickDirective extends AbstractDebounceDirective {
+    constructor();
+    onKeyUp(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDebounceClickDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDebounceClickDirective, "[cmatDebounceClick]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatDebounceKeyupDirective extends AbstractDebounceDirective {
+    constructor();
+    onKeyUp(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDebounceKeyupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDebounceKeyupDirective, "input[cmatDebounceKeyup]", never, {}, {}, never, never, true, never>;
+}
+
+export { CmatDebounceClickDirective, CmatDebounceKeyupDirective };