cmat 0.0.76 → 0.0.79

package/types/cmat.d.ts

@@ -1,2 +1,4498 @@
+import { DateAdapter, MatDateFormats, ThemePalette, MatOption } from '@angular/material/core';
+import * as i0 from '@angular/core';
+import { InjectionToken, TemplateRef, OnChanges, SimpleChanges, AfterContentInit, AfterContentChecked, OnDestroy, ElementRef, NgZone, ChangeDetectorRef, EventEmitter, QueryList, OnInit, AfterViewInit, Type as Type$2, PipeTransform, Injector } from '@angular/core';
+import { Dayjs } from 'dayjs';
+import { Observable, Subject, ReplaySubject } from 'rxjs';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ControlValueAccessor, NgControl, FormControl, FormGroup, UntypedFormGroup, Validator, AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { CdkOverlayOrigin, OverlayRef, ScrollStrategy, Overlay } from '@angular/cdk/overlay';
+import { CdkPortal } from '@angular/cdk/portal';
+import { MatBottomSheetRef } from '@angular/material/bottom-sheet';
+import { MatFormFieldControl, MatFormField } from '@angular/material/form-field';
+import { MatAutocompleteSelectedEvent, MatAutocompleteActivatedEvent } from '@angular/material/autocomplete';
+import { MatChipInputEvent } from '@angular/material/chips';
+import { NgxEditorModel } from 'ngx-monaco-editor-v2';
+import { FormlyFieldConfig, FieldWrapper, FieldTypeConfig, FieldArrayType, FieldType as FieldType$2 } from '@ngx-formly/core';
+import { FormlyFieldProps, FieldType } from '@ngx-formly/material/form-field';
+import { FieldType as FieldType$1 } from '@ngx-formly/material';
+import { CmatCalendarView as CmatCalendarView$1, CmatDatetimepickerMode as CmatDatetimepickerMode$1, CmatDatetimepickerType as CmatDatetimepickerType$1 } from 'cmat/components/material-datetimepicker';
+import { MatCheckbox } from '@angular/material/checkbox';
+import { MatRadioGroup } from '@angular/material/radio';
+import { FormlyFieldSelectProps } from '@ngx-formly/core/select';
+import { CmatSelectTableDataSource as CmatSelectTableDataSource$1, CmatSelectTableRow as CmatSelectTableRow$1 } from 'cmat/components/select-table';
+import { MatTable, MatTableDataSource } from '@angular/material/table';
+import { QuillModules } from 'ngx-quill';
+import { SafeUrl } from '@angular/platform-browser';
+import { Content as Content$1 } from 'vanilla-jsoneditor';
+import { MatButton } from '@angular/material/button';
+import { DatetimeAdapter as DatetimeAdapter$1 } from 'cmat/components/adapter';
+import { IsActiveMatchOptions } from '@angular/router';
+import { Direction as Direction$1 } from '@angular/cdk/bidi';
+import { MatSelect } from '@angular/material/select';
+import { Sort } from '@angular/material/sort';
+import { SelectionModel } from '@angular/cdk/collections';
+import { CdkTree } from '@angular/cdk/tree';
+import { Node, NodeProperties, NodeView, Dom } from '@antv/x6';
+import { WritingOptions } from 'xlsx';
+import { HttpResponseBase, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpHeaders } from '@angular/common/http';
+import { MatDialogRef } from '@angular/material/dialog';
+import { BreakpointState } from '@angular/cdk/layout';
+import { Language } from '@ngx-translate/core';
 
-export { };
+declare abstract class DatetimeAdapter<D> extends DateAdapter<D> {
+    protected _delegate: DateAdapter<D>;
+    constructor(_delegate: DateAdapter<D>);
+    getValidDateOrNull(obj: any): D | null;
+    compareDatetime(first: D, second: D, respectMinutePart?: boolean): number | boolean;
+    sameDatetime(first: D | null, second: D | null): boolean;
+    sameYear(first: D, second: D): boolean;
+    sameDay(first: D, second: D): boolean;
+    sameHour(first: D, second: D): boolean;
+    sameMinute(first: D, second: D): boolean;
+    sameMonthAndYear(first: D | null, second: D | null): boolean;
+    clone(date: D): D;
+    addCalendarYears(date: D, years: number): D;
+    addCalendarMonths(date: D, months: number): D;
+    addCalendarDays(date: D, days: number): D;
+    getYear(date: D): number;
+    getMonth(date: D): number;
+    getDate(date: D): number;
+    getDayOfWeek(date: D): number;
+    getMonthNames(style: any): string[];
+    getDateNames(): string[];
+    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    getYearName(date: D): string;
+    getFirstDayOfWeek(): number;
+    getNumDaysInMonth(date: D): number;
+    createDate(year: number, month: number, date: number): D;
+    today(): D;
+    parse(value: any, parseFormat: any): D | null;
+    format(date: D, displayFormat: any): string;
+    toIso8601(date: D): string;
+    isDateInstance(obj: any): boolean;
+    isValid(date: D): boolean;
+    invalid(): D;
+    clampDate(date: D, min?: D | null, max?: D | null): D;
+    abstract getHour(date: D): number;
+    abstract getMinute(date: D): number;
+    abstract getFirstDateOfMonth(date: D): D;
+    abstract isInNextMonth(startDate: D, endDate: D): boolean;
+    abstract getHourNames(): string[];
+    abstract getMinuteNames(): string[];
+    abstract addCalendarHours(date: D, months: number): D;
+    abstract addCalendarMinutes(date: D, months: number): D;
+    abstract createDatetime(year: number, month: number, date: number, hour: number, minute: number): D;
+}
+
+interface CmatDatetimeFormats {
+    parse: {
+        dateInput?: any;
+        monthInput?: any;
+        timeInput?: any;
+        datetimeInput?: any;
+        yearInput?: any;
+    };
+    display: {
+        dateInput: any;
+        monthInput: any;
+        timeInput: any;
+        datetimeInput: any;
+        yearInput: any;
+        monthYearLabel: any;
+        dateA11yLabel: any;
+        monthYearA11yLabel: any;
+        popupHeaderDateLabel: any;
+    };
+}
+declare const CMAT_DATETIME_FORMATS: InjectionToken<CmatDatetimeFormats>;
+
+declare class CNativeDatetimeAdapter extends DatetimeAdapter<Date> {
+    constructor();
+    clone(date: Date): Date;
+    getHour(date: Date): number;
+    getMinute(date: Date): number;
+    isInNextMonth(startDate: Date, endDate: Date): boolean;
+    createDatetime(year: number, month: number, date: number, hour: number, minute: number): Date;
+    getFirstDateOfMonth(date: Date): Date;
+    getHourNames(): string[];
+    getMinuteNames(): string[];
+    addCalendarYears(date: Date, years: number): Date;
+    addCalendarMonths(date: Date, months: number): Date;
+    addCalendarDays(date: Date, days: number): Date;
+    addCalendarHours(date: Date, hours: number): Date;
+    addCalendarMinutes(date: Date, minutes: number): Date;
+    toIso8601(date: Date): string;
+    private _getDateInNextMonth;
+    private _2digit;
+    private _createDateWithOverflow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CNativeDatetimeAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CNativeDatetimeAdapter>;
+}
+
+declare const CMAT_NATIVE_DATETIME_FORMATS: CmatDatetimeFormats;
+
+declare class DayjsDatetimeAdapter extends DatetimeAdapter<Dayjs> {
+    private _localeData;
+    constructor();
+    setLocale(locale: any): void;
+    getHour(date: Dayjs): number;
+    getMinute(date: Dayjs): number;
+    isInNextMonth(startDate: Dayjs, endDate: Dayjs): boolean;
+    createDatetime(year: number, month: number, date: number, hour: number, minute: number): Dayjs;
+    getFirstDateOfMonth(date: Dayjs): Dayjs;
+    getHourNames(): string[];
+    getMinuteNames(): string[];
+    addCalendarHours(date: Dayjs, hours: number): Dayjs;
+    addCalendarMinutes(date: Dayjs, minutes: number): Dayjs;
+    deserialize(value: any): Dayjs | null;
+    private _getDateInNextMonth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DayjsDatetimeAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DayjsDatetimeAdapter>;
+}
+
+declare const CMAT_DAYJS_DATETIME_FORMATS: CmatDatetimeFormats;
+
+interface DayJsDateAdapterOptions {
+    useUtc?: boolean;
+}
+declare const CMAT_DAYJS_DATE_ADAPTER_OPTIONS: InjectionToken<DayJsDateAdapterOptions>;
+declare function CMAT_DAYJS_DATE_ADAPTER_OPTIONS_FACTORY(): DayJsDateAdapterOptions;
+declare class DayjsDateAdapter extends DateAdapter<Dayjs> {
+    private _options;
+    private _localeData;
+    constructor();
+    private get _shouldUseUtc();
+    setLocale(locale: string): void;
+    getYear(date: Dayjs): number;
+    getMonth(date: Dayjs): number;
+    getDate(date: Dayjs): number;
+    getDayOfWeek(date: Dayjs): number;
+    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    getDateNames(): string[];
+    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    getYearName(date: Dayjs): string;
+    getFirstDayOfWeek(): number;
+    getNumDaysInMonth(date: Dayjs): number;
+    clone(date: Dayjs): Dayjs;
+    createDate(year: number, month: number, date: number): Dayjs;
+    today(): Dayjs;
+    parse(value: any, parseFormat: string): Dayjs | null;
+    format(date: Dayjs, displayFormat: string): string;
+    addCalendarYears(date: Dayjs, years: number): Dayjs;
+    addCalendarMonths(date: Dayjs, months: number): Dayjs;
+    addCalendarDays(date: Dayjs, days: number): Dayjs;
+    toIso8601(date: Dayjs): string;
+    deserialize(value: any): Dayjs | null;
+    isDateInstance(obj: any): boolean;
+    isValid(date: Dayjs): boolean;
+    invalid(): Dayjs;
+    private _dayJs;
+    private _initializeParser;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DayjsDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DayjsDateAdapter>;
+}
+
+declare const CMAT_DAYJS_DATE_FORMATS: MatDateFormats;
+
+declare class CmatBreadcrumbItemDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatBreadcrumbItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatBreadcrumbItemDirective, "[cmatBreadcrumbItem]", never, {}, {}, never, never, true, never>;
+}
+
+interface CmatBreadcrumb {
+    routeLink?: string;
+    routeRegex?: string;
+    isAutoGeneratedLabel?: boolean;
+    queryParams?: any;
+    fragment?: string;
+    routeInterceptor?: (breadcrumb: CmatBreadcrumb, routeLink?: string) => string;
+}
+
+interface CmatBreadcrumbObject {
+    label?: string | CmatBreadcrumbFunction;
+    alias?: string;
+    skip?: boolean;
+    disable?: boolean;
+    info?: unknown;
+    routeInterceptor?: (breadcrumb: CmatBreadcrumb, routeLink?: string) => string;
+}
+type CmatBreadcrumbFunction = (resolvedLabel?: string) => string;
+
+type CmatBreadcrumbDefinition = CmatBreadcrumb & CmatBreadcrumbObject;
+declare class CmatBreadcrumbService {
+    private _activatedRoute;
+    private _router;
+    private readonly _destroyRef;
+    private _baseHref;
+    private readonly _dynamicBreadcrumbStore;
+    private _currentBreadcrumbs;
+    private _previousBreadcrumbs;
+    private _breadcrumbs;
+    private readonly _breadcrumbs$;
+    constructor();
+    get breadcrumbs$(): Observable<CmatBreadcrumbDefinition[]>;
+    set(key: string, breadcrumb: string | CmatBreadcrumbObject): void;
+    private _detectRouteChanges;
+    private _setupBreadcrumbs;
+    private _getRootBreadcrumb;
+    private _prepareBreadcrumbItem;
+    private _prepareBreadcrumbList;
+    private _getFromStore;
+    private _matchRegex;
+    private _resolvePathSegment;
+    private _getQueryParamsFromPreviousList;
+    private _setQueryParamsForActiveBreadcrumb;
+    private _parseRouteData;
+    private _mergeWithBaseChildData;
+    private _updateStore;
+    private _updateCurrentBreadcrumbs;
+    private _buildRegex;
+    private _ensureLeadingSlash;
+    private _extractLabel;
+    private _extractObject;
+    private _publishCurrentBreadcrumbs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatBreadcrumbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatBreadcrumbService>;
+}
+
+interface CmatBreadcrumbTemplateContext {
+    $implicit: string | undefined | CmatBreadcrumbFunction;
+    info: unknown;
+    last: boolean;
+    first: boolean;
+    index: number;
+    count: number;
+}
+declare class CmatBreadcrumbComponent {
+    itemTemplate: TemplateRef<CmatBreadcrumbTemplateContext> | null;
+    set autoGenerate(value: boolean);
+    get autoGenerate(): boolean;
+    preserveQueryParams: boolean;
+    preserveFragment: boolean;
+    class: string;
+    anchorTarget: '_blank' | void;
+    separatorTemplate: TemplateRef<void> | null;
+    readonly breadcrumbs: i0.Signal<CmatBreadcrumbDefinition[]>;
+    private readonly _breadcrumbService;
+    private readonly _autoGenerate;
+    private readonly _breadcrumbItems;
+    set separator(value: string | void);
+    get separator(): string | void;
+    private _separator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatBreadcrumbComponent, "cmat-breadcrumb", ["cmatBreadcrumb"], { "autoGenerate": { "alias": "autoGenerate"; "required": false; }; "preserveQueryParams": { "alias": "preserveQueryParams"; "required": false; }; "preserveFragment": { "alias": "preserveFragment"; "required": false; }; "class": { "alias": "class"; "required": false; }; "anchorTarget": { "alias": "anchorTarget"; "required": false; }; "separator": { "alias": "separator"; "required": false; }; }, {}, ["itemTemplate"], never, true, never>;
+}
+
+type CmatCardFace = 'front' | 'back';
+
+declare class CmatCardComponent implements OnChanges {
+    static ngAcceptInputType_expanded: BooleanInput;
+    static ngAcceptInputType_flippable: BooleanInput;
+    expanded: boolean;
+    face: CmatCardFace;
+    flippable: boolean;
+    get classList(): any;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatCardComponent, "cmat-card", ["cmatCard"], { "expanded": { "alias": "expanded"; "required": false; }; "face": { "alias": "face"; "required": false; }; "flippable": { "alias": "flippable"; "required": false; }; }, {}, never, ["[cmatCardFront]", "[cmatCardBack]", "*", "[cmatCardExpansion]"], true, never>;
+}
+
+interface CmatCarouselResponsiveOptions {
+    breakpoint: string;
+    numVisible: number;
+    numScroll: number;
+}
+interface CmatCarouselPageEvent {
+    page?: number;
+}
+interface CmatCarouselTemplates {
+    header(): TemplateRef<any>;
+    item(context: {
+        $implicit: any;
+    }): TemplateRef<{
+        $implicit: any;
+    }>;
+    previousicon(): TemplateRef<any>;
+    nexticon(): TemplateRef<any>;
+    footer(): TemplateRef<any>;
+}
+
+declare class CmatCarouselHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCarouselHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatCarouselHeaderComponent, "cmat-carousel-header", never, {}, {}, never, ["*"], true, never>;
+}
+declare class CmatCarouselFooterComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCarouselFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatCarouselFooterComponent, "cmat-carousel-footer", never, {}, {}, never, ["*"], true, never>;
+}
+declare class CmatCarouselTemplateDirective {
+    template: TemplateRef<any>;
+    type: string | undefined;
+    name: string | undefined;
+    getType(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCarouselTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatCarouselTemplateDirective, "[cmatCarouselTemplate]", never, { "type": { "alias": "type"; "required": false; }; "name": { "alias": "cmatCarouselTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class CmatCarouselComponent implements AfterContentInit, OnChanges, AfterContentChecked, OnDestroy {
+    el: ElementRef<any>;
+    zone: NgZone;
+    cd: ChangeDetectorRef;
+    private renderer;
+    private _document;
+    get page(): number;
+    set page(val: number);
+    get numVisible(): number;
+    set numVisible(val: number);
+    get numScroll(): number;
+    set numScroll(val: number);
+    responsiveOptions: CmatCarouselResponsiveOptions[] | undefined;
+    orientation: 'horizontal' | 'vertical';
+    navigatorsType: 'normal' | 'arrow';
+    verticalViewPortHeight: string;
+    arrowSelector: string;
+    contentClass: string;
+    indicatorsContentClass: string;
+    indicatorsContentStyle: Record<string, any> | null | undefined;
+    indicatorStyleClass: string;
+    indicatorStyle: Record<string, any> | null | undefined;
+    get data(): any[];
+    set data(val: any[]);
+    circular: boolean;
+    showIndicators: boolean;
+    showNavigators: boolean;
+    suspendAutoPlay: boolean;
+    autoplayInterval: number;
+    style: Record<string, any> | null | undefined;
+    styleClass: string;
+    pageEvent: EventEmitter<CmatCarouselPageEvent>;
+    itemsContainer: ElementRef | undefined;
+    indicatorContent: ElementRef | undefined;
+    headerFacet: QueryList<CmatCarouselHeaderComponent> | undefined;
+    footerFacet: QueryList<CmatCarouselFooterComponent> | undefined;
+    templates: QueryList<CmatCarouselTemplateDirective> | undefined;
+    prevState: any;
+    defaultNumScroll: number;
+    defaultNumVisible: number;
+    carouselStyle: any;
+    id: string | undefined;
+    totalShiftedItems: number;
+    isRemainingItemsAdded: boolean;
+    animationTimeout: any;
+    translateTimeout: any;
+    remainingItems: number;
+    startPos: any;
+    documentResizeListener: any;
+    clonedItemsForStarting: any[] | undefined;
+    clonedItemsForFinishing: any[] | undefined;
+    allowAutoplay: boolean | undefined;
+    interval: any;
+    isCreated: boolean | undefined;
+    swipeThreshold: number;
+    itemTemplate: TemplateRef<any> | null;
+    headerTemplate: TemplateRef<any> | null;
+    footerTemplate: TemplateRef<any> | null;
+    previousIconTemplate: TemplateRef<any> | null;
+    nextIconTemplate: TemplateRef<any> | null;
+    window: Window;
+    private _numVisible;
+    private _numScroll;
+    private _oldNumScroll;
+    private _page;
+    private _data;
+    constructor();
+    ngOnChanges(simpleChange: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
+    ngOnDestroy(): void;
+    firstIndex(): number;
+    lastIndex(): number;
+    totalDots(): number;
+    totalDotsArray(): number[];
+    isVertical(): boolean;
+    isCircular(): boolean;
+    isAutoplay(): boolean | undefined;
+    isForwardNavDisabled(): boolean;
+    isBackwardNavDisabled(): boolean;
+    isEmpty(): boolean;
+    navForward(e: MouseEvent | TouchEvent | null, index?: number): void;
+    navBackward(e: MouseEvent | TouchEvent | null, index?: number): void;
+    onDotClick(e: MouseEvent, index: number): void;
+    onIndicatorKeydown(event: KeyboardEvent): void;
+    isPlaying(): boolean;
+    onTransitionEnd(): void;
+    onTouchStart(e: TouchEvent): void;
+    onTouchMove(e: TouchEvent | MouseEvent): void;
+    onTouchEnd(e: TouchEvent): void;
+    arrowCursorClick(cursorSide: string | null): void;
+    private _changePageOnTouch;
+    private _bindDocumentListeners;
+    private _unbindDocumentListeners;
+    private _onRightKey;
+    private _onLeftKey;
+    private _onHomeKey;
+    private _onEndKey;
+    private _onTabKey;
+    private _changedFocusedIndicator;
+    private _step;
+    private _startAutoplay;
+    private _stopAutoplay;
+    private _findFocusedIndicatorIndex;
+    private _createStyle;
+    private _calculatePosition;
+    private _updateSlideAccessibility;
+    private _updateCarouselItemsAccessibility;
+    private _setCloneItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCarouselComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatCarouselComponent, "cmat-carousel", never, { "page": { "alias": "page"; "required": false; }; "numVisible": { "alias": "numVisible"; "required": false; }; "numScroll": { "alias": "numScroll"; "required": false; }; "responsiveOptions": { "alias": "responsiveOptions"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "navigatorsType": { "alias": "navigatorsType"; "required": false; }; "verticalViewPortHeight": { "alias": "verticalViewPortHeight"; "required": false; }; "arrowSelector": { "alias": "arrowSelector"; "required": false; }; "contentClass": { "alias": "contentClass"; "required": false; }; "indicatorsContentClass": { "alias": "indicatorsContentClass"; "required": false; }; "indicatorsContentStyle": { "alias": "indicatorsContentStyle"; "required": false; }; "indicatorStyleClass": { "alias": "indicatorStyleClass"; "required": false; }; "indicatorStyle": { "alias": "indicatorStyle"; "required": false; }; "data": { "alias": "data"; "required": false; }; "circular": { "alias": "circular"; "required": false; }; "showIndicators": { "alias": "showIndicators"; "required": false; }; "showNavigators": { "alias": "showNavigators"; "required": false; }; "suspendAutoPlay": { "alias": "suspendAutoPlay"; "required": false; }; "autoplayInterval": { "alias": "autoplayInterval"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, { "pageEvent": "pageEvent"; }, ["headerFacet", "footerFacet", "templates"], ["cmat-carousel-header", "cmat-carousel-footer"], true, never>;
+    static ngAcceptInputType_circular: unknown;
+    static ngAcceptInputType_showIndicators: unknown;
+    static ngAcceptInputType_showNavigators: unknown;
+    static ngAcceptInputType_suspendAutoPlay: unknown;
+    static ngAcceptInputType_autoplayInterval: unknown;
+}
+
+interface CmatCascadeOptionsInterface {
+    [propName: string]: any;
+    label?: string;
+    value: string;
+    children?: CmatCascadeOptionsInterface[];
+    disabled?: boolean;
+    active?: boolean;
+}
+
+declare class CmatCascadeListComponent implements MatFormFieldControl<any>, OnDestroy, OnInit, OnChanges, ControlValueAccessor {
+    ngControl: NgControl;
+    private _overlay;
+    private _breakpointObserver;
+    private _bottomSheet;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    id: string;
+    options: CmatCascadeOptionsInterface[];
+    clearable: boolean;
+    fullLevels: boolean;
+    changeOnSelect: boolean;
+    allowLabelValue: boolean;
+    overlayOrigin: CdkOverlayOrigin;
+    menuTemplate: CdkPortal;
+    private _inputElement;
+    overlayRef: OverlayRef;
+    bottomSheetRef: MatBottomSheetRef;
+    steps: any[];
+    menuVisible: boolean;
+    currentLabels: CmatCascadeOptionsInterface[];
+    readonly stateChanges: Subject<void>;
+    focused: boolean;
+    touched: boolean;
+    controlType: string;
+    constructor();
+    private _touchUi;
+    get touchUi(): boolean;
+    set touchUi(value: boolean);
+    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;
+    onTouched: () => any;
+    controlChange: (value: any[] | null) => any;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    clickHandle(event: MouseEvent): void;
+    clearValue(event?: Event): void;
+    showClearIcon(): boolean;
+    selectHandle(event: Event, step: number, index: number): any;
+    onFocusIn(): void;
+    onFocusOut(event: FocusEvent): void;
+    private _initSteps;
+    private _changeLabels;
+    private _openBottomSheet;
+    private _init;
+    private _setInputValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCascadeListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatCascadeListComponent, "cmat-cascade-list", ["cmatCascadeList"], { "id": { "alias": "id"; "required": false; }; "options": { "alias": "options"; "required": true; }; "clearable": { "alias": "clearable"; "required": false; }; "fullLevels": { "alias": "fullLevels"; "required": false; }; "changeOnSelect": { "alias": "changeOnSelect"; "required": false; }; "allowLabelValue": { "alias": "allowLabelValue"; "required": false; }; "touchUi": { "alias": "touchUi"; "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>;
+}
+
+declare class CmatCascadeBottomSheetComponent {
+    root: CmatCascadeListComponent;
+    selected: FormControl<number | null>;
+    labels: string[];
+    constructor();
+    clickHandle(event: Event): void;
+    select(disabled: boolean, label: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCascadeBottomSheetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatCascadeBottomSheetComponent, "cmat-cascade-bottom-sheet", ["cmatCascadeBottomSheet"], {}, {}, never, never, true, never>;
+}
+
+declare class CmatChipInputComponent implements MatFormFieldControl<any>, ControlValueAccessor, OnDestroy {
+    ngControl: NgControl;
+    id: string;
+    private _inputElementRef;
+    selectableOptions: string[];
+    hasAutocomplete: boolean;
+    outputIsString: boolean;
+    separatorKey: string;
+    inputControl: FormControl<string | null>;
+    filteredOptions$: Observable<string[] | null>;
+    private _selectedOptions;
+    readonly selectedOptions$: Observable<any[]>;
+    separatorKeysCodes: number[];
+    readonly stateChanges: Subject<void>;
+    focused: boolean;
+    touched: boolean;
+    controlType: string;
+    autocompleteOptionActive: boolean;
+    private readonly _maxFilteredItems;
+    private readonly _destroyRef;
+    constructor();
+    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;
+    writeValue(value: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    onAdd(event: MatChipInputEvent): void;
+    onRemove(option: string): void;
+    onSelected(event: MatAutocompleteSelectedEvent): void;
+    onFocusIn(): void;
+    onFocusOut(event: FocusEvent): void;
+    onActivated(event: MatAutocompleteActivatedEvent): void;
+    private _onModelChange;
+    private _onTouchedChange;
+    private _filter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatChipInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatChipInputComponent, "cmat-chip-input", ["cmatChipInput"], { "id": { "alias": "id"; "required": false; }; "selectableOptions": { "alias": "selectableOptions"; "required": false; }; "hasAutocomplete": { "alias": "hasAutocomplete"; "required": false; }; "outputIsString": { "alias": "outputIsString"; "required": false; }; "separatorKey": { "alias": "separatorKey"; "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>;
+}
+
+declare class CmatCodeEditorComponent {
+    value: string;
+    language: string;
+    height: string;
+    readOnly: boolean;
+    options: any;
+    private readonly _document;
+    get model(): NgxEditorModel;
+    get editorOptions(): any;
+    private get _isDarkTheme();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCodeEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatCodeEditorComponent, "cmat-code-editor", never, { "value": { "alias": "value"; "required": false; }; "language": { "alias": "language"; "required": false; }; "height": { "alias": "height"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function addonsExtension(field: FormlyFieldConfig): void;
+
+declare class CmatAddonsWrapperComponent extends FieldWrapper implements AfterViewInit {
+    matPrefix: TemplateRef<any>;
+    matSuffix: TemplateRef<any>;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatAddonsWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatAddonsWrapperComponent, "cmat-addons-wrapper", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatCardWrapperComponent extends FieldWrapper {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCardWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatCardWrapperComponent, "cmat-card-wrapper", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatExpansionWrapperComponent extends FieldWrapper {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatExpansionWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatExpansionWrapperComponent, "cmat-expansion-wrapper", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatPanelWrapperComponent extends FieldWrapper {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPanelWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatPanelWrapperComponent, "cmat-panel-wrapper", never, {}, {}, never, never, true, never>;
+}
+
+interface MatFormlyFieldConfig extends FormlyFieldConfig<CustomFormFieldProps> {
+    _formField?: CmatFormFieldWrapperComponent;
+}
+interface CustomFormFieldProps extends FormlyFieldProps {
+    showValidationMessage?: boolean;
+}
+declare class CmatFormFieldWrapperComponent extends FieldWrapper<MatFormlyFieldConfig> implements OnInit, OnDestroy, AfterViewInit {
+    formField: MatFormField;
+    private _renderer;
+    private _elementRef;
+    private _focusMonitor;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatFormFieldWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatFormFieldWrapperComponent, "cmat-form-field-wrapper", never, {}, {}, never, never, true, never>;
+}
+
+interface ButtonProps extends CustomFormFieldProps {
+    color?: 'primary' | 'accent' | 'warn';
+    onClick?: any;
+}
+declare class CmatButtonTypeComponent extends FieldType<FieldTypeConfig<ButtonProps>> {
+    defaultOptions: {
+        props: {
+            color: "primary";
+        };
+    };
+    constructor();
+    onClick($event: Event): void;
+    private _executeFunctionFromString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatButtonTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatButtonTypeComponent, "cmat-button-type", never, {}, {}, never, never, true, never>;
+}
+
+interface ChipsCascadeProps extends CustomFormFieldProps {
+    clearable: boolean;
+    fullLevels: boolean;
+    changeOnSelect: boolean;
+    domain?: {
+        url?: string;
+        code?: string;
+        key?: string;
+        value?: string;
+    };
+}
+declare class CmatCascadeTypeComponent extends FieldType<FieldTypeConfig<ChipsCascadeProps>> implements OnInit {
+    defaultOptions: {
+        props: {
+            clearable: boolean;
+            fullLevels: boolean;
+            changeOnSelect: boolean;
+        };
+    };
+    urlData: [];
+    isHandSet: boolean;
+    private _http;
+    private _changeDetectorRef;
+    private _cmatMediaWatcherService;
+    private readonly _destroyRef;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCascadeTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatCascadeTypeComponent, "cmat-cascade-type", never, {}, {}, never, never, true, never>;
+}
+
+interface CheckListProps extends CustomFormFieldProps {
+    showAllCheck: boolean;
+    controlMaxHeight: boolean;
+    domain?: {
+        url?: string;
+        code?: string;
+        key?: string;
+        value?: string;
+    };
+}
+declare class CmatCheckListTypeComponent extends FieldType<FieldTypeConfig<CheckListProps>> implements OnInit {
+    isIndeterminate: boolean;
+    isChecked: boolean;
+    urlData: [];
+    optionsData: any[];
+    checklist: any[];
+    filteredData: any[];
+    private _http;
+    private readonly _destroyRef;
+    private _filteredItems;
+    private readonly _filteredItems$;
+    constructor();
+    get filteredItems$(): Observable<any[] | null>;
+    get datas(): any[];
+    ngOnInit(): void;
+    trackByFn(index: number, item: any): any;
+    filterByQuery(event: any): void;
+    toggleCheckList(data: any, event: any): void;
+    allCheckChange(check: boolean): void;
+    isCheck(data: any): boolean;
+    private _getAllCheckCountState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatCheckListTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatCheckListTypeComponent, "cmat-checklist-type", never, {}, {}, never, never, true, never>;
+}
+
+interface ChipsInputProps extends CustomFormFieldProps {
+    hasAutocomplete?: boolean;
+    autocompleteText?: string;
+    domain?: {
+        url?: string;
+        code?: string;
+        key?: string;
+        value?: string;
+    };
+}
+declare class CmatChipsInputTypeComponent extends FieldType<FieldTypeConfig<ChipsInputProps>> implements OnInit {
+    autocompleteUrlData: [];
+    private _http;
+    private readonly _destroyRef;
+    constructor();
+    get autocompleteText(): string[];
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatChipsInputTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatChipsInputTypeComponent, "cmat-chips-input-type", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatColorPickerTypeComponent extends FieldType$1<FieldTypeConfig> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatColorPickerTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatColorPickerTypeComponent, "cmat-color-picker-type", never, {}, {}, never, never, true, never>;
+}
+
+interface DateRangeProps extends CustomFormFieldProps {
+    dateFormat: string;
+    timeFormat: string;
+    timeRange: boolean;
+}
+declare class CmatDateRangeTypeComponent extends FieldType<FieldTypeConfig<DateRangeProps>> {
+    defaultOptions: {
+        props: {
+            dateFormat: string;
+            timeFormat: string;
+            timeRange: boolean;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDateRangeTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDateRangeTypeComponent, "cmat-date-range-type", never, {}, {}, never, never, true, never>;
+}
+
+interface DatepickerProps extends CustomFormFieldProps {
+    startView: CmatCalendarView$1;
+    mode: CmatDatetimepickerMode$1;
+    togglePosition: 'left' | 'right';
+    timeInterval: number;
+    type: CmatDatetimepickerType$1;
+    multiYearSelector: boolean;
+    twelvehour: boolean;
+    timeInput: boolean;
+}
+declare class CmatDatepickerTypeComponent extends FieldType<FieldTypeConfig<DatepickerProps>> implements OnInit {
+    defaultOptions: {
+        props: {
+            startView: "month";
+            mode: "auto";
+            togglePosition: "left";
+            timeInterval: number;
+            type: "datetime";
+            multiYearSelector: boolean;
+            disabled: boolean;
+            timeInput: boolean;
+            twelvehour: boolean;
+        };
+    };
+    isHandSet: boolean;
+    private _changeDetectorRef;
+    private _cmatMediaWatcherService;
+    private readonly _destroyRef;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatepickerTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatepickerTypeComponent, "cmat-datepicker-type", never, {}, {}, never, never, true, never>;
+}
+
+interface MultiCheckboxProps extends CustomFormFieldProps {
+    labelPosition: 'before' | 'after';
+    domain?: {
+        url?: string;
+        code?: string;
+        key?: string;
+        value?: string;
+    };
+}
+interface FormlyMultiCheckboxFieldConfig extends FormlyFieldConfig<MultiCheckboxProps> {
+    type: 'multicheckbox' | Type$2<CmatMultiCheckboxTypeComponent>;
+}
+declare class CmatMultiCheckboxTypeComponent extends FieldType<FieldTypeConfig<MultiCheckboxProps>> implements OnInit {
+    checkboxes: QueryList<MatCheckbox>;
+    defaultOptions: {
+        props: {
+            hideFieldUnderline: boolean;
+            floatLabel: "always";
+            color: "accent";
+            labelPosition: "after";
+        };
+    };
+    private _http;
+    private readonly _destroyRef;
+    private _urlData;
+    private readonly _urlData$;
+    constructor();
+    get urlData$(): Observable<any[]>;
+    onChange(value: any, checked: boolean): void;
+    ngOnInit(): void;
+    isChecked(option: any): any;
+    trackByFn(index: number): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatMultiCheckboxTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatMultiCheckboxTypeComponent, "cmat-multicheckbox-type", never, {}, {}, never, never, true, never>;
+}
+
+interface NumberProps extends CustomFormFieldProps {
+    decimal: boolean;
+    min: number;
+    max: number;
+}
+declare class CmatNumberTypeComponent extends FieldType<FieldTypeConfig<NumberProps>> {
+    defaultOptions: {
+        props: {
+            decimal: boolean;
+            min: number;
+            max: number;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatNumberTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatNumberTypeComponent, "cmat-number-type", never, {}, {}, never, never, true, never>;
+}
+
+interface RatingProps extends CustomFormFieldProps {
+    stars: number;
+    readonly: boolean;
+    hover: boolean;
+    half: boolean;
+    customColor?: string;
+    showMode?: 'horizontal' | 'vertical';
+}
+declare class CmatRatingTypeComponent extends FieldType<FieldTypeConfig<RatingProps>> {
+    defaultOptions: {
+        props: {
+            stars: number;
+            readonly: boolean;
+            hover: boolean;
+            half: boolean;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatRatingTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatRatingTypeComponent, "cmat-rating-type", never, {}, {}, never, never, true, never>;
+}
+
+interface RadioProps extends CustomFormFieldProps {
+    labelPosition: 'before' | 'after';
+    domain?: {
+        url?: string;
+        code?: string;
+        key?: string;
+        value?: string;
+    };
+}
+interface FormlyRadioFieldConfig extends FormlyFieldConfig<RadioProps> {
+    type: 'radio' | Type$2<CmatRadioTypeComponent>;
+}
+declare class CmatRadioTypeComponent extends FieldType<FieldTypeConfig<RadioProps>> implements OnInit, AfterViewInit {
+    radioGroup: MatRadioGroup;
+    defaultOptions: {
+        props: {
+            hideFieldUnderline: boolean;
+            floatLabel: "always";
+            tabindex: number;
+            labelPosition: "after";
+        };
+    };
+    private _http;
+    private focusObserver;
+    private _urlData;
+    private readonly _destroyRef;
+    private readonly _urlData$;
+    constructor();
+    get urlData$(): Observable<any[]>;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    trackByFn(index: number): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatRadioTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatRadioTypeComponent, "cmat-radio-type", never, {}, {}, never, never, true, never>;
+}
+
+interface RepeatProps extends CustomFormFieldProps {
+    addText: string;
+}
+declare class CmatRepeatTypeComponent extends FieldArrayType<FieldTypeConfig<RepeatProps>> {
+    defaultOptions: {
+        props: {
+            addText: string;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatRepeatTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatRepeatTypeComponent, "cmat-repeat-type", never, {}, {}, never, never, true, never>;
+}
+
+interface SelectProps extends CustomFormFieldProps, FormlyFieldSelectProps {
+    multiple?: boolean;
+    disableOptionCentering?: boolean;
+    typeaheadDebounceInterval?: number;
+    search: boolean;
+    canNull: boolean;
+    showToggleAllCheckbox: boolean;
+    domain?: {
+        url?: string;
+        code?: string;
+        key?: string;
+        value?: string;
+    };
+}
+declare class CmatSelectTypeComponent extends FieldType<FieldTypeConfig<SelectProps>> implements OnInit, OnDestroy {
+    defaultOptions: {
+        props: {
+            search: boolean;
+            canNull: boolean;
+            showToggleAllCheckbox: boolean;
+        };
+    };
+    optionsData: any[];
+    filteredCustomDetails: ReplaySubject<any[]>;
+    filteredCache: any[];
+    isIndeterminate: boolean;
+    isChecked: boolean;
+    multiFilterCtrl: FormControl;
+    private _http;
+    private readonly _destroyRef;
+    private _urlData;
+    constructor();
+    get datas(): any[];
+    ngOnInit(): void;
+    getAriaLabelledby(): string;
+    getAriaLabel(): string;
+    toggleSelectAll(selectAllValue: boolean): void;
+    filterMulti(): void;
+    setToggleAllCheckboxState(): void;
+    compareWithFn(o1: any, o2: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSelectTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatSelectTypeComponent, "cmat-select-search-type", never, {}, {}, never, never, true, never>;
+}
+
+interface SelectTreeProps extends CustomFormFieldProps, FormlyFieldSelectProps {
+    multiple: boolean;
+    search: boolean;
+    canNull: boolean;
+    showToggleAllCheckbox: boolean;
+    expandable: boolean;
+    customTriggerLabelTemplate: string;
+    domain?: {
+        url?: string;
+        code?: string;
+        key?: string;
+        value?: string;
+    };
+}
+declare class CmatSelectTreeTypeComponent extends FieldType$1<FieldTypeConfig<SelectTreeProps>> implements OnInit, OnDestroy {
+    defaultOptions: {
+        props: {
+            multiple: boolean;
+            search: boolean;
+            canNull: boolean;
+            showToggleAllCheckbox: boolean;
+            expandable: boolean;
+            customTriggerLabelTemplate: string;
+        };
+    };
+    urlData: [];
+    private _http;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSelectTreeTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatSelectTreeTypeComponent, "cmat-select-tree-type", never, {}, {}, never, never, true, never>;
+}
+
+interface SelectTableProps extends CustomFormFieldProps, FormlyFieldSelectProps {
+    multiple: boolean;
+    search: boolean;
+    canNull: boolean;
+    customTriggerLabelTemplate: string;
+    domain?: {
+        url?: string;
+        code?: string;
+        key?: string;
+        value?: string;
+    };
+}
+declare class CmatSelectTableTypeComponent extends FieldType$1<FieldTypeConfig<SelectTableProps>> implements OnInit, OnDestroy {
+    defaultOptions: {
+        props: {
+            multiple: boolean;
+            search: boolean;
+            canNull: boolean;
+            customTriggerLabelTemplate: string;
+        };
+    };
+    urlData: CmatSelectTableDataSource$1<CmatSelectTableRow$1>;
+    private _http;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSelectTableTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatSelectTableTypeComponent, "cmat-select-table-type", never, {}, {}, never, never, true, never>;
+}
+
+interface StepperProps extends CustomFormFieldProps {
+    isEditable?: boolean;
+    isLinear?: boolean;
+    isOptional?: boolean;
+}
+
+declare class CmatStepperHorizontalTypeComponent extends FieldType$2<FieldTypeConfig<StepperProps>> {
+    isValid(field: FormlyFieldConfig): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatStepperHorizontalTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatStepperHorizontalTypeComponent, "cmat-stepper-horizontal-type", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatStepperVerticalTypeComponent extends FieldType$2<FieldTypeConfig<StepperProps>> {
+    isValid(field: FormlyFieldConfig): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatStepperVerticalTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatStepperVerticalTypeComponent, "cmat-stepper-vertical-type", never, {}, {}, never, never, true, never>;
+}
+
+interface TableProps extends CustomFormFieldProps {
+    addText: string;
+    showColumn?: boolean;
+}
+declare class CmatTableTypeComponent extends FieldArrayType<FieldTypeConfig<TableProps>> implements OnInit {
+    dialogRef: TemplateRef<any>;
+    table: MatTable<any>;
+    inlineform: FormGroup<{}>;
+    currentMode: any;
+    currentIndex: number;
+    columns: {
+        key: string;
+        label: string;
+    }[];
+    displayedColumns: string[];
+    dialogType: 'add' | 'edit' | '';
+    defaultOptions: {
+        props: {
+            addText: string;
+        };
+    };
+    private _changeDetectorRef;
+    private readonly _dialog;
+    private readonly _viewContainerRef;
+    private _dialogRef;
+    constructor();
+    get fieldArray(): FormlyFieldConfig[];
+    get key(): string;
+    ngOnInit(): void;
+    addRow(): void;
+    editRow(item: any, index: number): void;
+    deleteRow(id: number): void;
+    confirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTableTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTableTypeComponent, "cmat-table-type", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatTabTypeComponent extends FieldType$1<FieldTypeConfig> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTabTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTabTypeComponent, "cmat-tab-type", never, {}, {}, never, never, true, never>;
+}
+
+interface TagsProps extends CustomFormFieldProps {
+    domain?: {
+        url?: string;
+        code?: string;
+        key?: string;
+        value?: string;
+    };
+}
+declare class CmatTagsTypeComponent extends FieldType<FieldTypeConfig<TagsProps>> implements OnInit {
+    private _tagsPanelOrigin;
+    private _tagsPanel;
+    urlData: [];
+    optionsData: any[];
+    private _http;
+    private _overlay;
+    private _viewContainerRef;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    private _filteredItems;
+    private readonly _filteredItems$;
+    private _tagsPanelOverlayRef;
+    constructor();
+    get filteredItems$(): Observable<any[] | null>;
+    get tags(): any[];
+    ngOnInit(): void;
+    openTagsPanel(): void;
+    filterTags(event: any): void;
+    toggleTag(tag: any): void;
+    isCheck(tag: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTagsTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTagsTypeComponent, "cmat-tags-type", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatTextareaTypeComponent extends FieldType$1<FieldTypeConfig> {
+    defaultOptions: {
+        props: {
+            cols: number;
+            rows: number;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTextareaTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTextareaTypeComponent, "cmat-textarea-type", never, {}, {}, never, never, true, never>;
+}
+
+interface UploadProps extends CustomFormFieldProps {
+    fileAlias: string;
+    filePath: string;
+    fileCategory: string;
+    multiple: boolean;
+    accept: string;
+    editMode: boolean;
+    autoUpload: boolean;
+}
+declare class CmatUploadTypeComponent extends FieldType<FieldTypeConfig<UploadProps>> implements AfterViewInit {
+    defaultOptions: {
+        props: {
+            fileAlias: string;
+            filePath: string;
+            fileCategory: string;
+            multiple: boolean;
+            accept: string;
+            editMode: boolean;
+            autoUpload: boolean;
+        };
+    };
+    baseGroup: UntypedFormGroup;
+    ngAfterViewInit(): void;
+    upload(id: string): void;
+    remove(id: string): void;
+    updateData(i: any): void;
+    private _getRootControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatUploadTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatUploadTypeComponent, "cmat-upload-type", never, {}, {}, never, never, true, never>;
+}
+
+interface QuillProps extends CustomFormFieldProps {
+    fileAlias: string;
+    filePath: string;
+}
+declare class CmatQuillTypeComponent extends FieldType<FieldTypeConfig<QuillProps>> implements OnDestroy, AfterViewInit {
+    private imgInput;
+    private videoInput;
+    quillModules: QuillModules;
+    defaultOptions: {
+        props: {
+            fileAlias: string;
+            filePath: string;
+        };
+    };
+    baseGroup: UntypedFormGroup;
+    private _fileService;
+    private _urlStateConfigService;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    private _editorInstance;
+    private _imgIds;
+    private _config;
+    constructor();
+    ngAfterViewInit(): void;
+    fileChangeEvent(file: any): void;
+    editorCreated(editorInstance: any): void;
+    contentChanged(editorInstance: any): void;
+    private _imgFileHandler;
+    private _videoFileHandler;
+    private _wordFileHandler;
+    private _convertDeltaToDocxChildren;
+    private _createTextRun;
+    private _createParagraph;
+    private _createImageRun;
+    private _getImageBuffer;
+    private _getImageDimensions;
+    private _base64ToUint8Array;
+    private _mapFontSize;
+    private _mapAlignment;
+    private _parseColor;
+    private _dropFileHandler;
+    private _upload;
+    private _getMediaType;
+    private _getRootControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatQuillTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatQuillTypeComponent, "cmat-quill-type", never, {}, {}, never, never, true, never>;
+}
+
+interface KnobProps extends CustomFormFieldProps {
+    valueColor: string;
+    rangeColor: string;
+    textColor: string;
+    valueTemplate: string;
+    name?: string;
+    size: number;
+    step: number;
+    min: number;
+    max: number;
+    strokeWidth: number;
+    showValue: boolean;
+}
+declare class CmatKnobTypeComponent extends FieldType<FieldTypeConfig<KnobProps>> {
+    defaultOptions: {
+        props: {
+            valueColor: string;
+            rangeColor: string;
+            textColor: string;
+            valueTemplate: string;
+            size: number;
+            step: number;
+            min: number;
+            max: number;
+            strokeWidth: number;
+            showValue: boolean;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatKnobTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatKnobTypeComponent, "cmat-knob-type", never, {}, {}, never, never, true, never>;
+}
+
+interface SliderProps extends CustomFormFieldProps {
+    displayWith?: (value: number) => string;
+    discrete?: boolean;
+    showTickMarks?: boolean;
+    color?: ThemePalette;
+    input?: (field: FormlyFieldConfig<SliderProps>, $event: Event) => void;
+    change?: (field: FormlyFieldConfig<SliderProps>, $event: Event) => void;
+}
+interface FormlySliderFieldConfig extends FormlyFieldConfig<SliderProps> {
+    type: 'slider' | Type$2<CmatSliderTypeComponent>;
+}
+declare class CmatSliderTypeComponent extends FieldType$1<FieldTypeConfig<SliderProps>> {
+    defaultOptions: {
+        props: {
+            hideFieldUnderline: boolean;
+            floatLabel: "always";
+            displayWith: (value: number) => string;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSliderTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatSliderTypeComponent, "cmat-slider-type", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatDateRangeComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    controlClass: string;
+    initData: boolean;
+    readonly rangeChanged: EventEmitter<{
+        start: string;
+        end: string;
+    }>;
+    private _matMonthView1;
+    private _matMonthView2;
+    private _pickerPanelOrigin;
+    private _pickerPanel;
+    activeDates: {
+        month1: Dayjs | null;
+        month2: Dayjs | null;
+    };
+    setWhichDate: 'start' | 'end';
+    startTimeFormControl: FormControl;
+    endTimeFormControl: FormControl;
+    private _overlay;
+    private _viewContainerRef;
+    private _changeDetectorRef;
+    private _dateFormat;
+    private _onChange;
+    private _onTouched;
+    private _programmaticChange;
+    private _range;
+    private _timeFormat;
+    private _timeRange;
+    private _readonly;
+    private readonly _timeRegExp;
+    constructor();
+    get readonly(): boolean;
+    set readonly(value: boolean);
+    get dateFormat(): string;
+    set dateFormat(value: string);
+    get timeFormat(): string;
+    set timeFormat(value: string);
+    get timeRange(): boolean;
+    set timeRange(value: boolean);
+    get range(): any;
+    set range(value: any);
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(range: {
+        start: string;
+        end: string;
+    }): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    openPickerPanel(): void;
+    getMonthLabel(month: number): string | void;
+    dateClass(): any;
+    dateFilter(): any;
+    onSelectedDateChange(date: Dayjs): void;
+    prev(): void;
+    next(): void;
+    updateStartTime(event: any): void;
+    updateEndTime(event: any): void;
+    private _init;
+    private _parseTime;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDateRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDateRangeComponent, "cmat-date-range", ["cmatDateRange"], { "controlClass": { "alias": "controlClass"; "required": false; }; "initData": { "alias": "initData"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "timeFormat": { "alias": "timeFormat"; "required": false; }; "timeRange": { "alias": "timeRange"; "required": false; }; "range": { "alias": "range"; "required": false; }; }, { "rangeChanged": "rangeChanged"; }, never, never, true, never>;
+}
+
+declare class CmatDateTimeDisplayComponent {
+    value: string | number | Date | null | undefined;
+    format: string;
+    timezone: string;
+    prefix: string;
+    emptyText: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDateTimeDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDateTimeDisplayComponent, "cmat-date-time-display", never, { "value": { "alias": "value"; "required": false; }; "format": { "alias": "format"; "required": false; }; "timezone": { "alias": "timezone"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type CmatDrawerMode = 'over' | 'side';
+type CmatDrawerPosition = 'left' | 'right';
+
+declare class CmatDrawerComponent implements OnChanges, OnInit, OnDestroy {
+    static ngAcceptInputType_fixed: BooleanInput;
+    static ngAcceptInputType_opened: BooleanInput;
+    static ngAcceptInputType_transparentOverlay: BooleanInput;
+    fixed: boolean;
+    mode: CmatDrawerMode;
+    name: string;
+    opened: boolean;
+    position: CmatDrawerPosition;
+    transparentOverlay: boolean;
+    readonly fixedChanged: EventEmitter<boolean>;
+    readonly modeChanged: EventEmitter<CmatDrawerMode>;
+    readonly openedChanged: EventEmitter<boolean>;
+    readonly positionChanged: EventEmitter<CmatDrawerPosition>;
+    private _elementRef;
+    private _renderer2;
+    private _cmatDrawerService;
+    private _animationsEnabled;
+    private _hovered;
+    private _overlay;
+    private _overlayClickDestroyFn;
+    private _changeDetectorRef;
+    get classList(): any;
+    get styleList(): any;
+    onMouseenter(): void;
+    onMouseleave(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    private _enableAnimations;
+    private _disableAnimations;
+    private _showOverlay;
+    private _hideOverlay;
+    private _toggleOpened;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDrawerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDrawerComponent, "cmat-drawer", ["cmatDrawer"], { "fixed": { "alias": "fixed"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "name": { "alias": "name"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "position": { "alias": "position"; "required": false; }; "transparentOverlay": { "alias": "transparentOverlay"; "required": false; }; }, { "fixedChanged": "fixedChanged"; "modeChanged": "modeChanged"; "openedChanged": "openedChanged"; "positionChanged": "positionChanged"; }, never, ["*"], true, never>;
+}
+
+declare class CmatDrawerService {
+    private _componentRegistry;
+    registerComponent(name: string, component: CmatDrawerComponent): void;
+    deregisterComponent(name: string): void;
+    getComponent(name: string): CmatDrawerComponent | void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDrawerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatDrawerService>;
+}
+
+declare class CmatEmptyStateComponent {
+    icon: string;
+    title: string;
+    description: string;
+    ctaLabel: string;
+    ctaDisabled: boolean;
+    ctaClick: EventEmitter<void>;
+    emitAction(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatEmptyStateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatEmptyStateComponent, "cmat-empty-state", never, { "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "ctaLabel": { "alias": "ctaLabel"; "required": false; }; "ctaDisabled": { "alias": "ctaDisabled"; "required": false; }; }, { "ctaClick": "ctaClick"; }, never, never, true, never>;
+}
+
+declare class CmatFilePreviewComponent {
+    name: string;
+    description: string;
+    fileType: string;
+    size: string;
+    src: any;
+    previewImage: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatFilePreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatFilePreviewComponent, "cmat-file-preview", never, { "name": { "alias": "name"; "required": false; }; "description": { "alias": "description"; "required": false; }; "fileType": { "alias": "fileType"; "required": false; }; "size": { "alias": "size"; "required": false; }; "src": { "alias": "src"; "required": false; }; "previewImage": { "alias": "previewImage"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CmatFilterToolbarComponent implements OnInit {
+    title: string;
+    description: string;
+    searchPlaceholder: string;
+    showSearch: boolean;
+    searchText: string;
+    clearable: boolean;
+    searchTextChange: EventEmitter<string>;
+    clear: EventEmitter<void>;
+    searchSubmit: EventEmitter<string>;
+    hostClass: string;
+    searchControl: FormControl<string | null>;
+    private readonly _destroyRef;
+    ngOnInit(): void;
+    submitSearch(): void;
+    clearSearch(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatFilterToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatFilterToolbarComponent, "cmat-filter-toolbar", never, { "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "showSearch": { "alias": "showSearch"; "required": false; }; "searchText": { "alias": "searchText"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; }, { "searchTextChange": "searchTextChange"; "clear": "clear"; "searchSubmit": "searchSubmit"; }, never, ["[cmatFilterToolbarActions]"], true, never>;
+}
+
+declare class CmatFormActionsComponent {
+    align: 'start' | 'center' | 'end';
+    divider: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatFormActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatFormActionsComponent, "cmat-form-actions", never, { "align": { "alias": "align"; "required": false; }; "divider": { "alias": "divider"; "required": false; }; }, {}, never, ["[cmatFormActionsLeft]", "[cmatFormActions]"], true, never>;
+}
+
+declare class CmatFullscreenComponent {
+    iconTpl: TemplateRef<any>;
+    tooltip: string;
+    private _document;
+    toggleFullscreen(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatFullscreenComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatFullscreenComponent, "cmat-fullscreen", ["cmatFullscreen"], { "iconTpl": { "alias": "iconTpl"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CmatHighlightComponent implements OnChanges, AfterViewInit {
+    code: string;
+    lang: string;
+    templateRef: TemplateRef<any>;
+    highlightedCode: string | null;
+    private _viewRef;
+    private _domSanitizer;
+    private _elementRef;
+    private _cmatHighlightService;
+    private _viewContainerRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    private _highlightAndInsert;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatHighlightComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatHighlightComponent, "textarea[cmat-highlight]", ["cmatHighlight"], { "code": { "alias": "code"; "required": false; }; "lang": { "alias": "lang"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class CmatHighlightService {
+    highlight(code: string, language: string): string;
+    private _format;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatHighlightService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatHighlightService>;
+}
+
+declare class CmatImageComponent {
+    imageClass: string | undefined;
+    imageStyle: Record<string, any> | null | undefined;
+    src: SafeUrl | undefined;
+    srcSet: SafeUrl | undefined;
+    previewImageSrc: SafeUrl | undefined;
+    previewImageSrcSet: SafeUrl | undefined;
+    alt: string | undefined;
+    width: number | undefined;
+    height: number | undefined;
+    loading: 'lazy' | 'eager' | undefined;
+    appendTo: HTMLElement | ElementRef | TemplateRef<any> | string | null | undefined;
+    preview: boolean;
+    previewShowChange: EventEmitter<boolean>;
+    imageErrorEvent: EventEmitter<Event>;
+    el: ElementRef<any>;
+    maskVisible: boolean;
+    previewVisible: boolean;
+    rotate: number;
+    scale: number;
+    private _loadingPreview;
+    private _closePreviewByEscape;
+    private _document;
+    private _changeDetectorRef;
+    private _originalOverflow;
+    private _zoomSettings;
+    get isZoomOutDisabled(): boolean;
+    get isZoomInDisabled(): boolean;
+    private _mask?;
+    set mask(value: ElementRef<HTMLDivElement> | undefined);
+    private _previewButton?;
+    set previewButton(value: ElementRef<HTMLButtonElement> | undefined);
+    private _closeButton?;
+    set closeButton(value: ElementRef<HTMLButtonElement> | undefined);
+    onKeydownHandler(): void;
+    onImageClick(): void;
+    onMaskKeydown(event: KeyboardEvent): void;
+    onPreviewImageClick(event: MouseEvent): void;
+    rotateRight(): void;
+    rotateLeft(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    handleToolbarClick(event: MouseEvent): void;
+    appendContainer(): void;
+    imagePreviewStyle(): {
+        transform: string;
+    };
+    closePreview(): void;
+    imageError(event: Event): void;
+    private _disableBackgroundScroll;
+    private _enableBackgroundScroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatImageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatImageComponent, "cmat-image", never, { "imageClass": { "alias": "imageClass"; "required": false; }; "imageStyle": { "alias": "imageStyle"; "required": false; }; "src": { "alias": "src"; "required": false; }; "srcSet": { "alias": "srcSet"; "required": false; }; "previewImageSrc": { "alias": "previewImageSrc"; "required": false; }; "previewImageSrcSet": { "alias": "previewImageSrcSet"; "required": false; }; "alt": { "alias": "alt"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "preview": { "alias": "preview"; "required": false; }; }, { "previewShowChange": "previewShowChange"; "imageErrorEvent": "imageErrorEvent"; }, never, never, true, never>;
+    static ngAcceptInputType_preview: unknown;
+}
+
+declare class CmatInlineLoadingComponent {
+    message: string;
+    diameter: number;
+    showText: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatInlineLoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatInlineLoadingComponent, "cmat-inline-loading", never, { "message": { "alias": "message"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "showText": { "alias": "showText"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CmatJsonEditorComponent implements OnInit, OnChanges, OnDestroy {
+    options: any;
+    data: any;
+    contentChanged: EventEmitter<any>;
+    pathChanged: EventEmitter<string>;
+    id: string;
+    content: Content$1;
+    private _editor?;
+    private _jsonEditorContainer?;
+    private _destroyed;
+    private readonly _document;
+    private _changeDetectorRef;
+    get darkTheme(): boolean;
+    private get _isDarkTheme();
+    set jsonEditorContainer(value: ElementRef | undefined);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    setSchema(schema: any): void;
+    setSelectionToPath(pathString: string): void;
+    get(): JSON | undefined;
+    set(json: any): void;
+    private _onSelect;
+    private _initializeEditor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatJsonEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatJsonEditorComponent, "cmat-json-editor", never, { "options": { "alias": "options"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "contentChanged": "contentChanged"; "pathChanged": "pathChanged"; }, never, never, true, never>;
+}
+
+declare class CmatKnobInputComponent implements MatFormFieldControl<any>, OnDestroy, ControlValueAccessor {
+    private _knobElementRef;
+    id: string;
+    valueColor: string;
+    rangeColor: string;
+    textColor: string;
+    valueTemplate: string;
+    name: string | undefined;
+    size: number;
+    step: number;
+    min: number;
+    max: number;
+    strokeWidth: number;
+    showValue: boolean;
+    valueChange: EventEmitter<number | null>;
+    radius: number;
+    midX: number;
+    midY: number;
+    minRadians: number;
+    maxRadians: number;
+    windowMouseMoveListener: VoidFunction | null;
+    windowMouseUpListener: VoidFunction | null;
+    windowTouchMoveListener: VoidFunction | null;
+    windowTouchEndListener: VoidFunction | null;
+    readonly stateChanges: Subject<void>;
+    focused: boolean;
+    touched: boolean;
+    ngControl: NgControl;
+    private _document;
+    private _renderer;
+    private _changeDetectorRef;
+    private _el;
+    constructor();
+    ngOnDestroy(): void;
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    get value(): number;
+    set value(value: number);
+    protected _value: number | null;
+    get empty(): boolean;
+    get errorState(): boolean;
+    get shouldLabelFloat(): boolean;
+    get required(): boolean;
+    set required(value: boolean);
+    protected _required: boolean;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    protected _disabled: boolean;
+    onKeyDown(event: Event): void;
+    onMouseDown(event: MouseEvent): void;
+    onMouseUp(event: MouseEvent): void;
+    onTouchStart(event: TouchEvent): void;
+    onTouchEnd(event: TouchEvent): void;
+    mapRange(x: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+    onClick(event: MouseEvent): void;
+    onFocusIn(): void;
+    onFocusOut(event: FocusEvent): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    updateValue(offsetX: number, offsetY: number): void;
+    updateModel(angle: number, start: number): void;
+    onMouseMove(event: MouseEvent): void;
+    onTouchMove(event: Event): void;
+    updateModelValue(newValue: number): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(val: boolean): void;
+    rangePath(): string;
+    valuePath(): string;
+    zeroRadians(): number;
+    valueRadians(): number;
+    minX(): number;
+    minY(): number;
+    maxX(): number;
+    maxY(): number;
+    zeroX(): number;
+    zeroY(): number;
+    valueX(): number;
+    valueY(): number;
+    largeArc(): number;
+    sweep(): number;
+    valueToDisplay(): string;
+    private _onModelChange;
+    private _onTouchedChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatKnobInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatKnobInputComponent, "cmat-knob-input", ["cmatKnobInput"], { "id": { "alias": "id"; "required": false; }; "valueColor": { "alias": "valueColor"; "required": false; }; "rangeColor": { "alias": "rangeColor"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "valueTemplate": { "alias": "valueTemplate"; "required": false; }; "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; "step": { "alias": "step"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "showValue": { "alias": "showValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+interface MasonryColumn {
+    items: any[];
+}
+declare class CmatMasonryComponent implements OnChanges, AfterViewInit {
+    columnsTemplate: TemplateRef<any>;
+    columns: number;
+    items: any[];
+    distributedColumns: MasonryColumn[];
+    private _changeDetectorRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    private _distributeItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatMasonryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatMasonryComponent, "cmat-masonry", ["cmatMasonry"], { "columnsTemplate": { "alias": "columnsTemplate"; "required": true; }; "columns": { "alias": "columns"; "required": true; }; "items": { "alias": "items"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CmatSelectedColor {
+    palette: string;
+    hue: string;
+    color: string;
+}
+
+declare const CMAT_MATERIAL_COLOR_PICKER_VALUE_ACCESSOR: any;
+declare class CmatMaterialColorPickerComponent implements ControlValueAccessor {
+    colorChanged: EventEmitter<any>;
+    palettes: string[];
+    hues: string[];
+    view: string;
+    selectedColor: CmatSelectedColor;
+    selectedPalette: string;
+    selectedHue: string;
+    private _changeDetectorRef;
+    private _color;
+    private _title;
+    private _readonly;
+    private _modelChange;
+    private _modelTouched;
+    constructor();
+    get color(): string;
+    set color(value: string);
+    get title(): string;
+    set title(value: string);
+    get readonly(): boolean;
+    set readonly(value: boolean);
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(color: any): void;
+    selectPalette(palette: string): void;
+    selectHue(hue: string): void;
+    removeColor(): void;
+    updateSelectedColor(): void;
+    goToPalettesView(): void;
+    onMenuOpen(opened: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatMaterialColorPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatMaterialColorPickerComponent, "cmat-material-color-picker", ["cmatMaterialColorPicker"], { "color": { "alias": "color"; "required": false; }; "title": { "alias": "title"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "colorChanged": "colorChanged"; }, never, never, true, never>;
+}
+
+declare enum CmatDatetimepickerFilterType {
+    DATE = 0,
+    HOUR = 1,
+    MINUTE = 2
+}
+
+type CmatDatetimepickerType = 'date' | 'time' | 'month' | 'year' | 'datetime';
+type CmatCalendarView = 'clock' | 'month' | 'year' | 'multi-year';
+type CmatAMPM = 'AM' | 'PM';
+type CmatDatetimepickerMode = 'auto' | 'portrait' | 'landscape';
+type DatetimepickerDropdownPositionX = 'start' | 'end';
+type DatetimepickerDropdownPositionY = 'above' | 'below';
+type CmatClockView = 'hour' | 'minute';
+
+declare const CLOCK_RADIUS = 50;
+declare const CLOCK_INNER_RADIUS = 27.5;
+declare const CLOCK_OUTER_RADIUS = 41.25;
+declare const CLOCK_TICK_RADIUS = 7.0833;
+declare class CmatDatetimepickerClockComponent<D> implements AfterContentInit {
+    userSelection: EventEmitter<void>;
+    dateFilter: (date: D, type: CmatDatetimepickerFilterType) => boolean;
+    interval: number;
+    twelvehour: boolean;
+    selectedChange: EventEmitter<D>;
+    activeDateChange: EventEmitter<D>;
+    role: string;
+    class: string;
+    hours: any[];
+    minutes: any[];
+    hourView: boolean;
+    selectedHour: number;
+    selectedMinute: number;
+    private _element;
+    private _adapter;
+    private _timeChanged;
+    private _mouseMoveListener;
+    private _mouseUpListener;
+    private _activeDate;
+    private _selected;
+    private _minDate;
+    private _maxDate;
+    constructor();
+    get activeDate(): D;
+    set activeDate(value: D);
+    get selected(): D | null;
+    set selected(value: D | null);
+    get minDate(): D | null;
+    set minDate(value: D | null);
+    get maxDate(): D | null;
+    set maxDate(value: D | null);
+    set startView(value: CmatClockView);
+    get hand(): any;
+    handleMousedown(event: MouseEvent): void;
+    ngAfterContentInit(): void;
+    handleMousemove(event: any): void;
+    handleMouseup(): void;
+    private _init;
+    private _setTime;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerClockComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerClockComponent<any>, "cmat-datetimepicker-clock", ["cmatDatetimepickerClock"], { "dateFilter": { "alias": "dateFilter"; "required": false; }; "interval": { "alias": "interval"; "required": false; }; "twelvehour": { "alias": "twelvehour"; "required": false; }; "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "startView": { "alias": "startView"; "required": false; }; }, { "userSelection": "userSelection"; "selectedChange": "selectedChange"; "activeDateChange": "activeDateChange"; }, never, never, true, never>;
+}
+
+declare class CmatDatetimepickerCalendarComponent<D> implements AfterContentInit, OnDestroy {
+    userSelection: EventEmitter<void>;
+    multiYearSelector: boolean;
+    startView: CmatCalendarView;
+    twelvehour: boolean;
+    timeInterval: number;
+    dateFilter: (date: D, type: CmatDatetimepickerFilterType) => boolean;
+    preventSameDateTimeSelection: boolean;
+    selectedChange: EventEmitter<D>;
+    viewChanged: EventEmitter<CmatCalendarView>;
+    class: string;
+    label: string;
+    role: string;
+    tabindex: number;
+    AMPM: CmatAMPM;
+    clockView: CmatClockView;
+    calendarState: string;
+    private _elementRef;
+    private _intl;
+    private _adapter;
+    private _dateFormats;
+    private _changeDetectorRef;
+    private _currentView;
+    private _intlChanges;
+    private _clampedActiveDate;
+    private _type;
+    private _startAt;
+    private _selected;
+    private _minDate;
+    private _maxDate;
+    private _timeInput;
+    private _calendarAnimationListener;
+    constructor();
+    get type(): CmatDatetimepickerType;
+    set type(value: CmatDatetimepickerType);
+    get startAt(): D | null;
+    set startAt(value: D | null);
+    get timeInput(): boolean;
+    set timeInput(value: boolean);
+    get selected(): D | null;
+    set selected(value: D | null);
+    get minDate(): D | null;
+    set minDate(value: D | null);
+    get maxDate(): D | null;
+    set maxDate(value: D | null);
+    get activeDate(): D;
+    set activeDate(value: D);
+    get currentView(): CmatCalendarView;
+    set currentView(view: CmatCalendarView);
+    get yearButtonText(): string;
+    get yearPeriodText(): string;
+    get yearButtonLabel(): string;
+    get dateButtonText(): string;
+    get dateButtonLabel(): string;
+    get hoursButtonText(): string;
+    get hourButtonLabel(): string;
+    get minutesButtonText(): string;
+    get minuteButtonLabel(): string;
+    get prevButtonLabel(): string;
+    get nextButtonLabel(): string;
+    handleCalendarBodyKeydown(event: KeyboardEvent): void;
+    dateFilterForViews: (date: D) => boolean;
+    userSelected(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    dateSelected(date: D): void;
+    monthSelected(month: D): void;
+    yearSelected(year: D): void;
+    timeSelected(date: D): void;
+    dialTimeSelected(date: D): void;
+    onActiveDateChange(date: D): void;
+    updateDate(date: D): D;
+    selectAMPM(date: D): void;
+    ampmClicked(source: CmatAMPM): void;
+    yearClicked(): void;
+    dateClicked(): void;
+    hoursClicked(): void;
+    minutesClicked(): void;
+    previousClicked(): void;
+    nextClicked(): void;
+    previousEnabled(): boolean;
+    nextEnabled(): boolean;
+    focusActiveCell(): void;
+    calendarStateDone(event: AnimationEvent): void;
+    private _isSameView;
+    private _handleCalendarBodyKeydownInMonthView;
+    private _handleCalendarBodyKeydownInYearView;
+    private _handleCalendarBodyKeydownInMultiYearView;
+    private _handleCalendarBodyKeydownInClockView;
+    private _prevMonthInSameCol;
+    private _nextMonthInSameCol;
+    private _changeCalendarState;
+    private _2digit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerCalendarComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerCalendarComponent<any>, "cmat-datetimepicker-calendar", ["cmatDatetimepickerCalendar"], { "multiYearSelector": { "alias": "multiYearSelector"; "required": false; }; "startView": { "alias": "startView"; "required": false; }; "twelvehour": { "alias": "twelvehour"; "required": false; }; "timeInterval": { "alias": "timeInterval"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "preventSameDateTimeSelection": { "alias": "preventSameDateTimeSelection"; "required": false; }; "type": { "alias": "type"; "required": false; }; "startAt": { "alias": "startAt"; "required": false; }; "timeInput": { "alias": "timeInput"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "userSelection": "userSelection"; "selectedChange": "selectedChange"; "viewChanged": "viewChanged"; }, never, never, true, never>;
+}
+
+declare class CmatDatetimepickerCalendarCellComponent {
+    value: number;
+    displayValue: string;
+    ariaLabel: string;
+    enabled: boolean;
+    constructor(value: number, displayValue: string, ariaLabel: string, enabled: boolean);
+}
+declare class CmatDatetimepickerCalendarBodyComponent {
+    label: string;
+    rows: CmatDatetimepickerCalendarCellComponent[][];
+    todayValue: number | null;
+    selectedValue: number | null;
+    labelMinRequiredCells: number;
+    numCols: number;
+    allowDisabledSelection: boolean;
+    activeCell: number;
+    selectedValueChange: EventEmitter<number>;
+    class: string;
+    get _firstRowOffset(): number;
+    cellClicked(cell: CmatDatetimepickerCalendarCellComponent): void;
+    isActiveCell(rowIndex: number, colIndex: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerCalendarBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerCalendarBodyComponent, "[cmat-datetimepicker-calendar-body]", ["cmatDatetimepickerCalendarBody"], { "label": { "alias": "label"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "todayValue": { "alias": "todayValue"; "required": false; }; "selectedValue": { "alias": "selectedValue"; "required": false; }; "labelMinRequiredCells": { "alias": "labelMinRequiredCells"; "required": false; }; "numCols": { "alias": "numCols"; "required": false; }; "allowDisabledSelection": { "alias": "allowDisabledSelection"; "required": false; }; "activeCell": { "alias": "activeCell"; "required": false; }; }, { "selectedValueChange": "selectedValueChange"; }, never, never, true, never>;
+}
+
+declare const CMAT_DATETIMEPICKER_VALUE_ACCESSOR: any;
+declare const CMAT_DATETIMEPICKER_VALIDATORS: any;
+declare class CmatDatetimepickerInputEvent<D> {
+    target: CmatDatetimepickerInputDirective<D>;
+    targetElement: HTMLElement;
+    value: D | null;
+    constructor(target: CmatDatetimepickerInputDirective<D>, targetElement: HTMLElement);
+}
+declare class CmatDatetimepickerInputDirective<D> implements AfterContentInit, ControlValueAccessor, OnDestroy, Validator {
+    dateChange: EventEmitter<CmatDatetimepickerInputEvent<D>>;
+    dateInput: EventEmitter<CmatDatetimepickerInputEvent<D>>;
+    datetimepicker: CmatDatetimepickerComponent<D>;
+    dateFilter: (date: D | null, type: CmatDatetimepickerFilterType) => boolean;
+    valueChange: EventEmitter<D | null>;
+    disabledChange: EventEmitter<boolean>;
+    private _elementRef;
+    private _dateAdapter;
+    private _dateFormats;
+    private _formField;
+    private _datepickerSubscription;
+    private _localeSubscription;
+    private _lastValueValid;
+    private _value;
+    private _min;
+    private _max;
+    private _disabled;
+    constructor();
+    set cmatDatetimepicker(value: CmatDatetimepickerComponent<D>);
+    set cmatDatepickerFilter(filter: (date: D | null, type: CmatDatetimepickerFilterType) => boolean);
+    get value(): D | null;
+    set value(value: D | null);
+    get min(): D | null;
+    set min(value: D | null);
+    get max(): D | null;
+    set max(value: D | null);
+    get disabled(): boolean;
+    set disabled(value: any);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    registerOnValidatorChange(fn: VoidFunction): void;
+    validate(c: AbstractControl): ValidationErrors | null;
+    getConnectedOverlayOrigin(): ElementRef;
+    getOverlayLabelId(): string | null;
+    writeValue(value: D): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: VoidFunction): void;
+    setDisabledState(disabled: boolean): void;
+    onKeydown(event: KeyboardEvent): void;
+    onInput(value: string): void;
+    onChange(): void;
+    onBlur(): void;
+    getThemePalette(): ThemePalette;
+    private _registerDatetimepicker;
+    private _getDisplayFormat;
+    private _getParseFormat;
+    private _onTouched;
+    private _cvaOnChange;
+    private _validatorOnChange;
+    private _parseValidator;
+    private _minValidator;
+    private _maxValidator;
+    private _filterValidator;
+    private _validator;
+    private _formatValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerInputDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDatetimepickerInputDirective<any>, "input[cmatDatetimepicker]", ["cmatDatepickerInput"], { "cmatDatetimepicker": { "alias": "cmatDatetimepicker"; "required": false; }; "cmatDatepickerFilter": { "alias": "cmatDatepickerFilter"; "required": false; }; "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "dateChange": "dateChange"; "dateInput": "dateInput"; }, never, never, true, never>;
+}
+
+declare const CMAT_DATETIMEPICKER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+declare function CMAT_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+declare const CMAT_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof CMAT_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY;
+};
+declare class CmatDatetimepickerContentComponent<D> implements OnInit, AfterContentInit, OnDestroy {
+    _calendar: CmatDatetimepickerCalendarComponent<D>;
+    color: ThemePalette;
+    datetimepicker: CmatDatetimepickerComponent<D>;
+    isAbove: boolean;
+    animationState: 'enter-dropdown' | 'enter-dialog' | 'leave';
+    readonly animationDone: Subject<void>;
+    dialogLabelId: string | null;
+    protected _elementRef: ElementRef<any>;
+    private _changeDetectorRef;
+    private _animationEndListener;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    startExitAnimation(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerContentComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerContentComponent<any>, "cmat-datetimepicker-content", ["cmatDatetimepickerContent"], { "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class CmatDatetimepickerComponent<D> implements OnDestroy {
+    startView: CmatCalendarView;
+    mode: CmatDatetimepickerMode;
+    timeInterval: number;
+    preventSameDateTimeSelection: boolean;
+    xPosition: DatetimepickerDropdownPositionX;
+    yPosition: DatetimepickerDropdownPositionY;
+    selectedChanged: EventEmitter<D>;
+    openedStream: EventEmitter<void>;
+    closedStream: EventEmitter<void>;
+    viewChanged: EventEmitter<CmatCalendarView>;
+    id: string;
+    datetimepickerInput: CmatDatetimepickerInputDirective<D>;
+    disabledChange: Subject<boolean>;
+    private _overlay;
+    private _injector;
+    private _viewContainerRef;
+    private _scrollStrategy;
+    private _dateAdapter;
+    private _dir;
+    private _document;
+    private _validSelected;
+    private _overlayRef;
+    private _componentRef;
+    private _focusedElementBeforeOpen;
+    private _backdropHarnessClass;
+    private _inputStateChanges;
+    private _multiYearSelector;
+    private _twelvehour;
+    private _panelClass;
+    private _opened;
+    private _color;
+    private _startAt;
+    private _type;
+    private _touchUi;
+    private _disabled;
+    private _timeInput;
+    private _restoreFocus;
+    constructor();
+    get multiYearSelector(): boolean;
+    set multiYearSelector(value: boolean);
+    get twelvehour(): boolean;
+    set twelvehour(value: boolean);
+    get panelClass(): string | string[];
+    set panelClass(value: string | string[]);
+    get opened(): boolean;
+    set opened(value: boolean);
+    get color(): ThemePalette;
+    set color(value: ThemePalette);
+    get startAt(): D | null;
+    set startAt(date: D | null);
+    get type(): CmatDatetimepickerType;
+    set type(value: CmatDatetimepickerType);
+    get timeInput(): boolean;
+    set timeInput(value: boolean);
+    get touchUi(): boolean;
+    set touchUi(value: boolean);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get restoreFocus(): boolean;
+    set restoreFocus(value: boolean);
+    get selected(): D | null;
+    set selected(value: D | null);
+    get minDate(): D | null;
+    get maxDate(): D | null;
+    get dateFilter(): (date: D | null, type: CmatDatetimepickerFilterType) => boolean;
+    ngOnDestroy(): void;
+    registerInput(input: CmatDatetimepickerInputDirective<D>): void;
+    open(): void;
+    close(): void;
+    select(date: D): void;
+    viewChange(type: CmatCalendarView): void;
+    private _forwardContentValues;
+    private _openOverlay;
+    private _destroyOverlay;
+    private _getDialogStrategy;
+    private _getDropdownStrategy;
+    private _setConnectedPositions;
+    private _getCloseStream;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerComponent<any>, "cmat-datetimepicker", ["cmatDatetimepicker"], { "startView": { "alias": "startView"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "timeInterval": { "alias": "timeInterval"; "required": false; }; "preventSameDateTimeSelection": { "alias": "preventSameDateTimeSelection"; "required": false; }; "xPosition": { "alias": "xPosition"; "required": false; }; "yPosition": { "alias": "yPosition"; "required": false; }; "multiYearSelector": { "alias": "multiYearSelector"; "required": false; }; "twelvehour": { "alias": "twelvehour"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "color": { "alias": "color"; "required": false; }; "startAt": { "alias": "startAt"; "required": false; }; "type": { "alias": "type"; "required": false; }; "timeInput": { "alias": "timeInput"; "required": false; }; "touchUi": { "alias": "touchUi"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; }; }, { "selectedChanged": "selectedChanged"; "openedStream": "openedStream"; "closedStream": "closedStream"; "viewChanged": "viewChanged"; }, never, never, true, never>;
+}
+
+declare class CmatDatetimepickerIntl {
+    readonly changes: Subject<void>;
+    calendarLabel: string;
+    openCalendarLabel: string;
+    closeCalendarLabel: string;
+    prevMonthLabel: string;
+    nextMonthLabel: string;
+    prevYearLabel: string;
+    nextYearLabel: string;
+    prevMultiYearLabel: string;
+    nextMultiYearLabel: string;
+    switchToMonthViewLabel: string;
+    switchToYearViewLabel: string;
+    switchToMultiYearViewLabel: string;
+    startDateLabel: string;
+    endDateLabel: string;
+    switchToClockHourViewLabel: string;
+    switchToClockMinuteViewLabel: string;
+    okLabel: string;
+    cancelLabel: string;
+    formatYearRange(start: string, end: string): string;
+    formatYearRangeLabel(start: string, end: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatDatetimepickerIntl>;
+}
+
+declare class CmatDatetimepickerToggleIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerToggleIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDatetimepickerToggleIconDirective, "[cmatDatetimepickerToggleIcon]", never, {}, {}, never, never, true, never>;
+}
+declare class CmatDatetimepickerToggleComponent<D> implements AfterContentInit, OnChanges, OnDestroy {
+    datetimepicker: CmatDatetimepickerComponent<D>;
+    tabIndex: number;
+    ariaLabel?: string;
+    disableRipple: boolean;
+    customIcon: CmatDatetimepickerToggleIconDirective;
+    button: MatButton;
+    class: string;
+    protected intl: CmatDatetimepickerIntl;
+    private _stateChanges;
+    private _disabled;
+    private _changeDetectorRef;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    open(event: Event): void;
+    private _watchStateChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerToggleComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerToggleComponent<any>, "cmat-datetimepicker-toggle", ["cmatDatetimepickerToggle"], { "datetimepicker": { "alias": "for"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["customIcon"], ["[cmatDatetimepickerToggleIcon]"], true, never>;
+}
+
+declare class CmatDatetimepickerMonthViewComponent<D> implements AfterContentInit, OnDestroy {
+    type: CmatDatetimepickerType;
+    userSelection: EventEmitter<void>;
+    dateFilter: (date: D) => boolean;
+    selectedChange: EventEmitter<D>;
+    weeks: CmatDatetimepickerCalendarCellComponent[][];
+    firstWeekOffset: number;
+    selectedDate: number | null;
+    todayDate: number | null;
+    weekdays: {
+        long: string;
+        narrow: string;
+    }[];
+    calendarState: string;
+    adapter: DatetimeAdapter$1<D>;
+    private _dateFormats;
+    private _activeDate;
+    private _selected;
+    private _elementRef;
+    private _changeDetectorRef;
+    private _calendarAnimationListener;
+    constructor();
+    get activeDate(): D;
+    set activeDate(value: D);
+    get selected(): D;
+    set selected(value: D);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    dateSelected(date: number): void;
+    calendarStateDone(event: AnimationEvent): void;
+    private _init;
+    private _createWeekCells;
+    private _getDateInCurrentMonth;
+    private _changeCalendarState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerMonthViewComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerMonthViewComponent<any>, "cmat-datetimepicker-month-view", ["cmatDatetimepickerMonthView"], { "type": { "alias": "type"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "userSelection": "userSelection"; "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+
+declare class CmatDatetimepickerYearViewComponent<D> implements AfterContentInit, OnDestroy {
+    userSelection: EventEmitter<void>;
+    type: CmatDatetimepickerType;
+    dateFilter: (date: D) => boolean;
+    selectedChange: EventEmitter<D>;
+    months: CmatDatetimepickerCalendarCellComponent[][];
+    yearLabel: string;
+    todayMonth: number | null;
+    selectedMonth: number | null;
+    calendarState: string;
+    adapter: DatetimeAdapter$1<D>;
+    private _dateFormats;
+    private _activeDate;
+    private _selected;
+    private _changeDetectorRef;
+    private _elementRef;
+    private _calendarAnimationListener;
+    constructor();
+    get activeDate(): D;
+    set activeDate(value: D);
+    get selected(): D;
+    set selected(value: D);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    monthSelected(month: number): void;
+    calendarStateDone(event: AnimationEvent): void;
+    private _init;
+    private _getMonthInCurrentYear;
+    private _createCellForMonth;
+    private _isMonthEnabled;
+    private _changeCalendarState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerYearViewComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerYearViewComponent<any>, "cmat-datetimepicker-year-view", ["cmatDatetimepickerYearView"], { "type": { "alias": "type"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "userSelection": "userSelection"; "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+
+declare class CmatNavigationItem {
+    id?: string;
+    title?: string;
+    subTitle?: string;
+    type: 'aside' | 'basic' | 'collapsable' | 'divider' | 'group' | 'spacer';
+    hidden?: (item: CmatNavigationItem) => boolean;
+    active?: boolean;
+    disabled?: boolean;
+    tooltip?: string;
+    link?: string;
+    externalLink?: boolean;
+    target?: '_blank' | '_self' | '_parent' | '_top';
+    exactMatch?: boolean;
+    isActiveMatchOptions?: IsActiveMatchOptions;
+    function?: (item: CmatNavigationItem) => void;
+    classes?: {
+        title?: string;
+        subtitle?: string;
+        icon?: string;
+        wrapper?: string;
+    };
+    icon?: string;
+    badge?: {
+        title?: string;
+        classes?: string;
+    };
+    children?: CmatNavigationItem[];
+    meta?: unknown;
+    permission?: unknown;
+}
+interface CmatNavigationComponent {
+    close(): void;
+    open(): void;
+    toggle(): void;
+}
+type CmatVerticalNavigationAppearance = 'default' | 'compact' | 'dense' | 'thin';
+type CmatVerticalNavigationMode = 'over' | 'side';
+type CmatVerticalNavigationPosition = 'left' | 'right';
+
+declare class CmatHorizontalNavigationComponent implements OnChanges, OnInit, OnDestroy {
+    name: string;
+    navigation: CmatNavigationItem[];
+    hasRouteReuseStrategy: boolean;
+    readonly routeReuseStrategyEmitUrl: EventEmitter<string>;
+    onRefreshed: ReplaySubject<boolean>;
+    private _changeDetectorRef;
+    private _cmatNavigationService;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    refresh(): void;
+    trackByFn(index: number, item: any): any;
+    goToRouterLink(link: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatHorizontalNavigationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatHorizontalNavigationComponent, "cmat-horizontal-navigation", ["cmatHorizontalNavigation"], { "name": { "alias": "name"; "required": false; }; "navigation": { "alias": "navigation"; "required": false; }; "hasRouteReuseStrategy": { "alias": "hasRouteReuseStrategy"; "required": false; }; }, { "routeReuseStrategyEmitUrl": "routeReuseStrategyEmitUrl"; }, never, never, true, never>;
+}
+
+declare class CmatVerticalNavigationComponent implements OnChanges, OnInit, AfterViewInit, OnDestroy {
+    static ngAcceptInputType_inner: BooleanInput;
+    static ngAcceptInputType_opened: BooleanInput;
+    static ngAcceptInputType_transparentOverlay: BooleanInput;
+    classList: string;
+    styleList: string;
+    private _navigationContentEl;
+    appearance: CmatVerticalNavigationAppearance;
+    autoCollapse: boolean;
+    editState: boolean;
+    inner: boolean;
+    mode: CmatVerticalNavigationMode;
+    name: string;
+    navigation: CmatNavigationItem[];
+    opened: boolean;
+    position: CmatVerticalNavigationPosition;
+    transparentOverlay: boolean;
+    hasRouteReuseStrategy: boolean;
+    readonly routeReuseStrategyEmitUrl: EventEmitter<string>;
+    readonly appearanceChanged: EventEmitter<CmatVerticalNavigationAppearance>;
+    readonly modeChanged: EventEmitter<CmatVerticalNavigationMode>;
+    readonly openedChanged: EventEmitter<boolean>;
+    readonly positionChanged: EventEmitter<CmatVerticalNavigationPosition>;
+    readonly editSelectedItemChanged: EventEmitter<CmatNavigationItem>;
+    activeAsideItemId: string | null;
+    onCollapsableItemCollapsed: ReplaySubject<CmatNavigationItem>;
+    onCollapsableItemExpanded: ReplaySubject<CmatNavigationItem>;
+    onRefreshed: ReplaySubject<boolean>;
+    private _changeDetectorRef;
+    private _elementRef;
+    private _renderer2;
+    private _router;
+    private _scrollStrategyOptions;
+    private _cmatNavigationService;
+    private readonly _cmatUtilsService;
+    private readonly _destroyRef;
+    private _animationsEnabled;
+    private _asideOverlay;
+    private readonly _handleAsideOverlayClick;
+    private readonly _handleOverlayClick;
+    private _hovered;
+    private _overlay;
+    private _scrollStrategy;
+    constructor();
+    onMouseenter(): void;
+    onMouseleave(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    refresh(): void;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    openAside(item: CmatNavigationItem): void;
+    closeAside(): void;
+    toggleAside(item: CmatNavigationItem): void;
+    trackByFn(index: number, item: CmatNavigationItem): string | number;
+    selectItem(item: CmatNavigationItem): void;
+    goToRouterLink(link: string): void;
+    isItemVisible(item: CmatNavigationItem): boolean;
+    private _enableAnimations;
+    private _disableAnimations;
+    private _showOverlay;
+    private _hideOverlay;
+    private _showAsideOverlay;
+    private _hideAsideOverlay;
+    private _toggleOpened;
+    private _setNavigationOpened;
+    private _applyOpenedState;
+    private _setAsideActive;
+    private _removeOverlayElement;
+    private _syncHostBindings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatVerticalNavigationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatVerticalNavigationComponent, "cmat-vertical-navigation", ["cmatVerticalNavigation"], { "appearance": { "alias": "appearance"; "required": false; }; "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "editState": { "alias": "editState"; "required": false; }; "inner": { "alias": "inner"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "name": { "alias": "name"; "required": false; }; "navigation": { "alias": "navigation"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "position": { "alias": "position"; "required": false; }; "transparentOverlay": { "alias": "transparentOverlay"; "required": false; }; "hasRouteReuseStrategy": { "alias": "hasRouteReuseStrategy"; "required": false; }; }, { "routeReuseStrategyEmitUrl": "routeReuseStrategyEmitUrl"; "appearanceChanged": "appearanceChanged"; "modeChanged": "modeChanged"; "openedChanged": "openedChanged"; "positionChanged": "positionChanged"; "editSelectedItemChanged": "editSelectedItemChanged"; }, never, ["[cmatVerticalNavigationHeader]", "[cmatVerticalNavigationContentHeader]", "[cmatVerticalNavigationContentFooter]", "[cmatVerticalNavigationFooter]"], true, never>;
+}
+
+declare class CmatNavigationService {
+    private readonly _componentRegistry;
+    private readonly _navigationStore;
+    registerComponent(name: string, component: unknown): void;
+    deregisterComponent(name: string): void;
+    getComponent<T = unknown>(name: string): T;
+    storeNavigation(key: string, navigation: CmatNavigationItem[]): void;
+    getNavigation(key: string): CmatNavigationItem[];
+    deleteNavigation(key: string): void;
+    getFlatNavigation(navigation: CmatNavigationItem[], flatNavigation?: CmatNavigationItem[]): CmatNavigationItem[];
+    getItem(id: string, navigation: CmatNavigationItem[]): CmatNavigationItem | null;
+    getItemParent(id: string, navigation: CmatNavigationItem[], parent: CmatNavigationItem[] | CmatNavigationItem): CmatNavigationItem[] | CmatNavigationItem | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatNavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatNavigationService>;
+}
+
+declare class OptInputConfig {
+    inputStyles?: Record<string, any>;
+    containerStyles?: Record<string, any>;
+    length: number;
+    allowNumbersOnly?: boolean;
+    inputClass?: string;
+    containerClass?: string;
+    isPasswordInput?: boolean;
+    disableAutoFocus?: boolean;
+    placeholder?: string;
+    letterCase?: 'Upper' | 'Lower';
+    separator?: string;
+    showError?: boolean;
+}
+
+declare class CmatOtpInputComponent implements MatFormFieldControl<any>, AfterViewInit, OnDestroy, OnChanges, ControlValueAccessor {
+    id: string;
+    onBlur: Subject<void>;
+    onInputChange: Subject<string | null>;
+    config: OptInputConfig;
+    otpForm: UntypedFormGroup;
+    currentVal: string | null;
+    componentKey: string;
+    readonly stateChanges: Subject<void>;
+    focused: boolean;
+    ngControl: NgControl;
+    private _document;
+    private _formBuilder;
+    private readonly _destroyRef;
+    private _activeFocusCount;
+    constructor();
+    get inputType(): string;
+    get controlKeys(): string[];
+    get errorState(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    onFocusIn(): void;
+    onFocusOut(): 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 shouldLabelFloat(): boolean;
+    get required(): boolean;
+    set required(value: any);
+    protected _required: boolean;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    protected _disabled: boolean;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    onKeyDown($event: any, inputIdx: number): any;
+    onInput($event: any, inputIdx: number): void;
+    onKeyUp($event: any, inputIdx: number): void;
+    validateNumber(val: string): boolean | string;
+    getBoxId(idx: string | number): string;
+    focusTo(eleId: string): void;
+    setValue(value: any): void;
+    handlePaste(e: any): void;
+    getFormControl(key: string): FormControl;
+    private _onModelChange;
+    private _onTouchedChange;
+    private _getControlName;
+    private _clearInput;
+    private _setSelected;
+    private ifValidKeyCode;
+    private _rebuildValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatOtpInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatOtpInputComponent, "cmat-otp-input", ["cmatOtpInput"], { "id": { "alias": "id"; "required": false; }; "config": { "alias": "config"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onBlur": "onBlur"; "onInputChange": "onInputChange"; }, never, never, true, never>;
+}
+
+interface INode {
+    name: string;
+    cssClass: string;
+    image: string;
+    title?: string;
+    color?: string;
+    showDetail: boolean;
+    children: INode[];
+    heightFactor?: number;
+}
+declare class ChartNode implements INode {
+    name: string;
+    cssClass: string;
+    image: string;
+    title?: string;
+    color?: string;
+    showDetail: boolean;
+    children: ChartNode[];
+    heightFactor?: number;
+    parent?: ChartNode;
+    constructor(structure: string[], parent?: ChartNode);
+}
+
+declare class CmatOrgChartComponent {
+    nodes: INode[];
+    enableControlHeight: boolean;
+    direction: 'vertical' | 'horizontal';
+    detailsBtnTitle: string;
+    detailsBtnClick: EventEmitter<INode>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatOrgChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatOrgChartComponent, "cmat-org-chart", ["cmatOrgChart"], { "nodes": { "alias": "nodes"; "required": false; }; "enableControlHeight": { "alias": "enableControlHeight"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "detailsBtnTitle": { "alias": "detailsBtnTitle"; "required": false; }; }, { "detailsBtnClick": "detailsBtnClick"; }, never, never, true, never>;
+}
+
+declare class CmatPageHeaderComponent {
+    title: string;
+    description: string;
+    eyebrow: string;
+    divider: boolean;
+    align: 'start' | 'center';
+    get isCentered(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPageHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatPageHeaderComponent, "cmat-page-header", never, { "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "eyebrow": { "alias": "eyebrow"; "required": false; }; "divider": { "alias": "divider"; "required": false; }; "align": { "alias": "align"; "required": false; }; }, {}, never, ["[cmatPageHeaderActions]"], true, never>;
+}
+
+declare class CmatPaginationComponent implements OnInit {
+    pageChange: EventEmitter<number>;
+    pageBoundsCorrection: EventEmitter<number>;
+    perPageCountChange: EventEmitter<number>;
+    id: string;
+    maxSize: number;
+    itemsPerPages: number[];
+    initPerPage: number;
+    isScreenSmall: boolean;
+    private _cmatMediaWatcherService;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    private _autoHide;
+    get autoHide(): boolean;
+    set autoHide(value: boolean);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatPaginationComponent, "cmat-pagination", ["cmatPagination"], { "id": { "alias": "id"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; "itemsPerPages": { "alias": "itemsPerPages"; "required": false; }; "initPerPage": { "alias": "initPerPage"; "required": false; }; "autoHide": { "alias": "autoHide"; "required": false; }; }, { "pageChange": "pageChange"; "pageBoundsCorrection": "pageBoundsCorrection"; "perPageCountChange": "perPageCountChange"; }, never, never, true, never>;
+}
+
+interface CmatPaginationInstance {
+    [prop: string]: unknown;
+    id?: string;
+    itemsPerPage: number;
+    currentPage: number;
+    totalItems: number;
+}
+
+declare class CmatPaginationService {
+    private readonly _change;
+    private readonly _instances;
+    private readonly _defaultPaginationId;
+    get change$(): Observable<string>;
+    defaultId(): string;
+    notifyChange(id: string): void;
+    register(instance: CmatPaginationInstance): boolean;
+    getCurrentPage(id: string): number | undefined;
+    getItemsPerPage(id: string): number | undefined;
+    setCurrentPage(id: string, page: number): void;
+    setTotalItems(id: string, totalItems: number): void;
+    setItemsPerPage(id: string, itemsPerPage: number): void;
+    getInstance(id?: string): CmatPaginationInstance | undefined;
+    private _updateInstance;
+    private _clone;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPaginationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatPaginationService>;
+}
+
+type Collection<T> = readonly T[];
+interface CmatPaginatePipeArgs {
+    id?: string;
+    currentPage: string | number;
+    itemsPerPage: string | number;
+    totalItems: string | number;
+}
+interface CmatPipeState {
+    size: number;
+    start?: number;
+    end?: number;
+    slice: readonly unknown[];
+}
+declare class CmatPaginatePipe implements PipeTransform {
+    private service;
+    private readonly state;
+    transform<T, U extends Collection<T>>(collection: U, args: CmatPaginatePipeArgs): U;
+    private createInstance;
+    private checkConfig;
+    private _saveState;
+    private _stateIsIdentical;
+    private _toNumber;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPaginatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CmatPaginatePipe, "paginate", true>;
+}
+
+interface Page {
+    label: string | number;
+    value: number;
+}
+declare class CmatPaginationDirective implements OnInit, OnChanges {
+    id: string;
+    maxSize: number;
+    pageChange: EventEmitter<number>;
+    pageBoundsCorrection: EventEmitter<number>;
+    perPageCountChange: EventEmitter<number>;
+    pages: Page[];
+    private readonly service;
+    private readonly changeDetectorRef;
+    private readonly _destroyRef;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    previous(): void;
+    next(): void;
+    goFirstPage(): void;
+    goLastPage(): void;
+    isFirstPage(): boolean;
+    isLastPage(): boolean;
+    setCurrent(page: number | string): void;
+    getCurrent(): number | void;
+    getLastPage(): number | void;
+    getTotalItems(): number | void;
+    setItemsPerPage(count: number): void;
+    private _checkValidId;
+    private _updatePageLinks;
+    private _outOfBoundCorrection;
+    private _createPageArray;
+    private _calculatePageNumber;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPaginationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatPaginationDirective, "pagination-template,[pagination-template]", ["paginationApi"], { "id": { "alias": "id"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; }, { "pageChange": "pageChange"; "pageBoundsCorrection": "pageBoundsCorrection"; "perPageCountChange": "perPageCountChange"; }, never, never, true, never>;
+}
+
+type Type$1 = 'text' | 'password';
+declare class CmatPassToggleVisibilityComponent {
+    isVisible: boolean;
+    tabindex?: string;
+    _type: Type$1;
+    get type(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPassToggleVisibilityComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatPassToggleVisibilityComponent, "cmat-pass-toggle-visibility", ["cmatPassToggleVisibility"], { "isVisible": { "alias": "isVisible"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare enum Criteria {
+    at_least_eight_chars = "minChar",
+    at_least_one_lower_case_char = "lowerCase",
+    at_least_one_upper_case_char = "upperCase",
+    at_least_one_digit_char = "digit",
+    at_least_one_special_char = " specialChar",
+    at_custom_chars = "customChars"
+}
+
+declare class CmatPasswordStrengthValidator {
+    isUndefinedOrEmpty(control: AbstractControl): void;
+    validate(criteria: string, regex: RegExp): ValidatorFn;
+    confirm(password: string): ValidatorFn;
+}
+
+declare class CmatPasswordStrengthComponent implements OnInit, OnChanges {
+    password: string;
+    externalError: boolean;
+    enableLengthRule: boolean;
+    enableLowerCaseLetterRule: boolean;
+    enableUpperCaseLetterRule: boolean;
+    enableDigitRule: boolean;
+    enableSpecialCharRule: boolean;
+    min: number;
+    max: number;
+    customValidator: RegExp;
+    warnThreshold: number;
+    accentThreshold: number;
+    strengthChanged: EventEmitter<number>;
+    criteriaMap: Map<Criteria, RegExp>;
+    containAtLeastMinChars: boolean | void;
+    containAtLeastOneLowerCaseLetter: boolean | void;
+    containAtLeastOneUpperCaseLetter: boolean | void;
+    containAtLeastOneDigit: boolean | void;
+    containAtLeastOneSpecialChar: boolean | void;
+    containAtCustomChars: boolean | void;
+    passwordFormControl: FormControl;
+    passwordConfirmationFormControl: FormControl;
+    validatorsArray: ValidatorFn[];
+    validators: ValidatorFn | null;
+    cmatPasswordStrengthValidator: CmatPasswordStrengthValidator;
+    private _strength;
+    private _color;
+    get strength(): number;
+    get color(): ThemePalette;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    parseCustomValidatorsRegex(): RegExp;
+    setRulesAndValidators(): void;
+    calculatePasswordStrength(): void;
+    reset(): void;
+    private _containAtLeastMinChars;
+    private _containAtLeastOneLowerCaseLetter;
+    private _containAtLeastOneUpperCaseLetter;
+    private _containAtLeastOneDigit;
+    private _containAtLeastOneSpecialChar;
+    private _containCustomChars;
+    private _checkPassword;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPasswordStrengthComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatPasswordStrengthComponent, "cmat-password-strength", ["cmatPasswordStrength"], { "password": { "alias": "password"; "required": false; }; "externalError": { "alias": "externalError"; "required": false; }; "enableLengthRule": { "alias": "enableLengthRule"; "required": false; }; "enableLowerCaseLetterRule": { "alias": "enableLowerCaseLetterRule"; "required": false; }; "enableUpperCaseLetterRule": { "alias": "enableUpperCaseLetterRule"; "required": false; }; "enableDigitRule": { "alias": "enableDigitRule"; "required": false; }; "enableSpecialCharRule": { "alias": "enableSpecialCharRule"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "customValidator": { "alias": "customValidator"; "required": false; }; "warnThreshold": { "alias": "warnThreshold"; "required": false; }; "accentThreshold": { "alias": "accentThreshold"; "required": false; }; }, { "strengthChanged": "strengthChanged"; }, never, never, true, never>;
+}
+
+declare class CmatPasswordStrengthInfoComponent implements OnInit, AfterViewInit {
+    passwordComponent: CmatPasswordStrengthComponent;
+    enableScoreInfo: boolean;
+    lowerCaseCriteriaMsg: string;
+    upperCaseCriteriaMsg: string;
+    digitsCriteriaMsg: string;
+    specialCharsCriteriaMsg: string;
+    customCharsCriteriaMsg: string;
+    minCharsCriteriaMsg: string;
+    pageLoaded: boolean;
+    private _changeDetectorRef;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    getEnterIndex(itemType: string): number;
+    getLeaveIndex(itemType: string): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPasswordStrengthInfoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatPasswordStrengthInfoComponent, "cmat-password-strength-info", ["cmatPasswordStrengthInfo"], { "passwordComponent": { "alias": "passwordComponent"; "required": false; }; "enableScoreInfo": { "alias": "enableScoreInfo"; "required": false; }; "lowerCaseCriteriaMsg": { "alias": "lowerCaseCriteriaMsg"; "required": false; }; "upperCaseCriteriaMsg": { "alias": "upperCaseCriteriaMsg"; "required": false; }; "digitsCriteriaMsg": { "alias": "digitsCriteriaMsg"; "required": false; }; "specialCharsCriteriaMsg": { "alias": "specialCharsCriteriaMsg"; "required": false; }; "customCharsCriteriaMsg": { "alias": "customCharsCriteriaMsg"; "required": false; }; "minCharsCriteriaMsg": { "alias": "minCharsCriteriaMsg"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type CmatPopoverPositionStart = 'above' | 'below' | 'before' | 'after';
+type CmatPopoverPositionEnd = CmatPopoverPositionStart | 'center';
+type CmatPopoverPosition = [CmatPopoverPositionStart, CmatPopoverPositionEnd];
+type CmatPopoverTriggerEvent = 'click' | 'hover' | 'none';
+type CmatPopoverScrollStrategy = 'noop' | 'close' | 'block' | 'reposition';
+
+interface CmatPopoverPanel {
+    triggerEvent: CmatPopoverTriggerEvent;
+    position: CmatPopoverPosition;
+    xOffset: number;
+    yOffset: number;
+    enterDelay: number;
+    leaveDelay: number;
+    arrowOffsetX: number;
+    arrowOffsetY: number;
+    arrowWidth: number;
+    arrowHeight: number;
+    closeOnPanelClick: boolean;
+    closeOnBackdropClick: boolean;
+    scrollStrategy: CmatPopoverScrollStrategy;
+    containerPositioning: boolean;
+    closeDisabled: boolean;
+    templateRef: TemplateRef<any>;
+    closed: EventEmitter<void>;
+    setCurrentStyles: (pos?: CmatPopoverPosition) => void;
+    setPositionClasses: (pos?: CmatPopoverPosition) => void;
+    emitCloseEvent: VoidFunction;
+}
+interface CmatTarget {
+    _elementRef: ElementRef;
+}
+
+declare class CmatPopoverComponent implements CmatPopoverPanel, OnDestroy {
+    static ngAcceptInputType_closeOnPanelClick: BooleanInput;
+    static ngAcceptInputType_closeOnBackdropClick: BooleanInput;
+    static ngAcceptInputType_disableAnimation: BooleanInput;
+    static ngAcceptInputType_focusTrapEnabled: BooleanInput;
+    static ngAcceptInputType_focusTrapAutoCaptureEnabled: BooleanInput;
+    closed: EventEmitter<void>;
+    templateRef: TemplateRef<any>;
+    role: string;
+    popoverPanelStyles: {};
+    popoverArrowStyles: {};
+    popoverContentStyles: {};
+    containerPositioning: boolean;
+    closeDisabled: boolean;
+    classList: Record<string, boolean>;
+    _onAnimationStateChange: EventEmitter<AnimationEvent>;
+    private _dir;
+    private _elementRef;
+    private _position;
+    private _triggerEvent;
+    private _scrollStrategy;
+    private _enterDelay;
+    private _leaveDelay;
+    private _panelOffsetX;
+    private _panelOffsetY;
+    private _closeOnPanelClick;
+    private _closeOnBackdropClick;
+    private _disableAnimation;
+    private _focusTrapEnabled;
+    private _focusTrapAutoCaptureEnabled;
+    private _arrowOffsetX;
+    private _arrowOffsetY;
+    private _arrowWidth;
+    private _arrowHeight;
+    constructor();
+    get position(): CmatPopoverPosition;
+    set position(value: CmatPopoverPosition);
+    get triggerEvent(): CmatPopoverTriggerEvent;
+    set triggerEvent(value: CmatPopoverTriggerEvent);
+    get scrollStrategy(): CmatPopoverScrollStrategy;
+    set scrollStrategy(value: CmatPopoverScrollStrategy);
+    get enterDelay(): number;
+    set enterDelay(value: number);
+    get leaveDelay(): number;
+    set leaveDelay(value: number);
+    get xOffset(): number;
+    set xOffset(value: number);
+    get yOffset(): number;
+    set yOffset(value: number);
+    get arrowOffsetX(): number;
+    set arrowOffsetX(value: number);
+    get arrowOffsetY(): number;
+    set arrowOffsetY(value: number);
+    get arrowWidth(): number;
+    set arrowWidth(value: number);
+    get arrowHeight(): number;
+    set arrowHeight(value: number);
+    get closeOnPanelClick(): boolean;
+    set closeOnPanelClick(value: boolean);
+    get closeOnBackdropClick(): boolean;
+    set closeOnBackdropClick(value: boolean);
+    get disableAnimation(): boolean;
+    set disableAnimation(value: boolean);
+    get focusTrapEnabled(): boolean;
+    set focusTrapEnabled(value: boolean);
+    get focusTrapAutoCaptureEnabled(): boolean;
+    set focusTrapAutoCaptureEnabled(value: boolean);
+    set panelClass(classes: string);
+    ngOnDestroy(): void;
+    handleKeydown(event: KeyboardEvent): void;
+    emitCloseEvent(): void;
+    onClick(): void;
+    onMouseOver(): void;
+    onFocus(): void;
+    onMouseLeave(): void;
+    setCurrentStyles(pos?: CmatPopoverPosition): void;
+    setPositionClasses(pos?: CmatPopoverPosition): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatPopoverComponent, "cmat-popover", ["cmatPopover"], { "popoverPanelStyles": { "alias": "popoverPanelStyles"; "required": false; }; "popoverArrowStyles": { "alias": "popoverArrowStyles"; "required": false; }; "popoverContentStyles": { "alias": "popoverContentStyles"; "required": false; }; "position": { "alias": "position"; "required": false; }; "triggerEvent": { "alias": "triggerEvent"; "required": false; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; }; "enterDelay": { "alias": "enterDelay"; "required": false; }; "leaveDelay": { "alias": "leaveDelay"; "required": false; }; "xOffset": { "alias": "xOffset"; "required": false; }; "yOffset": { "alias": "yOffset"; "required": false; }; "arrowOffsetX": { "alias": "arrowOffsetX"; "required": false; }; "arrowOffsetY": { "alias": "arrowOffsetY"; "required": false; }; "arrowWidth": { "alias": "arrowWidth"; "required": false; }; "arrowHeight": { "alias": "arrowHeight"; "required": false; }; "closeOnPanelClick": { "alias": "closeOnPanelClick"; "required": false; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; }; "disableAnimation": { "alias": "disableAnimation"; "required": false; }; "focusTrapEnabled": { "alias": "focusTrapEnabled"; "required": false; }; "focusTrapAutoCaptureEnabled": { "alias": "focusTrapAutoCaptureEnabled"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+declare class CmatPopoverTriggerDirective implements OnChanges, AfterViewInit, OnDestroy {
+    ariaHaspopup: boolean;
+    popover: CmatPopoverPanel;
+    targetElement: CmatTarget;
+    triggerEvent: CmatPopoverTriggerEvent;
+    popoverOpened: EventEmitter<void>;
+    popoverClosed: EventEmitter<void>;
+    popoverOpened$: Subject<void>;
+    popoverClosed$: Subject<void>;
+    private _overlay;
+    private _elementRef;
+    private _viewContainerRef;
+    private _dir;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    private _portal;
+    private _overlayRef;
+    private _popoverOpen;
+    private _halt;
+    private _backdropSubscription;
+    private _positionSubscription;
+    private _detachmentsSubscription;
+    private _mouseoverTimer;
+    private _openedByMouse;
+    get popoverOpen(): boolean;
+    get dir(): Direction$1;
+    onClick(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    handleMousedown(event: MouseEvent): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    togglePopover(): void;
+    openPopover(): void;
+    closePopover(): void;
+    destroyPopover(): void;
+    focus(): void;
+    private _subscribeToBackdrop;
+    private _subscribeToDetachments;
+    private _initPopover;
+    private _resetPopover;
+    private _setPopoverOpened;
+    private _setPopoverClosed;
+    private _checkPopover;
+    private _createOverlay;
+    private _getOverlayConfig;
+    private _getOverlayScrollStrategy;
+    private _subscribeToPositions;
+    private _getPosition;
+    private _cleanUpSubscriptions;
+    private _setCurrentConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPopoverTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatPopoverTriggerDirective, "[cmatPopoverTriggerFor],[cmatPopoverTargetAt],[cmatPopoverTriggerOn]", ["cmatPopoverTrigger"], { "popover": { "alias": "cmatPopoverTriggerFor"; "required": false; }; "targetElement": { "alias": "cmatPopoverTargetAt"; "required": false; }; "triggerEvent": { "alias": "cmatPopoverTriggerOn"; "required": false; }; }, { "popoverOpened": "popoverOpened"; "popoverClosed": "popoverClosed"; }, never, never, true, never>;
+}
+
+declare class CmatPopoverTargetDirective {
+    elementRef: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPopoverTargetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatPopoverTargetDirective, "cmat-popover-target, [cmatPopoverTarget]", ["cmatPopoverTarget"], {}, {}, never, never, true, never>;
+}
+
+declare class CmatProgressBarComponent implements OnChanges, OnInit {
+    autoMode: boolean;
+    mode: 'determinate' | 'indeterminate';
+    progress: number | null;
+    show: boolean;
+    private _cmatLoadingService;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatProgressBarComponent, "cmat-progress-bar", ["cmatProgressBar"], { "autoMode": { "alias": "autoMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type QRCodeErrorCorrectionLevel = 'L' | 'M' | 'Q' | 'H' | 'low' | 'medium' | 'quartile' | 'high';
+type QRCodeElementType = 'url' | 'img' | 'canvas' | 'svg';
+
+declare class CmatQRCodeComponent implements OnChanges {
+    allowEmptyString: boolean;
+    cssClass: string;
+    elementType: QRCodeElementType;
+    errorCorrectionLevel: QRCodeErrorCorrectionLevel;
+    imageSrc?: string;
+    imageHeight?: number;
+    imageWidth?: number;
+    margin: number;
+    qrdata: string;
+    scale: number;
+    width: number;
+    alt?: string;
+    ariaLabel?: string;
+    title?: string;
+    qrCodeURL: EventEmitter<SafeUrl>;
+    qrcElement: ElementRef;
+    context: CanvasRenderingContext2D | null;
+    private _centerImage?;
+    private _renderer;
+    private _sanitizer;
+    private _currentOperationId;
+    ngOnChanges(): void;
+    convertBase64ImageUrlToBlob(base64ImageUrl: string): Blob;
+    emitQRCodeURL(element: HTMLCanvasElement | HTMLImageElement | SVGSVGElement): void;
+    private _isValidQrCodeText;
+    private _toDataURL;
+    private _toCanvas;
+    private _toSVG;
+    private _renderElement;
+    private _createQRCode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatQRCodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatQRCodeComponent, "cmat-qrcode", ["cmatQRCode"], { "allowEmptyString": { "alias": "allowEmptyString"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "elementType": { "alias": "elementType"; "required": false; }; "errorCorrectionLevel": { "alias": "errorCorrectionLevel"; "required": false; }; "imageSrc": { "alias": "imageSrc"; "required": false; }; "imageHeight": { "alias": "imageHeight"; "required": false; }; "imageWidth": { "alias": "imageWidth"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "qrdata": { "alias": "qrdata"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "width": { "alias": "width"; "required": false; }; "alt": { "alias": "alt"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, { "qrCodeURL": "qrCodeURL"; }, never, never, true, never>;
+}
+
+declare class CmatRatingComponent implements MatFormFieldControl<any>, ControlValueAccessor, OnInit, OnChanges, OnDestroy {
+    id: string;
+    private _ratingElementRef;
+    stars: number;
+    readonly: boolean;
+    hover: boolean;
+    half: boolean;
+    color?: string;
+    showMode?: 'horizontal' | 'vertical';
+    valueChange: EventEmitter<any>;
+    starArray: number[];
+    currentValue: number;
+    readonly stateChanges: Subject<void>;
+    focused: boolean;
+    touched: boolean;
+    controlType: string;
+    ngControl: NgControl;
+    private _changeDetectorRef;
+    constructor();
+    onModelChange: (value: any) => void;
+    onTouchedChange: () => any;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onFocus(): 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);
+    writeValue(value: number): void;
+    setDisabledState(isDisabled: boolean): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    isIn(value: number): boolean;
+    onClick(event: any, value: number, half?: boolean): void;
+    onMouseover(event: any, value: number, half?: boolean): void;
+    onMouseleave(): void;
+    private _initializeStarArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatRatingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatRatingComponent, "cmat-rating", ["cmatRating"], { "id": { "alias": "id"; "required": false; }; "stars": { "alias": "stars"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "hover": { "alias": "hover"; "required": false; }; "half": { "alias": "half"; "required": false; }; "color": { "alias": "color"; "required": false; }; "showMode": { "alias": "showMode"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class CmatRichTextEditorComponent implements OnChanges {
+    value: string;
+    placeholder: string;
+    readOnly: boolean;
+    theme: string;
+    minHeight: string;
+    control: FormControl<string | null>;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatRichTextEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatRichTextEditorComponent, "cmat-rich-text-editor", never, { "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CmatSelectNoEntriesFoundDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSelectNoEntriesFoundDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatSelectNoEntriesFoundDirective, "[cmatSelectNoEntriesFound]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatSelectSearchClearDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSelectSearchClearDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatSelectSearchClearDirective, "[cmatSelectSearchClear]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatSelectSearchComponent implements OnInit, ControlValueAccessor {
+    placeholderLabel: string;
+    type: string;
+    noEntriesFoundLabel: string;
+    showNoFoundLabel: boolean;
+    clearSearchInput: boolean;
+    searching: boolean;
+    disableInitialFocus: boolean;
+    enableClearOnEscapePressed: boolean;
+    preventHomeEndKeyPropagation: boolean;
+    disableScrollToActiveOnOptionsChanged: boolean;
+    ariaLabel: string;
+    showToggleAllCheckbox: boolean;
+    toggleAllCheckboxChecked: boolean;
+    toggleAllCheckboxIndeterminate: boolean;
+    toggleAllCheckboxTooltipMessage: string;
+    toggleAllCheckboxTooltipPosition: 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
+    hideClearSearchButton: boolean;
+    alwaysRestoreSelectedOptionsMulti: boolean;
+    toggleAll: EventEmitter<boolean>;
+    searchSelectInput: ElementRef;
+    innerSelectSearch: ElementRef;
+    clearIcon: CmatSelectSearchClearDirective;
+    noEntriesFound: CmatSelectNoEntriesFoundDirective;
+    formControl: FormControl;
+    protected matSelect: MatSelect;
+    protected matFormField: MatFormField | null;
+    private _changeDetectorRef;
+    private _viewportRuler;
+    private _matOption;
+    private _defaultOptions;
+    private readonly _destroyRef;
+    private _options$;
+    private _lastExternalInputValue?;
+    private _optionsList$;
+    private _optionsLength$;
+    private _previousSelectedValues;
+    private _activeDescendant?;
+    constructor();
+    showNoEntriesFound$: Observable<boolean>;
+    get isInsideMatOption(): boolean;
+    get value(): string;
+    get _options(): QueryList<MatOption> | null;
+    set _options(_options: QueryList<MatOption>);
+    onTouched: () => any;
+    ngOnInit(): void;
+    emitSelectAllBooleanToParent(state: boolean): void;
+    isToggleAllCheckboxVisible(): boolean;
+    handleKeydown(event: KeyboardEvent): void;
+    handleKeyup(event: KeyboardEvent): void;
+    writeValue(value: string): void;
+    onBlur(): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: any): void;
+    focus(): void;
+    reset(focus?: boolean): void;
+    updateInputWidth(): void;
+    private _getMatOptionHeight;
+    private _getOptionsLengthOffset;
+    private _unselectActiveDescendant;
+    private _applyDefaultOptions;
+    private _initMultipleHandling;
+    private _adjustScrollTopToFitActiveOptionIntoView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSelectSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatSelectSearchComponent, "cmat-select-search", ["cmatSelectSearch"], { "placeholderLabel": { "alias": "placeholderLabel"; "required": false; }; "type": { "alias": "type"; "required": false; }; "noEntriesFoundLabel": { "alias": "noEntriesFoundLabel"; "required": false; }; "showNoFoundLabel": { "alias": "showNoFoundLabel"; "required": false; }; "clearSearchInput": { "alias": "clearSearchInput"; "required": false; }; "searching": { "alias": "searching"; "required": false; }; "disableInitialFocus": { "alias": "disableInitialFocus"; "required": false; }; "enableClearOnEscapePressed": { "alias": "enableClearOnEscapePressed"; "required": false; }; "preventHomeEndKeyPropagation": { "alias": "preventHomeEndKeyPropagation"; "required": false; }; "disableScrollToActiveOnOptionsChanged": { "alias": "disableScrollToActiveOnOptionsChanged"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "showToggleAllCheckbox": { "alias": "showToggleAllCheckbox"; "required": false; }; "toggleAllCheckboxChecked": { "alias": "toggleAllCheckboxChecked"; "required": false; }; "toggleAllCheckboxIndeterminate": { "alias": "toggleAllCheckboxIndeterminate"; "required": false; }; "toggleAllCheckboxTooltipMessage": { "alias": "toggleAllCheckboxTooltipMessage"; "required": false; }; "toggleAllCheckboxTooltipPosition": { "alias": "toggleAllCheckboxTooltipPosition"; "required": false; }; "hideClearSearchButton": { "alias": "hideClearSearchButton"; "required": false; }; "alwaysRestoreSelectedOptionsMulti": { "alias": "alwaysRestoreSelectedOptionsMulti"; "required": false; }; }, { "toggleAll": "toggleAll"; }, ["clearIcon", "noEntriesFound"], ["[cmatSelectSearchClear]", ".cmat-select-search-custom-header-content", "[cmatSelectNoEntriesFound]"], true, never>;
+}
+
+declare const configurableDefaultOptions: readonly ["ariaLabel", "clearSearchInput", "disableInitialFocus", "disableScrollToActiveOnOptionsChanged", "enableClearOnEscapePressed", "hideClearSearchButton", "noEntriesFoundLabel", "placeholderLabel", "preventHomeEndKeyPropagation", "searching"];
+type ConfigurableDefaultOptions = typeof configurableDefaultOptions[number];
+declare const MAT_SELECTSEARCH_DEFAULT_OPTIONS: InjectionToken<Readonly<Partial<Pick<CmatSelectSearchComponent, "ariaLabel" | "clearSearchInput" | "disableInitialFocus" | "disableScrollToActiveOnOptionsChanged" | "enableClearOnEscapePressed" | "hideClearSearchButton" | "noEntriesFoundLabel" | "placeholderLabel" | "preventHomeEndKeyPropagation" | "searching">>>>;
+type MatSelectSearchOptions = Readonly<Partial<Pick<CmatSelectSearchComponent, ConfigurableDefaultOptions>>>;
+
+interface CmatSelectTableRow {
+    [key: string]: unknown;
+    id: string | number | null | undefined;
+}
+interface CmatSelectTableFilter {
+    enabled?: boolean;
+    type: 'string' | 'number';
+    comparator?: 'equalsIgnoreCase' | 'equals' | 'containsIgnoreCase' | 'contains' | 'startsWithIgnoreCase' | 'startsWith';
+    comparatorFn?: (value: string | number | boolean | null | undefined, filterValue: string | number | boolean | null | undefined, row: CmatSelectTableRow) => boolean;
+}
+interface CmatSelectTableColumn {
+    key: string;
+    name: string;
+    sortable: boolean;
+    filter: CmatSelectTableFilter;
+}
+interface CmatSelectTableDataSource<T extends CmatSelectTableRow> {
+    columns: CmatSelectTableColumn[];
+    data: T[];
+}
+
+declare class CmatSelectTableComponent implements MatFormFieldControl<any>, ControlValueAccessor, AfterViewInit, OnDestroy, OnChanges {
+    id: string;
+    dataSource: CmatSelectTableDataSource<CmatSelectTableRow>;
+    noEntriesFoundLabel: string;
+    showNoFoundLabel: boolean;
+    isPhone: boolean;
+    multiple: boolean;
+    overallSearchEnabled: boolean;
+    overallSearchVisible: boolean;
+    resetSortOnOpen: boolean;
+    resetFiltersOnOpen: boolean;
+    customTriggerLabelFn: (value: CmatSelectTableRow[]) => string;
+    triggerLabelSort: Sort;
+    customTriggerLabelTemplate: string;
+    canNull: boolean;
+    defaultSort: Sort;
+    resetOptionAction: () => void;
+    keyParam: string;
+    compareWith: (o1: CmatSelectTableRow | null, o2: CmatSelectTableRow | null) => boolean;
+    closed: EventEmitter<boolean>;
+    private _matSelectSearch;
+    private _sort;
+    private _table;
+    private _matOptions;
+    tableDataSource: CmatSelectTableRow[];
+    tableColumns: string[];
+    tableColumnsMap: Map<string, CmatSelectTableColumn>;
+    private readonly _rowById;
+    private _columnKeys;
+    filteredOutRows: Record<string, CmatSelectTableRow>;
+    completeRowList: CmatSelectTableRow[];
+    overallSearchVisibleState: boolean;
+    overallFilterControl: FormControl;
+    selectControl: FormControl;
+    readonly stateChanges: Subject<void>;
+    focused: boolean;
+    touched: boolean;
+    ngControl: NgControl;
+    private _cd;
+    private readonly _destroyRef;
+    private _matSelect;
+    private _filterControls;
+    private _nullRow;
+    private _completeValueList;
+    constructor();
+    set matSelect(m: MatSelect);
+    clickedOut(): 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: (value: any) => void): void;
+    registerOnTouched(fn: () => object): void;
+    setDisabledState(isDisabled: boolean): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    onFocusIn(): void;
+    onFocusOut(event: FocusEvent): void;
+    writeValue(value: any): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    emulateMatOptionClick(event: MouseEvent): void;
+    openedChange(opened: boolean): void;
+    filterFormControl(key: string): FormControl;
+    simpleTriggerLabelFn(value: CmatSelectTableRow[]): string;
+    getTriggerLabel(): string;
+    toggleOverallSearch(): void;
+    addNullRow(): boolean;
+    get hasNullRow(): boolean;
+    private _onModelChange;
+    private _onTouchedChange;
+    private _init;
+    private _updateCompleteRowList;
+    private _applyColumnLevelFilters;
+    private _applyOverallFilter;
+    private _resetFilters;
+    private _sortingDataAccessor;
+    private _sortData;
+    private _checkAndResetSelection;
+    private _matchesColumnFilter;
+    private _buildTableOptions;
+    private _getMatOptionById;
+    private _expandPanelForTableRows;
+    private _getCommittedValue;
+    private _syncMatSelectValue;
+    private _removeFilteredRow;
+    private _resolveTriggerLabel;
+    private _getTriggerRows;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSelectTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatSelectTableComponent, "cmat-select-table", ["cmatSelectTable"], { "id": { "alias": "id"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "noEntriesFoundLabel": { "alias": "noEntriesFoundLabel"; "required": false; }; "showNoFoundLabel": { "alias": "showNoFoundLabel"; "required": false; }; "isPhone": { "alias": "isPhone"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "overallSearchEnabled": { "alias": "overallSearchEnabled"; "required": false; }; "overallSearchVisible": { "alias": "overallSearchVisible"; "required": false; }; "resetSortOnOpen": { "alias": "resetSortOnOpen"; "required": false; }; "resetFiltersOnOpen": { "alias": "resetFiltersOnOpen"; "required": false; }; "customTriggerLabelFn": { "alias": "customTriggerLabelFn"; "required": false; }; "triggerLabelSort": { "alias": "triggerLabelSort"; "required": false; }; "customTriggerLabelTemplate": { "alias": "customTriggerLabelTemplate"; "required": false; }; "canNull": { "alias": "canNull"; "required": false; }; "defaultSort": { "alias": "defaultSort"; "required": false; }; "resetOptionAction": { "alias": "resetOptionAction"; "required": false; }; "keyParam": { "alias": "keyParam"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class CmatSelectTreeFlatNode {
+    id: string | number;
+    name: string;
+    level: number;
+    expandable: boolean;
+}
+
+declare class CmatSelectTreeNode {
+    id: string | number;
+    children: CmatSelectTreeNode[] | null;
+    name: string;
+}
+
+type CmatSelectTreeValueItem = CmatSelectTreeNode | CmatSelectTreeFlatNode;
+type CmatSelectTreeValue = CmatSelectTreeValueItem[] | CmatSelectTreeValueItem | null;
+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: CmatSelectTreeFlatNode[]) => string;
+    customTriggerLabelTemplate: string;
+    expandable: boolean;
+    showToggleAllCheckbox: boolean;
+    compareWith: (o1: CmatSelectTreeNode | CmatSelectTreeFlatNode | null, o2: CmatSelectTreeNode | CmatSelectTreeFlatNode | null) => boolean;
+    flatNodeMap: Map<CmatSelectTreeFlatNode, CmatSelectTreeNode>;
+    nestedNodeMap: Map<CmatSelectTreeNode, CmatSelectTreeFlatNode>;
+    private readonly _flatNodeById;
+    private readonly _parentFlatNodeById;
+    private readonly _selectedFlatNodeIds;
+    checklistSelection: SelectionModel<CmatSelectTreeFlatNode>;
+    treeDataSource: CmatSelectTreeNode[];
+    dataFlatNodes: CmatSelectTreeFlatNode[];
+    overallFilterControl: FormControl;
+    isIndeterminate: boolean;
+    isChecked: boolean;
+    checkCount: number;
+    selectControl: FormControl;
+    readonly matSelectData: CmatSelectTreeFlatNode[];
+    readonly stateChanges: Subject<void>;
+    focused: boolean;
+    touched: boolean;
+    ngControl: NgControl;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    private _matSelect;
+    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(): CmatSelectTreeValue;
+    set value(value: CmatSelectTreeValue);
+    protected _value: CmatSelectTreeValue;
+    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: (value: CmatSelectTreeValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    onFocusIn(): void;
+    onFocusOut(event: FocusEvent): void;
+    writeValue(value: CmatSelectTreeValue): void;
+    simpleTriggerLabelFn(value: CmatSelectTreeFlatNode[]): string;
+    openedChange(opened: boolean): void;
+    descendantsAllSelected(node: CmatSelectTreeFlatNode): boolean;
+    descendantsPartiallySelected(node: CmatSelectTreeFlatNode): boolean;
+    todoItemSelectionToggle(event: MouseEvent, node: CmatSelectTreeFlatNode): void;
+    todoLeafItemSelectionToggle(event: MouseEvent, node: CmatSelectTreeFlatNode): void;
+    clearSelection(): void;
+    toggleSelectAll(selectAllValue: boolean): void;
+    getChecklistSelectionIsSelected(i: CmatSelectTreeNode): boolean;
+    private _onModelChange;
+    private _onTouchedChange;
+    private _init;
+    private _checkAllParentsSelection;
+    private _checkRootNodeSelection;
+    private _getParentNode;
+    private _updateChecklistSelection;
+    private _updateSelect;
+    private _applyColumnLevelFilters;
+    private _updateCheckState;
+    private _getFlattenNodes;
+    private _cloneTreeNodes;
+    private _syncSelectedFlatNodeIds;
+    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; }; "compareWith": { "alias": "compareWith"; "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>;
+}
+
+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"], ["[matMiniFab]"], 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, ["[matFab]"], true, never>;
+}
+
+declare class CmatStatusTagComponent {
+    label: string;
+    variant: 'soft' | 'filled' | 'outline';
+    tone: 'neutral' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+    dot: boolean;
+    hostClass: string;
+    get classMap(): Record<string, boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatStatusTagComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatStatusTagComponent, "cmat-status-tag", never, { "label": { "alias": "label"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "tone": { "alias": "tone"; "required": false; }; "dot": { "alias": "dot"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CmatTableToolbarComponent {
+    title: string;
+    description: string;
+    count: number;
+    showCount: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTableToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTableToolbarComponent, "cmat-table-toolbar", never, { "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "count": { "alias": "count"; "required": false; }; "showCount": { "alias": "showCount"; "required": false; }; }, {}, never, ["[cmatTableToolbarActions]"], true, never>;
+}
+
+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 {
+    readonly items: QueryList<CmatTimelineItemComponent>;
+    readonly class = "cmat-timeline";
+    private _host;
+    private readonly _destroyRef;
+    private _reverse;
+    private _position;
+    private _orientation;
+    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;
+    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>;
+}
+
+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 readonly _position$;
+    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>;
+}
+
+declare class CmatTransferItemNode {
+    [key: string]: any;
+    children?: CmatTransferItemNode[];
+    label: string;
+    value: string | number;
+}
+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[] | undefined;
+    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 | undefined;
+    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 {
+    tree: CdkTree<CmatTransferItemNode>;
+    nestedNodeMap: Map<CmatTransferItemNode, CmatTransferItemFlatNode>;
+    dataSource: CmatTransferItemNode[];
+    dataFlatNodes: CmatTransferItemFlatNode[];
+    checklistSelection: SelectionModel<CmatTransferItemFlatNode>;
+    options: CmatSourceOptions | undefined;
+    selectedList: CmatTransferItemFlatNode[];
+    private readonly _flatNodeByValue;
+    private _service;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    getSelectedList(): CmatTransferItemFlatNode[];
+    resetSelectedItem(item: CmatTransferItemFlatNode): void;
+    childrenAccessor: (node: CmatTransferItemNode) => CmatTransferItemNode[];
+    hasChild: (_: number, node: CmatTransferItemNode) => boolean;
+    descendantsAllSelected(node: CmatTransferItemFlatNode): boolean;
+    descendantsPartiallySelected(node: CmatTransferItemFlatNode): boolean;
+    transferItemSelectionToggle(node: CmatTransferItemFlatNode): void;
+    transferLeafItemSelectionToggle(node: CmatTransferItemFlatNode): void;
+    private _getLevel;
+    private _isExpandable;
+    private _getChildren;
+    private _transformer;
+    private _getDescendants;
+    private _getFlattenNodes;
+    private _checkAllParentsSelection;
+    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 {
+    private readonly _dataSourceChange;
+    private readonly _refreshDataSourceChange;
+    private readonly _filtersChange;
+    private readonly _sourceOptionsChange;
+    private readonly _selectedValuesChange;
+    private _dataSource;
+    private _filterData;
+    private _keyword;
+    private _originalDataSource;
+    private _filteredDataSource;
+    private _compareMap;
+    private _conditionMap;
+    private readonly _dataSourceChange$;
+    private readonly _refreshDataSourceChange$;
+    private readonly _filtersChange$;
+    private readonly _sourceOptionsChange$;
+    private readonly _selectedValuesChange$;
+    constructor();
+    get dataSourceChange(): Observable<CmatTransferItemNode[]>;
+    get refreshDataSourceChange(): Observable<boolean>;
+    get filtersChange(): Observable<CmatTransferFilterItem[]>;
+    get sourceOptionsChange(): Observable<CmatSourceOptions | void>;
+    get selectedValuesChange(): Observable<string[]>;
+    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 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>;
+}
+
+declare class CmatUploadComponent implements OnInit {
+    fileAlias: string;
+    filePath: string;
+    fileCategory: string;
+    isPublic: boolean;
+    editMode: boolean;
+    autoUpload: boolean;
+    id: string;
+    removeEvent: EventEmitter<CmatUploadComponent>;
+    uploadEvent: EventEmitter<any>;
+    progressPercentage: number;
+    loaded: number;
+    total: number;
+    isUploading: boolean;
+    private _fileService;
+    private _changeDetectorRef;
+    private readonly _destroyRef;
+    private _file;
+    get file(): any;
+    set file(file: any);
+    get fileType(): 'csv' | 'gif' | 'word' | 'excel' | 'jpg' | 'outlook' | 'pdf' | 'png' | 'ppt' | 'file' | 'text' | 'video' | 'zip';
+    ngOnInit(): 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; }; "isPublic": { "alias": "isPublic"; "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 AfterViewInit {
+    fileUploads: QueryList<CmatUploadComponent>;
+    fileAlias: string;
+    filePath: string;
+    fileCategory: string;
+    isPublic: boolean;
+    required: boolean;
+    autoUpload: boolean;
+    multiple: boolean;
+    accept: string;
+    title: string;
+    editMode: boolean;
+    filesData: any[] | undefined;
+    outputRemoveIdEvent: EventEmitter<string>;
+    outputUploadIdEvent: EventEmitter<string>;
+    outputFilesDataEvent: EventEmitter<any>;
+    id: string;
+    isHandSet: boolean;
+    private _changeDetectorRef;
+    private _cmatMediaWatcherService;
+    private _elementRef;
+    private readonly _destroyRef;
+    constructor();
+    onDrop(event: any): void;
+    onDropOver(event: any): void;
+    ngAfterViewInit(): void;
+    add(file: any): void;
+    upload(event: any): void;
+    remove(event: CmatUploadComponent): void;
+    uploadAll(): void;
+    removeAll(): void;
+    choose(): void;
+    private isFileTypeAccepted;
+    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; }; "isPublic": { "alias": "isPublic"; "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>;
+}
+
+declare class CmatFilesUtilService {
+    private _http;
+    private _urlStateConfigService;
+    private readonly _destroyRef;
+    private _config;
+    constructor();
+    downloadFile(fileId: string, isStream?: boolean): Observable<any>;
+    downloadFileZip(fileIds?: string[]): Observable<any>;
+    uploadFile(file: FormData): Observable<any>;
+    uploadFileToProcessed(file: FormData): Observable<any>;
+    switchPublic(fileId: string, isPublic: boolean): Observable<any>;
+    deleteFile(fileId: string): Observable<any>;
+    getFileList(queryData: object, pageIndex?: number, pageSize?: number): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatFilesUtilService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatFilesUtilService>;
+}
+
+interface FileModel {
+    id?: string | null;
+    fileName: string;
+    filePath: string;
+    fileStatus?: 'Uploaded' | 'Processed';
+    length: number;
+    isPublic: boolean;
+    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[];
+}
+
+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 NodeProperties {
+        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;
+    private setInstanceInput;
+}
+declare namespace AngularShapeView {
+    const action: any;
+}
+
+type Content = TemplateRef<any> | Type$2<any>;
+type AngularShapeConfig = {
+    shape: string;
+    injector: Injector;
+    content: Content;
+} & Record<string, any>;
+declare const registerInfo: Map<string, {
+    injector: Injector;
+    content: Content;
+}>;
+declare function register(config: AngularShapeConfig): void;
+
+declare class CmatAnimationOnScrollDirective implements OnInit, OnDestroy, AfterViewInit {
+    animationName: string | null;
+    offset: number;
+    useScroll?: boolean;
+    threshold?: number;
+    private _offsetTop;
+    private _isVisible;
+    private _winHeight;
+    private _scrollSub;
+    private _resizeSub;
+    private _elementRef;
+    private _renderer;
+    private _scroll;
+    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>;
+}
+
+declare class CmatArrowCursorDirective implements AfterViewInit, OnDestroy {
+    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 _document;
+    private _cmatMediaWatcherService;
+    private readonly _destroyRef;
+    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>;
+}
+
+declare class CmatAutofocusDirective {
+    element: ElementRef<any>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatAutofocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatAutofocusDirective, "[cmatAutofocus]", never, {}, {}, never, never, true, never>;
+}
+
+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[];
+}
+
+declare class CmatDataExporterDirective implements OnChanges {
+    dataSource: any[];
+    exportColumns: ExporterListInfo[];
+    options?: Options | ExcelOptions | TxtOptions;
+    exportType: ExportType | 'xls' | 'xlsx' | 'csv' | 'txt' | 'json';
+    transformBoolean: boolean;
+    transformDate: boolean;
+    dateFormat: string;
+    private _serviceLocator;
+    private _data;
+    private _exporterService;
+    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; }; "transformBoolean": { "alias": "transformBoolean"; "required": false; }; "transformDate": { "alias": "transformDate"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class AbstractDebounceDirective implements OnInit {
+    debounceTime: number;
+    emitChanged: EventEmitter<any>;
+    emitEvent$: Subject<any>;
+    private readonly _destroyRef;
+    constructor();
+    ngOnInit(): void;
+    emitChange(value: any): 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>;
+}
+
+declare class CmatDigitOnlyDirective implements OnChanges {
+    decimal: boolean;
+    decimalSeparator: string;
+    allowNegatives: boolean;
+    allowPaste: boolean;
+    negativeSign: string;
+    min: number;
+    max: number;
+    pattern?: string | RegExp;
+    inputElement: HTMLInputElement;
+    value: string;
+    el: ElementRef<any>;
+    private _regex;
+    private _hasDecimalPoint;
+    private _hasNegativeSign;
+    private _navigationKeys;
+    constructor();
+    onBeforeInput(e: InputEvent): any;
+    onInputChange(event: any): void;
+    onKeyDown(e: KeyboardEvent): any;
+    onPaste(event: any): void;
+    onDrop(event: DragEvent): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _pasteData;
+    private _insertAtCursor;
+    private _triggerEvent;
+    private _sanitizeInput;
+    private _getNegativeSignRegExp;
+    private _isValidDecimal;
+    private _getSelection;
+    private _forecastValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDigitOnlyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDigitOnlyDirective, "[cmatDigitOnly]", never, { "decimal": { "alias": "decimal"; "required": false; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; }; "allowNegatives": { "alias": "allowNegatives"; "required": false; }; "allowPaste": { "alias": "allowPaste"; "required": false; }; "negativeSign": { "alias": "negativeSign"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CmatMaskDirective implements OnInit {
+    el: ElementRef<any>;
+    inputElement: HTMLInputElement;
+    value: string;
+    regex: RegExp;
+    private _navigationKeys;
+    constructor();
+    onInputChange(event: any): void;
+    onKeyDown(e: KeyboardEvent): void;
+    ngOnInit(): void;
+    private _forecastValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatMaskDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatMaskDirective, "[cmatMask]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatEqualValidatorDirective implements Validator {
+    private _validateEqual;
+    private _reverse;
+    private static _validateNoReverse;
+    private static _validateReverse;
+    validate(c: AbstractControl): Record<string, any> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatEqualValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatEqualValidatorDirective, "[cmatValidateEqual][formControlName],[cmatValidateEqual][formControl],[cmatValidateEqual][ngModel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatSeamlessAutoScrollDirective implements OnInit, AfterViewInit, OnDestroy {
+    data: any[];
+    speed: number;
+    direction: 'up' | 'down' | 'left' | 'right';
+    itemTemplate: TemplateRef<any>;
+    private _viewContainer;
+    private _containerElement;
+    private _contentElement;
+    private _resizeObserver;
+    private _isScrollEnabled;
+    private _dataCopies;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _renderContent;
+    private _checkScrollCondition;
+    private _initAnimation;
+    private _disableAnimation;
+    private _updateAnimationParams;
+    private _listenResize;
+    private _getDirection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSeamlessAutoScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatSeamlessAutoScrollDirective, "[cmatSeamlessAutoScroll]", never, { "data": { "alias": "data"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; }, {}, ["itemTemplate"], never, true, never>;
+}
+
+declare class CmatBytesPipe implements PipeTransform {
+    transform(bytes: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatBytesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CmatBytesPipe, "cmatBytes", true>;
+}
+
+declare class CmatDateFormatPipe implements PipeTransform {
+    transform(value: string | Date | void, format: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDateFormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CmatDateFormatPipe, "cmatDateFormat", true>;
+}
+
+declare class CmatFindByKeyPipe implements PipeTransform {
+    transform(value: string | string[], key: string, source: any[]): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatFindByKeyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CmatFindByKeyPipe, "cmatFindByKey", true>;
+}
+
+declare class CmatGroupByPipe implements PipeTransform {
+    transform(value: any[], field: string): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatGroupByPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CmatGroupByPipe, "cmatGroupBy", true>;
+}
+
+declare class CmatKeysPipe implements PipeTransform {
+    transform(value: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatKeysPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CmatKeysPipe, "cmatKeys", true>;
+}
+
+declare class CmatSecurePipe implements PipeTransform {
+    private _http;
+    private _sanitizer;
+    private _urlStateConfigService;
+    private readonly _destroyRef;
+    private _config;
+    constructor();
+    transform(fileId: string): Observable<SafeUrl>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSecurePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CmatSecurePipe, "cmatSecure", true>;
+}
+
+declare class CmatUppercasePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatUppercasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CmatUppercasePipe, "cmatUppercase", true>;
+}
+
+declare enum CmatDialogType {
+    alert = 0,
+    confirm = 1,
+    prompt = 2
+}
+declare enum CmatMessageSeverity {
+    info = "info",
+    success = "success",
+    error = "error",
+    warning = "warning",
+    wait = "wait"
+}
+interface ApiResult {
+    success: boolean;
+    msg: string;
+    type: number;
+    data?: any;
+    dataExt?: any;
+}
+
+declare class CmatAlertDialog {
+    message: string;
+    type: CmatDialogType;
+    okCallback?: ((val?: any) => any) | undefined;
+    cancelCallback?: (() => any) | undefined;
+    defaultValue?: string | undefined;
+    okLabel?: string | undefined;
+    cancelLabel?: string | undefined;
+    constructor(message: string, type: CmatDialogType, okCallback?: ((val?: any) => any) | undefined, cancelCallback?: (() => any) | undefined, defaultValue?: string | undefined, okLabel?: string | undefined, cancelLabel?: string | undefined);
+}
+
+declare class CmatAlertMessage {
+    severity: CmatMessageSeverity;
+    summary: string;
+    detail: string;
+    isPostionBottom: boolean;
+    constructor(severity: CmatMessageSeverity, summary: string, detail: string, isPostionBottom?: boolean);
+}
+
+declare class CmatAlertService {
+    private _messages;
+    private _stickyMessages;
+    private _dialogs;
+    private _isLoading;
+    private _loadingMessageId;
+    get dialogEvent$(): Observable<CmatAlertDialog>;
+    get messageEvent$(): Observable<CmatAlertMessage>;
+    get stickyMessageEvent$(): Observable<CmatAlertMessage | void>;
+    get isLoadingInProgress$(): Observable<boolean>;
+    showDialog(message: string, type?: CmatDialogType, okCallback?: (val?: any) => any, cancelCallback?: () => any, okLabel?: string, cancelLabel?: string, defaultValue?: string): void;
+    showMessage(summary: string): void;
+    showMessage(detail: string | string[] | HttpResponseBase, params: string, severity: CmatMessageSeverity): void;
+    showBottomMessage(summary: string): void;
+    showBottomMessage(summary: string, detail: string, severity: CmatMessageSeverity): void;
+    showStickyMessage(summary: string): void;
+    showStickyMessage(summary: string, detail: string, severity: CmatMessageSeverity, error?: any): void;
+    showStickyMessage(detail: string[] | HttpResponseBase, params: string, severity: CmatMessageSeverity): void;
+    startLoadingMessage(message?: string, caption?: string): void;
+    stopLoadingMessage(): void;
+    logDebug(msg: any): void;
+    logError(msg: any): void;
+    logInfo(msg: any): void;
+    logMessage(msg: any): void;
+    logTrace(msg: any): void;
+    logWarning(msg: any): void;
+    resetStickyMessage(): void;
+    private _showMessageHelper;
+    private isApiResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatAlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatAlertService>;
+}
+
+type CmatScheme = 'auto' | 'dark' | 'light';
+type CmatTheme = string;
+type CmatScreens = Record<string, string>;
+type CmatThemeOption<TExtra extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    name: string;
+} & TExtra;
+interface CmatAppConfigBase {
+    layout: string;
+    scheme: CmatScheme;
+    screens: CmatScreens;
+    theme: CmatTheme;
+    themes: CmatThemeOption[];
+}
+type CmatAppConfig<TExtra extends Record<string, unknown> = Record<string, unknown>> = CmatAppConfigBase & TExtra;
+declare const CMAT_APP_CONFIG: InjectionToken<CmatAppConfig<Record<string, unknown>>>;
+interface IUrlStateConfig {
+    fileUrl: string;
+    enableDataProtect: boolean;
+}
+
+declare class CmatConfigService {
+    private readonly _defaultConfig;
+    private readonly _config;
+    private readonly _config$;
+    get config$(): Observable<CmatAppConfig>;
+    set config(value: Partial<CmatAppConfig>);
+    updateConfig(value: Partial<CmatAppConfig>): void;
+    reset(): void;
+    private _mergeConfig;
+    private _isRecord;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatConfigService>;
+}
+
+declare class CmatUrlStateConfigService {
+    private readonly _defaultConfig;
+    private readonly _config;
+    private readonly _config$;
+    get config$(): Observable<IUrlStateConfig>;
+    config(value: Partial<IUrlStateConfig>): void;
+    updateConfig(value: Partial<IUrlStateConfig>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatUrlStateConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatUrlStateConfigService>;
+}
+
+interface CmatConfirmationConfig {
+    title?: string;
+    message?: string;
+    icon?: {
+        show?: boolean;
+        name?: string;
+        color?: 'primary' | 'accent' | 'warn' | 'basic' | 'info' | 'success' | 'warning' | 'error';
+    };
+    actions?: {
+        confirm?: {
+            show?: boolean;
+            label?: string;
+            color?: 'primary' | 'accent' | 'warn';
+        };
+        cancel?: {
+            show?: boolean;
+            label?: string;
+        };
+    };
+    dismissible?: boolean;
+}
+
+declare class CmatConfirmationDialogComponent {
+    data: CmatConfirmationConfig;
+    matDialogRef: MatDialogRef<CmatConfirmationDialogComponent, any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatConfirmationDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatConfirmationDialogComponent, "cmat-confirmation-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatConfirmationService {
+    private _matDialog;
+    private _defaultConfig;
+    open(config?: CmatConfirmationConfig): MatDialogRef<CmatConfirmationDialogComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatConfirmationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatConfirmationService>;
+}
+
+declare class CmatDataService {
+    private readonly _http;
+    private readonly _urlStateConfigService;
+    private readonly _destroyRef;
+    private _enableDataProtect;
+    constructor();
+    get<T>(url: string, params?: Record<string, unknown>, auth?: boolean): Observable<T>;
+    post<T>(url: string, data: any, params?: Record<string, unknown>, auth?: boolean, idempotent?: boolean): Observable<T>;
+    put<T>(url: string, data: any, params?: Record<string, unknown>, auth?: boolean): Observable<T>;
+    delete<T>(url: string, params?: Record<string, unknown>, auth?: boolean): Observable<T>;
+    patch<T>(url: string, data: any, params?: Record<string, unknown>, auth?: boolean): Observable<T>;
+    private _buildHttpParams;
+    private _decryptResponse;
+    private _normalizeParamValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatDataService>;
+}
+
+type SupportedExtensions = 'xlsx' | 'xls' | 'txt' | 'csv' | 'json' | 'xml';
+interface ExportAsConfig {
+    type: SupportedExtensions;
+    elementIdOrContent: string;
+    download?: boolean;
+    fileName: string;
+    options?: any;
+}
+
+declare class CmatExportAsService {
+    get(config: ExportAsConfig): Observable<any>;
+    save(config: ExportAsConfig, fileName: string): Observable<string | null>;
+    contentToBlob(content: string): Observable<Blob>;
+    removeFileTypeFromBase64(fileContent: string): string;
+    addFileTypeToBase64(fileContent: string, fileMime: string): string;
+    downloadFromDataURL(fileName: string, dataURL: string): void;
+    downloadFromBlob(blob: Blob, fileName: string): void;
+    private _getCSV;
+    private _getTXT;
+    private _getXLS;
+    private _getXLSX;
+    private _getJSON;
+    private _getXML;
+    private _btoa;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatExportAsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatExportAsService>;
+}
+
+declare class CmatLoadingService {
+    private readonly _auto$;
+    private readonly _mode$;
+    private readonly _progress$;
+    private readonly _show$;
+    private readonly _autoObservable$;
+    private readonly _modeObservable$;
+    private readonly _progressObservable$;
+    private readonly _showObservable$;
+    private readonly _urlSet;
+    get auto$(): Observable<boolean>;
+    get isAuto(): boolean;
+    get mode$(): Observable<'determinate' | 'indeterminate'>;
+    get currentMode(): 'determinate' | 'indeterminate';
+    get progress$(): Observable<number | null>;
+    get currentProgress(): number | null;
+    get show$(): Observable<boolean>;
+    get isShowing(): boolean;
+    show(): void;
+    hide(): void;
+    setAutoMode(value: boolean): void;
+    setMode(value: 'determinate' | 'indeterminate'): void;
+    setProgress(value: number): void;
+    setLoadingStatus(status: boolean, url: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatLoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatLoadingService>;
+}
+
+declare class CmatLoadingInterceptor implements HttpInterceptor {
+    private readonly _cmatLoadingService;
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatLoadingInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatLoadingInterceptor>;
+}
+
+declare class CmatLocalStorageService {
+    getItem(key: string): string | null;
+    setItem(key: string, item: string): void;
+    removeItem(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatLocalStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatLocalStorageService>;
+}
+
+interface CmatMediaChange {
+    matchingAliases: string[];
+    matchingQueries: Record<string, string>;
+}
+declare class CmatMediaWatcherService {
+    private readonly _breakpointObserver;
+    private readonly _cmatConfigService;
+    get onMediaChange$(): Observable<CmatMediaChange>;
+    onMediaQueryChange$(query: string | string[]): Observable<BreakpointState>;
+    private _screensAreEqual;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatMediaWatcherService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatMediaWatcherService>;
+}
+
+declare class CmatPlatformService {
+    osName: string;
+    private _platform;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatPlatformService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatPlatformService>;
+}
+
+declare class CmatSplashScreenService {
+    private _document;
+    private _router;
+    private readonly _destroyRef;
+    constructor();
+    show(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSplashScreenService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatSplashScreenService>;
+}
+
+declare class CmatTitleService {
+    private readonly _destroyRef;
+    private readonly _router;
+    private readonly _titleService;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTitleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatTitleService>;
+}
+
+declare class CmatTranslationService {
+    private _translate;
+    private readonly _defaultLanguage;
+    private _onLanguageChanged;
+    constructor();
+    get languageChanged$(): Observable<Language>;
+    addLanguages(lang: Language[]): void;
+    setDefaultLanguage(lang: Language): void;
+    getDefaultLanguage(): Language;
+    getBrowserLanguage(): Language | void;
+    useBrowserLanguage(): Language | void;
+    changeLanguage(language?: Language): Language;
+    getTranslation(key: string | string[], interpolateParams?: object): any;
+    getTranslationAsync(key: string | string[], interpolateParams?: object): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTranslationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatTranslationService>;
+}
+
+declare class CmatUtilsService {
+    static readonly captionAndMessageSeparator = ":";
+    static readonly noNetworkMessageCaption = "\u65E0\u7F51\u7EDC";
+    static readonly noNetworkMessageDetail = "\u65E0\u6CD5\u8FDE\u63A5\u670D\u52A1\u5668";
+    static readonly accessDeniedMessageCaption = "\u62D2\u7EDD\u8BBF\u95EE!";
+    static readonly accessDeniedMessageDetail = "";
+    private static readonly key;
+    private static readonly iv;
+    get exactMatchOptions(): IsActiveMatchOptions;
+    get subsetMatchOptions(): IsActiveMatchOptions;
+    static getRequestHeaders(): HttpHeaders;
+    static getRequestIdempotentHeaders(): HttpHeaders;
+    static getRequestBypassHeaders(): HttpHeaders;
+    static getRequestIdempotentBypassHeaders(): HttpHeaders;
+    static getRequestCryptoHeaders(params: string): HttpHeaders;
+    static getRequestCryptoBypassHeaders(params: string): HttpHeaders;
+    static getRequestCryptoIdempotentHeaders(params: string): HttpHeaders;
+    static getRequestCryptoIdempotentBypassHeaders(params: string): HttpHeaders;
+    static getEncryptData(data: string): string;
+    static getDecryptData(data: string): string;
+    static handleError(error: any): Observable<never>;
+    static getHttpResponseMessage(data: any): string[];
+    static findHttpResponseMessage(messageToFind: string, data: any, seachInCaptionOnly?: boolean, includeCaptionInResult?: boolean): string | null;
+    static getResponseBody(response: HttpResponseBase): any;
+    static checkNoNetwork(response: HttpResponseBase): boolean;
+    static checkAccessDenied(response: HttpResponseBase): boolean;
+    static checkNotFound(response: HttpResponseBase): boolean;
+    static checkIsLocalHost(url: string, base?: string): boolean;
+    static getQueryParamsFromString(paramString: string): Record<string, string | null> | null;
+    static splitInTwo(text: string, separator?: string): {
+        firstPart: string;
+        secondPart: string | null;
+    };
+    static safeStringify(object: any): string;
+    static jsonTryParse(value: string): string | void;
+    static capitalizeFirstLetter(text: string): string;
+    static toTitleCase(text: string): string;
+    static toLowerCase(items: any): string | string[] | void;
+    static uniqueId(): string;
+    static randomNumber(min: number, max: number): number;
+    static baseUrl(): string;
+    static newGuid(): string;
+    static testIsAbsoluteUrl(url: string): boolean;
+    static convertToAbsoluteUrl(url: string): string;
+    static urlBase64Decode(str: string): string;
+    static decodeToken(token: string): any;
+    static getTokenExpirationDate(token: string): Date | null;
+    static isTokenExpired(token: string, offsetSeconds?: number): boolean;
+    static readAsDataURL(file: File): Promise<any>;
+    static dataURIToBlob(dataURI: string): Blob;
+    static getFileType(accept: string): 'csv' | 'gif' | 'word' | 'excel' | 'jpg' | 'outlook' | 'pdf' | 'png' | 'ppt' | 'file' | 'text' | 'video' | 'zip';
+    static isDateString(value: any): boolean;
+    static transformObjectsForExport(jsonObjects: any[], columns: any[]): any[];
+    private static _base64DecodeUnicode;
+    randomId(stringLength?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatUtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatUtilsService>;
+}
+
+export { AngularShape, AngularShapeView, CLOCK_INNER_RADIUS, CLOCK_OUTER_RADIUS, CLOCK_RADIUS, CLOCK_TICK_RADIUS, CMAT_APP_CONFIG, CMAT_DATETIMEPICKER_SCROLL_STRATEGY, CMAT_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY, CMAT_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, CMAT_DATETIMEPICKER_VALIDATORS, CMAT_DATETIMEPICKER_VALUE_ACCESSOR, CMAT_DATETIME_FORMATS, CMAT_DAYJS_DATETIME_FORMATS, CMAT_DAYJS_DATE_ADAPTER_OPTIONS, CMAT_DAYJS_DATE_ADAPTER_OPTIONS_FACTORY, CMAT_DAYJS_DATE_FORMATS, CMAT_MATERIAL_COLOR_PICKER_VALUE_ACCESSOR, CMAT_NATIVE_DATETIME_FORMATS, CNativeDatetimeAdapter, ChartNode, CmatAddonsWrapperComponent, CmatAlertDialog, CmatAlertMessage, CmatAlertService, CmatAnimationOnScrollDirective, CmatArrowCursorDirective, CmatAutofocusDirective, CmatBreadcrumbComponent, CmatBreadcrumbItemDirective, CmatBreadcrumbService, CmatButtonTypeComponent, CmatBytesPipe, CmatCardComponent, CmatCardWrapperComponent, CmatCarouselComponent, CmatCarouselFooterComponent, CmatCarouselHeaderComponent, CmatCarouselTemplateDirective, CmatCascadeBottomSheetComponent, CmatCascadeListComponent, CmatCascadeTypeComponent, CmatCheckListTypeComponent, CmatChipInputComponent, CmatChipsInputTypeComponent, CmatCodeEditorComponent, CmatColorPickerTypeComponent, CmatConfigService, CmatConfirmationService, CmatDataExporterDirective, CmatDataService, CmatDateFormatPipe, CmatDateRangeComponent, CmatDateRangeTypeComponent, CmatDateTimeDisplayComponent, CmatDatepickerTypeComponent, CmatDatetimepickerCalendarBodyComponent, CmatDatetimepickerCalendarCellComponent, CmatDatetimepickerCalendarComponent, CmatDatetimepickerClockComponent, CmatDatetimepickerComponent, CmatDatetimepickerContentComponent, CmatDatetimepickerFilterType, CmatDatetimepickerInputDirective, CmatDatetimepickerInputEvent, CmatDatetimepickerMonthViewComponent, CmatDatetimepickerToggleComponent, CmatDatetimepickerToggleIconDirective, CmatDatetimepickerYearViewComponent, CmatDebounceClickDirective, CmatDebounceKeyupDirective, CmatDialogType, CmatDigitOnlyDirective, CmatDrawerComponent, CmatDrawerService, CmatEmptyStateComponent, CmatEqualValidatorDirective, CmatExpansionWrapperComponent, CmatExportAsService, CmatFilePreviewComponent, CmatFilesUtilService, CmatFilterToolbarComponent, CmatFindByKeyPipe, CmatFormActionsComponent, CmatFormFieldWrapperComponent, CmatFullscreenComponent, CmatGroupByPipe, CmatHighlightComponent, CmatHighlightService, CmatHorizontalNavigationComponent, CmatImageComponent, CmatInlineLoadingComponent, CmatJsonEditorComponent, CmatKeysPipe, CmatKnobInputComponent, CmatKnobTypeComponent, CmatLoadingInterceptor, CmatLoadingService, CmatLocalStorageService, CmatMaskDirective, CmatMasonryComponent, CmatMaterialColorPickerComponent, CmatMediaWatcherService, CmatMessageSeverity, CmatMultiCheckboxTypeComponent, CmatNavigationItem, CmatNavigationService, CmatNumberTypeComponent, CmatOrgChartComponent, CmatOtpInputComponent, CmatPageHeaderComponent, CmatPaginatePipe, CmatPaginationComponent, CmatPaginationDirective, CmatPaginationService, CmatPanelWrapperComponent, CmatPassToggleVisibilityComponent, CmatPasswordStrengthComponent, CmatPasswordStrengthInfoComponent, CmatPlatformService, CmatPopoverComponent, CmatPopoverTargetDirective, CmatPopoverTriggerDirective, CmatProgressBarComponent, CmatQRCodeComponent, CmatQuillTypeComponent, CmatRadioTypeComponent, CmatRatingComponent, CmatRatingTypeComponent, CmatRepeatTypeComponent, CmatRichTextEditorComponent, CmatSeamlessAutoScrollDirective, CmatSecurePipe, CmatSelectSearchComponent, CmatSelectTableComponent, CmatSelectTableTypeComponent, CmatSelectTreeComponent, CmatSelectTreeFlatNode, CmatSelectTreeNode, CmatSelectTreeTypeComponent, CmatSelectTypeComponent, CmatSelectedColor, CmatSliderTypeComponent, CmatSpeedDialActionsComponent, CmatSpeedDialComponent, CmatSpeedDialTriggerComponent, CmatSplashScreenService, CmatStatusTagComponent, CmatStepperHorizontalTypeComponent, CmatStepperVerticalTypeComponent, CmatTabTypeComponent, CmatTableToolbarComponent, CmatTableTypeComponent, CmatTagsTypeComponent, CmatTextareaTypeComponent, CmatTimelineComponent, CmatTimelineItemComponent, CmatTimelineItemIconDirective, CmatTimelineItemLabelDirective, CmatTitleService, CmatToastComponent, CmatToastModalComponent, CmatToastService, CmatTransferFilterCondition, CmatTransferItemFlatNode, CmatTransferItemNode, CmatTransferPickerComponent, CmatTransferPickerFilterComponent, CmatTransferPickerSearchComponent, CmatTransferPickerService, CmatTransferPickerSourceComponent, CmatTransferPickerTargetComponent, CmatTranslationService, CmatTreeTableColumnDirective, CmatTreeTableComponent, CmatTreeTableNode, CmatUploadComponent, CmatUploadQueueComponent, CmatUploadTypeComponent, CmatUppercasePipe, CmatUrlStateConfigService, CmatUtilsService, CmatVerticalNavigationComponent, DatetimeAdapter, DayjsDateAdapter, DayjsDatetimeAdapter, ExportType, MAT_SELECTSEARCH_DEFAULT_OPTIONS, addonsExtension, configurableDefaultOptions, register, registerInfo };
+export type { AngularShapeConfig, AnimationMode, ApiResult, CMAT_TIMELINE_ORIENTATION, CMAT_TIMELINE_POSITION, CmatAMPM, CmatAppConfig, CmatAppConfigBase, CmatBreadcrumb, CmatBreadcrumbDefinition, CmatBreadcrumbFunction, CmatBreadcrumbObject, CmatCalendarView, CmatCardFace, CmatCarouselPageEvent, CmatCarouselResponsiveOptions, CmatCarouselTemplates, CmatCascadeOptionsInterface, CmatClockView, CmatConfirmationConfig, CmatDatetimeFormats, CmatDatetimepickerMode, CmatDatetimepickerType, CmatDrawerMode, CmatDrawerPosition, CmatNavigationComponent, CmatPaginatePipeArgs, CmatPaginationInstance, CmatPipeState, CmatPopoverPosition, CmatPopoverPositionEnd, CmatPopoverPositionStart, CmatPopoverScrollStrategy, CmatPopoverTriggerEvent, CmatScheme, CmatScreens, CmatSelectTableColumn, CmatSelectTableDataSource, CmatSelectTableFilter, CmatSelectTableRow, CmatSourceOptions, CmatTheme, CmatThemeOption, CmatToastModel, CmatTransferFilterData, CmatTransferFilterItem, CmatVerticalNavigationAppearance, CmatVerticalNavigationMode, CmatVerticalNavigationPosition, Collection, ConfigurableDefaultOptions, Content, CustomFormFieldProps, DatetimepickerDropdownPositionX, DatetimepickerDropdownPositionY, DayJsDateAdapterOptions, Direction, ExcelOptions, ExportAsConfig, ExporterListInfo, FileCategoryModel, FileListModel, FileModel, FormlyMultiCheckboxFieldConfig, FormlyRadioFieldConfig, FormlySliderFieldConfig, GlobalConfigModel, GlobalPosition, GlobalTheme, GlobalType, INode, IUrlStateConfig, MatSelectSearchOptions, Options, Page, Position, PositionX, PositionY, SupportedExtensions, Theme, ToastAPrefix, TxtOptions, Type };