@wavemaker-ai/app-ng-runtime 1.0.0-rc.309

package/components/base/index.d.ts

@@ -0,0 +1,1436 @@
+import * as i0 from '@angular/core';
+import { PipeTransform, InjectionToken, OnDestroy, OnInit, AfterViewInit, AfterContentInit, Injector, ViewContainerRef, ElementRef, EnvironmentInjector, SecurityContext, TemplateRef } from '@angular/core';
+import { DecimalPipe, DatePipe } from '@angular/common';
+import { CustomPipeManager, App, AbstractI18nService, PartialRefProvider, CustomWidgetRefProvider, Viewport, IDGenerator } from '@wm/core';
+import * as _wavemaker_focus_trap from '@wavemaker/focus-trap';
+import { Subject } from 'rxjs';
+import { EventManager, DomSanitizer, SafeHtml, SafeValue } from '@angular/platform-browser';
+import * as lodash from 'lodash';
+import { SwipeAnimation } from '@swipey';
+
+declare enum Live_Operations {
+    INSERT = "insert",
+    UPDATE = "update",
+    DELETE = "delete",
+    READ = "read"
+}
+declare const ALLFIELDS = "All Fields";
+declare const LIVE_CONSTANTS: {
+    EMPTY_KEY: string;
+    EMPTY_VALUE: string;
+    LABEL_KEY: string;
+    LABEL_VALUE: string;
+    NULL_EMPTY: string[];
+    NULL: string;
+    EMPTY: string;
+};
+declare function performDataOperation(dataSource: any, requestData: any, options: any): Promise<any>;
+declare function refreshDataSource(dataSource: any, options: any): Promise<any>;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.fetchRelatedFieldData
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * This function fetches the data for the related field in live form/ grid
+ *
+ * @param {object} columnDef field definition
+ * @param {string} relatedField related field name
+ * @param {string} datafield Datafield to be set on widget
+ * @param {string} widget Type of the widget
+ * @param {object} elScope element scope
+ * @param {object} parentScope live form// grid scope
+ */
+declare function fetchRelatedFieldData(dataSource: any, formField: any, options: any): void;
+/**
+ * used to interpolate the bind expression for keys in the query builder
+ * @param context where we find the variable obj
+ * @param filterexpressions - obj containing all the rule objs
+ * @param callbackFn - function to be called with the new replaced values if any in the filterexpressions object
+ */
+declare const interpolateBindExpressions: (context: any, filterexpressions: any, callbackFn: any) => void;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.LiveWidgetUtils#getDistinctFieldProperties
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Returns the properties required for dataset widgets
+ *
+ * @param {object} dataSource variable source for the widget
+ * @param {object} formField definition of the column/ field
+ *
+ */
+declare const getDistinctFieldProperties: (dataSource: any, formField: any) => any;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.LiveWidgetUtils#getDistinctValues
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Returns the distinct values for a field
+ *
+ * @param {object} formField definition of the column/ field
+ * @param {string} widget widget property on the field
+ * @param {object} variable variable for the widget
+ * @param {function} callBack Function to be executed after fetching results
+ *
+ */
+declare function getDistinctValues(dataSource: any, formField: any, widget: any): Promise<unknown>;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.LiveWidgetUtils#fetchDistinctValues
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to fetch the distinct values for a field
+ *
+ * @param {object} scope scope of the widget
+ * @param {object} formFields definitions of the column/ field
+ * @param {string} widget widget property on the field
+ * @param {boolean} isEnableEmptyFilter is null or empty values allowed on filter
+ *
+ */
+declare function fetchDistinctValues(dataSource: any, formFields: any, options: any): void;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.LiveWidgetUtils#getDistinctValuesForField
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to fetch the distinct values for a field
+ *
+ * @param {object} scope scope of the widget
+ * @param {object} formFields definitions of the column/ field
+ * @param {string} widget widget property on the field
+ * @param {boolean} isEnableEmptyFilter is null or empty values allowed on filter
+ *
+ */
+declare function getDistinctValuesForField(dataSource: any, formField: any, options?: any): void;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getRangeFieldValue
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the field value for range
+ *
+ * @param {string} minValue min value selected
+ * @param {string} maxValue max value selected
+ */
+declare function getRangeFieldValue(minValue: any, maxValue: any): any;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getRangeMatchMode
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the match mode for range
+ *
+ * @param {string} minValue min value selected
+ * @param {string} maxValue max value selected
+ */
+declare function getRangeMatchMode(minValue: any, maxValue: any): any;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getEnableEmptyFilter
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * This function checks if enable filter options is set on live filter
+ *
+ * @param {object} enableemptyfilter empty filter options
+ */
+declare function getEnableEmptyFilter(enableemptyfilter: any): boolean;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getEmptyMatchMode
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the match mode based on the filter selected
+ *
+ * @param {object} enableemptyfilter empty filter options
+ */
+declare function getEmptyMatchMode(enableemptyfilter: any): any;
+/**
+ * converts the data passed to array.
+ *  -> Array: [1,2,3] - [1,2,3]
+ *  -> String: a,b,c - ['a','b','c']
+ *  -> object: {a:1} - [{a:1}]
+ *  -> null - []
+ *  -> undefined - []
+ * @param data
+ * @returns {Array<any>}
+ */
+declare const createArrayFrom: (data: any) => Array<any>;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.applyFilterOnField
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the updated values when filter on field is changed
+ *
+ * @param {object} $scope scope of the filter field/form field
+ * @param {object} filterDef filter/form definition of the field
+ * @param {boolean} isFirst boolean value to check if this method is called on load
+ */
+declare function applyFilterOnField(dataSource: any, filterDef: any, formFields: any, newVal: any, options?: any): void;
+declare function transformData(dataObject: any, variableName: any): any;
+
+declare class WmPipe {
+    private pipeName;
+    protected customPipeManager: CustomPipeManager;
+    protected pipeRef: any;
+    protected isCustomPipe: any;
+    constructor(pipeName: any, customPipeManager: CustomPipeManager);
+    customFormatter(data: any, args: any, variables: any): any;
+}
+
+declare class TrailingZeroDecimalPipe implements PipeTransform {
+    private decimalPipe;
+    transform(value: any, selectedLocale: string, numberfilter: string, localefilter: any, trailingzero: boolean, decimalValue: string, skipTrailingZeroCheck?: boolean, formattedLocale?: any): any;
+    constructor(decimalPipe: DecimalPipe);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrailingZeroDecimalPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TrailingZeroDecimalPipe, "trailingZeroDecimalPipe", true>;
+}
+declare class ToDatePipe extends WmPipe implements PipeTransform {
+    private datePipe;
+    private i18nService;
+    private app;
+    protected customPipeManager: CustomPipeManager;
+    returnFn(data: any, args: any, variables: any): any;
+    transform(data: any, format: any, timezone?: any, compInstance?: any): any;
+    constructor(datePipe: DatePipe, i18nService: AbstractI18nService, app: App, customPipeManager: CustomPipeManager);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToDatePipe, "toDate", true>;
+}
+declare class ToNumberPipe implements PipeTransform {
+    private decimalPipe;
+    private i18nService;
+    transform(data: any, fracSize: any): string;
+    constructor(decimalPipe: DecimalPipe, i18nService: AbstractI18nService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToNumberPipe, "toNumber", true>;
+}
+declare class ToCurrencyPipe implements PipeTransform {
+    private decimalPipe;
+    private i18nService;
+    transform(data: any, currencySymbol: any, fracSize: any): string;
+    constructor(decimalPipe: DecimalPipe, i18nService: AbstractI18nService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToCurrencyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToCurrencyPipe, "toCurrency", true>;
+}
+declare class PrefixPipe implements PipeTransform {
+    transform(data: any, padding: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrefixPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PrefixPipe, "prefix", true>;
+}
+declare class SuffixPipe implements PipeTransform {
+    transform(data: any, padding: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuffixPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SuffixPipe, "suffix", true>;
+}
+/**
+ * Custom pipe: It is work as interceptor between the user custom pipe function and angular pipe
+ */
+declare class CustomPipe implements PipeTransform {
+    private app;
+    private custmeUserPipe;
+    constructor(app: App, custmeUserPipe: CustomPipeManager);
+    transform(data: any, pipename: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CustomPipe, "custom", true>;
+}
+declare class TimeFromNowPipe implements PipeTransform {
+    transform(data: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeFromNowPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TimeFromNowPipe, "timeFromNow", true>;
+}
+declare class NumberToStringPipe extends ToNumberPipe implements PipeTransform {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberToStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NumberToStringPipe, "numberToString", true>;
+}
+declare class StringToNumberPipe implements PipeTransform {
+    transform(data: any): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StringToNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<StringToNumberPipe, "stringToNumber", true>;
+}
+declare class FilterPipe implements PipeTransform {
+    transform(data: any[], field: any, value: any): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterPipe, "filter", true>;
+}
+declare class FileSizePipe implements PipeTransform {
+    transform(bytes: number, precision: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FileSizePipe, "filesize", true>;
+}
+declare class FileIconClassPipe implements PipeTransform {
+    transform(fileExtension: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileIconClassPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FileIconClassPipe, "fileIconClass", true>;
+}
+declare class StateClassPipe implements PipeTransform {
+    transform(state: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StateClassPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<StateClassPipe, "stateClass", true>;
+}
+declare class TemplateReplacePipe implements PipeTransform {
+    transform(data: any, replaceObj: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateReplacePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TemplateReplacePipe, "templateReplace", true>;
+}
+declare class FileExtensionFromMimePipe implements PipeTransform {
+    transform(mimeType: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileExtensionFromMimePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FileExtensionFromMimePipe, "fileExtensionFromMime", true>;
+}
+
+/**
+ * function to get the ordered dataset based on the given orderby
+ */
+declare const getOrderedDataset: (dataSet: any, orderBy: string, innerItem?: any) => any;
+/**
+ * Returns an array of object, each object contain the DataSetItem whose key, value, label are extracted from object keys.
+ */
+declare const transformDataWithKeys: (dataSet: any) => DataSetItem[];
+declare const extractDataAsArray: (data: any) => any;
+declare const convertDataToObject: (dataResult: any) => any;
+/**
+ * The first step in datasetItems creation is data transformation:
+ *
+ * The dataset can contain one of the following formats and each of them to be converted to the given format;
+ *
+ * 1) The comma separated string..eg: A,B,C => [{ key: 'A', value: 'A'}, { key: 'B', value: 'B'}, { key: 'C', value: 'C'}]
+ * 2) The array of values eg: [1,2,3] => [{ key: 1, value: 1}, { key: 2, value: 2}, { key: 3, value: 3}]
+ * 3) an object eg: {name: 'A', age: 20} => [ {key: 'name', value: 'A'}, {key: 'age', value: 20}]
+ * 4) an array of objects...eg: [ {name: 'A', age: 20}, {name: 'B', age: 20}] ==> returns [{key: _DATAFIELD_, value: _DISPLAYFIELD, label: _DISPLAYVALUE}]
+ */
+declare const transformFormData: (context: any, dataSet: any, myDataField?: string, displayOptions?: any, startIndex?: number, scope?: any) => Array<DataSetItem>;
+/**
+ * Private method to get the unique objects by the data field
+ */
+declare const getUniqObjsByDataField: (data: Array<DataSetItem>, dataField: string, displayField: string, allowEmptyFields?: boolean) => any;
+/**
+ * This function sets the selectedItem by comparing the field values, where fields are passed by "compareby" property.
+ * works only for datafield with ALL_FIELDS
+ * @param datasetItems list of dataset items.
+ * @param compareWithDataObj represents the datavalue (object) whose properties are to be checked against each property of datasetItem.
+ * @param compareByField specifies the property names on which datasetItem has to be compared against datavalue object.
+ */
+declare const setItemByCompare: (datasetItems: Array<DataSetItem>, compareWithDataObj: Object, compareByField: string) => void;
+/**
+ * This method gets the groupedData using groupby property and match and returns the sorted array of objects.
+ *
+ * @param compRef represents the component's reference i.e. "this" value.
+ * @param data represents the dataset i.e array of objects.
+ * @param groupby, string groupby property
+ * @param match, string match property
+ * @param orderby, string orderby property
+ * @param dateformat, string dateFormat property
+ * @param innerItem, represents the innerItem on which groupby has to be applied. Incase of datasetItems, 'dataObject' contains the full object. Here innerItem is dataObject.
+ * @returns {any[]} groupedData, array of objects, each object having key and data.
+ */
+declare const groupData: (compRef: any, data: Array<Object | DataSetItem>, groupby: string, match: string, orderby: string, dateformat: string, datePipe: ToDatePipe, innerItem?: string, AppDefaults?: any) => any[];
+declare const filterDate: (value: string | number, format: string, defaultFormat: string, datePipe: ToDatePipe) => any;
+/**
+ * This method toggles all the list items inside the each list group.
+ * @param el, component reference on which groupby is applied.
+ */
+declare const toggleAllHeaders: (el: any) => void;
+/**
+ * On list header click, toggle the list items in this group.
+ * and also toggle the header icon.
+ * @param $event
+ */
+declare const handleHeaderClick: ($event: Event) => void;
+/**
+ * configures reordering the items.
+ * @param $el element to be sortable
+ * @param options object containing the sortable options.
+ * @param startCb callback on drag start on the element.
+ * @param updateCb callback triggerred when sorting is stopped and the DOM position has changed.
+ * @param sortCb callback triggerred during the sorting of an element.
+ */
+declare const configureDnD: ($el: any, options: object, startCb: Function, updateCb: Function, sortCb?: Function) => void;
+/**
+ * key represents the datafield value
+ * label represents display value or expression value
+ * value displayValue for primitives and data object for allFields
+ * dataObject represent the object from the dataset when datafield is ALLFIELDS. This is used as innerItem while grouping the datasetItems.
+ * imgSrc picture source
+ * selected represents boolean to notify selected item.
+ */
+declare class DataSetItem {
+    key: any;
+    label: any;
+    value: any;
+    dataObject?: Object;
+    index?: number;
+    imgSrc?: string;
+    selected?: boolean;
+}
+
+declare const EDIT_MODE: {
+    QUICK_EDIT: string;
+    INLINE: string;
+    FORM: string;
+    DIALOG: string;
+};
+declare const setHeaderConfig: (headerConfig: any, config: any, field: any, index?: number) => void;
+declare const setHeaderConfigForTable: (headerConfig: any, config: any, fieldName: string, index?: number) => void;
+declare const getRowOperationsColumn: () => any;
+/**
+ * Returns caption and widget bootstrap classes for the field
+ */
+declare const getFieldLayoutConfig: (captionWidth: any, captionPosition: any, os: any) => any;
+declare const getDefaultViewModeWidget: (widget: any) => string;
+declare const parseValueByType: (value: any, type: any, widget: any, trailingzero?: any) => any;
+declare const getFieldTypeWidgetTypesMap: () => {
+    integer: string[];
+    big_integer: string[];
+    short: string[];
+    float: string[];
+    big_decimal: string[];
+    number: string[];
+    double: string[];
+    long: string[];
+    byte: string[];
+    string: string[];
+    character: string[];
+    text: string[];
+    date: string[];
+    time: string[];
+    timestamp: string[];
+    datetime: string[];
+    boolean: string[];
+    list: string[];
+    clob: string[];
+    blob: string[];
+    file: string[];
+    custom: string[];
+};
+declare const getDataTableFilterWidget: (type: any) => any;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getEditModeWidget
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * This function returns the default widget for grid
+ *
+ * @param {object} colDef field definition
+ */
+declare const getEditModeWidget: (colDef: any) => any;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.LiveWidgetUtils#getDefaultValue
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * return the formatted default value
+ *
+ * @param {string} value value to be formatted
+ * @param {string} type column type of the value
+ */
+declare const getDefaultValue: (value: any, type: any, widget: any) => any;
+
+declare const WidgetConfig: InjectionToken<IWidgetConfig>;
+interface IWidgetConfig {
+    widgetType: string;
+    widgetSubType?: string;
+    hostClass?: string;
+    displayType?: string;
+}
+interface IRedrawableComponent {
+    redraw: Function;
+}
+type ChangeListener = (key: string, nv: any, ov?: any) => void;
+declare abstract class WidgetRef {
+}
+declare abstract class DialogRef<T extends BaseComponent> {
+    bsModal: any;
+}
+declare const Context: InjectionToken<unknown>;
+interface IDialog {
+    open: (initState?: any) => void;
+    close: () => void;
+}
+
+interface Child {
+    widget: any;
+    nativeElement: any;
+}
+declare abstract class BaseComponent implements OnDestroy, OnInit, AfterViewInit, AfterContentInit {
+    protected inj: Injector;
+    /**
+     * unique identifier for the widget
+     */
+    readonly widgetId: any;
+    isDestroyed: boolean;
+    isAttached: boolean;
+    /**
+     * jQuery nativeElement reference of the component root
+     */
+    get $element(): any;
+    /**
+     * DOM node reference of the component root
+     */
+    readonly nativeElement: HTMLElement;
+    /**
+     * Type of the component
+     */
+    protected readonly widgetType: string;
+    /**
+     * Most of the cases it is same as widgetType
+     * for specific widgets like charts widgetType can be wm-chart where as the subtype can be wm-bar-chart
+     */
+    protected readonly widgetSubType: string;
+    /**
+     * Proxy for the component instance.
+     */
+    protected widget: any;
+    /**
+     * View parent component
+     * eg, Page, Partial, Prefab
+     */
+    protected readonly viewParent: any;
+    /**
+     * EventManger to add/remove events
+     */
+    protected readonly eventManager: EventManager;
+    /**
+     * App Locale
+     */
+    readonly appLocale: any;
+    /**
+     * Style change subject and observable
+     */
+    private readonly styleChange;
+    /**
+     * Property change subject and observable
+     */
+    private readonly propertyChange;
+    /**
+     * On Ready State change subject and observable
+     */
+    private readonly readyState;
+    /**
+     * Component destroy subject and observable
+     */
+    private readonly destroy;
+    /**
+     * Map of event handler callbacks
+     */
+    private eventHandlers;
+    /**
+     * context of the widget
+     * when the widget is preset inside a repeater this context will have the repeater related properties
+     */
+    context: any;
+    /**
+     * Initial state of the widget.
+     * Will be undefined once the initial properties are set on to the component
+     */
+    private initState;
+    /**
+     * Internal flag to determine whether to wait for the widget initialization or not
+     * If the initPromise is provided in the construction wait till the promise is resolved
+     * If the initPromise is not provided proceed with the initialization, which is the default behavior.
+     */
+    private readonly delayedInit;
+    /**
+     * Display type of the component. eg, block(Default), inline-block, inline etc
+     */
+    private readonly displayType;
+    /**
+     * Holds the event registration functions.
+     * these functions needs to be executed after onViewInit
+     */
+    private toBeSetupEventsQueue;
+    __cloneable__: boolean;
+    widgetProps: Map<string, any>;
+    private $attrs;
+    private isMuted;
+    viewContainerRef: ViewContainerRef;
+    viewParentApp: App;
+    /**
+     * To avoid re-rendering of widget, passing unique id as contextKey to createCustomInjector
+     * (for List, Dynamic Tabs, Accordion, Nav, Carousel)
+     */
+    trackId: string;
+    customWidgetSubType: string;
+    protected constructor(inj: Injector, config: IWidgetConfig, explicitContext?: any, initPromise?: Promise<any>);
+    getNativeElement(): HTMLElement;
+    getWidgetType(): string;
+    getWidgetSubType(): string;
+    getWidget(): any;
+    setProperty(propName: any, propValue: any): void;
+    getViewParent(): any;
+    notifyStyleChange(key: string, nv: any, ov: any): void;
+    notifyPropertyChange(key: string, nv: any, ov: any): void;
+    registerStyleChangeListener(fn: ChangeListener, ctx?: any): void;
+    registerReadyStateListener(fn: Function, ctx?: any): void;
+    registerPropertyChangeListener(fn: ChangeListener, ctx?: any): void;
+    registerDestroyListener(fn: Function, ctx?: any): void;
+    getDisplayType(): string;
+    protected createProxy(): any;
+    protected initContext(): void;
+    /**
+     * set the value on the proxy object ie, widget
+     * setting the property on the proxy will invoke the change listeners
+     * @param {string} key
+     * @param value
+     */
+    setWidgetProperty(key: string, value: any): void;
+    getAttr(attrName: string): string;
+    /**
+     * returns app instance
+     * @returns {App}
+     */
+    getAppInstance(): App;
+    /**
+     * Generates a unique id
+     * Default pattern is `widget-id-${id}`
+     * Components can override this method to generate a different id eg, bar-chart-1
+     */
+    protected generateWidgetId(): string;
+    /**
+     * Handles the common functionality across the components
+     * eg,
+     *  1. value of the class property will be applied on the host element
+     *  2. based on the value of show property component is shown/hidden
+     *
+     * @param {string} key
+     * @param nv
+     * @param ov
+     */
+    protected onPropertyChange(key: string, nv: any, ov?: any): void;
+    /**
+     * Default style change handler
+     */
+    protected onStyleChange(k: string, nv: any, ov?: any): void;
+    /**
+     * Register the widget with the widgetRegistry
+     */
+    protected registerWidget(widgetName: string): void;
+    /**
+     * override the
+     */
+    protected getMappedEventName(eventName: any): any;
+    /**
+     * invoke the event handler
+     * Components can override this method to execute custom logic before invoking the user callback
+     */
+    protected handleEvent(node: HTMLElement, eventName: string, eventCallback: Function, locals: any, meta?: string): void;
+    /**
+     * parse the event expression and save reference to the function inside eventHandlers map
+     * If the component provides a override for an event through @Event decorator invoke that
+     * else invoke the resolved function
+     *
+     * @param {string} eventName
+     * @param {string} expr
+     */
+    protected processEventAttr(eventName: string, expr: string, meta?: string, child?: Child): void;
+    /**
+     * Process the bound property
+     * Register a watch on the bound expression
+     */
+    protected processBindAttr(propName: string, expr: string, child?: any): void;
+    /**
+     * Remove watch on the bound property
+     */
+    protected removePropertyBinding(propName: string): void;
+    /**
+     * invoke the event callback method
+     * @param {string} eventName
+     * @param extraLocals
+     */
+    invokeEventCallback(eventName: string, extraLocals?: any): any;
+    /**
+     * Process the attribute
+     * If the attribute is an event expression, generate a functional representation of the expression
+     *      and keep in eventHandlers
+     * If the attribute is a bound expression, register a watch on the expression
+     */
+    protected processAttr(attrName: string, attrValue: string, child?: Child): void;
+    /**
+     * This is required as the native element attributes are case insensitive(camelcase) like customExpressions becomes customexpression
+     * and our logic to check like these changes will fail. Before IVY changes, angular maintains a separate object with these attributes
+     * as it is like in the camelcase. With IVY all those are gone. So need to maintain a separate list with the camelcasing of attributes
+     * @private
+     * _tNode.attrs attributes are stored in array(even index: key, odd index: value)
+     */
+    protected getAttributes(): string[];
+    /**
+     * Process the attributes
+     */
+    private processAttrs;
+    /**
+     * Update the initState with the default property values and the values provided in the markup
+     * Process the attributes
+     * Register the widget
+     */
+    protected initWidget(): void;
+    /**
+     * Update the default properties and the properties provided in the markup in component
+     * Invoking this method will result in invocation of propertyChange handlers on the component for the first time
+     */
+    protected setInitProps(): void;
+    /**
+     * Returns true, if a listener registered for the given event on this widget markup.
+     * @param eventName
+     * @returns {boolean}
+     */
+    protected hasEventCallback(eventName: any): boolean;
+    /**
+     * Sets the focus on the widget
+     */
+    protected focus(): void;
+    protected execute(operation: any, options: any): any;
+    mute(): void;
+    unmute(): void;
+    private customInjectorMap;
+    /**
+     * After the Angular 17 upgrade, Angular is no longer sending ngTemplateContext to components in ng-template.
+     * Wavemaker widgets inside ng-template require context to evaluate bind expressions.
+     * So we're creating an injectionToken that returns the context as a value.
+     * We are passing the injectionToken to the ngTemplateOutletInjector.
+     * This injects the context into each widget in the ng-template.
+     * In the widget component constructor we are getting the injectionToken using dependency injection.
+     * If injectionToken is present, we extend the component context with the value of injectionToken.
+     * @param contextKey
+     * @param context
+     * @returns injector
+     */
+    createCustomInjector(contextKey: string, context: any): any;
+    /**
+     * After the host page is attached from cache, this function is called.
+     */
+    ngOnAttach(): void;
+    /**
+     * Before the host page is detached from dom and stored in cache,  this function is called.
+     */
+    ngOnDetach(): void;
+    /**
+     * nativeElement will be available by this time
+     * if the delayInit is false, properties meta will be available by this time
+     * Invoke the setInitProps if the delayInit is false
+     */
+    ngOnInit(): void;
+    /**
+     * Register the events
+     */
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent, [null, null, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseComponent>;
+}
+
+declare abstract class StylableComponent extends BaseComponent {
+    backgroundattachment: string;
+    backgroundcolor: string;
+    backgroundgradient: string;
+    backgroundimage: string;
+    backgroundposition: string;
+    backgroundrepeat: string;
+    backgroundsize: string;
+    bordercolor: string;
+    borderradius: string;
+    borderstyle: string;
+    borderwidth: string;
+    borderbottomwidth: string;
+    borderleftwidth: string;
+    borderrightwidth: string;
+    bordertopwidth: string;
+    color: string;
+    cursor: string;
+    display: string;
+    fontsize: string;
+    fontfamily: string;
+    fontstyle: string;
+    fontunit: string;
+    fontvariant: string;
+    fontweight: string;
+    height: string;
+    horizontalalign: string;
+    lineheight: string;
+    margin: string;
+    marginbottom: string;
+    marginleft: string;
+    marginright: string;
+    margintop: string;
+    opacity: string;
+    overflow: string;
+    padding: string;
+    paddingbottom: string;
+    paddingleft: string;
+    paddingright: string;
+    paddingtop: string;
+    picturesource: string;
+    textalign: string;
+    textdecoration: string;
+    verticalalign: string;
+    visibility: string;
+    whitespace: string;
+    width: string;
+    wordbreak: string;
+    zindex: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StylableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StylableComponent>;
+}
+
+declare abstract class DatasetAwareNavComponent extends StylableComponent implements OnDestroy {
+    nodes: Array<NavNode>;
+    dataset: any;
+    itemicon: string;
+    itemlabel: string;
+    itemhint: string;
+    itemlink: string;
+    itemtarget: string;
+    itembadge: string;
+    itemchildren: string;
+    itemaction: string;
+    itemclass: string;
+    itemid: string;
+    isactive: string;
+    userrole: string;
+    orderby: string;
+    datafield: string;
+    displayfield: string;
+    private _itemFieldMap;
+    private binditemlabel;
+    private binditemhint;
+    private binditemicon;
+    private binditemaction;
+    private binditembadge;
+    private binditemchildren;
+    private binditemlink;
+    private binditemtarget;
+    private binduserrole;
+    private bindisactive;
+    private securityService;
+    protected binditemid: string | null;
+    protected nodes$: Subject<unknown>;
+    constructor(inj: Injector, WIDGET_CONFIG: any, explicitContext: any);
+    /**
+     * constructs individual node for the widget model.
+     * @param fields
+     * @param node
+     */
+    private getNode;
+    resetItemFieldMap(): void;
+    getItemFieldsMap(): any;
+    /**
+     * returns array for the value passed as nv.
+     * nv: 'a,b' => [{label:a, value:a}, {label:b, value:b}]
+     * nv: [1,2] => [{label:1, value:1}, {label:2, value:2}]
+     * nv: [{obj}, {obj}] => [{obj}, {obj}]
+     * @param nv
+     */
+    private prepareNodeDataSet;
+    /**
+     * constructs dataset form the nav elements.
+     */
+    private getNodes;
+    protected resetNodes(): void;
+    private _resetNodes;
+    onPropertyChange(key: any, nv: any, ov: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatasetAwareNavComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatasetAwareNavComponent>;
+}
+interface NavNode {
+    label: string;
+    action?: any;
+    badge?: string;
+    children?: Array<NavNode>;
+    class?: string;
+    disabled?: boolean;
+    icon?: string;
+    id?: string;
+    link?: string;
+    role?: string;
+    value?: any;
+}
+
+/**
+ * Returns the value for the provided key in the object
+ */
+declare const getObjValueByKey: (obj: any, strKey: string) => any;
+/**
+ * returns the display field data for any dataset widgets
+ * Based on the bind display expression or display expression or display name,
+ * data is extracted and formatted from the passed option object
+ * If there is field is specified, field value is obtained from the dataObj.
+ * If expression is given, evaluates the expression value.
+ * else check for bindExpression, extract the value from the dataObj
+ */
+declare const getEvaluatedData: (dataObj: any, options: any, context?: any) => any;
+declare const isActiveNavItem: (link: any, routeName: any) => boolean;
+/**
+* returns true if the menu has link to the current page.
+* @param nodes
+* @param routeUrl
+*/
+declare const hasLinkToCurrentPage: (nodes: Array<NavNode>, routeUrl: any) => any;
+/**
+ * Returns the orderBy Expression based on the 'sort 'option in pageable object
+ * returned by backend
+ * @param pageableObj
+ * @returns {string}
+ */
+declare const getOrderByExpr: (pageableObj: any) => string;
+declare const isDataSetWidget: (widget: any) => boolean;
+declare const getImageUrl: (urlString: any, shouldEncode?: any, defaultUrl?: any) => any;
+declare const getBackGroundImageUrl: (urlString: any) => any;
+declare function provideAs(reference: any, key: any, multi?: boolean): {
+    provide: any;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare function provideAsWidgetRef(reference: any): {
+    provide: any;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare function provideAsDialogRef(reference: any): {
+    provide: any;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare const NAVIGATION_TYPE: {
+    ADVANCED: string;
+    BASIC: string;
+    CLASSIC: string;
+    INLINE: string;
+    NONE: string;
+    ONDEMAND: string;
+    PAGER: string;
+    SCROLL: string;
+};
+declare const INPUTMODE: {
+    FINANCIAL: string;
+    NATURAL: string;
+};
+declare const AUTOCLOSE_TYPE: {
+    OUTSIDECLICK: string;
+    ALWAYS: string;
+    DISABLED: string;
+};
+declare const unsupportedStatePersistenceTypes: string[];
+declare const getWatchIdentifier: (...args: any[]) => string;
+declare const getMatchModeTypesMap: (multiMode?: any) => {
+    boolean: string[];
+    clob: any[];
+    blob: any[];
+};
+declare const getMatchModeMsgs: (appLocale: any) => {
+    start: any;
+    startignorecase: any;
+    end: any;
+    endignorecase: any;
+    anywhere: any;
+    anywhereignorecase: any;
+    exact: any;
+    exactignorecase: any;
+    notequals: any;
+    notequalsignorecase: any;
+    lessthan: any;
+    lessthanequal: any;
+    greaterthan: any;
+    greaterthanequal: any;
+    null: any;
+    isnotnull: any;
+    empty: any;
+    isnotempty: any;
+    nullorempty: any;
+    in: any;
+    notin: any;
+    between: any;
+};
+declare const getConditionalClasses: (nv: any, ov?: any) => {
+    toAdd: any;
+    toRemove: any;
+};
+declare const prepareFieldDefs: (data: any, options?: any) => any[] | {
+    objects: any[];
+    terminals: any[];
+};
+/**
+ * To get container target element to append the list for search and datepicker panel when field present in dialog
+ */
+declare const getContainerTargetClass: (element: any) => string;
+/**
+ * To extract the Variable Name from a Widget's binddatasource attribute
+ */
+declare const extractDataSourceName: (bindDataSource: any) => any;
+declare const setFocusTrap: (container: any, allowOutsideClick: any, setReturnFocusElement?: any) => _wavemaker_focus_trap.FocusTrap;
+/**
+ * Gets keyboard focusable elements within a specified element
+ * @param element {HTMLElement}
+ * @returns {Array}
+ */
+declare const getKeyboardFocusableElements: (element: HTMLElement) => Element[];
+declare const getCurrentWidgets: (element: any, widgets: any) => any;
+
+declare abstract class BaseContainerComponent extends StylableComponent implements OnDestroy {
+    reDrawableComponents: any;
+    content: any;
+    Widgets: any;
+    constructor(inj: Injector, WIDGET_CONFIG: IWidgetConfig, explicitContext: any);
+    private updateRedrawableComponents;
+    private redrawChildren;
+    onPropertyChange(key: string, nv: any, ov?: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseContainerComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseContainerComponent, never, never, {}, {}, ["reDrawableComponents"], never, true, never>;
+}
+
+declare class PartialContainerDirective implements OnDestroy {
+    componentInstance: any;
+    vcRef: ViewContainerRef;
+    elRef: ElementRef;
+    inj: Injector;
+    private envInjector;
+    private app;
+    private partialRefProvider;
+    private contentInitialized;
+    private $target;
+    get name(): any;
+    _renderPartial(partialName: string): Promise<void>;
+    /**
+     * Resolve prefab context for the partial
+     * Checks if partial is inside a prefab and returns the prefab name
+     */
+    private resolvePrefabContext;
+    renderPartial: lodash.DebouncedFunc<(partialName: string) => Promise<void>>;
+    onLoadSuccess(): void;
+    constructor(componentInstance: any, vcRef: ViewContainerRef, elRef: ElementRef, inj: Injector, envInjector: EnvironmentInjector, app: App, _content: string, partialRefProvider: PartialRefProvider);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PartialContainerDirective, [{ self: true; }, null, null, null, null, null, { attribute: "content"; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PartialContainerDirective, "[partialContainer]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CustomWidgetContainerDirective implements OnDestroy {
+    componentInstance: any;
+    vcRef: ViewContainerRef;
+    elRef: ElementRef;
+    inj: Injector;
+    private envInjector;
+    private app;
+    private customWidgetRefProvider;
+    constructor(componentInstance: any, vcRef: ViewContainerRef, elRef: ElementRef, inj: Injector, envInjector: EnvironmentInjector, app: App, widgetname: string, customWidgetRefProvider: CustomWidgetRefProvider);
+    private loadCustomWidget;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomWidgetContainerDirective, [{ self: true; }, null, null, null, null, null, { attribute: "widgetname"; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomWidgetContainerDirective, "[customWidgetContainer][widgetname]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BaseFieldValidations {
+    private hasValidators;
+    private instance;
+    formwidget: any;
+    private widgettype;
+    private widgetControl;
+    private widgetContext;
+    private tableFieldType;
+    private defaultValidatorMessages;
+    private _syncValidators;
+    private _asyncValidatorFn;
+    constructor(instance: any, formwidget: any, widgettype: any, widgetControl: any, widgetContext: any, tableFieldType?: any);
+    private getDefaultValidators;
+    setUpValidators(customValidator?: any): void;
+    getPromiseList(validators: any): any[];
+    setAsyncValidators(validators: any): void;
+    isDefaultValidator(type: any): undefined;
+    setDefaultValidator(key: any, value: any): void;
+    setValidators(validators: any): void;
+    observeOn(fields: any, context: any): void;
+    validate(): void;
+    watchDefaultValidatorExpr(fn: any, key: any): void;
+    isNullOrEmptyOrFalsy(value: any): boolean;
+    applyDefaultValidators(): void;
+    setCustomValidationMessage(): void;
+    destroy(): void;
+}
+
+/**
+ * This directive is used to set custom template partial for an item and maintains separate scope for each item.
+ * This takes two inputs
+ *      1) template partial name as wmItemTemplate
+ *      2) item object as userComponentParams
+ * Example: Providing a custom template for the search/autocomplete widget (customized UI in the dropdown for each item)
+ * Add this directive to the li tag and provide item object and partial name like below. And also provide partialContainer and partial-container-target to render the partial.
+ * <li #liElements *ngFor="let match of matches" [wmItemTemplate]="content" [userComponentParams]="match.item" partialContainer>
+ *      <a partial-container-target></a>
+ * </li>
+ */
+
+declare class ItemTemplateDirective extends StylableComponent implements OnInit, OnDestroy {
+    private app;
+    static initializeProps: void;
+    context: any;
+    content: any;
+    partialParams: any;
+    nativeElement: HTMLElement;
+    viewContainerRef: ViewContainerRef;
+    get $index(): any;
+    userComponentParams: any;
+    set wmItemTemplate(value: any);
+    constructor(inj: Injector, elRef: ElementRef, app: App, explicitContext: any);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemTemplateDirective, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ItemTemplateDirective, "[wmItemTemplate]", ["itemTemplateRef"], { "userComponentParams": { "alias": "userComponentParams"; "required": false; }; "wmItemTemplate": { "alias": "wmItemTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RepeatTemplateDirective extends StylableComponent {
+    static initializeProps: void;
+    constructor(inj: Injector, explicitContext: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatTemplateDirective, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RepeatTemplateDirective, "[wmRepeatTemplate]", ["repeatItemRef"], {}, {}, never, never, true, never>;
+}
+
+declare class MessageComponent extends StylableComponent {
+    static initializeProps: void;
+    messageClass: string;
+    messageIconClass: string;
+    type: string;
+    caption: string;
+    hideclose: any;
+    constructor(inj: Injector, explicitContext: any);
+    showMessage(caption?: string, type?: string): void;
+    hideMessage(): void;
+    dismiss($event: any): void;
+    private onMessageTypeChange;
+    onPropertyChange(key: any, nv: any, ov?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageComponent, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageComponent, "[wmMessage]", ["wmMessage"], {}, {}, never, never, true, never>;
+}
+
+declare class PullToRefresh extends SwipeAnimation {
+    private $el;
+    private app;
+    private onPullToRefresh;
+    private infoContainer;
+    private runAnimation;
+    private count;
+    private spinner;
+    cancelSubscription: () => void;
+    private animationInProgress;
+    constructor($el: JQuery<HTMLElement>, app: App, onPullToRefresh: () => void);
+    threshold(): number;
+    direction(): any;
+    private subscribe;
+    bounds($event: any, $d: any): {
+        lower: any;
+        upper: any;
+        center?: undefined;
+        strict?: undefined;
+    } | {
+        lower: number;
+        center: number;
+        upper: number;
+        strict: boolean;
+    };
+    context(): object;
+    animation(): {
+        css: {
+            transform: string;
+            spin: string;
+            opacity?: undefined;
+        };
+        target?: undefined;
+    } | {
+        target: JQuery<HTMLElement>;
+        css: {
+            transform: string;
+            spin: string;
+            opacity: string;
+        };
+    };
+    onAnimation(): void;
+    stopAnimation(): void;
+    wait(): void;
+    destroy(): void;
+}
+
+declare class PartialDirective extends StylableComponent implements OnDestroy {
+    private viewport;
+    static initializeProps: void;
+    constructor(inj: Injector, viewport: Viewport, explicitContext: any);
+    private callback;
+    ngOnAttach(): void;
+    ngOnDetach(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PartialDirective, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PartialDirective, "[wmPartial]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RedrawableDirective implements IRedrawableComponent {
+    redraw: Function;
+    constructor(widget: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RedrawableDirective, [{ self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RedrawableDirective, "[redrawable]", never, {}, {}, never, never, true, never>;
+}
+
+declare const EVENTS_MAP: Map<string, string>;
+declare const DISPLAY_TYPE: {
+    BLOCK: string;
+    INLINE_BLOCK: string;
+    INLINE: string;
+};
+/**
+ * Returns true if the provided key is a boolean attribute
+ * @param {string} key
+ * @returns {boolean}
+ */
+declare const isBooleanAttr: (key: string) => boolean;
+declare const isDimensionProp: (key: string) => boolean;
+declare const DEBOUNCE_TIMES: {
+    PAGINATION_DEBOUNCE_TIME: number;
+};
+
+declare const updateDeviceView: (element: HTMLElement, isTablet?: boolean) => void;
+
+declare enum APPLY_STYLES_TYPE {
+    CONTAINER = 0,
+    SCROLLABLE_CONTAINER = 1,
+    INNER_SHELL = 2,
+    SHELL = 3
+}
+declare const propNameCSSKeyMap: {
+    backgroundattachment: string;
+    backgroundcolor: string;
+    backgroundgradient: string;
+    backgroundimage: string;
+    backgroundposition: string;
+    backgroundrepeat: string;
+    backgroundsize: string;
+    bordercolor: string;
+    borderradius: string;
+    borderstyle: string;
+    borderwidth: string;
+    borderbottomwidth: string;
+    borderleftwidth: string;
+    borderrightwidth: string;
+    bordertopwidth: string;
+    color: string;
+    cursor: string;
+    display: string;
+    fontsize: string;
+    fontfamily: string;
+    fontstyle: string;
+    fontunit: string;
+    fontvariant: string;
+    fontweight: string;
+    height: string;
+    horizontalalign: string;
+    lineheight: string;
+    margin: string;
+    marginbottom: string;
+    marginleft: string;
+    marginright: string;
+    margintop: string;
+    opacity: string;
+    overflow: string;
+    padding: string;
+    paddingbottom: string;
+    paddingleft: string;
+    paddingright: string;
+    paddingtop: string;
+    picturesource: string;
+    textalign: string;
+    textdecoration: string;
+    verticalalign: string;
+    visibility: string;
+    whitespace: string;
+    width: string;
+    wordbreak: string;
+    zindex: string;
+};
+declare const isStyle: (key: any) => boolean;
+declare function styler($node: HTMLElement, component: StylableComponent, type?: APPLY_STYLES_TYPE, skipList?: Array<string>): void;
+
+declare const widgetIdGenerator: IDGenerator;
+
+declare const getWidgetPropsByType: (identifier: string) => Map<string, any>;
+declare const register: (identifier: string, props: Map<string, any>) => void;
+declare const registerFormWidget: (identifier: string, props: Map<string, any>) => void;
+declare enum PROP_TYPE {
+    BOOLEAN = 1,
+    NUMBER = 2,
+    STRING = 3
+}
+declare const PROP_STRING: any;
+declare const PROP_NUMBER: any;
+declare const PROP_BOOLEAN: any;
+declare const PROP_ANY: any;
+
+declare class DialogServiceImpl {
+    /**
+     * map which contains the references to all dialogs by name
+     * @type {Map<any, any>}
+     * Ex Map[[dialogName, [[dialogScope, dialogRef]]]]
+     */
+    private dialogRefsCollection;
+    private appConfirmDialog;
+    constructor();
+    /**
+     * Register dialog by name and scope
+     * @param {string} name
+     * @param {BaseDialog} dialogRef
+     * @param {scope}
+     */
+    register(name: string, dialogRef: any, scope: any): void;
+    getDialogRefsCollection(): Map<any, any>;
+    /**
+     * De Register dialog by name and scope
+     * @param name
+     * @param dialogRef
+     * @param scope
+     */
+    deRegister(name: string, scope: any): void;
+    private getDialogRef;
+    /**
+     * Opens the dialog with the given name
+     * @param {string} name
+     */
+    open(name: string, scope?: any, initState?: any): void;
+    /**
+     * closes the dialog with the given name
+     * @param {string} name
+     */
+    close(name: string, scope?: any, callBackFn?: any): void;
+    /**
+     * closes all the opened dialogs
+     */
+    closeAllDialogs(): void;
+    showAppConfirmDialog(initState?: any): void;
+    closeAppConfirmDialog(): void;
+    getAppConfirmDialog(): string;
+    setAppConfirmDialog(dialogName: string): void;
+    addToOpenedDialogs(ref: any): void;
+    getLastOpenedDialog(): any;
+    removeFromOpenedDialogs(ref: any): void;
+    getOpenedDialogs(): any[];
+    addToClosedDialogs(ref: any): void;
+    removeFromClosedDialogs(ref: any): void;
+    getDialogRefFromClosedDialogs(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogServiceImpl>;
+}
+
+declare class TrustAsPipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(content: string, context: string | SecurityContext): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrustAsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TrustAsPipe, "trustAs", true>;
+}
+
+declare class SanitizePipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(content: string | SafeValue, context: string | SecurityContext): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SanitizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SanitizePipe, "sanitize", true>;
+}
+
+declare class ImagePipe implements PipeTransform {
+    transform(url: string, encode?: boolean, defaultImageUrl?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImagePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ImagePipe, "image", true>;
+}
+
+declare class ContainerDirective extends BaseContainerComponent {
+    app?: App;
+    static initializeProps: void;
+    isPrism: boolean;
+    constructor(inj: Injector, explicitContext?: any, app?: App);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContainerDirective, [null, { optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContainerDirective, "[wmContainer]", never, {}, {}, never, never, true, never>;
+}
+
+declare class LazyLoadDirective implements OnDestroy {
+    private templateRef;
+    private viewContainer;
+    private readonly viewParent;
+    private context;
+    private embeddedView;
+    private unSubscribeFn;
+    constructor(inj: Injector, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, explicitContext?: any);
+    set lazyLoad(expr: any);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LazyLoadDirective, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LazyLoadDirective, "[lazyLoad]", never, { "lazyLoad": { "alias": "lazyLoad"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PartialParamHandlerDirective implements OnDestroy {
+    private widgetRef;
+    constructor(widgetRef: any);
+    registerParams(name: string, value: string, bindExpr: string, type: string): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PartialParamHandlerDirective, [{ self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PartialParamHandlerDirective, "[partialContainer]", never, {}, {}, never, never, true, never>;
+}
+declare class PartialParamDirective implements OnInit {
+    bindValue: any;
+    type: any;
+    private partialParamsProvider;
+    name: string;
+    value: any;
+    constructor(bindValue: any, type: any, partialParamsProvider: PartialParamHandlerDirective);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PartialParamDirective, [{ attribute: "value.bind"; }, { attribute: "type"; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PartialParamDirective, "[wmParam]", never, { "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TextContentDirective {
+    private elRef;
+    set textContent(nv: any);
+    constructor(elRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextContentDirective, "[textContent]", never, { "textContent": { "alias": "textContent"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ShowInDeviceDirective implements OnDestroy {
+    private viewContainerRef;
+    private templateRef;
+    private context;
+    private devices;
+    private embeddedView;
+    private boundOnResize;
+    constructor(viewContainerRef: ViewContainerRef, inj: Injector, templateRef: TemplateRef<any>, explicitContext: any);
+    set wmShowInDevice(devices: any);
+    private onResize;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowInDeviceDirective, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ShowInDeviceDirective, "[wmShowInDevice]", never, { "wmShowInDevice": { "alias": "wmShowInDevice"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function AutoLayout(options?: {
+    targetSelector?: string;
+    bindParent?: string;
+}): (constructor: Function) => void;
+
+declare const AUTO_LAYOUT_PROPS: Map<string, any>;
+
+export { ALLFIELDS, APPLY_STYLES_TYPE, AUTOCLOSE_TYPE, AUTO_LAYOUT_PROPS, AutoLayout, BaseComponent, BaseContainerComponent, BaseFieldValidations, ContainerDirective, Context, CustomPipe, CustomWidgetContainerDirective, DEBOUNCE_TIMES, DISPLAY_TYPE, DataSetItem, DatasetAwareNavComponent, DialogRef, DialogServiceImpl, EDIT_MODE, EVENTS_MAP, FileExtensionFromMimePipe, FileIconClassPipe, FileSizePipe, FilterPipe, INPUTMODE, ImagePipe, ItemTemplateDirective, LIVE_CONSTANTS, LazyLoadDirective, Live_Operations, MessageComponent, NAVIGATION_TYPE, NumberToStringPipe, PROP_ANY, PROP_BOOLEAN, PROP_NUMBER, PROP_STRING, PROP_TYPE, PartialContainerDirective, PartialDirective, PartialParamDirective, PartialParamHandlerDirective, PrefixPipe, PullToRefresh, RedrawableDirective, RepeatTemplateDirective, SanitizePipe, ShowInDeviceDirective, StateClassPipe, StringToNumberPipe, StylableComponent, SuffixPipe, TemplateReplacePipe, TextContentDirective, TimeFromNowPipe, ToCurrencyPipe, ToDatePipe, ToNumberPipe, TrailingZeroDecimalPipe, TrustAsPipe, WidgetConfig, WidgetRef, applyFilterOnField, configureDnD, convertDataToObject, createArrayFrom, extractDataAsArray, extractDataSourceName, fetchDistinctValues, fetchRelatedFieldData, filterDate, getBackGroundImageUrl, getConditionalClasses, getContainerTargetClass, getCurrentWidgets, getDataTableFilterWidget, getDefaultValue, getDefaultViewModeWidget, getDistinctFieldProperties, getDistinctValues, getDistinctValuesForField, getEditModeWidget, getEmptyMatchMode, getEnableEmptyFilter, getEvaluatedData, getFieldLayoutConfig, getFieldTypeWidgetTypesMap, getImageUrl, getKeyboardFocusableElements, getMatchModeMsgs, getMatchModeTypesMap, getObjValueByKey, getOrderByExpr, getOrderedDataset, getRangeFieldValue, getRangeMatchMode, getRowOperationsColumn, getUniqObjsByDataField, getWatchIdentifier, getWidgetPropsByType, groupData, handleHeaderClick, hasLinkToCurrentPage, interpolateBindExpressions, isActiveNavItem, isBooleanAttr, isDataSetWidget, isDimensionProp, isStyle, parseValueByType, performDataOperation, prepareFieldDefs, propNameCSSKeyMap, provideAs, provideAsDialogRef, provideAsWidgetRef, refreshDataSource, register, registerFormWidget, setFocusTrap, setHeaderConfig, setHeaderConfigForTable, setItemByCompare, styler, toggleAllHeaders, transformData, transformDataWithKeys, transformFormData, unsupportedStatePersistenceTypes, updateDeviceView, widgetIdGenerator };
+export type { ChangeListener, IDialog, IRedrawableComponent, IWidgetConfig, NavNode };