cmat 0.0.28 → 0.0.30

package/components/select-tree/index.d.ts

@@ -1,5 +1,120 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/components/select-tree" />
-export * from './public-api';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { SelectionModel } from '@angular/cdk/collections';
+import { CdkTree } from '@angular/cdk/tree';
+import * as i0 from '@angular/core';
+import { OnChanges, AfterViewInit, OnDestroy, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor, FormControl, NgControl } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { MatSelect } from '@angular/material/select';
+import { ReplaySubject, Subject } from 'rxjs';
+
+declare class CmatSelectTreeFlatNode {
+    id: string | number;
+    name: string;
+    level: number;
+    expandable: boolean;
+}
+
+declare class CmatSelectTreeNode {
+    id: string | number;
+    children: CmatSelectTreeNode[] | null;
+    name: string;
+}
+
+declare class CmatSelectTreeComponent implements MatFormFieldControl<any>, ControlValueAccessor, OnChanges, AfterViewInit, OnDestroy {
+    id: string;
+    dataSource: CmatSelectTreeNode[];
+    noEntriesFoundLabel: string;
+    showNoFoundLabel: boolean;
+    multiple: boolean;
+    overallSearchEnabled: boolean;
+    canNull: boolean;
+    customTriggerLabelFn: (value: CmatSelectTreeNode[]) => string;
+    customTriggerLabelTemplate: string;
+    expandable: boolean;
+    showToggleAllCheckbox: boolean;
+    flatNodeMap: Map<CmatSelectTreeFlatNode, CmatSelectTreeNode>;
+    nestedNodeMap: Map<CmatSelectTreeNode, CmatSelectTreeFlatNode>;
+    selectedParent: CmatSelectTreeFlatNode | null;
+    checklistSelection: SelectionModel<CmatSelectTreeFlatNode>;
+    treeDataSource: CmatSelectTreeNode[];
+    dataFlatNodes: CmatSelectTreeFlatNode[];
+    overallFilterControl: FormControl;
+    isIndeterminate: boolean;
+    isChecked: boolean;
+    checkCount: number;
+    selectControl: FormControl;
+    matSelectData: ReplaySubject<any[]>;
+    readonly stateChanges: Subject<void>;
+    focused: boolean;
+    touched: boolean;
+    ngControl: NgControl;
+    private _changeDetectorRef;
+    private _matSelect;
+    private _unsubscribeAll;
+    constructor();
+    tree: CdkTree<CmatSelectTreeNode>;
+    set matSelect(m: MatSelect);
+    clickedOut(): void;
+    getLevel: (dataNode: CmatSelectTreeFlatNode) => number;
+    childrenAccessor: (node: CmatSelectTreeNode) => CmatSelectTreeNode[];
+    hasChild: (_: number, node: CmatSelectTreeNode) => boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    get value(): any;
+    set value(value: any);
+    protected _value: any;
+    get empty(): boolean;
+    get errorState(): boolean;
+    get shouldLabelFloat(): boolean;
+    get required(): boolean;
+    set required(value: any);
+    protected _required: boolean;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    protected _disabled: boolean;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    onFocusIn(): void;
+    onFocusOut(event: FocusEvent): void;
+    writeValue(value: any): void;
+    simpleTriggerLabelFn(value: CmatSelectTreeFlatNode[]): string;
+    openedChange(opened: boolean): void;
+    /** Whether all the descendants of the node are selected. */
+    descendantsAllSelected(node: CmatSelectTreeFlatNode): boolean;
+    /** Whether part of the descendants are selected */
+    descendantsPartiallySelected(node: CmatSelectTreeFlatNode): boolean;
+    /** Toggle the to-do item selection. Select/deselect all the descendants node */
+    todoItemSelectionToggle(event: any, node: CmatSelectTreeFlatNode): void;
+    /** Toggle a leaf to-do item selection. Check all the parents to see if they changed */
+    todoLeafItemSelectionToggle(event: any, node: CmatSelectTreeFlatNode): void;
+    clearSelection(): void;
+    toggleSelectAll(selectAllValue: boolean): void;
+    getChecklistSelectionIsSelected(i: CmatSelectTreeNode): boolean;
+    compareObjects(o1: any, o2: any): boolean;
+    private _onModelChange;
+    private _onTouchedChange;
+    private _init;
+    private _checkAllParentsSelection;
+    /** Check root node checked state and change it accordingly */
+    private _checkRootNodeSelection;
+    private _getParentNode;
+    private _updateChecklistSelection;
+    private _updateSelect;
+    private _applyColumnLevelFilters;
+    private _updateCheckState;
+    private _getFlattenNodes;
+    private _transformer;
+    private _getDescendants;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSelectTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatSelectTreeComponent, "cmat-select-tree", ["cmatSelectTree"], { "id": { "alias": "id"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "noEntriesFoundLabel": { "alias": "noEntriesFoundLabel"; "required": false; }; "showNoFoundLabel": { "alias": "showNoFoundLabel"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "overallSearchEnabled": { "alias": "overallSearchEnabled"; "required": false; }; "canNull": { "alias": "canNull"; "required": false; }; "customTriggerLabelFn": { "alias": "customTriggerLabelFn"; "required": false; }; "customTriggerLabelTemplate": { "alias": "customTriggerLabelTemplate"; "required": false; }; "expandable": { "alias": "expandable"; "required": false; }; "showToggleAllCheckbox": { "alias": "showToggleAllCheckbox"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { CmatSelectTreeComponent, CmatSelectTreeFlatNode, CmatSelectTreeNode };

package/components/speed-dial/index.d.ts

@@ -1,5 +1,66 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/components/speed-dial" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { AfterContentInit, OnDestroy, EventEmitter } from '@angular/core';
+
+type Direction = 'up' | 'down' | 'left' | 'right';
+type AnimationMode = 'fling' | 'scale';
+declare class CmatSpeedDialActionsComponent implements AfterContentInit {
+    private _buttons;
+    miniFabVisible: boolean;
+    private readonly _renderer;
+    private readonly _parent;
+    private _showMiniFabAnimation;
+    private _hideMiniFab;
+    private _changeDetectorRef;
+    ngAfterContentInit(): void;
+    show(): void;
+    hide(): void;
+    private _initButtonStates;
+    private _resetAnimationState;
+    private _getTranslateFunction;
+    private _changeElementStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSpeedDialActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatSpeedDialActionsComponent, "cmat-speed-dial-actions", never, {}, {}, ["_buttons"], ["[mat-mini-fab]"], true, never>;
+}
+declare class CmatSpeedDialComponent implements OnDestroy, AfterContentInit {
+    readonly openChange: EventEmitter<boolean>;
+    private _childActions;
+    private readonly _elementRef;
+    private readonly _renderer;
+    private readonly _document;
+    private _isInitialized;
+    private _direction;
+    private _open;
+    private _animationMode;
+    private _fixed;
+    private _documentClickUnlistener;
+    get fixed(): boolean;
+    set fixed(fixed: boolean);
+    get open(): boolean;
+    set open(open: boolean);
+    get direction(): Direction;
+    set direction(direction: Direction);
+    get animationMode(): AnimationMode;
+    set animationMode(animationMode: AnimationMode);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    toggle(): void;
+    onClick(): void;
+    setActionsVisibility(): void;
+    private _setElementClass;
+    private _processOutsideClickState;
+    private _setDocumentClickListener;
+    private _unsetDocumentClickListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSpeedDialComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatSpeedDialComponent, "cmat-speed-dial", never, { "fixed": { "alias": "fixed"; "required": false; }; "open": { "alias": "open"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "animationMode": { "alias": "animationMode"; "required": false; }; }, { "openChange": "openChange"; }, ["_childActions"], ["cmat-speed-dial-trigger", "cmat-speed-dial-actions"], true, never>;
+}
+declare class CmatSpeedDialTriggerComponent {
+    spin: boolean;
+    private readonly _parent;
+    get sp(): boolean;
+    onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSpeedDialTriggerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatSpeedDialTriggerComponent, "cmat-speed-dial-trigger", never, { "spin": { "alias": "spin"; "required": false; }; }, {}, never, ["[mat-fab]"], true, never>;
+}
+
+export { CmatSpeedDialActionsComponent, CmatSpeedDialComponent, CmatSpeedDialTriggerComponent };
+export type { AnimationMode, Direction };

package/components/timeline/index.d.ts

@@ -1,5 +1,56 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/components/timeline" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { TemplateRef, OnInit, OnDestroy, QueryList } from '@angular/core';
+
+declare class CmatTimelineItemIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTimelineItemIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatTimelineItemIconDirective, "ng-template[cmatTimelineItemIcon]", never, {}, {}, never, never, true, never>;
+}
+declare class CmatTimelineItemLabelDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTimelineItemLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatTimelineItemLabelDirective, "ng-template[cmatTimelineItemLabel]", never, {}, {}, never, never, true, never>;
+}
+declare class CmatTimelineItemComponent {
+    label?: string | null;
+    icon?: string | null;
+    svgIcon?: string | null;
+    iconUrl?: string | null;
+    class: string;
+    customIconTpl?: TemplateRef<any>;
+    customLabelTpl?: TemplateRef<any>;
+    private _contentEl;
+    private _fillEl;
+    updateVerticalCenteredLayout(): void;
+    updateHorizontalCenteredLayout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTimelineItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTimelineItemComponent, "cmat-timeline-item", ["cmatTimelineItem"], { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "svgIcon": { "alias": "svgIcon"; "required": false; }; "iconUrl": { "alias": "iconUrl"; "required": false; }; }, {}, ["customIconTpl", "customLabelTpl"], ["*"], true, never>;
+}
+
+type CMAT_TIMELINE_POSITION = 'start' | 'end' | 'center' | 'center-alt';
+type CMAT_TIMELINE_ORIENTATION = 'vertical' | 'horizontal';
+declare class CmatTimelineComponent implements OnInit, OnDestroy {
+    readonly items: QueryList<CmatTimelineItemComponent>;
+    readonly class = "cmat-timeline";
+    private _host;
+    private _reverse;
+    private _position;
+    private _orientation;
+    private _unsubscribeAll;
+    get isStartPosition(): boolean;
+    get isEndPosition(): boolean;
+    get isCenterPosition(): boolean;
+    get isCenterAltPosition(): boolean;
+    get isVerticalOrientation(): boolean;
+    get isHorizontalOrientation(): boolean;
+    get isReverse(): boolean;
+    set position(position: CMAT_TIMELINE_POSITION);
+    set orientation(orientation: CMAT_TIMELINE_ORIENTATION);
+    set reverse(reverse: boolean);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    updateLayout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTimelineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTimelineComponent, "cmat-timeline", ["cmatTimeLine"], { "position": { "alias": "position"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "reverse": { "alias": "reverse"; "required": false; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+export { CmatTimelineComponent, CmatTimelineItemComponent, CmatTimelineItemIconDirective, CmatTimelineItemLabelDirective };
+export type { CMAT_TIMELINE_ORIENTATION, CMAT_TIMELINE_POSITION };

package/components/toast/index.d.ts

@@ -1,5 +1,84 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/components/toast" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { AfterViewInit, EventEmitter, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+
+type Prefixable = keyof Pick<CmatToastModel, 'theme' | 'position' | 'type'>;
+type ToastAPrefix<Key extends Prefixable> = `toasta-${Key}`;
+type Theme = 'material';
+type GlobalTheme = `${ToastAPrefix<'theme'>}-${Theme}` | Theme;
+type PositionY = 'bottom' | 'top';
+type PositionX = 'right' | 'left' | 'center' | 'fullwidth';
+type Position = `${PositionY}-${PositionX}` | 'center-center';
+type GlobalPosition = `${ToastAPrefix<'position'>}-${Position}` | Position;
+type Type = 'error' | 'info' | 'success' | 'wait' | 'warning';
+type GlobalType = `${ToastAPrefix<'type'>}-${Type}` | Type;
+
+interface GlobalConfigModel {
+    id?: number;
+    title?: string;
+    showClose?: boolean;
+    showDuration?: boolean;
+    theme?: GlobalTheme;
+    timeout?: number;
+    position?: GlobalPosition;
+    limit?: number;
+    isCountdown?: boolean;
+}
+
+interface CmatToastModel extends GlobalConfigModel {
+    type: GlobalType;
+    message: string;
+}
+
+declare class CmatToastModalComponent implements AfterViewInit {
+    toast: CmatToastModel;
+    closeToastEvent: EventEmitter<number>;
+    progressPercent: number;
+    timeout: number;
+    private _ref;
+    private _progressInterval;
+    private _startTime;
+    ngAfterViewInit(): void;
+    handleProgress(): void;
+    close(toast: CmatToastModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatToastModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatToastModalComponent, "cmat-toast-modal", ["cmatToastModal"], { "toast": { "alias": "toast"; "required": false; }; }, { "closeToastEvent": "closeToastEvent"; }, never, never, true, never>;
+}
+
+declare class CmatToastComponent implements OnInit {
+    toasts$: Observable<CmatToastModel[]>;
+    position$: Observable<string>;
+    private _cmatToastService;
+    ngOnInit(): void;
+    listenForToastEvent(): void;
+    clearToast(toastId: any): void;
+    trackByFn(index: number, item: CmatToastModel): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatToastComponent, "cmat-toast", ["cmatToast"], {}, {}, never, never, true, never>;
+}
+
+declare class CmatToastService {
+    toasts: CmatToastModel[];
+    private _positionSubject;
+    private _toastPopSubject;
+    private _globalConfigs;
+    private _counter;
+    get position$(): Observable<string>;
+    get toastPop$(): Observable<CmatToastModel[]>;
+    receiveGlobalConfigs(configs: GlobalConfigModel): void;
+    removeToast(toastId: number): void;
+    clearAll(): void;
+    clearLast(): void;
+    addToast(toast: CmatToastModel): void;
+    getGlobalConfigs(): GlobalConfigModel;
+    getToasts(): CmatToastModel[];
+    private _getDefaultToast;
+    private _setGlobalValues;
+    private _setPosition;
+    private _serveToast;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatToastService>;
+}
+
+export { CmatToastComponent, CmatToastModalComponent, CmatToastService };
+export type { CmatToastModel, GlobalConfigModel, GlobalPosition, GlobalTheme, GlobalType, Position, PositionX, PositionY, Theme, ToastAPrefix, Type };

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

@@ -1,5 +1,190 @@
+import { CdkOverlayOrigin, OverlayRef } from '@angular/cdk/overlay';
+import { CdkPortal } from '@angular/cdk/portal';
+import * as i0 from '@angular/core';
+import { OnInit, AfterViewInit, OnDestroy, EventEmitter } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { SelectionModel } from '@angular/cdk/collections';
+import { CdkTree } from '@angular/cdk/tree';
+import { BehaviorSubject } from 'rxjs';
+
 /**
- * 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 CmatTransferPickerFilterComponent implements OnInit {
+    filters: CmatTransferFilterItem[];
+    overlayOrigin: CdkOverlayOrigin;
+    filterTemplate: CdkPortal;
+    overlayRef: OverlayRef;
+    filterData: CmatTransferFilterData;
+    private _overlay;
+    private _service;
+    constructor();
+    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 {
+    searchPlaceholder: string;
+    keyword: FormControl;
+    private _service;
+    constructor();
+    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 {
+    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 _service;
+    private _changeDetectorRef;
+    private _unsubscribeAll;
+    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 {
+    title: string;
+    filterable: boolean;
+    searchable: boolean;
+    searchPlaceholder: string;
+    dataSource: CmatTransferItemNode[];
+    filters: CmatTransferFilterItem[];
+    selectedValues: string[];
+    selectChange: EventEmitter<CmatTransferItemFlatNode[]>;
+    source: CmatTransferPickerSourceComponent;
+    selectedList: CmatTransferItemFlatNode[];
+    private _service;
+    private _changeDetectorRef;
+    constructor();
+    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>;
+}
+
+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>;
+}
+
+export { CmatTransferFilterCondition, CmatTransferItemFlatNode, CmatTransferItemNode, CmatTransferPickerComponent, CmatTransferPickerFilterComponent, CmatTransferPickerSearchComponent, CmatTransferPickerService, CmatTransferPickerSourceComponent, CmatTransferPickerTargetComponent };
+export type { CmatSourceOptions, CmatTransferFilterData, CmatTransferFilterItem };

package/components/treetable/index.d.ts

@@ -1,5 +1,43 @@
-/**
- * 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, 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 {
+    data: CmatTreeTableNode[];
+    verticalSeparator: boolean;
+    initExpand: boolean;
+    tableClass: string;
+    showControlColumn: boolean;
+    nodeClicked: Subject<CmatTreeTableNode>;
+    customColumnTpl?: TemplateRef<any>;
+    displayedColumns: string[];
+    dataSource: MatTableDataSource<CmatTreeTableNode>;
+    private _treeTable;
+    private _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 };