@mediusinc/mng-commons 4.2.0 → 5.0.0-rc.0

package/fesm2022/mediusinc-mng-commons-table-api.mjs

@@ -0,0 +1,1363 @@
+import { Subject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { DataProviderInst, toObservable, TypeRegistry, CommonsInternalError, DateUtil, ObjectUtil } from '@mediusinc/mng-commons/core';
+import { FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor, FilterTypeEnum } from '@mediusinc/mng-commons/filter';
+import { enumModelGeneric, ModelUtil, ModelDescriptor } from '@mediusinc/mng-commons/model';
+
+class TableDataProviderInst extends DataProviderInst {
+    constructor(type, serviceType) {
+        super(type, serviceType);
+        this._getAllReloadSubject = new Subject();
+        this._isLazy = true;
+        this._getAll = () => ({ data: [] });
+    }
+    get isLazy() {
+        return this._isLazy;
+    }
+    get getAll() {
+        return this._getAll;
+    }
+    get getAllReload$() {
+        return this._getAllReloadSubject.asObservable();
+    }
+    withGetAll(fn) {
+        this._getAll = fn;
+        return this;
+    }
+    withGetAllEagerly(fn) {
+        this._getAll = (qp, service, locale) => toObservable(fn(service, locale)).pipe(map(data => ({ data: data })));
+        this._isLazy = false;
+        return this;
+    }
+    getAllReload(queryParam) {
+        this._getAllReloadSubject.next(queryParam);
+    }
+}
+class TableDataProvider extends TableDataProviderInst {
+    constructor() {
+        super(undefined, undefined);
+    }
+    static create() {
+        return new TableDataProviderInst(undefined, undefined);
+    }
+    static fromClass(type) {
+        return new TableDataProviderInst(type, undefined);
+    }
+    static fromClassWithService(type, serviceType) {
+        return new TableDataProviderInst(type, serviceType);
+    }
+    static fromService(serviceType) {
+        return new TableDataProviderInst(undefined, serviceType);
+    }
+    static fromAnyParam(type, serviceType) {
+        if (typeof type !== 'undefined') {
+            return typeof serviceType !== 'undefined'
+                ? TableDataProvider.fromClassWithService(type, serviceType)
+                : TableDataProvider.fromClass(type);
+        }
+        else if (typeof serviceType !== 'undefined') {
+            return TableDataProvider.fromService(serviceType);
+        }
+        else {
+            return TableDataProvider.create();
+        }
+    }
+}
+
+var ColumnTypeEnum;
+(function (ColumnTypeEnum) {
+    ColumnTypeEnum["String"] = "STRING";
+    ColumnTypeEnum["Number"] = "NUMBER";
+    ColumnTypeEnum["Boolean"] = "BOOLEAN";
+    ColumnTypeEnum["Date"] = "DATE";
+    ColumnTypeEnum["Enum"] = "ENUM";
+    ColumnTypeEnum["Custom"] = "CUSTOM";
+})(ColumnTypeEnum || (ColumnTypeEnum = {}));
+var ColumnDisplayTypeEnum;
+(function (ColumnDisplayTypeEnum) {
+    ColumnDisplayTypeEnum["String"] = "STRING";
+    ColumnDisplayTypeEnum["Number"] = "NUMBER";
+    ColumnDisplayTypeEnum["Currency"] = "CURRENCY";
+    ColumnDisplayTypeEnum["Boolean"] = "BOOLEAN";
+    ColumnDisplayTypeEnum["Date"] = "DATE";
+    ColumnDisplayTypeEnum["Enum"] = "ENUM";
+    ColumnDisplayTypeEnum["Component"] = "COMPONENT";
+    ColumnDisplayTypeEnum["Html"] = "HTML";
+})(ColumnDisplayTypeEnum || (ColumnDisplayTypeEnum = {}));
+
+const dateRegex = /\d{4}-[01]\d-[0-3]\d/;
+const dateTimeRegex = /\d{4}-[01]\d-[0-3]\dT([0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z?)|([0-2]\d:[0-5]\d:[0-5]\d\+[0-2]\d:[0-5]\d))/;
+/**
+ * converts column to number or date on value based
+ * @param column column to be transformed
+ * @param value value to check if applicable
+ */
+function columnToDateNumberOrBoolean(column, value) {
+    if (typeof value === 'boolean') {
+        return column.asBoolean();
+    }
+    else if (!isNaN(value) && typeof value === 'number') {
+        return column.asNumber();
+    }
+    else if (dateRegex.test(value)) {
+        if (dateTimeRegex.test(value)) {
+            return column.asDate('dd. MMM yyyy HH:mm');
+        }
+        return column.asDate('dd. MMM yyyy');
+    }
+    else {
+        return column;
+    }
+}
+/**
+ * converts string type to column type enum, default is string
+ * @param attributeType
+ */
+function getColumnTypeFromClassAttributeDefType(attributeType) {
+    const typeRegistry = TypeRegistry.get();
+    if (typeRegistry.findEnum(attributeType)) {
+        attributeType = 'enum';
+    }
+    else if (typeRegistry.findType(attributeType)) {
+        attributeType = 'class';
+    }
+    switch (attributeType.toLowerCase()) {
+        case 'number':
+        case 'currency':
+            return ColumnTypeEnum.Number;
+        case 'boolean':
+            return ColumnTypeEnum.Boolean;
+        case 'date':
+            return ColumnTypeEnum.Date;
+        case 'enum':
+            return ColumnTypeEnum.Enum;
+        case 'custom':
+            return ColumnTypeEnum.Custom;
+        case 'class':
+            return ColumnTypeEnum.String;
+        case 'string':
+        default:
+            return ColumnTypeEnum.String;
+    }
+}
+function getColumnDisplayTypeFromColumnType(columnType, attributeType) {
+    switch (columnType) {
+        case ColumnTypeEnum.Number:
+            return attributeType === 'currency' ? ColumnDisplayTypeEnum.Currency : ColumnDisplayTypeEnum.Number;
+        case ColumnTypeEnum.Boolean:
+            return ColumnDisplayTypeEnum.Boolean;
+        case ColumnTypeEnum.Date:
+            return ColumnDisplayTypeEnum.Date;
+        case ColumnTypeEnum.Enum:
+            return ColumnDisplayTypeEnum.Enum;
+        case ColumnTypeEnum.Custom:
+            return ColumnDisplayTypeEnum.Component;
+        case ColumnTypeEnum.String:
+        default:
+            return ColumnDisplayTypeEnum.String;
+    }
+}
+function expandClassAttributeDefWithTableDef(attributes) {
+    if (!attributes) {
+        throw new CommonsInternalError('Class attribute definition is null, problem with TypeRegistry::findAttributesDefinitionByClassType?', { name: 'TableviewUtilsError' });
+    }
+    const typeRegistry = TypeRegistry.get();
+    const tableClassAttributeDef = [];
+    for (const attribute of attributes) {
+        const enumType = typeRegistry.findEnum(attribute.type);
+        const columnType = enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type);
+        tableClassAttributeDef.push({
+            name: attribute.name,
+            baseName: attribute.baseName,
+            type: attribute.type,
+            subtype: attribute.subtype,
+            columnType: enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type),
+            columnDisplayType: getColumnDisplayTypeFromColumnType(columnType, attribute.type),
+            enumType: typeRegistry.findEnum(attribute.type),
+            classType: typeRegistry.findType(attribute.type)
+        });
+    }
+    return tableClassAttributeDef;
+}
+/**
+ * returns attributes from class type and extends to typed def with column and field enum type
+ * @param type class type
+ */
+function getTableClassAttributeDef(type) {
+    return expandClassAttributeDefWithTableDef(TypeRegistry.get().findAttributesDefinitionByClassType(type));
+}
+
+class ColumnDescriptor {
+    constructor(table, property) {
+        this._columnType = ColumnTypeEnum.String;
+        this._columnDisplayType = ColumnDisplayTypeEnum.String;
+        this._isMultiline = false;
+        this._hasValueAsTooltip = false;
+        this._isReorderable = false;
+        this._isToggleable = false;
+        this._isVisible = true;
+        // styling
+        this._headerClassName = '';
+        this._className = '';
+        this._width = null;
+        this._minWidth = null;
+        this._maxWidth = null;
+        // boolean specifics
+        this._booleanAsIcon = false;
+        // helpers
+        this._hasCopyToClipboard = false;
+        // localization
+        this._isLocalized = false;
+        this._table = table;
+        this._property = property;
+    }
+    get columnType() {
+        return this._columnType;
+    }
+    get columnDisplayType() {
+        return this._columnDisplayType;
+    }
+    get title() {
+        return this._title;
+    }
+    get displayFormat() {
+        return this._displayFormat;
+    }
+    get table() {
+        return this._table;
+    }
+    get property() {
+        return this._property;
+    }
+    get headerClassName() {
+        return this._headerClassName;
+    }
+    get className() {
+        return this._className;
+    }
+    get classNameMapFn() {
+        return this._classNameMapFn;
+    }
+    get width() {
+        return this._width;
+    }
+    get minWidth() {
+        return this._minWidth;
+    }
+    get maxWidth() {
+        return this._maxWidth;
+    }
+    get enum() {
+        return this._enum;
+    }
+    get booleanAsIcon() {
+        return this._booleanAsIcon;
+    }
+    get booleanYes() {
+        return this._booleanYes;
+    }
+    get booleanNo() {
+        return this._booleanNo;
+    }
+    get customComponentType() {
+        return this._customComponentType;
+    }
+    get locale() {
+        return this._locale;
+    }
+    get currencyCode() {
+        return this._currencyCode;
+    }
+    get currencyDisplay() {
+        return this._currencyDisplay;
+    }
+    get currencyProperty() {
+        return this._currencyProperty;
+    }
+    get hasCopyToClipboard() {
+        return this._hasCopyToClipboard;
+    }
+    get clipboardValueGetter() {
+        return this._clipboardValueGetter;
+    }
+    get template() {
+        return this._template;
+    }
+    get getter() {
+        return this._getter;
+    }
+    get isMultiline() {
+        return this._isMultiline;
+    }
+    get hasValueAsTooltip() {
+        return this._hasValueAsTooltip;
+    }
+    get isReorderable() {
+        return this._isReorderable;
+    }
+    get isToggleable() {
+        return this._isToggleable;
+    }
+    get isVisible() {
+        return this._isVisible;
+    }
+    get isLocalized() {
+        return this._isLocalized;
+    }
+    get localizationExistsProperty() {
+        return this._localizationExistsProperty;
+    }
+    /**
+     * Converts column to given type with additional arguments
+     * @param type column type enum
+     * @param displayType column display type
+     * @param args any additional arguments for column (optional)
+     */
+    asType(type, displayType, ...args) {
+        switch (type) {
+            case ColumnTypeEnum.Number:
+                return displayType === ColumnDisplayTypeEnum.Currency ? this.asCurrency(...args) : this.asNumber(...args);
+            case ColumnTypeEnum.Boolean:
+                return this.asBoolean(...args);
+            case ColumnTypeEnum.Date:
+                return this.asDate(...args);
+            case ColumnTypeEnum.Enum:
+                return this.asEnumUnsafe(args[0]);
+            case ColumnTypeEnum.Custom:
+                return this.asCustomComponent(args[0]);
+            case ColumnTypeEnum.String:
+            default:
+                return this;
+        }
+    }
+    asNumber(opts) {
+        this._columnType = ColumnTypeEnum.Number;
+        this._columnDisplayType = ColumnDisplayTypeEnum.Number;
+        this._displayFormat =
+            opts?.minIntegerDigits || opts?.minFractionDigits || opts?.maxFractionDigits
+                ? `${opts?.minIntegerDigits ?? 0}.${opts?.minFractionDigits ?? 0}-${opts?.maxFractionDigits ?? opts?.minFractionDigits ?? 0}`
+                : undefined;
+        this._locale = opts?.locale;
+        return this;
+    }
+    asCurrency(opts) {
+        return this.asCurrencyUnsafe({
+            ...opts,
+            currencyProperty: opts?.currencyProperty ? opts.currencyProperty : undefined
+        });
+    }
+    asCurrencyUnsafe(opts) {
+        this._columnType = ColumnTypeEnum.Number;
+        this._columnDisplayType = ColumnDisplayTypeEnum.Currency;
+        this._currencyCode = opts?.currency;
+        this._currencyProperty = opts?.currencyProperty;
+        this._currencyDisplay = opts?.currencyDisplay;
+        this._displayFormat =
+            opts?.minIntegerDigits || opts?.minFractionDigits || opts?.maxFractionDigits
+                ? `${opts?.minIntegerDigits ?? 0}.${opts?.minFractionDigits ?? 0}-${opts?.maxFractionDigits ?? opts?.minFractionDigits ?? 0}`
+                : undefined;
+        this._locale = opts?.locale;
+        return this;
+    }
+    asDate(displayFormat = 'dd.MM.yyyy') {
+        this._columnType = ColumnTypeEnum.Date;
+        this._columnDisplayType = ColumnDisplayTypeEnum.Date;
+        this._displayFormat = displayFormat;
+        return this;
+    }
+    asBoolean(yes, no, asIcon = false) {
+        this._columnType = ColumnTypeEnum.Boolean;
+        this._columnDisplayType = ColumnDisplayTypeEnum.Boolean;
+        this._booleanAsIcon = asIcon;
+        this._booleanYes = yes;
+        this._booleanNo = no;
+        return this;
+    }
+    asEnumUnsafe(enumDesc) {
+        this._columnType = ColumnTypeEnum.Enum;
+        this._columnDisplayType = ColumnDisplayTypeEnum.Enum;
+        this._enum = enumDesc;
+        return this;
+    }
+    asCustomComponent(customComponentType) {
+        this._columnType = ColumnTypeEnum.Custom;
+        this._columnDisplayType = ColumnDisplayTypeEnum.Component;
+        this._customComponentType = customComponentType;
+        return this;
+    }
+    asHtml() {
+        this._columnDisplayType = ColumnDisplayTypeEnum.Html;
+        return this;
+    }
+    withClassName(className, headerClassName, classNameMapFn) {
+        this._className = className ?? '';
+        this._headerClassName = headerClassName ?? '';
+        this._classNameMapFn = classNameMapFn;
+        return this;
+    }
+    withWidth(width, minWidth, maxWidth) {
+        this._width = width ?? null;
+        this._minWidth = minWidth ?? null;
+        this._maxWidth = maxWidth ?? null;
+        return this;
+    }
+    withTitle(title) {
+        this._title = title;
+        return this;
+    }
+    withFilterUnsafe(forceSimple = false) {
+        return this._table.addFilterFromColumnDescriptorUnsafe(this, forceSimple);
+    }
+    withSortUnsafe(isDefault = false, ascending) {
+        this._table.withSortUnsafe(this.property, isDefault, ascending);
+        return this;
+    }
+    withCopyToClipboard(hasCopyToClipboard = true, clipboardValueGetter) {
+        this._hasCopyToClipboard = hasCopyToClipboard;
+        if (clipboardValueGetter) {
+            this._clipboardValueGetter = clipboardValueGetter;
+        }
+        return this;
+    }
+    withTemplate(template) {
+        this._template = template;
+        return this;
+    }
+    withGetter(getter) {
+        this._getter = getter;
+        return this;
+    }
+    withMultiline(isMultiline = true) {
+        this._isMultiline = isMultiline;
+        return this;
+    }
+    withValueAsTooltip(valueAsTooltip = true) {
+        this._hasValueAsTooltip = valueAsTooltip;
+        return this;
+    }
+    withReorderable(isReorderable = true) {
+        this._isReorderable = isReorderable;
+        return this;
+    }
+    withToggleable(isToggleable = true, isVisible = true) {
+        this._isToggleable = isToggleable;
+        this._isVisible = isVisible;
+        return this;
+    }
+    localized(existsProperty) {
+        if (existsProperty) {
+            this._localizationExistsProperty = existsProperty;
+        }
+        else {
+            this._localizationExistsProperty = `${this._property}Localized`;
+        }
+        return this;
+    }
+    copy() {
+        const descriptor = new ColumnDescriptor(this._table, this._property);
+        this.copyFieldsTo(descriptor);
+        return descriptor;
+    }
+    copyFieldsTo(obj) {
+        obj._title = this._title;
+        obj._columnType = this._columnType;
+        obj._columnDisplayType = this._columnDisplayType;
+        obj._enum = this._enum;
+        obj._booleanAsIcon = this._booleanAsIcon;
+        obj._booleanYes = this._booleanYes;
+        obj._booleanNo = this._booleanNo;
+        obj._locale = this._locale;
+        obj._currencyCode = this._currencyCode;
+        obj._currencyDisplay = this._currencyDisplay;
+        obj._currencyProperty = this._currencyProperty;
+        obj._displayFormat = this._displayFormat;
+        obj._headerClassName = this._headerClassName;
+        obj._className = this._className;
+        obj._classNameMapFn = this._classNameMapFn;
+        obj._width = this._width;
+        obj._minWidth = this._minWidth;
+        obj._maxWidth = this._maxWidth;
+        obj._customComponentType = this._customComponentType;
+        obj._hasCopyToClipboard = this._hasCopyToClipboard;
+        obj._template = this._template;
+        obj._getter = this._getter;
+        obj._isMultiline = this._isMultiline;
+        obj._hasValueAsTooltip = this._hasValueAsTooltip;
+        obj._isReorderable = this._isReorderable;
+        obj._isToggleable = this._isToggleable;
+        obj._isVisible = this._isVisible;
+        obj._isLocalized = this._isLocalized;
+        obj._localizationExistsProperty = this._localizationExistsProperty;
+    }
+}
+class ColumnDynamicDescriptor extends ColumnDescriptor {
+    // private _filterStatus;
+    constructor(table, property) {
+        super(table, property);
+        this._title = undefined;
+        this._visibility = true;
+    }
+    get visibility() {
+        return this._visibility;
+    }
+    /**
+     * sets column's title and returns this column
+     * @param title title to be set
+     * @param override should column title if all ready set?
+     */
+    withTitle(title, override = false) {
+        if (this._title == null || override) {
+            this._title = title;
+        }
+        return this;
+    }
+    /**
+     * defines automatic type and returns this column
+     * @param value
+     */
+    withAutomaticType(value) {
+        columnToDateNumberOrBoolean(this, value);
+        return this;
+    }
+    /**
+     * sets visibility state for column and returns this column
+     * @param visibility
+     */
+    withVisibility(visibility) {
+        this._visibility = visibility;
+        return this;
+    }
+    /**
+     * creates deep copy of column dynamic descriptor
+     */
+    copy() {
+        const descriptor = new ColumnDynamicDescriptor(this._table, this._property);
+        this.copyFieldsTo(descriptor);
+        descriptor._title = this._title;
+        descriptor._visibility = this._visibility;
+        return descriptor;
+    }
+    toColumnDescriptor(tableDescriptor) {
+        const descriptor = new ColumnDescriptor(tableDescriptor, this._property);
+        this.copyFieldsTo(descriptor);
+        return descriptor;
+    }
+}
+
+class SortDescriptor {
+    constructor(property) {
+        this._defaultIsEnabled = false;
+        this._defaultIsAscending = undefined;
+        this._defaultOrder = undefined;
+        this._property = property;
+        this._showOnColumn = property;
+    }
+    get property() {
+        return this._property;
+    }
+    get showOnColumn() {
+        return this._showOnColumn;
+    }
+    get defaultIsEnabled() {
+        return this._defaultIsEnabled;
+    }
+    get defaultIsAscending() {
+        return this._defaultIsAscending;
+    }
+    get defaultOrder() {
+        return this._defaultOrder;
+    }
+    withShowOnColumn(property) {
+        return this.withShowOnColumnUnsafe(property);
+    }
+    withShowOnColumnUnsafe(property) {
+        this._showOnColumn = property;
+        return this;
+    }
+    withDefaultSort(enabled = true, ascending, order) {
+        this._defaultIsEnabled = enabled;
+        this._defaultIsAscending = true;
+        this._defaultOrder = order;
+        return this;
+    }
+    copy() {
+        const descriptor = new SortDescriptor(this._property);
+        descriptor._defaultIsEnabled = this._defaultIsEnabled;
+        descriptor._defaultIsAscending = this._defaultIsAscending;
+        descriptor._defaultOrder = this._defaultOrder;
+        return descriptor;
+    }
+}
+
+var TablePaginationModeEnum;
+(function (TablePaginationModeEnum) {
+    TablePaginationModeEnum[TablePaginationModeEnum["Pagination"] = 0] = "Pagination";
+    TablePaginationModeEnum[TablePaginationModeEnum["InfiniteScroll"] = 1] = "InfiniteScroll";
+    TablePaginationModeEnum[TablePaginationModeEnum["None"] = 2] = "None";
+})(TablePaginationModeEnum || (TablePaginationModeEnum = {}));
+var TableSizeEnum;
+(function (TableSizeEnum) {
+    TableSizeEnum[TableSizeEnum["Small"] = 0] = "Small";
+    TableSizeEnum[TableSizeEnum["Normal"] = 1] = "Normal";
+    TableSizeEnum[TableSizeEnum["Large"] = 2] = "Large";
+})(TableSizeEnum || (TableSizeEnum = {}));
+/**
+ * EXCLUDE default, all columns has sort and filter on by default, developer EXCLUDES properties from sort/filter
+ * INCLUDE_ONLY only selected columns have sort/filter, developers INCLUDES properties
+ */
+var TableDynamicColumnsModeEnum;
+(function (TableDynamicColumnsModeEnum) {
+    TableDynamicColumnsModeEnum[TableDynamicColumnsModeEnum["EXCLUDE"] = 0] = "EXCLUDE";
+    TableDynamicColumnsModeEnum[TableDynamicColumnsModeEnum["INCLUDE_ONLY"] = 1] = "INCLUDE_ONLY";
+})(TableDynamicColumnsModeEnum || (TableDynamicColumnsModeEnum = {}));
+
+class TableDescriptorInst {
+    constructor(model, autoGenerated = false) {
+        this._columns = [];
+        this._hideHeader = false;
+        this._loadingIcon = 'pi pi-spinner';
+        // extra
+        this._hasHover = true;
+        this._hasGridlines = false;
+        this._hasResizableColumns = false;
+        // styling
+        this._size = TableSizeEnum.Large;
+        this._className = '';
+        // filters&sorts
+        this._filters = [];
+        this._sorts = [];
+        // localization
+        this._isLocalized = false;
+        this._model = model;
+        this._trackProperty = this._model.idProperty;
+        this._autoGenerated = autoGenerated;
+    }
+    get identifier() {
+        return this._identifier;
+    }
+    get trackProperty() {
+        return this._trackProperty;
+    }
+    get paginationMode() {
+        return this._paginationMode;
+    }
+    get rowsPerPageOptions() {
+        return this._rowsPerPageOptions;
+    }
+    get defaultNumRows() {
+        return this._defaultNumRows;
+    }
+    get columns() {
+        return this._columns;
+    }
+    get title() {
+        return this._title;
+    }
+    get hideHeader() {
+        return this._hideHeader;
+    }
+    get loadingText() {
+        return this._loadingText;
+    }
+    get loadingIcon() {
+        return this._loadingIcon;
+    }
+    get filters() {
+        return this._filters;
+    }
+    get sorts() {
+        return this._sorts;
+    }
+    get model() {
+        return this._model;
+    }
+    get className() {
+        return this._className;
+    }
+    get size() {
+        return this._size;
+    }
+    get tableFullHeightOffset() {
+        return this._tableFullHeightOffset;
+    }
+    get rowHeight() {
+        return this._rowHeight;
+    }
+    get hasHover() {
+        return this._hasHover;
+    }
+    get hasGridlines() {
+        return this._hasGridlines;
+    }
+    get hasResizableColumns() {
+        return this._hasResizableColumns;
+    }
+    get columnResizeMode() {
+        return this._columnResizeMode;
+    }
+    get rowClassName() {
+        return this._rowClassName;
+    }
+    get rowClassNameMapFn() {
+        return this._rowClassNameMapFn;
+    }
+    get selectionColumnFrozen() {
+        return this._selectionColumnFrozen;
+    }
+    get actionColumnFrozen() {
+        return this._actionColumnFrozen;
+    }
+    get headerClassName() {
+        return this._headerClassName;
+    }
+    get isLocalized() {
+        return this._isLocalized;
+    }
+    get localizationLocaleProperty() {
+        return this._localizationLocaleProperty;
+    }
+    /**
+     * Track property is used for the purpose of combined saving user preferences in localstorage if 2 tables have the same track properties they will share the same localstorage entry.
+     * Similarly, this property can also be used to differentiate two tables of the same model on the same url (so that they have separate entries in localstorage).
+     * @param identifier
+     */
+    withIdentifier(identifier) {
+        this._identifier = identifier;
+        return this;
+    }
+    withTrackProperty(property) {
+        return this.withTrackPropertyUnsafe(property);
+    }
+    withTrackPropertyUnsafe(property) {
+        this._trackProperty = property;
+        return this;
+    }
+    getColumn(property) {
+        return this.getColumnUnsafe(property);
+    }
+    getColumnUnsafe(property) {
+        return this._columns.find(col => col.property === property) ?? null;
+    }
+    removeColumn(property) {
+        this.removeColumnUnsafe(property);
+    }
+    removeColumnUnsafe(property) {
+        const columnIdx = this._columns.findIndex(c => c.property === property);
+        this._columns.splice(columnIdx, 1);
+    }
+    withColumn(column) {
+        this._columns.push(column);
+        return this;
+    }
+    addColumn(property) {
+        const column = new ColumnDescriptor(this, property);
+        this._columns.push(column);
+        return column;
+    }
+    addColumnEnum(property, enumDesc) {
+        const column = new ColumnDescriptor(this, property);
+        column.asEnumUnsafe(enumDesc);
+        this._columns.push(column);
+        return column;
+    }
+    addColumnUnsafe(property) {
+        const column = new ColumnDescriptor(this, property);
+        this._columns.push(column);
+        return column;
+    }
+    withColumns(...properties) {
+        properties.forEach(p => this.addColumn(p));
+        return this;
+    }
+    withPaginationMode(paginationMode) {
+        this._paginationMode = paginationMode;
+        return this;
+    }
+    withRowsPerPage(rows, options) {
+        this._defaultNumRows = rows;
+        this._rowsPerPageOptions = options;
+        return this;
+    }
+    withTitle(title) {
+        this._title = title;
+        return this;
+    }
+    withHideHeader(hideHeader = true) {
+        this._hideHeader = hideHeader;
+        return this;
+    }
+    withLoading(text, icon) {
+        this._loadingText = text;
+        this._loadingIcon = icon === undefined ? 'pi pi-spinner' : icon;
+        return this;
+    }
+    /**
+     * Helper method that enables/disables reorderable property on all columns currently in the descriptor.
+     * @param columnsReorderable
+     */
+    withCurrentColumnsReorderable(columnsReorderable = true) {
+        for (const col of this.columns) {
+            col.withReorderable(columnsReorderable);
+        }
+        return this;
+    }
+    /**
+     * Helper method that enables/disables toggleable property on all columns currently in the descriptor.
+     * @param columnsToggleable
+     */
+    withCurrentColumnsToggleable(columnsToggleable = true) {
+        for (const col of this.columns) {
+            col.withToggleable(columnsToggleable);
+        }
+        return this;
+    }
+    getSort(property) {
+        return this.getSortUnsafe(property);
+    }
+    getSortUnsafe(property) {
+        return this._sorts.find(s => s.property === property) ?? null;
+    }
+    removeSort(property) {
+        return this.removeSortUnsafe(property);
+    }
+    removeSortUnsafe(property) {
+        const sortIdx = this._sorts.findIndex(c => c.property === property);
+        this._sorts.splice(sortIdx, 1);
+    }
+    addSort(property, isDefault = false, ascending) {
+        return this.addSortUnsafe(property, isDefault, ascending);
+    }
+    addSortUnsafe(property, isDefault = false, ascending) {
+        const sort = new SortDescriptor(property);
+        if (isDefault) {
+            const defaultOrderMax = this._sorts
+                .filter(s => s.defaultIsEnabled)
+                .reduce((acc, s) => (s.defaultOrder !== undefined && s.defaultOrder > acc ? s.defaultOrder : acc), -1);
+            sort.withDefaultSort(true, ascending, defaultOrderMax + 1);
+        }
+        this._sorts.push(sort);
+        return sort;
+    }
+    withSort(property, isDefault = false, ascending) {
+        return this.withSortUnsafe(property, isDefault, ascending);
+    }
+    withSortUnsafe(property, isDefault = false, ascending) {
+        this.addSortUnsafe(property, isDefault, ascending);
+        return this;
+    }
+    withDefaultSort(property, ascending, order, enabled) {
+        return this.withDefaultSortUnsafe(property, ascending, order, enabled);
+    }
+    withDefaultSortUnsafe(property, ascending, order, enabled) {
+        let sort = this._sorts.find(s => s.property === property);
+        if (!sort) {
+            sort = new SortDescriptor(property);
+            this._sorts.push(sort);
+        }
+        sort.withDefaultSort(enabled ?? true, ascending, order);
+        return this;
+    }
+    withSorts(...properties) {
+        return this.withSortsUnsafe(...properties);
+    }
+    withSortsUnsafe(...properties) {
+        properties.forEach(p => {
+            this._sorts.push(new SortDescriptor(p));
+        });
+        return this;
+    }
+    getFilter(property) {
+        return this.getFilterUnsafe(property);
+    }
+    getFilterUnsafe(property) {
+        return this._filters.find(s => s.property === property) ?? null;
+    }
+    removeFilter(property) {
+        return this.removeFilterUnsafe(property);
+    }
+    removeFilterUnsafe(property) {
+        const filterIdx = this._filters.findIndex(c => c.property === property);
+        this._filters.splice(filterIdx, 1);
+    }
+    addFilter(property) {
+        return this.addFilterUnsafe(property);
+    }
+    addFilterUnsafe(property) {
+        const filter = new FilterDescriptor(property);
+        this._filters.push(filter);
+        return filter;
+    }
+    addFilterLookup(property, provider, optionsValueProperty) {
+        return this.addFilterLookupUnsafe(property, provider, optionsValueProperty);
+    }
+    addFilterLookupUnsafe(property, provider, optionsValueProperty) {
+        const filter = new FilterLookupDescriptor(property, {
+            dataProvider: provider,
+            optionsValueProperty: optionsValueProperty
+        });
+        this._filters.push(filter);
+        return filter;
+    }
+    addFilterLookupEnum(property, enumDesc, options) {
+        return this.addFilterLookupEnumUnsafe(property, enumDesc, options);
+    }
+    addFilterLookupEnumUnsafe(property, enumDesc, options) {
+        const filter = new FilterLookupEnumDescriptor(property, enumDesc, options);
+        this._filters.push(filter);
+        return filter;
+    }
+    addFilterFromColumn(property, forceSimple = false) {
+        return this.addFilterFromColumnUnsafe(property, forceSimple);
+    }
+    withFiltersFromColumns(...properties) {
+        return this.withFiltersFromColumnsUnsafe(...properties);
+    }
+    withFiltersFromColumnsUnsafe(...properties) {
+        properties.forEach(p => {
+            this.addFilterFromColumnUnsafe(p);
+        });
+        return this;
+    }
+    addFilterFromColumnUnsafe(property, forceSimple = false) {
+        const column = this.getColumnUnsafe(property);
+        if (!column) {
+            throw new CommonsInternalError(`No column found for filter property "${property}"`);
+        }
+        return this.addFilterFromColumnDescriptorUnsafe(column, forceSimple);
+    }
+    addFilterFromColumnDescriptorUnsafe(column, forceSimple) {
+        let filterDescriptor = new FilterDescriptor(column.property);
+        let filterType;
+        switch (column.columnType) {
+            case ColumnTypeEnum.Number:
+                filterType = FilterTypeEnum.Number;
+                break;
+            case ColumnTypeEnum.Boolean:
+                filterType = FilterTypeEnum.Boolean;
+                break;
+            case ColumnTypeEnum.Date:
+                filterType = FilterTypeEnum.Date;
+                break;
+            case ColumnTypeEnum.Enum:
+                if (!forceSimple && column.enum) {
+                    filterDescriptor = new FilterLookupEnumDescriptor(column.property, column.enum);
+                    filterType = FilterTypeEnum.LookupEnum;
+                }
+                else {
+                    filterType = FilterTypeEnum.String;
+                }
+                break;
+            case ColumnTypeEnum.String:
+            case ColumnTypeEnum.Custom:
+            default:
+                filterType = FilterTypeEnum.String;
+                break;
+        }
+        filterDescriptor.asFilterType(filterType);
+        if (filterType === FilterTypeEnum.Number) {
+            const displayFormatFractions = column.displayFormat?.split('.')?.[1]?.split('-');
+            if (displayFormatFractions && displayFormatFractions.length > 2) {
+                filterDescriptor.withNumberFractions(parseInt(displayFormatFractions[0]), parseInt(displayFormatFractions[1]));
+            }
+        }
+        else if (filterType === FilterTypeEnum.Date) {
+            const displayFormat = column.displayFormat;
+            if (displayFormat) {
+                const filterDisplayFormat = DateUtil.fromAngularToPrimeDateFormat(displayFormat);
+                const hasTime = DateUtil.fromAngularDateFormatHasTime(displayFormat);
+                const hasSeconds = DateUtil.fromAngularDateFormatHasSeconds(displayFormat);
+                filterDescriptor.withDateFormat(filterDisplayFormat, hasTime, hasSeconds);
+            }
+        }
+        this._filters.push(filterDescriptor);
+        return filterDescriptor;
+    }
+    withFilter(property, filter) {
+        if (filter.property !== property) {
+            throw new CommonsInternalError(`Filter property "${property}" and Filter descriptor property "${filter.property}" do not match.`);
+        }
+        return this.withFilterUnsafe(filter);
+    }
+    withFilterUnsafe(filter) {
+        this._filters.push(filter);
+        return this;
+    }
+    withClassName(className) {
+        this._className = className;
+        return this;
+    }
+    withSize(size = TableSizeEnum.Normal) {
+        this._size = size;
+        return this;
+    }
+    withTableFullHeightOffset(tableFullHeightOffset) {
+        this._tableFullHeightOffset = tableFullHeightOffset;
+        return this;
+    }
+    withRowHeight(rowHeight) {
+        this._rowHeight = rowHeight;
+        return this;
+    }
+    withHover(hover) {
+        this._hasHover = hover;
+        return this;
+    }
+    withGridlines(gridlines) {
+        this._hasGridlines = gridlines;
+        return this;
+    }
+    /**
+     * Method that enables/disabled column resize feature with columnResizeMode on all columns.
+     * @param resizableColumns True if enabled
+     * @param columnResizeMode 'fit' or 'expand' mode
+     */
+    withColumnsResizable(resizableColumns = true, columnResizeMode = 'fit') {
+        this._hasResizableColumns = resizableColumns;
+        this._columnResizeMode = columnResizeMode;
+        return this;
+    }
+    /**
+     * Sets column to (un)frozen.
+     * @param selectionColumnFrozen True to freeze selection column, false to unfreeze it.
+     * @param actionColumnFrozen True to freeze action column, false to unfreeze it.
+     */
+    withColumnFrozen(selectionColumnFrozen, actionColumnFrozen) {
+        this._selectionColumnFrozen = selectionColumnFrozen;
+        this._actionColumnFrozen = actionColumnFrozen;
+        return this;
+    }
+    withRowClassName(rowClassName, classNameMapFn) {
+        this._rowClassName = rowClassName;
+        this._rowClassNameMapFn = classNameMapFn;
+        return this;
+    }
+    withHeaderClassName(headerClassName) {
+        this._headerClassName = headerClassName;
+        return this;
+    }
+    withLocalized() {
+        this._isLocalized = true;
+        return this;
+    }
+    withLocalizationLocaleProperty(localizationLocaleProperty) {
+        this._isLocalized = true;
+        this._localizationLocaleProperty = localizationLocaleProperty;
+        return this;
+    }
+    copyFieldsTo(obj) {
+        obj._title = this._title;
+        obj._hideHeader = this._hideHeader;
+        obj._trackProperty = this._trackProperty;
+        obj._filters = this._filters.map(f => f.copy());
+        obj._sorts = this._sorts.map(s => s.copy());
+        obj._className = this._className;
+        obj._size = this._size;
+        obj._tableFullHeightOffset = this._tableFullHeightOffset;
+        obj._rowHeight = this._rowHeight;
+        obj._hasHover = this._hasHover;
+        obj._hasGridlines = this._hasGridlines;
+        obj._hasResizableColumns = this._hasResizableColumns;
+        obj._columnResizeMode = this._columnResizeMode;
+        obj._actionColumnFrozen = this._actionColumnFrozen;
+        obj._selectionColumnFrozen = this._selectionColumnFrozen;
+        obj._isLocalized = this._isLocalized;
+        obj._localizationLocaleProperty = this._localizationLocaleProperty;
+        obj._paginationMode = this._paginationMode;
+        obj._rowsPerPageOptions = this._rowsPerPageOptions;
+    }
+    copy() {
+        const descriptor = new TableDescriptorInst(this.model.copy());
+        this.copyFieldsTo(descriptor);
+        descriptor._columns = this.columns.map(c => c.copy());
+        return descriptor;
+    }
+    /**
+     * defines modified type of column
+     * DO NOT USE with enum (use withCustomEnumType)
+     * @param property column name
+     * @param columnType modified type
+     * @param args additional attributes
+     * @param columnDisplayType
+     */
+    withColumnModifiedType(property, columnType, columnDisplayType, ...args) {
+        return this.withColumnModifiedTypeUnsafe(property, columnType, columnDisplayType, ...args);
+    }
+    withColumnModifiedTypeUnsafe(property, columnType, columnDisplayType, ...args) {
+        if (!this.model.type) {
+            throw new CommonsInternalError(`withColumnModifiedType cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        const attributeDef = getTableClassAttributeDef(this.model.type).find(attr => attr.name === property);
+        if (attributeDef != null) {
+            attributeDef.columnType = columnType ?? attributeDef.columnType;
+            attributeDef.columnDisplayType = columnDisplayType ?? attributeDef.columnDisplayType;
+            TableDescriptorInst.upsertColumnFromAttributeDef(this, attributeDef, this.columns.find(col => col.property === attributeDef.name), ...args);
+        }
+        return this;
+    }
+    /**
+     * defines custom enum type for column
+     * @param property column name
+     * @param enumDesc Enum descriptor.
+     */
+    withColumnModifiedEnum(property, enumDesc) {
+        return this.withColumnModifiedEnumUnsafe(property, enumDesc);
+    }
+    withColumnModifiedEnumUnsafe(property, enumDesc) {
+        if (!this.model.type) {
+            throw new CommonsInternalError(`withColumnModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        const attributeDef = getTableClassAttributeDef(this.model.type).find(attr => attr.name === property);
+        if (attributeDef != null) {
+            attributeDef.columnType = ColumnTypeEnum.Enum;
+            TableDescriptorInst.upsertColumnFromAttributeDef(this, attributeDef, this.columns.find(col => col.property === property), enumDesc ?? enumModelGeneric(TypeRegistry.get().findEnum(attributeDef.type)));
+        }
+        return this;
+    }
+    /**
+     * modifies column with class and lookup provider
+     * @param property column name
+     * @param lookupProvider lookupProvider for class
+     * @param optionsLabelProperty
+     * @param filterProperty
+     */
+    withModifiedLookup(property, lookupProvider, optionsLabelProperty, filterProperty) {
+        return this.withColumnModifiedLookupUnsafe(property, lookupProvider, optionsLabelProperty, filterProperty);
+    }
+    withColumnModifiedLookupUnsafe(property, lookupProvider, optionsLabelProperty, filterProperty) {
+        const column = this.columns.find(col => col.property === property);
+        if (column) {
+            const filter = this.addFilterLookupUnsafe(column.property, lookupProvider, filterProperty);
+            if (optionsLabelProperty) {
+                filter.withOptionsLabelPropertyUnsafe(optionsLabelProperty);
+            }
+        }
+        return this;
+    }
+    /**
+     * generates column based on attributes
+     * @param desc Table descriptor
+     * @param attribute attribute map
+     * @param column if provided, replaced by new, otherwise new is created
+     * @param args additional parameters
+     */
+    static upsertColumnFromAttributeDef(desc, attribute, column, ...args) {
+        if (column == null) {
+            column = desc.addColumnUnsafe(attribute.name);
+        }
+        if (attribute.columnType === ColumnTypeEnum.Enum && args.length === 0 && attribute.enumType) {
+            args = [enumModelGeneric(attribute.enumType)];
+        }
+        column = column.asType(attribute.columnType, attribute.columnDisplayType, ...args);
+        if (attribute.classType) {
+            const titleProperty = ModelUtil.findTitleAttribute(attribute.classType) ?? undefined;
+            if (titleProperty) {
+                column.withGetter(value => value?.[titleProperty]);
+            }
+        }
+        else {
+            column.withSortUnsafe().withFilterUnsafe();
+        }
+        return column;
+    }
+}
+class TableDescriptor extends TableDescriptorInst {
+    constructor() {
+        super(ModelDescriptor.create());
+    }
+    static create(idProperty, titleProperty, i18nBaseKey) {
+        return new TableDescriptorInst(ModelDescriptor.create(idProperty, titleProperty, i18nBaseKey));
+    }
+    static fromClass(type, idProperty, titleProperty, i18nBaseKey, isAutoGenerated = false) {
+        return new TableDescriptorInst(ModelDescriptor.fromClass(type, idProperty, titleProperty, i18nBaseKey), isAutoGenerated);
+    }
+    static fromModel(model) {
+        return new TableDescriptorInst(model);
+    }
+    /**
+     * generates descriptor based on type attribute definition
+     * @param type class type
+     * @param idProperty
+     * @param titleProperty
+     */
+    static fromClassWithAutoAttrsDef(type, idProperty, titleProperty) {
+        return TableDescriptor.fromClassWithCustomAttrsDef(type, getTableClassAttributeDef(type), idProperty, titleProperty);
+    }
+    /**
+     * generates descriptor base on given attribute definition
+     * @param type class type
+     * @param attributes attributes from which descriptor is generated
+     * @param idProperty
+     * @param titleProperty
+     */
+    static fromClassWithCustomAttrsDef(type, attributes, idProperty, titleProperty) {
+        const descriptor = TableDescriptor.fromClass(type, idProperty, titleProperty, undefined, true);
+        attributes.filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array')).forEach(attr => TableDescriptorInst.upsertColumnFromAttributeDef(descriptor, attr));
+        return descriptor;
+    }
+}
+class TableDynamicDescriptorInst extends TableDescriptorInst {
+    constructor(model) {
+        super(model);
+        this._excludedColumns = [];
+        this._filterColumns = [];
+        this._sortColumns = [];
+        this._sortColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;
+        this._filterColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;
+        this._columns = [];
+        if (model.titleProperty) {
+            this.withTitle(model.titleProperty);
+        }
+    }
+    get columns() {
+        return this._columns;
+    }
+    /**
+     * defines excluded columns when generating descriptor
+     * @param excludedColumn names of excluded columns
+     */
+    withColumnsExcluded(excludedColumn) {
+        this._excludedColumns = excludedColumn;
+        return this;
+    }
+    /**
+     * defines column properties on which sort is defined or not depending on sortColumnMode
+     * @param sortOnColumns column names
+     * @param sortColumnMode INCLUDE_ONLY (default) only given columns will have sort, EXCLUDE given columns will NOT have sort
+     */
+    withColumnsSort(sortOnColumns, sortColumnMode = TableDynamicColumnsModeEnum.INCLUDE_ONLY) {
+        this._sortColumnMode = sortColumnMode;
+        this._sortColumns = sortOnColumns;
+        return this;
+    }
+    /**
+     * defines column properties on which filter is defined or not depending on filterColumnMode
+     * @param filterOnColumn column names
+     * @param filterColumnMode INCLUDE_ONLY (default) only given columns will have filter, EXCLUDE given columns will NOT have filter
+     */
+    withColumnsFilter(filterOnColumn, filterColumnMode = TableDynamicColumnsModeEnum.INCLUDE_ONLY) {
+        this._filterColumnMode = filterColumnMode;
+        this._filterColumns = filterOnColumn;
+        return this;
+    }
+    /**
+     * sets given type to column with given property and returns this table
+     * @param property column's property
+     * @param type custom type for column
+     * @param displayType custom column value display type
+     * @param args addition arguments for column
+     */
+    withColumnModifiedType(property, type, displayType, ...args) {
+        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property).withTitle(property);
+        if (column) {
+            column.asType(type, displayType, ...args);
+        }
+        return this;
+    }
+    /**
+     * sets title to column with given property and returns this table
+     * @param property column's property
+     * @param title column's title
+     */
+    withColumnTitle(property, title) {
+        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property);
+        column.withTitle(title, true);
+        return this;
+    }
+    /**
+     * generates columns defined on table based on data fetched from api
+     * @param data data from api
+     */
+    toTableDescriptorFromData(data) {
+        const tableDescriptor = this.toTableDescriptor();
+        if (data.data == null || data.data.length == 0) {
+            return tableDescriptor;
+        }
+        const objectModel = data.data[0];
+        const entries = ObjectUtil.flattenObjectKeys(objectModel)
+            .filter(([key]) => !this._excludedColumns.includes(key))
+            .filter(([, value]) => !Array.isArray(value)); //exclude arrays and sets
+        for (const [key, value] of entries) {
+            const metaColumn = this._columns.find(col => col.property === key);
+            let column;
+            if (metaColumn) {
+                if (!metaColumn.visibility) {
+                    continue;
+                }
+                column = metaColumn.toColumnDescriptor(tableDescriptor);
+                tableDescriptor.withColumn(column);
+            }
+            else {
+                column = tableDescriptor.addColumn(key).withTitle(key);
+                columnToDateNumberOrBoolean(column, value);
+            }
+            if (this.model.i18nBaseKey && !column.property.includes('rev')) {
+                column.withTitle([this.model.i18nBaseKey, 'properties', column.property].join('.').replace('state.', ''));
+            }
+            const elementOfSortColumns = this._sortColumns.includes(column.property);
+            if ((this._sortColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfSortColumns) ||
+                (this._sortColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfSortColumns)) {
+                column.withSortUnsafe();
+            }
+            const elementOfFilterColumns = this._filterColumns.includes(column.property);
+            if (this._filterColumns.length > 0 &&
+                ((this._filterColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfFilterColumns) ||
+                    (this._filterColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfFilterColumns))) {
+                column.withFilterUnsafe();
+            }
+        }
+        return tableDescriptor;
+    }
+    /**
+     * adds ColumnDynamicDescriptor to this table
+     * @param property column's property
+     */
+    addColumn(property) {
+        const column = new ColumnDynamicDescriptor(this, property);
+        this._columns.push(column);
+        return column;
+    }
+    removeColumn(property) {
+        const column = this.columns.find(col => col.property === property) ?? this.addColumn(property);
+        column.withVisibility(false);
+        return this;
+    }
+    /**
+     * creates deep copy of table dynamic descriptor
+     */
+    copy() {
+        const descriptor = new TableDynamicDescriptorInst(this.model.copy());
+        this.copyFieldsTo(descriptor);
+        descriptor._columns = this.columns.map(c => c.copy());
+        descriptor._excludedColumns = [...this._excludedColumns];
+        descriptor._filterColumns = [...this._filterColumns];
+        descriptor._sortColumns = [...this._sortColumns];
+        descriptor._filterColumnMode = this._filterColumnMode;
+        descriptor._sortColumnMode = this._sortColumnMode;
+        return descriptor;
+    }
+    toTableDescriptor() {
+        const descriptor = new TableDescriptorInst(this.model);
+        this.copyFieldsTo(descriptor);
+        return descriptor;
+    }
+}
+class TableDynamicDescriptor extends TableDynamicDescriptorInst {
+    constructor() {
+        super(ModelDescriptor.create());
+    }
+    static create(idProperty, titleProperty, i18nBaseKey) {
+        return new TableDynamicDescriptorInst(ModelDescriptor.create(idProperty, titleProperty, i18nBaseKey));
+    }
+    static fromModel(model) {
+        return new TableDynamicDescriptorInst(model);
+    }
+}
+
+// data providers
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ColumnDescriptor, ColumnDisplayTypeEnum, ColumnDynamicDescriptor, ColumnTypeEnum, SortDescriptor, TableDataProvider, TableDataProviderInst, TableDescriptor, TableDescriptorInst, TableDynamicColumnsModeEnum, TableDynamicDescriptor, TableDynamicDescriptorInst, TablePaginationModeEnum, TableSizeEnum, columnToDateNumberOrBoolean, expandClassAttributeDefWithTableDef, getColumnDisplayTypeFromColumnType, getColumnTypeFromClassAttributeDefType, getTableClassAttributeDef };
+//# sourceMappingURL=mediusinc-mng-commons-table-api.mjs.map