@mediusinc/mng-commons 0.13.0 → 0.14.0

package/fesm2020/mediusinc-mng-commons.mjs

@@ -3,11 +3,11 @@ import { CommonModule } from '@angular/common';
 import * as i1$3 from '@angular/common/http';
 import { HttpErrorResponse, HttpClient, HttpClientModule } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Pipe, Inject, EventEmitter, Component, ChangeDetectionStrategy, Optional, HostBinding, Input, Output, Directive, ContentChildren, ViewChild, forwardRef, LOCALE_ID, ViewChildren, HostListener, APP_INITIALIZER, NgModule } from '@angular/core';
+import { InjectionToken, Injectable, Pipe, Inject, EventEmitter, Component, ChangeDetectionStrategy, Optional, HostBinding, Input, Output, Directive, ContentChildren, ViewChild, forwardRef, LOCALE_ID, ViewChildren, inject, HostListener, APP_INITIALIZER, NgModule } from '@angular/core';
 import * as i2$1 from '@angular/forms';
 import { Validators, FormGroup, FormArray, NG_VALUE_ACCESSOR, FormControl, ReactiveFormsModule } from '@angular/forms';
 import * as i1 from '@angular/router';
-import { NavigationEnd, GuardsCheckEnd, RouterModule } from '@angular/router';
+import { NavigationEnd, ActivatedRoute, GuardsCheckEnd, RouterModule } from '@angular/router';
 import * as i2$2 from '@ngx-formly/core';
 import { FieldWrapper, FieldType, FORMLY_CONFIG, FormlyModule } from '@ngx-formly/core';
 import * as i1$2 from '@ngx-translate/core';
@@ -523,28 +523,63 @@ class TableDataProvider extends DataProvider {
     constructor(modelType, serviceType) {
         super(modelType, serviceType);
         this._getAll = () => of(new MediusQueryResult());
+        this._getAllReloadSubject = new Subject();
     }
     get getAll() {
         return this._getAll;
     }
+    get getAllReload$() {
+        return this._getAllReloadSubject.asObservable();
+    }
     withGetAll(getAll) {
         this._getAll = getAll;
         return this;
     }
+    getAllReload(queryParam) {
+        this._getAllReloadSubject.next(queryParam);
+    }
 }
 
 class TableviewDataProvider extends EditorDataProvider {
     constructor(modelType, serviceType) {
         super(modelType, serviceType);
         this._getAll = () => of(new MediusQueryResult());
+        this._getAllReloadSubject = new Subject();
     }
     get getAll() {
         return this._getAll;
     }
+    get getAllReload$() {
+        return this._getAllReloadSubject.asObservable();
+    }
     withGetAll(getAll) {
         this._getAll = getAll;
         return this;
     }
+    getAllReload(queryParam) {
+        this._getAllReloadSubject.next(queryParam);
+    }
+}
+class DynamicTableviewDataProvider extends TableviewDataProvider {
+    constructor() {
+        super({});
+        this._getAll = () => of(new MediusQueryResult());
+        this._fetch = () => of({});
+    }
+    withGetAll(getAll) {
+        this._getAll = getAll;
+        return this;
+    }
+    withFetch(fetch) {
+        this._fetch = fetch;
+        return this;
+    }
+    get getAll() {
+        return this._getAll;
+    }
+    get fetch() {
+        return this._fetch;
+    }
 }
 
 class TableviewCrudDataProvider extends TableviewDataProvider {
@@ -841,6 +876,15 @@ var TableSizeEnum;
     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 StylesUtil {
     static calculateTableColumnActionWidth(table, actions) {
@@ -1159,6 +1203,8 @@ class ActionDescriptor {
         this._hasRunNotificationError = true;
         //button
         this._buttonDescriptor = new ButtonDescriptor();
+        // multiple row selection
+        this._hasItemsSelection = false;
         this._model = model;
         this._actionName = actionName;
         if ((parentType && !parentProperty) || (!parentProperty && parentProperty)) {
@@ -1270,6 +1316,9 @@ class ActionDescriptor {
     get permissionsRouteType() {
         return this._permissionsRouteType;
     }
+    get hasItemsSelection() {
+        return this._hasItemsSelection;
+    }
     get buttonDescriptor() {
         return this._buttonDescriptor;
     }
@@ -1357,6 +1406,11 @@ class ActionDescriptor {
         this._buttonDescriptor = buttonDescriptor;
         return this;
     }
+    withItemsSelection(hasSelection = true) {
+        this._hasItemsSelection = hasSelection;
+        this._isEnabledFunction = this._isEnabledFunction ?? (ctx => of((ctx.parameters.selectedItems?.length ?? 0) > 0));
+        return this;
+    }
 }
 class ActionSimpleDescriptor extends ActionDescriptor {
     constructor(actionName, modelType, idProperty, titleProperty) {
@@ -1655,11 +1709,152 @@ class ActionLinkDescriptor extends ActionDescriptor {
     }
 }
 
+class TableviewUtil {
+    /**
+     * returns attributes from class type and extends to typed def with column and field enum type
+     * @param modelType class type
+     */
+    static getAttributeDefMap(modelType) {
+        return TableviewUtil.expandAttributeDefWithTableviewTypes(ObjectSerializer.get().findAttributesDefinitionByClassType(modelType));
+    }
+    /**
+     * expands AttributeDef to TableviewAttributeDef with defined input and column enum type
+     * @param attributes open api specification model
+     */
+    static expandAttributeDefWithTableviewTypes(attributes) {
+        if (attributes == null) {
+            throw new Error('AttributeDef is null, problem with ObjectSerializer::findAttributesDefinitionByClassType?');
+        }
+        const objectSerializer = ObjectSerializer.get();
+        const tableviewAttributeDef = [];
+        for (const attribute of attributes) {
+            const enumType = objectSerializer.findEnum(attribute.type);
+            tableviewAttributeDef.push({
+                name: attribute.name,
+                baseName: attribute.baseName,
+                type: attribute.type,
+                columnType: enumType ? ColumnTypeEnum.Enum : TableviewUtil.toColumnType(attribute.type),
+                fieldType: TableviewUtil.toFieldInputType(attribute.type),
+                enumType: objectSerializer.findEnum(attribute.type),
+                classType: objectSerializer.findType(attribute.type)
+            });
+        }
+        return tableviewAttributeDef;
+    }
+    /**
+     * converts column to number or date on value based
+     * @param column column to be transformed
+     * @param value value to check if applicable
+     */
+    static stringColumnConverter(column, value) {
+        if (typeof value === 'boolean') {
+            return column.asBoolean();
+        }
+        else if (!isNaN(value) && typeof value === 'number') {
+            return column.asNumber();
+        }
+        else if (this._dateRegex.test(value)) {
+            return column.asDate();
+        }
+        else {
+            return column;
+        }
+    }
+    /**
+     * converts string type to column type enum, default is string
+     * @param property
+     */
+    static toColumnType(property) {
+        const os = ObjectSerializer.get();
+        if (os.findEnum(property)) {
+            property = 'enum';
+        }
+        else if (os.findType(property)) {
+            property = 'class';
+        }
+        switch (property) {
+            case 'number':
+                return ColumnTypeEnum.Number;
+            case 'currency':
+                return ColumnTypeEnum.Currency;
+            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;
+        }
+    }
+    /**
+     * converts string type to type enum, default is text
+     * @param property
+     */
+    static toFieldInputType(property) {
+        switch (property) {
+            case 'hidden':
+                return FieldInputTypeEnum.Hidden;
+            case 'label':
+                return FieldInputTypeEnum.Label;
+            case 'textarea':
+                return FieldInputTypeEnum.Textarea;
+            case 'number':
+                return FieldInputTypeEnum.Number;
+            case 'currency':
+                return FieldInputTypeEnum.Currency;
+            case 'switch':
+            case 'boolean':
+                return FieldInputTypeEnum.Switch;
+            case 'radio':
+                return FieldInputTypeEnum.Radio;
+            case 'datepicker':
+                return FieldInputTypeEnum.Datepicker;
+            case 'mask':
+                return FieldInputTypeEnum.Mask;
+            case 'file':
+                return FieldInputTypeEnum.File;
+            case 'custom':
+                return FieldInputTypeEnum.Custom;
+            case 'text':
+            default:
+                return FieldInputTypeEnum.Text;
+        }
+    }
+    /**
+     * convert column type to equivalent field input type
+     * @param type column type
+     */
+    static toFieldInputTypeFromColumnType(type) {
+        switch (type) {
+            case ColumnTypeEnum.Number:
+                return FieldInputTypeEnum.Number;
+            case ColumnTypeEnum.Currency:
+                return FieldInputTypeEnum.Currency;
+            case ColumnTypeEnum.Boolean:
+                return FieldInputTypeEnum.Switch;
+            case ColumnTypeEnum.Date:
+                return FieldInputTypeEnum.Datepicker;
+            case ColumnTypeEnum.Custom:
+                return FieldInputTypeEnum.Custom;
+            case ColumnTypeEnum.String:
+            case ColumnTypeEnum.Enum:
+            default:
+                return FieldInputTypeEnum.Text;
+        }
+    }
+}
+TableviewUtil._dateRegex = /\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)/;
+
 class FilterDescriptor {
     constructor(property) {
         this._filterType = FilterTypeEnum.String;
         this._hasDefaultValue = false;
-        this._defaultFilterMatchMode = FilterMatchModeEnum.Equals;
         this._matchModes = null;
         this._numberUseGrouping = true;
         this._datePickerShowTime = false;
@@ -1735,13 +1930,11 @@ class FilterDescriptor {
         this._filterProperty = filterProperty;
         return this;
     }
-    withDefaultFilter(filterValue, filterValueTo, filterMatchMode = FilterMatchModeEnum.Equals) {
+    withDefaultFilter(filterValue, filterValueTo, filterMatchMode) {
         this._hasDefaultValue = true;
         this._defaultValue = filterValue;
         this._defaultValueTo = filterValueTo;
-        if (filterMatchMode) {
-            this._defaultFilterMatchMode = filterMatchMode;
-        }
+        this._defaultFilterMatchMode = filterMatchMode;
         return this;
     }
     withNumberFractions(min, max) {
@@ -1888,6 +2081,16 @@ class FilterLookupDescriptor extends FilterDescriptor {
         this._dropdownClassName = dropdownClassName;
         return this;
     }
+    withDefaultFilter(filterValue, filterValueTo, filterMatchMode) {
+        this._hasDefaultValue = true;
+        this._defaultValue = filterValue;
+        this._defaultValueTo = filterValueTo;
+        this._defaultFilterMatchMode = filterMatchMode;
+        if (Array.isArray(filterValue) && !this.multiselect) {
+            throw new Error('Array default filter can only be used with a multiselect filter.');
+        }
+        return this;
+    }
     asAutocomplete(openOnFocus = false, inlineSearch = false) {
         this._lookupType = FilterLookupTypeEnum.Autocomplete;
         this._autocompleteOpenOnFocus = openOnFocus;
@@ -2047,9 +2250,29 @@ class ColumnDescriptor {
     get getter() {
         return this._getter;
     }
-    asType(type = ColumnTypeEnum.String) {
-        this._columnType = type;
-        return this;
+    /**
+     * converts column to given type with additional arguments
+     * @param type column type enum
+     * @param args any additional arguments for column (optional)
+     */
+    asType(type, ...args) {
+        switch (type) {
+            case ColumnTypeEnum.Number:
+                return this.asNumber(...args);
+            case ColumnTypeEnum.Currency:
+                return this.asCurrency(...args);
+            case ColumnTypeEnum.Boolean:
+                return this.asBoolean(...args);
+            case ColumnTypeEnum.Date:
+                return this.asDate(...args);
+            case ColumnTypeEnum.Enum:
+                return this.asEnum(args[0], args[1], args[2]);
+            case ColumnTypeEnum.Custom:
+                return this.asCustomComponent(args[0]);
+            case ColumnTypeEnum.String:
+            default:
+                return this;
+        }
     }
     asNumber(displayFormat = '1.0-0', locale) {
         this._columnType = ColumnTypeEnum.Number;
@@ -2190,32 +2413,88 @@ class ColumnDescriptor {
     }
     copy() {
         const descriptor = new ColumnDescriptor(this._table, this._property);
-        descriptor._jsonPath = this._jsonPath;
+        this.copyFieldsTo(descriptor);
+        return descriptor;
+    }
+    copyFieldsTo(obj) {
+        obj._jsonPath = this._jsonPath;
+        obj._title = this._title;
+        obj._isSortEnabled = this._isSortEnabled;
+        obj._columnType = this._columnType;
+        obj._filterDescriptor = this._filterDescriptor?.copy();
+        obj._enumType = this._enumType;
+        obj._enumTitlePath = this._enumTitlePath;
+        obj._enumNameAsValue = this._enumNameAsValue;
+        obj._booleanAsIcon = this._booleanAsIcon;
+        obj._booleanYes = this._booleanYes;
+        obj._booleanNo = this._booleanNo;
+        obj._objectModelType = this._objectModelType;
+        obj._objectTitleProperty = this._objectTitleProperty;
+        obj._locale = this._locale;
+        obj._currencyCode = this._currencyCode;
+        obj._currencyDisplay = this._currencyDisplay;
+        obj._currencyFromProperty = this._currencyFromProperty;
+        obj._displayFormat = this._displayFormat;
+        obj._headerClassName = this._headerClassName;
+        obj._className = this._className;
+        obj._width = this._width;
+        obj._minWidth = this._minWidth;
+        obj._maxWidth = this._maxWidth;
+        obj._hasCopyToClipboard = this._hasCopyToClipboard;
+        obj._template = this._template;
+        obj._getter = this._getter;
+    }
+}
+class ColumnDynamicDescriptor extends ColumnDescriptor {
+    // private _filterStatus;
+    constructor(table, property) {
+        super(table, property);
+        this._visibility = true;
+        this._table = table;
+    }
+    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) {
+        TableviewUtil.stringColumnConverter(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._isSortEnabled = this._isSortEnabled;
-        descriptor._columnType = this._columnType;
-        descriptor._filterDescriptor = this._filterDescriptor?.copy();
-        descriptor._enumType = this._enumType;
-        descriptor._enumTitlePath = this._enumTitlePath;
-        descriptor._enumNameAsValue = this._enumNameAsValue;
-        descriptor._booleanAsIcon = this._booleanAsIcon;
-        descriptor._booleanYes = this._booleanYes;
-        descriptor._booleanNo = this._booleanNo;
-        descriptor._objectModelType = this._objectModelType;
-        descriptor._objectTitleProperty = this._objectTitleProperty;
-        descriptor._locale = this._locale;
-        descriptor._currencyCode = this._currencyCode;
-        descriptor._currencyDisplay = this._currencyDisplay;
-        descriptor._currencyFromProperty = this._currencyFromProperty;
-        descriptor._displayFormat = this._displayFormat;
-        descriptor._headerClassName = this._headerClassName;
-        descriptor._className = this._className;
-        descriptor._width = this._width;
-        descriptor._minWidth = this._minWidth;
-        descriptor._maxWidth = this._maxWidth;
-        descriptor._hasCopyToClipboard = this._hasCopyToClipboard;
-        descriptor._template = this._template;
-        descriptor._getter = this._getter;
+        descriptor._visibility = this._visibility;
+        return descriptor;
+    }
+    toColumnDescriptor(tableDescriptor) {
+        const descriptor = new ColumnDescriptor(tableDescriptor, this._property);
+        this.copyFieldsTo(descriptor);
         return descriptor;
     }
 }
@@ -2226,9 +2505,37 @@ class EditorDescriptor {
         this._groups = [];
         this._fields = [];
         this._disabled = false;
+        this._modelType = modelType;
         this._model = new ModelDescriptor(modelType, idProperty, titleProperty);
         this._tableviewEditorType = tableviewEditorType;
     }
+    /**
+     * auto generated editor descriptor based on openapi definition
+     * generates all fields from definition
+     * @param modelType class type
+     * @param idProperty
+     * @param titleProperty
+     * @param tableEditorType
+     */
+    static from(modelType, idProperty, titleProperty, tableEditorType = TableviewTypeEnum.None) {
+        return EditorDescriptor.fromModelWithAttributes(modelType, TableviewUtil.getAttributeDefMap(modelType), titleProperty, idProperty, tableEditorType);
+    }
+    /**
+     * auto generated editor descriptor based on openapi definition
+     * generates only selected fields
+     * @param modelType class type
+     * @param attributes list of selected properties to generate fields based on
+     * @param idProperty
+     * @param titleProperty
+     * @param tableEditorType
+     */
+    static fromModelWithAttributes(modelType, attributes, idProperty, titleProperty, tableEditorType = TableviewTypeEnum.None) {
+        const descriptor = new EditorDescriptor(modelType, idProperty, titleProperty, tableEditorType);
+        attributes
+            .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))
+            .forEach(attr => descriptor.upsertFieldFromAttributeDef(attr, descriptor.fields.find(col => col.property === attr.name)));
+        return descriptor;
+    }
     get model() {
         return this._model;
     }
@@ -2275,20 +2582,23 @@ class EditorDescriptor {
         this.addFieldDescriptor(field);
         return field;
     }
+    /**
+     * removes filed if exists in descriptor
+     * @param property field name
+     */
     removeField(property) {
         const fieldIdx = this._fields.findIndex(f => f.property === property);
         if (fieldIdx < 0) {
             throw new Error(`Field ${property} does not exist.`);
         }
-        const field = this._fields[fieldIdx];
-        if (field.group) {
-            const groupFieldIdx = field.group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);
+        for (const group of this._groups) {
+            const groupFieldIdx = group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);
             if (groupFieldIdx >= 0) {
-                field.group.fields.splice(groupFieldIdx, 1);
+                group.fields.splice(groupFieldIdx, 1);
+                break;
             }
         }
         this._fields.splice(fieldIdx, 1);
-        return this;
     }
     getField(property) {
         return this._fields.find(f => f.property === property) ?? null;
@@ -2361,6 +2671,75 @@ class EditorDescriptor {
             this.createTabGroup(EditorDescriptor.defaultGroupName, 'general.general');
         }
     }
+    /**
+     * modifies selected field
+     * do not use it for enums! (use withFieldModifiedEnum instead)
+     * @param property field name
+     * @param fieldType new field type for selected field
+     * @param args additional parameters for field
+     */
+    withFieldModifiedType(property, fieldType, ...args) {
+        const attribute = TableviewUtil.getAttributeDefMap(this._modelType).find(attribute => attribute.name === property);
+        if (attribute) {
+            attribute.fieldType = fieldType;
+            this.upsertFieldFromAttributeDef(attribute, this.fields.find(fi => fi.property === property), ...args);
+        }
+        return this;
+    }
+    /**
+     * modifies selected field with enum type
+     * @param property field property name
+     * @param enumType type of enum for new field
+     * @param optionsTitlePath
+     * @param values
+     * @param nameAsValue
+     */
+    withFieldModifiedEnum(property, enumType, optionsTitlePath, values, nameAsValue = false) {
+        const attribute = TableviewUtil.getAttributeDefMap(this._modelType).find(a => a.name === property);
+        if (attribute) {
+            attribute.fieldType = FieldInputTypeEnum.Radio;
+            const field = this.fields.find(f => f.property === property);
+            if (field && field instanceof FieldInputDescriptor) {
+                field.asRadioFromEnum(enumType ?? ObjectSerializer.get().findEnum(attribute.type), optionsTitlePath, values, nameAsValue);
+            }
+        }
+        return this;
+    }
+    /**
+     * adds lookup to given field
+     * @param property field property name
+     * @param modelType model type of field
+     * @param lookupProvider provider to be added to field
+     * @param titleProperty
+     */
+    withFieldModifiedLookup(property, modelType, lookupProvider, titleProperty) {
+        this.removeField(property);
+        const field = this.addFieldLookup(property, modelType).asAutocomplete().withLookupDataProvider(lookupProvider);
+        if (titleProperty) {
+            field.withItemsLabelProperty(titleProperty);
+        }
+        return this;
+    }
+    /**
+     * generates field based on attribute definition, used for auto model
+     * @param attribute definition
+     * @param field optional, if defined will be replaced, otherwise new will be generated
+     * @param args additional arguments
+     */
+    upsertFieldFromAttributeDef(attribute, field, ...args) {
+        if (field == null) {
+            field = this.addField(attribute.name);
+        }
+        if (field instanceof FieldInputDescriptor) {
+            if (attribute.enumType) {
+                return field.asRadioFromEnum(attribute.enumType);
+            }
+            else {
+                return field.asType(attribute.fieldType ?? TableviewUtil.toFieldInputTypeFromColumnType(attribute.columnType), ...args);
+            }
+        }
+        return field;
+    }
 }
 EditorDescriptor.defaultGroupName = '_default';
 
@@ -2433,9 +2812,6 @@ class AFieldDescriptor extends AGenericFieldDescriptor {
     get property() {
         return this._property;
     }
-    get group() {
-        return this._group;
-    }
     get label() {
         return this._label;
     }
@@ -2599,6 +2975,39 @@ class FieldInputDescriptor extends AFieldDescriptor {
         this._fileMultiple = false;
         this._fileMaxFileSize = 500000;
     }
+    /**
+     * converts field to given type with additional arguments
+     * @param fieldType field type enum
+     * @param args any additional arguments for field (optional)
+     */
+    asType(fieldType, ...args) {
+        switch (fieldType) {
+            case FieldInputTypeEnum.Hidden:
+                return this.asHidden();
+            case FieldInputTypeEnum.Label:
+                return this.asLabel();
+            case FieldInputTypeEnum.Textarea:
+                return this.asTextarea(...args);
+            case FieldInputTypeEnum.Number:
+                return this.asNumber();
+            case FieldInputTypeEnum.Currency:
+                return this.asCurrency(...args);
+            case FieldInputTypeEnum.Switch:
+                return this.asSwitch();
+            case FieldInputTypeEnum.Radio:
+                return this.asRadio(args[0], args[1]);
+            case FieldInputTypeEnum.Datepicker:
+                return this.asDatePicker(...args);
+            case FieldInputTypeEnum.Mask:
+                return this.asMask(args[0], args[1]);
+            case FieldInputTypeEnum.File:
+                return this.asFile(...args);
+            case FieldInputTypeEnum.Custom:
+                return this.asCustomComponent(args[0]);
+            case FieldInputTypeEnum.Text:
+                return this.asText();
+        }
+    }
     get fieldType() {
         return this._fieldType;
     }
@@ -3132,6 +3541,10 @@ class AFieldGroupDescriptor extends AGenericFieldDescriptor {
         this._name = `${this.baseName}${name}`;
         this._default = name === EditorDescriptor.defaultGroupName;
     }
+    removeField(property, filterFunction) {
+        this._fields = filterFunction(this._fields);
+        return this._fields;
+    }
     get title() {
         return this._title;
     }
@@ -3281,9 +3694,33 @@ class TableDescriptor {
         this._size = TableSizeEnum.Large;
         this._hasHover = true;
         this._hasGridlines = false;
+        this._autoGenerated = false;
+        this._modelType = modelType;
         this._model = new ModelDescriptor(modelType, idProperty, titleProperty);
         this._dataKeyProperty = idProperty ?? ModelUtil.findIdAttribute(modelType) ?? undefined;
     }
+    /**
+     * generates descriptor based on modelType attribute definition
+     * @param modelType class type
+     * @param idProperty
+     * @param titleProperty
+     */
+    static from(modelType, idProperty, titleProperty) {
+        return TableDescriptor.fromModelWithAttributes(modelType, TableviewUtil.getAttributeDefMap(modelType), idProperty, titleProperty);
+    }
+    /**
+     * generates descriptor base on given attribute definition
+     * @param modelType class type
+     * @param attributes attributes from which descriptor is generated
+     * @param idProperty
+     * @param titleProperty
+     */
+    static fromModelWithAttributes(modelType, attributes, idProperty, titleProperty) {
+        const descriptor = new TableDescriptor(modelType, idProperty, titleProperty);
+        descriptor._autoGenerated = true;
+        attributes.filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array')).forEach(attr => descriptor.upsertColumnFromAttributeDef(attr));
+        return descriptor;
+    }
     get filterDisplay() {
         return this._filterDisplay;
     }
@@ -3338,6 +3775,18 @@ class TableDescriptor {
     get hasGridlines() {
         return this._hasGridlines;
     }
+    get rowClassName() {
+        return this._rowClassName;
+    }
+    get rowClassNameMapFn() {
+        return this._rowClassNameMapFn;
+    }
+    get headerClassName() {
+        return this._headerClassName;
+    }
+    getColumn(property) {
+        return this._columns.find(col => col.property === property);
+    }
     addColumnDescriptor(column) {
         this._columns.push(column);
         return this;
@@ -3377,6 +3826,10 @@ class TableDescriptor {
         this._columns.push(column);
         return column;
     }
+    removeColumn(property) {
+        const columndIdx = this._columns.findIndex(c => c.property === property);
+        this._columns.splice(columndIdx, 1);
+    }
     withFilterDisplay(filterDisplayType) {
         this._filterDisplay = filterDisplayType;
         return this;
@@ -3439,28 +3892,252 @@ class TableDescriptor {
         this._hasGridlines = gridlines;
         return this;
     }
+    withRowClassName(rowClassName, classNameMapFn) {
+        this._rowClassName = rowClassName;
+        this._rowClassNameMapFn = classNameMapFn;
+        return this;
+    }
+    withHeaderClassName(headerClassName) {
+        this._headerClassName = headerClassName;
+        return this;
+    }
+    copyFieldsTo(obj) {
+        obj._title = this._title;
+        obj._hideHeader = this._hideHeader;
+        obj._dataKeyProperty = this._dataKeyProperty;
+        obj._hasDefaultSort = this._hasDefaultSort;
+        obj._defaultSortProperty = this._defaultSortProperty.map(p => p);
+        obj._defaultSortAsc = this._defaultSortAsc.map(p => p);
+        obj._filterDisplay = this._filterDisplay;
+        obj._className = this._className;
+        obj._size = this._size;
+        obj._tableFullHeightOffset = this._tableFullHeightOffset;
+        obj._rowHeight = this._rowHeight;
+        obj._hasHover = this._hasHover;
+        obj._hasGridlines = this._hasGridlines;
+    }
     copy() {
         const descriptor = new TableDescriptor(this.model.type, this.model.idPropertyName, this.model.titlePropertyName);
+        this.copyFieldsTo(descriptor);
         descriptor._columns = this.columns.map(c => c.copy());
-        descriptor._title = this._title;
-        descriptor._hideHeader = this._hideHeader;
-        descriptor._dataKeyProperty = this._dataKeyProperty;
-        descriptor._hasDefaultSort = this._hasDefaultSort;
-        descriptor._defaultSortProperty = this._defaultSortProperty.map(p => p);
-        descriptor._defaultSortAsc = this._defaultSortAsc.map(p => p);
-        descriptor._filterDisplay = this._filterDisplay;
-        descriptor._className = this._className;
-        descriptor._size = this._size;
-        descriptor._tableFullHeightOffset = this._tableFullHeightOffset;
-        descriptor._rowHeight = this._rowHeight;
-        descriptor._hasHover = this._hasHover;
-        descriptor._hasGridlines = this._hasGridlines;
+        return descriptor;
+    }
+    /**
+     * generates column based on attributes
+     * @param attribute attribute map
+     * @param column if provided, replaced by new, otherwise new is created
+     * @param args additional parameters
+     */
+    upsertColumnFromAttributeDef(attribute, column, ...args) {
+        if (column == null) {
+            column = this.addColumn(attribute.name);
+        }
+        if (attribute.columnType === ColumnTypeEnum.Enum && args.length === 0) {
+            args = [attribute.enumType];
+        }
+        column = column.asType(attribute.columnType, ...args);
+        if (attribute.classType) {
+            column.withObjectProperty(attribute.classType).withSort();
+        }
+        else {
+            column.withSort().withFilter();
+        }
+        return column;
+    }
+    /**
+     * defines modified type of column
+     * DO NOT USE with enum (use withCustomEnumType)
+     * @param property column name
+     * @param columnType modified type
+     * @param args additional attributes
+     */
+    withColumnModifiedType(property, columnType, ...args) {
+        const attributeDef = TableviewUtil.getAttributeDefMap(this._modelType).find(atribute => atribute.name === property);
+        if (attributeDef != null) {
+            attributeDef.columnType = columnType ?? attributeDef.columnType;
+            this.upsertColumnFromAttributeDef(attributeDef, this.columns.find(col => col.property === attributeDef.name), ...args);
+        }
+        return this;
+    }
+    /**
+     * defines custom enum type for column
+     * @param property column name
+     * @param enumType
+     */
+    withColumnModifiedEnum(property, enumType) {
+        const attributeDef = TableviewUtil.getAttributeDefMap(this._modelType).find(atribute => atribute.name === property);
+        if (attributeDef != null) {
+            attributeDef.columnType = ColumnTypeEnum.Enum;
+            this.upsertColumnFromAttributeDef(attributeDef, this.columns.find(col => col.property === property), enumType ?? ObjectSerializer.get().findEnum(attributeDef.type));
+        }
+        return this;
+    }
+    /**
+     * modifies column with class and lookup provider
+     * @param property column name
+     * @param lookupProvider lookupProvider for class
+     * @param itemsLabelProperty
+     * @param filterProperty
+     */
+    withColumnModifiedLookup(property, lookupProvider, itemsLabelProperty, filterProperty) {
+        const column = this.columns.find(col => col.property === property);
+        if (column) {
+            column.withFilterLookup().withLookupDataProvider(lookupProvider);
+            if (column instanceof FilterLookupDescriptor) {
+                if (itemsLabelProperty) {
+                    column.withItemsLabelProperty(itemsLabelProperty);
+                }
+                if (filterProperty) {
+                    column.withFilterProperty(filterProperty);
+                }
+            }
+        }
+        return this;
+    }
+}
+class TableDynamicDescriptor extends TableDescriptor {
+    constructor(idProperty, titleProperty) {
+        super({}, idProperty, titleProperty);
+        this._excludedColumns = [];
+        this._filterColumns = [];
+        this._sortColumns = [];
+        this._sortColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;
+        this._filterColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;
+        this._columns = [];
+        this.withTitle('Dynamic table');
+    }
+    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 args addition arguments for column
+     */
+    withColumnModifiedType(property, type, ...args) {
+        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property).withTitle(property);
+        if (column) {
+            column.asType(type, ...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.pageData == null || data.pageData.length == 0) {
+            return tableDescriptor;
+        }
+        const objectModel = data.pageData[0];
+        const entries = Object.entries(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.addColumnDescriptor(column);
+            }
+            else {
+                column = tableDescriptor.addColumn(key).withTitle(key);
+                TableviewUtil.stringColumnConverter(column, value);
+            }
+            const elementOfSortColumns = this._sortColumns.includes(column.property);
+            if ((this._sortColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfSortColumns) ||
+                (this._sortColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfSortColumns)) {
+                column.withSort();
+            }
+            const elementOfFilterColumns = this._filterColumns.includes(column.property);
+            if ((this._filterColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfFilterColumns) ||
+                (this._filterColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfFilterColumns)) {
+                column.withFilter();
+            }
+        }
+        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 TableDynamicDescriptor(this.model.idPropertyName, this.model.titlePropertyName);
+        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 TableDescriptor({}, this.model.idPropertyName, this.model.titlePropertyName);
+        this.copyFieldsTo(descriptor);
         return descriptor;
     }
 }
 
 class TableviewDescriptor {
     constructor(modelType, idProperty, titleProperty) {
+        this._modelType = modelType;
         this._model = new ModelDescriptor(modelType, idProperty, titleProperty);
         this._table = new TableDescriptor(modelType, idProperty, titleProperty);
         this._viewEditor = new EditorDescriptor(modelType, idProperty, titleProperty, TableviewTypeEnum.View);
@@ -3469,6 +4146,38 @@ class TableviewDescriptor {
         this._editEditor = new EditorDescriptor(modelType, idProperty, titleProperty, TableviewTypeEnum.Edit);
         this._tableTitle = `${this._model.typeName}.name`;
     }
+    /**
+     * generates descriptor from attribute definition of openaapi model
+     * @param modelType class type
+     * @param idProperty
+     * @param titleProperty
+     */
+    static from(modelType, idProperty, titleProperty) {
+        const descriptor = new TableviewDescriptor(modelType, idProperty, titleProperty);
+        descriptor._table = TableDescriptor.from(modelType, idProperty, titleProperty);
+        descriptor._editEditor = EditorDescriptor.from(modelType, idProperty, titleProperty);
+        descriptor._viewEditor = EditorDescriptor.from(modelType, idProperty, titleProperty);
+        descriptor._addEditor = EditorDescriptor.from(modelType, idProperty, titleProperty);
+        return descriptor;
+    }
+    /**
+     * generates descriptor from given attribute definition
+     * @param modelType class type
+     * @param columnAttributes attribute definition to generate columns
+     * @param fieldAttributes attribute definition to generate fields, if undefined columnDefinition is used, if null editors are not generated
+     * @param idProperty
+     * @param titleProperty
+     */
+    static fromModelWithDefinition(modelType, columnAttributes, fieldAttributes, idProperty, titleProperty) {
+        const descriptor = new TableviewDescriptor(modelType, idProperty, titleProperty);
+        descriptor._table = TableDescriptor.fromModelWithAttributes(modelType, columnAttributes, idProperty, titleProperty);
+        if (fieldAttributes !== null) {
+            descriptor._editEditor = EditorDescriptor.fromModelWithAttributes(modelType, fieldAttributes ?? columnAttributes, idProperty, titleProperty);
+            descriptor._viewEditor = EditorDescriptor.fromModelWithAttributes(modelType, fieldAttributes ?? columnAttributes, idProperty, titleProperty);
+            descriptor._addEditor = EditorDescriptor.fromModelWithAttributes(modelType, fieldAttributes ?? columnAttributes, idProperty, titleProperty);
+        }
+        return descriptor;
+    }
     get table() {
         return this._table;
     }
@@ -3491,6 +4200,12 @@ class TableviewDescriptor {
         this._table = descriptor;
         return this;
     }
+    withEditorDescriptors(descriptor) {
+        this._viewEditor = descriptor;
+        this._editEditor = descriptor;
+        this._addEditor = descriptor;
+        return this;
+    }
     withViewDescriptor(descriptor) {
         this._viewEditor = descriptor;
         return this;
@@ -3519,6 +4234,26 @@ class TableviewDescriptor {
     addColumn(property) {
         return this._table.addColumn(property);
     }
+    removeColumn(property) {
+        this._table.removeColumn(property);
+    }
+    getField(property, editorType) {
+        switch (editorType) {
+            case TableviewTypeEnum.Edit:
+                return this._editEditor.getField(property);
+            case TableviewTypeEnum.Add:
+                return this._addEditor.getField(property);
+            case TableviewTypeEnum.View:
+                return this._viewEditor.getField(property);
+            case TableviewTypeEnum.None:
+                return null;
+        }
+    }
+    removeField(property) {
+        this._editEditor.removeField(property);
+        this._addEditor.removeField(property);
+        this._viewEditor.removeField(property);
+    }
     addColumnNumber(property, displayFormat) {
         return this._table.addColumnNumber(property, displayFormat);
     }
@@ -3590,6 +4325,116 @@ class TableviewDescriptor {
         tableview._editEditor = this._editEditor.copy();
         return tableview;
     }
+    /**
+     * creates column and field with custom type, for example currency
+     * if field exists, it is replaced
+     * DO NOT USE WITH TYPES WHERE ARGS ARE REQUIRED - ERROR WILL BE THROWN
+     * for enum use withEnumType
+     * for custom class use withClassType
+     * @param property name of field
+     * @param columnType required column type
+     * @param fieldType optional, if not provided it is converted from column type
+     */
+    withModifiedType(property, columnType, fieldType) {
+        if (columnType === ColumnTypeEnum.Enum) {
+            throw new Error('Do not use with types where args are required');
+        }
+        const attributeDef = TableviewUtil.getAttributeDefMap(this._modelType).find(atribute => atribute.name === property);
+        if (attributeDef != null) {
+            fieldType ?? (fieldType = TableviewUtil.toFieldInputTypeFromColumnType(columnType));
+            attributeDef.fieldType = fieldType;
+            this._table.withColumnModifiedType(property, columnType);
+            this._editEditor.withFieldModifiedType(property, fieldType);
+            this._addEditor.withFieldModifiedType(property, fieldType);
+            this._viewEditor.withFieldModifiedType(property, fieldType);
+        }
+        return this;
+    }
+    /**
+     * creates column with enum type
+     * if fields exists, it is replaced
+     * @param property property name
+     * @param enumType type of enum
+     * @param fieldType type of field, optional, default is Text
+     */
+    withModifiedEnum(property, enumType, fieldType) {
+        const attributeDef = TableviewUtil.getAttributeDefMap(this._modelType).find(atribute => atribute.name === property);
+        if (attributeDef != null) {
+            attributeDef.fieldType = fieldType ?? FieldInputTypeEnum.Text;
+            this._table.withColumnModifiedEnum(property, enumType);
+            this._editEditor.withFieldModifiedEnum(property, enumType);
+            this._viewEditor.withFieldModifiedEnum(property, enumType);
+            this._addEditor.withFieldModifiedEnum(property, enumType);
+        }
+        return this;
+    }
+    /**
+     * generates column with custom class type
+     * field is generated only if lookupProvider is provided
+     * @param property property name
+     * @param modelType class type of object
+     * @param titleProperty
+     * @param lookupProvider
+     * @param itemsLabelProperty
+     * @param filterProperty
+     */
+    withModifiedLookup(property, modelType, lookupProvider, titleProperty, itemsLabelProperty, filterProperty) {
+        const attributeDef = TableviewUtil.getAttributeDefMap(this._modelType).find(atribute => atribute.name === property);
+        if (attributeDef != null) {
+            modelType ?? (modelType = attributeDef.classType ?? ObjectSerializer.get().findType(attributeDef.type));
+            titleProperty ?? (titleProperty = ModelUtil.findTitleAttribute(modelType) ?? undefined);
+            itemsLabelProperty ?? (itemsLabelProperty = titleProperty);
+            attributeDef.columnType = ColumnTypeEnum.String;
+            attributeDef.fieldType = FieldInputTypeEnum.Text;
+            if (lookupProvider != null) {
+                this._table.withColumnModifiedLookup(property, lookupProvider, itemsLabelProperty, filterProperty);
+                this._addEditor.withFieldModifiedLookup(property, modelType, lookupProvider, itemsLabelProperty);
+                this._viewEditor.withFieldModifiedLookup(property, modelType, lookupProvider, itemsLabelProperty);
+                this._editEditor.withFieldModifiedLookup(property, modelType, lookupProvider, itemsLabelProperty);
+            }
+            else {
+                const column = this._table.getColumn(property) ?? this.addColumn(property);
+                column.withObjectProperty(modelType, titleProperty);
+            }
+        }
+        return this;
+    }
+}
+class TableviewDynamicDescriptor extends TableviewDescriptor {
+    constructor(idProperty, titleProperty) {
+        super({}, idProperty, titleProperty);
+        this._table = new TableDynamicDescriptor(idProperty, titleProperty);
+        super._tableTitle = undefined;
+    }
+    get table() {
+        return this._table;
+    }
+    /**
+     * sets custom table descriptor
+     * @param descriptor
+     */
+    withTableDescriptor(descriptor) {
+        this._table = descriptor;
+        return this;
+    }
+    /**
+     * sets visibility hidden state to column with given property
+     * equals to be removing in auto and base tableview descriptor
+     * * @param property column's property
+     */
+    removeColumn(property) {
+        this._table.removeColumn(property);
+        return this;
+    }
+    /**
+     * creates depp copy of tableview object and its children
+     */
+    copy() {
+        const descriptor = new TableviewDynamicDescriptor(this.model.idPropertyName, this.model.titlePropertyName);
+        descriptor._table = this._table.copy();
+        descriptor._tableTitle = this._tableTitle;
+        return descriptor;
+    }
 }
 
 class ButtonDescriptor {
@@ -4757,8 +5602,7 @@ class MediusRestUtil {
                 const filterDescriptor = filterDescriptors.find(f => f.property === field);
                 const matchMode = MediusRestUtil.getMapping(operator, filterDescriptor?.filterType, 1);
                 if (matchMode && filterDescriptor) {
-                    const fieldFilterProperty = filterDescriptor.filterProperty ?? filterDescriptor.property;
-                    mediusParamsBuilder.withFilter(fieldFilterProperty, value, valueTo, MediusRestUtil.getMediusFilterMatchTypeFromPrimeMatchMode(matchMode[0]));
+                    mediusParamsBuilder.withFilter(filterDescriptor.property, value, valueTo, MediusRestUtil.getMediusFilterMatchTypeFromPrimeMatchMode(matchMode[0]));
                 }
             }
         }
@@ -4814,6 +5658,12 @@ class MediusRestUtil {
         }
         return params;
     }
+    static modifyFilterProperties(mediusQueryParams, filterDescriptors) {
+        for (const filterParam of mediusQueryParams.filterParams ?? []) {
+            const filterDescriptor = filterDescriptors.find(f => f.property === filterParam.property);
+            filterParam.property = filterDescriptor?.filterProperty ?? filterParam.property;
+        }
+    }
     static fromPrimeLazyLoadEventToMediusQueryParams(event) {
         const queryParamBuilder = MediusQueryParamBuilder.create(event.rows, event.first);
         // apply sorting
@@ -5063,6 +5913,7 @@ class ActionParameters {
     constructor(itemId, item) {
         this.itemId = itemId;
         this.item = item;
+        this.selectedItems = [];
     }
     withActionData(actionData) {
         this.actionData = actionData;
@@ -5084,6 +5935,10 @@ class ActionParameters {
         this.route = route;
         return this;
     }
+    withSelectedItems(selectedItems) {
+        this.selectedItems = selectedItems;
+        return this;
+    }
 }
 var ActionInstanceStateEnum;
 (function (ActionInstanceStateEnum) {
@@ -5107,6 +5962,17 @@ var ActionInstanceStateEnum;
     ActionInstanceStateEnum[ActionInstanceStateEnum["FinishDismissed"] = 17] = "FinishDismissed"; // action was dismissed by user
 })(ActionInstanceStateEnum || (ActionInstanceStateEnum = {}));
 
+/**
+ * Default categories for tableview actions
+ */
+class TableviewActionDefaultCategories {
+}
+TableviewActionDefaultCategories.READ = 'read';
+TableviewActionDefaultCategories.ADD = 'add';
+TableviewActionDefaultCategories.EDIT = 'edit';
+TableviewActionDefaultCategories.DELETE = 'delete';
+TableviewActionDefaultCategories.DETAILS = 'details';
+
 class AuthorizationUtil {
     static isPermitted(permissions, userRoles) {
         switch (permissions.authorizationType) {
@@ -5567,6 +6433,26 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImpor
                 }]
         }], ctorParameters: function () { return [{ type: MngParametrizePipe }]; } });
 
+class MngClassMapPipe {
+    transform(value, classNameMapFn, i) {
+        if (classNameMapFn && typeof classNameMapFn === 'function') {
+            return classNameMapFn(value, i);
+        }
+        else {
+            return value ?? '';
+        }
+    }
+}
+MngClassMapPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngClassMapPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+MngClassMapPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.1.0", ngImport: i0, type: MngClassMapPipe, name: "mngClassMapPipe" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngClassMapPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'mngClassMapPipe',
+                    pure: true
+                }]
+        }] });
+
 class MngActionExecutorService {
     constructor(injector, router, dialogService, confirmationService, translate, configurationService, navigationService, errorMapper, parametrize, defaultEditorDialogComponent) {
         this.injector = injector;
@@ -6533,6 +7419,7 @@ class MngActionComponent {
         this.isHostHidden = false;
         this.inputDisabled = of(false);
         this.inputLoading = of(false);
+        this.selectedItems = [];
         this.finishEventEmitter = new EventEmitter();
         this.loadingSubject = new ReplaySubject(1);
         this.$loading = this.loadingSubject.asObservable();
@@ -6580,7 +7467,10 @@ class MngActionComponent {
         this.buttonClass = this.action.buttonDescriptor.styleClass.getButtonClass(this.hasNoTitle);
     }
     ngOnChanges(changes) {
-        if (!(changes['item']?.firstChange ?? true) || !(changes['itemId']?.firstChange ?? true) || !(changes['actionData']?.firstChange ?? true)) {
+        if (!(changes['item']?.firstChange ?? true) ||
+            !(changes['itemId']?.firstChange ?? true) ||
+            !(changes['actionData']?.firstChange ?? true) ||
+            (this.action.hasItemsSelection && !(changes['selectedItems']?.firstChange ?? true))) {
             this.processSubscriptions();
         }
     }
@@ -6601,11 +7491,15 @@ class MngActionComponent {
             .withQueryParam(this.queryParam)
             .withRoute(this.route)
             .withViewContainer(this.viewContainer)
-            .withSourceComponent(this);
+            .withSourceComponent(this)
+            .withSelectedItems(this.selectedItems);
         const instance = this.actionExecutor.triggerAction(this.action, parameters);
         this.subscriptions.push(instance.result$.subscribe({
             next: () => {
                 this.finishEventEmitter.next(instance);
+                if (this.action.hasItemsSelection) {
+                    this.viewContainerService?.triggerTableReload({});
+                }
             }
         }));
         this.subscriptions.push(instance.error$.subscribe({
@@ -6630,6 +7524,9 @@ class MngActionComponent {
             .withActionData(this.actionData)
             .withViewContainer(this.viewContainer ?? undefined)
             .withSourceComponent(this);
+        if (this.action.hasItemsSelection) {
+            parameters.withSelectedItems(this.selectedItems);
+        }
         const context = this.actionExecutor.prepareActionContextValidation(this.action, parameters, this.dataProvider);
         if (typeof this.action.isVisibleFunction === 'function') {
             this.isVisibleSubscription?.unsubscribe();
@@ -6665,7 +7562,7 @@ class MngActionComponent {
     }
 }
 MngActionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngActionComponent, deps: [{ token: i1.ActivatedRoute }, { token: i1$2.TranslateService }, { token: MngAuthorizationService }, { token: MngActionExecutorService }, { token: i2.ConfirmationService }, { token: MngViewContainerComponentService, optional: true }], target: i0.ɵɵFactoryTarget.Component });
-MngActionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngActionComponent, selector: "mng-action", inputs: { action: "action", item: "item", itemId: "itemId", actionData: "actionData", queryParam: "queryParam", dataProvider: "dataProvider", inputDisabled: ["disabled", "inputDisabled"], inputLoading: ["loading", "inputLoading"], viewContainerInit: ["viewContainer", "viewContainerInit"] }, outputs: { finishEventEmitter: "finish" }, host: { properties: { "class": "this.hostClass", "class.m-0": "this.isHostHidden" } }, providers: [ConfirmationService], usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"($isVisible | async) && ($isPermitted | async)\">\n    <a\n        *ngIf=\"actionLink && actionLink.url !== ''; else routerLink\"\n        pButton\n        pRipple\n        [icon]=\"$any(action.buttonDescriptor.icon)\"\n        [href]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false) ? null : (actionLink.url | parametrize: itemId:item:actionData)\"\n        [target]=\"actionLink.target\"\n        [class.disabled]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false)\"\n        [class]=\"buttonClass\"\n        >{{ ($label | async) ?? '' }}</a\n    >\n    <ng-template #routerLink>\n        <a\n            *ngIf=\"actionLink; else button\"\n            pButton\n            pRipple\n            [icon]=\"$any(action.buttonDescriptor.icon)\"\n            [target]=\"actionLink.target\"\n            [replaceUrl]=\"actionLink.replaceUrl\"\n            [routerLink]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false) ? null : (actionLink.pathSegments | parametrize: itemId:item:actionData)\"\n            [queryParams]=\"actionLink.queryParams | parametrize: itemId:item:actionData\"\n            [queryParamsHandling]=\"actionLink.queryParamsHandling\"\n            [class.disabled]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false)\"\n            [class]=\"buttonClass\"\n            >{{ ($label | async) ?? '' }}</a\n        >\n    </ng-template>\n    <ng-template #button>\n        <button\n            type=\"button\"\n            pButton\n            pRipple\n            [icon]=\"$any(action.buttonDescriptor.icon)\"\n            [label]=\"($label | async) ?? ''\"\n            [pTooltip]=\"$any($tooltip | async)\"\n            [loading]=\"(($loading | async) ?? false) || ((inputLoading | async) ?? false)\"\n            [disabled]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false)\"\n            (click)=\"triggerAction($event)\"\n            [class]=\"buttonClass\"></button>\n    </ng-template>\n    <p-confirmDialog\n        *ngIf=\"action.runConfirmationDialogDescriptor\"\n        [key]=\"action.actionName + '_' + cmpId\"\n        [baseZIndex]=\"50\"\n        appendTo=\"body\"\n        [closable]=\"action.runConfirmationDialogDescriptor.closable\"></p-confirmDialog>\n</ng-container>\n", styles: [":host{display:inline-block}\n"], dependencies: [{ kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "preserveFragment", "skipLocationChange", "replaceUrl", "state", "relativeTo", "routerLink"] }, { kind: "directive", type: i7.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "fitContent", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "directive", type: i4$1.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading"] }, { kind: "component", type: i9.ConfirmDialog, selector: "p-confirmDialog", inputs: ["header", "icon", "message", "style", "styleClass", "maskStyleClass", "acceptIcon", "acceptLabel", "acceptAriaLabel", "acceptVisible", "rejectIcon", "rejectLabel", "rejectAriaLabel", "rejectVisible", "acceptButtonStyleClass", "rejectButtonStyleClass", "closeOnEscape", "dismissableMask", "blockScroll", "rtl", "closable", "appendTo", "key", "autoZIndex", "baseZIndex", "transitionOptions", "focusTrap", "defaultFocus", "breakpoints", "visible", "position"], outputs: ["onHide"] }, { kind: "directive", type: i6.Ripple, selector: "[pRipple]" }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "pipe", type: MngParametrizePipe, name: "parametrize" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+MngActionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngActionComponent, selector: "mng-action", inputs: { action: "action", item: "item", itemId: "itemId", actionData: "actionData", queryParam: "queryParam", dataProvider: "dataProvider", inputDisabled: ["disabled", "inputDisabled"], inputLoading: ["loading", "inputLoading"], viewContainerInit: ["viewContainer", "viewContainerInit"], selectedItems: "selectedItems" }, outputs: { finishEventEmitter: "finish" }, host: { properties: { "class": "this.hostClass", "class.m-0": "this.isHostHidden" } }, providers: [ConfirmationService], usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"($isVisible | async) && ($isPermitted | async)\">\n    <a\n        *ngIf=\"actionLink && actionLink.url !== ''; else routerLink\"\n        pButton\n        pRipple\n        [icon]=\"$any(action.buttonDescriptor.icon)\"\n        [href]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false) ? null : (actionLink.url | parametrize: itemId:item:actionData)\"\n        [target]=\"actionLink.target\"\n        [class.disabled]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false)\"\n        [class]=\"buttonClass\"\n        >{{ ($label | async) ?? '' }}</a\n    >\n    <ng-template #routerLink>\n        <a\n            *ngIf=\"actionLink; else button\"\n            pButton\n            pRipple\n            [icon]=\"$any(action.buttonDescriptor.icon)\"\n            [target]=\"actionLink.target\"\n            [replaceUrl]=\"actionLink.replaceUrl\"\n            [routerLink]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false) ? null : (actionLink.pathSegments | parametrize: itemId:item:actionData)\"\n            [queryParams]=\"actionLink.queryParams | parametrize: itemId:item:actionData\"\n            [queryParamsHandling]=\"actionLink.queryParamsHandling\"\n            [class.disabled]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false)\"\n            [class]=\"buttonClass\"\n            >{{ ($label | async) ?? '' }}</a\n        >\n    </ng-template>\n    <ng-template #button>\n        <button\n            type=\"button\"\n            pButton\n            pRipple\n            [icon]=\"$any(action.buttonDescriptor.icon)\"\n            [label]=\"($label | async) ?? ''\"\n            [pTooltip]=\"$any($tooltip | async)\"\n            [loading]=\"(($loading | async) ?? false) || ((inputLoading | async) ?? false)\"\n            [disabled]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false)\"\n            (click)=\"triggerAction($event)\"\n            [class]=\"buttonClass\"></button>\n    </ng-template>\n    <p-confirmDialog\n        *ngIf=\"action.runConfirmationDialogDescriptor\"\n        [key]=\"action.actionName + '_' + cmpId\"\n        [baseZIndex]=\"50\"\n        appendTo=\"body\"\n        [closable]=\"action.runConfirmationDialogDescriptor.closable\"></p-confirmDialog>\n</ng-container>\n", styles: [":host{display:inline-block}\n"], dependencies: [{ kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "preserveFragment", "skipLocationChange", "replaceUrl", "state", "relativeTo", "routerLink"] }, { kind: "directive", type: i7.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "fitContent", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "directive", type: i4$1.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading"] }, { kind: "component", type: i9.ConfirmDialog, selector: "p-confirmDialog", inputs: ["header", "icon", "message", "style", "styleClass", "maskStyleClass", "acceptIcon", "acceptLabel", "acceptAriaLabel", "acceptVisible", "rejectIcon", "rejectLabel", "rejectAriaLabel", "rejectVisible", "acceptButtonStyleClass", "rejectButtonStyleClass", "closeOnEscape", "dismissableMask", "blockScroll", "rtl", "closable", "appendTo", "key", "autoZIndex", "baseZIndex", "transitionOptions", "focusTrap", "defaultFocus", "breakpoints", "visible", "position"], outputs: ["onHide"] }, { kind: "directive", type: i6.Ripple, selector: "[pRipple]" }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "pipe", type: MngParametrizePipe, name: "parametrize" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngActionComponent, decorators: [{
             type: Component,
             args: [{ selector: 'mng-action', changeDetection: ChangeDetectionStrategy.OnPush, providers: [ConfirmationService], template: "<ng-container *ngIf=\"($isVisible | async) && ($isPermitted | async)\">\n    <a\n        *ngIf=\"actionLink && actionLink.url !== ''; else routerLink\"\n        pButton\n        pRipple\n        [icon]=\"$any(action.buttonDescriptor.icon)\"\n        [href]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false) ? null : (actionLink.url | parametrize: itemId:item:actionData)\"\n        [target]=\"actionLink.target\"\n        [class.disabled]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false)\"\n        [class]=\"buttonClass\"\n        >{{ ($label | async) ?? '' }}</a\n    >\n    <ng-template #routerLink>\n        <a\n            *ngIf=\"actionLink; else button\"\n            pButton\n            pRipple\n            [icon]=\"$any(action.buttonDescriptor.icon)\"\n            [target]=\"actionLink.target\"\n            [replaceUrl]=\"actionLink.replaceUrl\"\n            [routerLink]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false) ? null : (actionLink.pathSegments | parametrize: itemId:item:actionData)\"\n            [queryParams]=\"actionLink.queryParams | parametrize: itemId:item:actionData\"\n            [queryParamsHandling]=\"actionLink.queryParamsHandling\"\n            [class.disabled]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false)\"\n            [class]=\"buttonClass\"\n            >{{ ($label | async) ?? '' }}</a\n        >\n    </ng-template>\n    <ng-template #button>\n        <button\n            type=\"button\"\n            pButton\n            pRipple\n            [icon]=\"$any(action.buttonDescriptor.icon)\"\n            [label]=\"($label | async) ?? ''\"\n            [pTooltip]=\"$any($tooltip | async)\"\n            [loading]=\"(($loading | async) ?? false) || ((inputLoading | async) ?? false)\"\n            [disabled]=\"($isEnabled | async) === false || ((inputDisabled | async) ?? false)\"\n            (click)=\"triggerAction($event)\"\n            [class]=\"buttonClass\"></button>\n    </ng-template>\n    <p-confirmDialog\n        *ngIf=\"action.runConfirmationDialogDescriptor\"\n        [key]=\"action.actionName + '_' + cmpId\"\n        [baseZIndex]=\"50\"\n        appendTo=\"body\"\n        [closable]=\"action.runConfirmationDialogDescriptor.closable\"></p-confirmDialog>\n</ng-container>\n", styles: [":host{display:inline-block}\n"] }]
@@ -6698,6 +7595,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImpor
             }], viewContainerInit: [{
                 type: Input,
                 args: ['viewContainer']
+            }], selectedItems: [{
+                type: Input
             }], finishEventEmitter: [{
                 type: Output,
                 args: ['finish']
@@ -7745,7 +8644,7 @@ class MngActionEditorComponent {
     }
 }
 MngActionEditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngActionEditorComponent, deps: [{ token: i0.Injector }, { token: i1$2.TranslateService }, { token: MngActionExecutorService }, { token: MngCommonsService }, { token: MngNavigationService }, { token: i3.DynamicDialogRef, optional: true }, { token: i3.DynamicDialogConfig, optional: true }, { token: MngViewContainerComponentService, optional: true }], target: i0.ɵɵFactoryTarget.Component });
-MngActionEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngActionEditorComponent, selector: "mng-action-editor", inputs: { action: "action", itemId: "itemId", item: "item", actionData: "actionData", dataProvider: "dataProvider", viewContainerInit: ["viewContainer", "viewContainerInit"] }, outputs: { actionRunEventEmitter: "actionSubmit", actionCancelEventEmitter: "actionCancel" }, queries: [{ propertyName: "templates", predicate: MngTemplateDirective }], viewQueries: [{ propertyName: "submitButtonElementRef", first: true, predicate: ["submitButton"], descendants: true }, { propertyName: "editorComponent", first: true, predicate: MngFormEditorComponent, descendants: true }], ngImport: i0, template: "<h5 *ngIf=\"!isDialog && title\">{{ title }}</h5>\n<div class=\"h-full flex flex-column\">\n    <div class=\"flex-grow-1\" *ngIf=\"toolbarLeftActions.length > 0 || toolbarRightActions.length > 0\">\n        <p-toolbar styleClass=\"mng-action-editor-toolbar\">\n            <ng-template pTemplate=\"left\">\n                <mng-action *ngFor=\"let action of toolbarLeftActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n            </ng-template>\n            <ng-template pTemplate=\"right\">\n                <mng-action *ngFor=\"let action of toolbarRightActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n            </ng-template>\n        </p-toolbar>\n    </div>\n\n    <div class=\"flex-grow-1\">\n        <div class=\"text-center\" *ngIf=\"loading$ | async\">\n            <p-progressSpinner [style]=\"{width: '3rem', height: '3rem'}\" strokeWidth=\"3\"></p-progressSpinner>\n        </div>\n        <mng-form-editor *ngIf=\"action.editorDescriptor && (loading$ | async) === false\" [descriptor]=\"action.editorDescriptor\" [item]=\"item\" (formSubmit)=\"onSubmit($event)\">\n        </mng-form-editor>\n    </div>\n\n    <div class=\"flex flex-row justify-content-between\">\n        <div>\n            <mng-action *ngFor=\"let action of footerLeftActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n        </div>\n        <div>\n            <mng-action *ngFor=\"let action of footerRightActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n        </div>\n    </div>\n</div>\n", dependencies: [{ kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "component", type: i6$2.Toolbar, selector: "p-toolbar", inputs: ["style", "styleClass"] }, { kind: "component", type: i7$1.ProgressSpinner, selector: "p-progressSpinner", inputs: ["style", "styleClass", "strokeWidth", "fill", "animationDuration"] }, { kind: "component", type: MngFormEditorComponent, selector: "mng-form-editor", inputs: ["descriptor", "submitLoading", "item", "isSubmitButtonVisible", "isFormDisabled"], outputs: ["formSubmit"] }, { kind: "component", type: MngActionComponent, selector: "mng-action", inputs: ["action", "item", "itemId", "actionData", "queryParam", "dataProvider", "disabled", "loading", "viewContainer"], outputs: ["finish"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+MngActionEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngActionEditorComponent, selector: "mng-action-editor", inputs: { action: "action", itemId: "itemId", item: "item", actionData: "actionData", dataProvider: "dataProvider", viewContainerInit: ["viewContainer", "viewContainerInit"] }, outputs: { actionRunEventEmitter: "actionSubmit", actionCancelEventEmitter: "actionCancel" }, queries: [{ propertyName: "templates", predicate: MngTemplateDirective }], viewQueries: [{ propertyName: "submitButtonElementRef", first: true, predicate: ["submitButton"], descendants: true }, { propertyName: "editorComponent", first: true, predicate: MngFormEditorComponent, descendants: true }], ngImport: i0, template: "<h5 *ngIf=\"!isDialog && title\">{{ title }}</h5>\n<div class=\"h-full flex flex-column\">\n    <div class=\"flex-grow-1\" *ngIf=\"toolbarLeftActions.length > 0 || toolbarRightActions.length > 0\">\n        <p-toolbar styleClass=\"mng-action-editor-toolbar\">\n            <ng-template pTemplate=\"left\">\n                <mng-action *ngFor=\"let action of toolbarLeftActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n            </ng-template>\n            <ng-template pTemplate=\"right\">\n                <mng-action *ngFor=\"let action of toolbarRightActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n            </ng-template>\n        </p-toolbar>\n    </div>\n\n    <div class=\"flex-grow-1\">\n        <div class=\"text-center\" *ngIf=\"loading$ | async\">\n            <p-progressSpinner [style]=\"{width: '3rem', height: '3rem'}\" strokeWidth=\"3\"></p-progressSpinner>\n        </div>\n        <mng-form-editor *ngIf=\"action.editorDescriptor && (loading$ | async) === false\" [descriptor]=\"action.editorDescriptor\" [item]=\"item\" (formSubmit)=\"onSubmit($event)\">\n        </mng-form-editor>\n    </div>\n\n    <div class=\"flex flex-row justify-content-between\">\n        <div>\n            <mng-action *ngFor=\"let action of footerLeftActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n        </div>\n        <div>\n            <mng-action *ngFor=\"let action of footerRightActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n        </div>\n    </div>\n</div>\n", dependencies: [{ kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "component", type: i6$2.Toolbar, selector: "p-toolbar", inputs: ["style", "styleClass"] }, { kind: "component", type: i7$1.ProgressSpinner, selector: "p-progressSpinner", inputs: ["style", "styleClass", "strokeWidth", "fill", "animationDuration"] }, { kind: "component", type: MngFormEditorComponent, selector: "mng-form-editor", inputs: ["descriptor", "submitLoading", "item", "isSubmitButtonVisible", "isFormDisabled"], outputs: ["formSubmit"] }, { kind: "component", type: MngActionComponent, selector: "mng-action", inputs: ["action", "item", "itemId", "actionData", "queryParam", "dataProvider", "disabled", "loading", "viewContainer", "selectedItems"], outputs: ["finish"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngActionEditorComponent, decorators: [{
             type: Component,
             args: [{ selector: 'mng-action-editor', changeDetection: ChangeDetectionStrategy.OnPush, template: "<h5 *ngIf=\"!isDialog && title\">{{ title }}</h5>\n<div class=\"h-full flex flex-column\">\n    <div class=\"flex-grow-1\" *ngIf=\"toolbarLeftActions.length > 0 || toolbarRightActions.length > 0\">\n        <p-toolbar styleClass=\"mng-action-editor-toolbar\">\n            <ng-template pTemplate=\"left\">\n                <mng-action *ngFor=\"let action of toolbarLeftActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n            </ng-template>\n            <ng-template pTemplate=\"right\">\n                <mng-action *ngFor=\"let action of toolbarRightActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n            </ng-template>\n        </p-toolbar>\n    </div>\n\n    <div class=\"flex-grow-1\">\n        <div class=\"text-center\" *ngIf=\"loading$ | async\">\n            <p-progressSpinner [style]=\"{width: '3rem', height: '3rem'}\" strokeWidth=\"3\"></p-progressSpinner>\n        </div>\n        <mng-form-editor *ngIf=\"action.editorDescriptor && (loading$ | async) === false\" [descriptor]=\"action.editorDescriptor\" [item]=\"item\" (formSubmit)=\"onSubmit($event)\">\n        </mng-form-editor>\n    </div>\n\n    <div class=\"flex flex-row justify-content-between\">\n        <div>\n            <mng-action *ngFor=\"let action of footerLeftActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n        </div>\n        <div>\n            <mng-action *ngFor=\"let action of footerRightActions\" [action]=\"action\" [disabled]=\"submitLoading$\" [viewContainer]=\"viewContainer\"></mng-action>\n        </div>\n    </div>\n</div>\n" }]
@@ -8094,7 +8993,7 @@ class MngTableColumnFilterComponent {
         this.primeMatchModes = null;
     }
     ngOnInit() {
-        this.primeDefaultMatchMode = this.descriptor.defaultFilterMatchMode;
+        this.primeDefaultMatchMode = this.descriptor.defaultFilterMatchMode ?? FilterMatchModeEnum.Equals;
         switch (this.descriptor.filterType) {
             case FilterTypeEnum.Boolean:
                 this.primeType = 'boolean';
@@ -8113,6 +9012,9 @@ class MngTableColumnFilterComponent {
                 this.lookupDescriptor = this.descriptor;
                 this.primeField = `${this.descriptor.property}${this.lookupDescriptor.itemsValueProperty ? `.${this.lookupDescriptor.itemsValueProperty}` : ''}`;
                 this.primeMatchModes = [{ value: FilterMatchModeEnum.Equals, label: this.primeConfig.getTranslation(FilterMatchModeEnum.Equals) }];
+                if (this.lookupDescriptor.multiselect) {
+                    this.primeDefaultMatchMode = FilterMatchModeEnum.In;
+                }
                 break;
             case FilterTypeEnum.String:
                 this.primeType = 'text';
@@ -8218,6 +9120,7 @@ class MngTableComponent {
         this.dataProviderLatestLazyLoadEventVersion = 0;
         this.dataProviderLatestQueryParamVersion = 0;
         // filter, sort
+        this.hasColumnFilters = false;
         this.isFilterChanged = false;
         this.isSortChanged = false;
         this.filterDescriptors = [];
@@ -8229,10 +9132,14 @@ class MngTableComponent {
     }
     ngOnInit() {
         this.viewContainer = this.viewContainerInit ?? this.viewContainerService ?? undefined;
-        this.filterDescriptors = this.descriptor.columns.filter(c => typeof c.filterDescriptor !== 'undefined').map(c => c.filterDescriptor);
+        if (!(this.initialDescriptor instanceof TableDynamicDescriptor)) {
+            this.descriptor = this.initialDescriptor;
+        }
         // map row settings
-        this.rows = this.descriptor.defaultNumRows;
-        this.rowsPerPageOptions = this.descriptor.rowsPerPageOptions;
+        this.filterDescriptors = this.descriptor?.columns.filter(c => typeof c.filterDescriptor !== 'undefined').map(c => c.filterDescriptor) ?? [];
+        this.hasColumnFilters = this.filterDescriptors.length > 0;
+        this.rows = this.descriptor?.defaultNumRows ?? 25;
+        this.rowsPerPageOptions = this.descriptor?.rowsPerPageOptions ?? [25, 50, 100];
         // process actions
         for (const action of this.actions) {
             switch (action.position) {
@@ -8246,14 +9153,14 @@ class MngTableComponent {
         }
         this.showInlineActionsColumn = typeof this.columnActionComponent !== 'undefined' || this.rowInlineActions.length > 0;
         // define all styles
-        this.className = this.descriptor.className;
-        this.tableFullHeightOffset = this.descriptor.tableFullHeightOffset ?? null;
-        this.rowHeight = this.descriptor.rowHeight ?? null;
+        this.className = this.descriptor?.className ?? '';
+        this.tableFullHeightOffset = this.descriptor?.tableFullHeightOffset ?? null;
+        this.rowHeight = this.descriptor?.rowHeight ?? null;
         if (typeof this.isColumnClickable === 'undefined') {
             // define if cell click is being observed via output
             this.isColumnClickable = this.rowClickActions.length > 0 || this.cellClickEventEmitter.observed;
         }
-        switch (this.descriptor.size) {
+        switch (this.descriptor?.size) {
             case TableSizeEnum.Small:
                 this.className += ' p-datatable-sm';
                 break;
@@ -8261,14 +9168,14 @@ class MngTableComponent {
                 this.className += ' p-datatable-lg';
                 break;
         }
-        if (this.descriptor.hasGridlines) {
+        if (this.descriptor?.hasGridlines) {
             this.className += ' p-datatable-gridlines';
         }
-        if (!this.columnActionMinWidth) {
+        if (this.descriptor && !this.columnActionMinWidth) {
             this.columnActionMinWidth = StylesUtil.calculateTableColumnActionWidth(this.descriptor, this.rowInlineActions);
         }
         // check if infinite scroll
-        if (this.descriptor.paginationMode === TablePaginationModeEnum.InfiniteScroll) {
+        if (this.descriptor?.paginationMode === TablePaginationModeEnum.InfiniteScroll) {
             this.infiniteScroll = true;
             this.scrollHeight = 'flex';
             this.tableFullHeightOffset = this.descriptor.tableFullHeightOffset ?? 315;
@@ -8290,6 +9197,12 @@ class MngTableComponent {
             if (this.dataProvider.serviceType) {
                 this.dataProviderService = this.injector.get(this.dataProvider.serviceType);
             }
+            const reloadSubscription = this.dataProvider.getAllReload$.subscribe({
+                next: () => {
+                    this.reload();
+                }
+            });
+            this.subscriptions.push(reloadSubscription);
         }
         else {
             // if query result is provided, use it as secondary source or else try to use items
@@ -8316,7 +9229,7 @@ class MngTableComponent {
         }
         const initialQueryParamMap = this.route.snapshot.queryParamMap;
         if (this.useQueryParams &&
-            ((!initialQueryParamMap.has('sort') && this.descriptor.hasDefaultSort) ||
+            ((!initialQueryParamMap.has('sort') && this.descriptor?.hasDefaultSort) ||
                 (!initialQueryParamMap.has('filter') && this.filterDescriptors.some(fd => fd.hasDefaultValue)))) {
             // default sort/filters are applied, no additional filtering/sorting is specified in query param
             // redirect must be done at first step
@@ -8364,7 +9277,12 @@ class MngTableComponent {
         this.subscriptions.forEach(s => s.unsubscribe());
     }
     reload(emitEvent = false, resetParams = false) {
-        this.loadTableWithDataProvider(resetParams ? MediusQueryParamBuilder.create(this.rowsPerPageOptions[0], 0).build() : this.dataProviderLatestQueryParam ?? new MediusQueryParam(), emitEvent);
+        const queryParamsBuilder = resetParams
+            ? MediusQueryParamBuilder.create(this.rowsPerPageOptions[0], 0)
+            : MediusQueryParamBuilder.createFromExisting(this.dataProviderLatestQueryParam ?? new MediusQueryParam())
+                .withItemsPerPage(this.rows)
+                .withItemsOffset(this.offset);
+        this.loadTableWithDataProvider(queryParamsBuilder.build(), emitEvent);
     }
     onTableLazyLoad(event) {
         this.dataProviderLatestLazyLoadEvent = event;
@@ -8430,8 +9348,16 @@ class MngTableComponent {
         }
         this.dataProviderLatestQueryParam = queryParam;
         this.dataProviderLatestQueryParamVersion++;
+        MediusRestUtil.modifyFilterProperties(queryParam, this.filterDescriptors);
         this.dataProviderSubscription = this.dataProvider?.getAll(queryParam, this.dataProviderService).subscribe({
             next: res => {
+                if (this.initialDescriptor instanceof TableDynamicDescriptor) {
+                    this.descriptor = this.initialDescriptor.toTableDescriptorFromData(res);
+                    this.filterDescriptors = this.descriptor.columns.filter(c => typeof c.filterDescriptor !== 'undefined').map(c => c.filterDescriptor);
+                    this.hasColumnFilters = this.filterDescriptors.length > 0;
+                    // } else {
+                    //     this.descriptor = this.initialDescriptor.onDataReceivedTypeBuilding(res);
+                }
                 if (this.infiniteScroll) {
                     if (this.isFilterChanged || this.isSortChanged) {
                         this.dataProviderInfiniteScrollItems = [];
@@ -8447,6 +9373,7 @@ class MngTableComponent {
                 this.dataProviderLoadingSubject.next(false);
             },
             error: err => {
+                // TODO: check what happens on error with no model iniside descriptor
                 NotificationUtil.tableNotificationError(this.translate, this.descriptor, err, this.viewContainer);
                 const emptyQueryResult = new MediusQueryResult();
                 emptyQueryResult.pageData = [];
@@ -8490,7 +9417,7 @@ class MngTableComponent {
         const applyDefaultFilters = (params.filterParams?.length ?? 0) === 0;
         this.filterDescriptors.forEach(f => {
             let matchMode;
-            if (f.hasDefaultValue) {
+            if (f.defaultFilterMatchMode) {
                 matchMode = f.defaultFilterMatchMode;
             }
             else {
@@ -8550,7 +9477,7 @@ class MngTableComponent {
         }
         let sortMeta;
         const applyDefaultSorts = (params.sortProperty?.length ?? 0) === 0;
-        if (applyDefaultSorts && this.descriptor.hasDefaultSort) {
+        if (applyDefaultSorts && this.descriptor?.hasDefaultSort) {
             sortMeta = this.descriptor.defaultSortProperty.map((p, idx) => ({
                 field: p,
                 order: this.descriptor.defaultSortAsc[idx] ? 1 : -1
@@ -8595,14 +9522,15 @@ class MngTableComponent {
     }
 }
 MngTableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngTableComponent, deps: [{ token: i0.Injector }, { token: i1.Router }, { token: i1.ActivatedRoute }, { token: i1$2.TranslateService }, { token: MngActionExecutorService }, { token: MngViewContainerComponentService, optional: true }], target: i0.ɵɵFactoryTarget.Component });
-MngTableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngTableComponent, selector: "mng-table", inputs: { descriptor: "descriptor", items: "items", queryResult: "queryResult", loading: "loading", dataProvider: "dataProvider", useQueryParams: "useQueryParams", selectionMode: "selectionMode", selectionEnabled: "selectionEnabled", actions: "actions", isColumnClickable: "isColumnClickable", viewContainerInit: ["viewContainer", "viewContainerInit"], captionComponent: "captionComponent", columnActionComponent: "columnActionComponent", columnActionMinWidth: "columnActionMinWidth" }, outputs: { loadEventEmitter: "tableLoad", cellClickEventEmitter: "cellClick", selectionChangeEventEmitter: "selectionChange", captionCmpInstEventEmitter: "captionComponentInstance", columnActionCmpInstEventEmitter: "columnActionComponentInstance" }, queries: [{ propertyName: "templates", predicate: MngTemplateDirective }], viewQueries: [{ propertyName: "primeTable", first: true, predicate: Table, descendants: true }, { propertyName: "components", predicate: MngComponentDirective, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div [style.height]=\"scrollHeight === 'flex' ? 'calc(100vh - ' + tableFullHeightOffset + 'px)' : null\">\n    <!-- MUST NOT use observable for value when using virtual scroll - does not work for some reason -->\n    <p-table\n        *ngIf=\"!useQueryParams || (useQueryParamsInitialized$ | async)\"\n        [value]=\"infiniteScroll ? dataProviderInfiniteScrollItems : (queryResult$ | async)?.pageData ?? []\"\n        [dataKey]=\"$any(descriptor.dataKeyProperty)\"\n        [lazy]=\"useDataProvider\"\n        [loading]=\"(loading$ | async) ?? false\"\n        [paginator]=\"useDataProvider && !infiniteScroll\"\n        [rows]=\"$any(infiniteScroll ? 20 : rows)\"\n        [first]=\"$any(infiniteScroll ? 0 : offset)\"\n        [totalRecords]=\"$any(infiniteScroll ? null : (queryResult$ | async)?.allDataCount ?? 0)\"\n        [rowsPerPageOptions]=\"$any(infiniteScroll ? null : rowsPerPageOptions)\"\n        [showCurrentPageReport]=\"!infiniteScroll\"\n        [currentPageReportTemplate]=\"'mngTable.paginationMsg' | translate\"\n        [multiSortMeta]=\"$any(multiSortMeta)\"\n        [filters]=\"filterMetadata\"\n        [(selection)]=\"selection\"\n        (selectionChange)=\"onSelectionChange($event)\"\n        [scrollable]=\"infiniteScroll\"\n        [virtualScroll]=\"infiniteScroll\"\n        [virtualRowHeight]=\"$any(rowHeight)\"\n        [scrollHeight]=\"$any(scrollHeight)\"\n        [selectionMode]=\"$any(selectionEnabled ? selectionMode : null)\"\n        [rowHover]=\"descriptor.hasHover\"\n        [styleClass]=\"className\"\n        (onLazyLoad)=\"onTableLazyLoad($event)\"\n        (onSort)=\"onTableSort($event)\"\n        (onFilter)=\"onTableFilter($event)\"\n        sortMode=\"multiple\"\n        responsiveLayout=\"scroll\"\n        [resizableColumns]=\"true\"\n        [autoLayout]=\"true\">\n        <ng-template *ngIf=\"captionTemplate || captionComponent || descriptor.title\" pTemplate=\"caption\">\n            <ng-container *ngIf=\"captionTemplate; else componentOrDefaultCaption\">\n                <ng-container *ngTemplateOutlet=\"captionTemplate\"></ng-container>\n            </ng-container>\n            <ng-template #componentOrDefaultCaption>\n                <div *ngIf=\"captionComponent; else defaultCaption\" [mngComponent]=\"captionComponent\" (instanceCreated)=\"onCaptionCmpInst($event)\"></div>\n                <ng-template #defaultCaption>\n                    <h5 class=\"p-0 m-0\">{{ descriptor.title }}</h5>\n                </ng-template>\n            </ng-template>\n        </ng-template>\n\n        <ng-template pTemplate=\"header\">\n            <tr *ngIf=\"!descriptor.hideHeader\">\n                <th *ngIf=\"selectionEnabled && selectionMode === 'multiple'\">\n                    <p-tableHeaderCheckbox></p-tableHeaderCheckbox>\n                </th>\n                <!-- We need the line below, because otherwise p-tableRadioButton shifts the rest of the columns in table -->\n                <th *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"min-width: 36px\"></th>\n                <ng-container *ngFor=\"let col of descriptor.columns\">\n                    <th *ngIf=\"col.isSortEnabled\" [pSortableColumn]=\"col.property\" [class]=\"col.headerClassName\" [style.width.%]=\"col.width\" [style.min-width.px]=\"col.minWidth\">\n                        <div class=\"flex justify-content-between align-items-center\">\n                            {{ col.title ?? (col.property | i18nProperty: descriptor.model) | translate }}\n                            <p-sortIcon [field]=\"col.property\"></p-sortIcon>\n                            <mng-table-column-filter\n                                *ngIf=\"col.filterDescriptor && descriptor.filterDisplay === filterDisplayMenu\"\n                                class=\"ml-auto\"\n                                [display]=\"descriptor.filterDisplay\"\n                                [descriptor]=\"col.filterDescriptor\">\n                            </mng-table-column-filter>\n                        </div>\n                    </th>\n                    <th *ngIf=\"!col.isSortEnabled\">\n                        {{ col.title ?? (col.property | i18nProperty: descriptor.model) | translate }}\n                        <ng-container>\n                            <mng-table-column-filter\n                                *ngIf=\"col.filterDescriptor && descriptor.filterDisplay === filterDisplayMenu\"\n                                class=\"ml-auto\"\n                                [display]=\"descriptor.filterDisplay\"\n                                [descriptor]=\"col.filterDescriptor\">\n                            </mng-table-column-filter>\n                        </ng-container>\n                    </th>\n                </ng-container>\n                <th *ngIf=\"showInlineActionsColumn\"></th>\n            </tr>\n            <tr *ngIf=\"descriptor.filterDisplay === filterDisplayRow\" class=\"mng-column-filter-row\">\n                <!-- We need the line below, because otherwise p-tableRadioButton shifts the rest of the columns in table -->\n                <th *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"min-width: 36px\"></th>\n                <th\n                    *ngFor=\"let col of descriptor.columns\"\n                    [class]=\"(col.filterDescriptor ? 'mng-column-filter-' + col.filterDescriptor.filterType + ' ' : ' ') + col.filterDescriptor?.columnClassName\"\n                    [style.width.%]=\"col.filterDescriptor?.columnWidth ?? col.width\"\n                    [style.min-width.px]=\"col.filterDescriptor?.columnMinWidth ?? col.minWidth\">\n                    <div class=\"flex\" *ngIf=\"col.filterDescriptor\">\n                        <mng-table-column-filter [display]=\"descriptor.filterDisplay\" [descriptor]=\"col.filterDescriptor\"></mng-table-column-filter>\n                    </div>\n                </th>\n                <th *ngIf=\"showInlineActionsColumn\"></th>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"body\" let-item let-idx=\"rowIndex\">\n            <tr [style.height.px]=\"rowHeight\">\n                <td *ngIf=\"selectionEnabled && selectionMode === 'multiple'\" style=\"width: 3rem\">\n                    <p-tableCheckbox [value]=\"item\"></p-tableCheckbox>\n                </td>\n                <td *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"width: 3rem\">\n                    <p-tableRadioButton [value]=\"item\"></p-tableRadioButton>\n                </td>\n                <td\n                    *ngFor=\"let col of descriptor.columns\"\n                    (click)=\"onCellClick($event, col, item, idx)\"\n                    [class]=\"col.className\"\n                    [class.clickable]=\"isColumnClickable\"\n                    [style.width.%]=\"col.width\"\n                    [style.min-width.px]=\"col.minWidth\">\n                    <mng-table-column-value [descriptor]=\"col\" [item]=\"item\"></mng-table-column-value>\n                </td>\n                <td *ngIf=\"showInlineActionsColumn\" class=\"column-action text-right\" [style.min-width.px]=\"columnActionMinWidth\">\n                    <ng-container *ngIf=\"columnActionTemplate; else showColumnActionComponentOrDefault\">\n                        <ng-container *ngTemplateOutlet=\"columnActionTemplate; context: {rowItem: item, rowIndex: idx}\"></ng-container>\n                    </ng-container>\n                    <ng-template #showColumnActionComponentOrDefault>\n                        <span\n                            *ngIf=\"columnActionComponent; else defaultColumnActions\"\n                            [mngComponent]=\"columnActionComponent!\"\n                            (instanceCreated)=\"onColumnActionCmpInst($event)\"></span>\n                    </ng-template>\n                    <ng-template #defaultColumnActions>\n                        <mng-action\n                            *ngFor=\"let action of rowInlineActions\"\n                            [action]=\"action\"\n                            [item]=\"item\"\n                            [itemId]=\"descriptor.model.idPropertyName ? item[descriptor.model.idPropertyName] : null\"\n                            [actionData]=\"{itemIndex: idx}\"\n                            (finish)=\"onActionFinish($event)\">\n                        </mng-action>\n                    </ng-template>\n                </td>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"loadingbody\">\n            <tr [style.height.px]=\"rowHeight\">\n                <td [attr.colspan]=\"descriptor.columns.length + (showInlineActionsColumn ? 1 : 0) + (selectionEnabled ? 1 : 0)\">\n                    <div class=\"loading-text\"></div>\n                    <p-skeleton [ngStyle]=\"{width: '100%'}\"></p-skeleton>\n                </td>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"emptymessage\">\n            <tr [style.height.px]=\"rowHeight\">\n                <td [attr.colspan]=\"descriptor.columns.length + (showInlineActionsColumn ? 1 : 0) + (selectionEnabled ? 1 : 0)\">\n                    {{ 'mngTable.noItems' | translate }}\n                </td>\n            </tr>\n        </ng-template>\n    </p-table>\n</div>\n", dependencies: [{ kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1$1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i1$1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i2.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "component", type: i6$4.Table, selector: "p-table", inputs: ["frozenColumns", "frozenValue", "style", "styleClass", "tableStyle", "tableStyleClass", "paginator", "pageLinks", "rowsPerPageOptions", "alwaysShowPaginator", "paginatorPosition", "paginatorDropdownAppendTo", "paginatorDropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showJumpToPageDropdown", "showJumpToPageInput", "showFirstLastIcon", "showPageLinks", "defaultSortOrder", "sortMode", "resetPageOnSort", "selectionMode", "selectionPageOnly", "contextMenuSelection", "contextMenuSelectionMode", "dataKey", "metaKeySelection", "rowSelectable", "rowTrackBy", "lazy", "lazyLoadOnInit", "compareSelectionBy", "csvSeparator", "exportFilename", "filters", "globalFilterFields", "filterDelay", "filterLocale", "expandedRowKeys", "editingRowKeys", "rowExpandMode", "scrollable", "scrollDirection", "rowGroupMode", "scrollHeight", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "virtualScrollDelay", "frozenWidth", "responsive", "contextMenu", "resizableColumns", "columnResizeMode", "reorderableColumns", "loading", "loadingIcon", "showLoader", "rowHover", "customSort", "showInitialSortBadge", "autoLayout", "exportFunction", "exportHeader", "stateKey", "stateStorage", "editMode", "groupRowsBy", "groupRowsByOrder", "responsiveLayout", "breakpoint", "virtualRowHeight", "value", "columns", "first", "rows", "totalRecords", "sortField", "sortOrder", "multiSortMeta", "selection", "selectAll"], outputs: ["selectAllChange", "selectionChange", "contextMenuSelectionChange", "onRowSelect", "onRowUnselect", "onPage", "onSort", "onFilter", "onLazyLoad", "onRowExpand", "onRowCollapse", "onContextMenuSelect", "onColResize", "onColReorder", "onRowReorder", "onEditInit", "onEditComplete", "onEditCancel", "onHeaderCheckboxToggle", "sortFunction", "firstChange", "rowsChange", "onStateSave", "onStateRestore"] }, { kind: "directive", type: i6$4.SortableColumn, selector: "[pSortableColumn]", inputs: ["pSortableColumn", "pSortableColumnDisabled"] }, { kind: "component", type: i6$4.SortIcon, selector: "p-sortIcon", inputs: ["field"] }, { kind: "component", type: i6$4.TableRadioButton, selector: "p-tableRadioButton", inputs: ["disabled", "value", "index", "inputId", "name", "ariaLabel"] }, { kind: "component", type: i6$4.TableCheckbox, selector: "p-tableCheckbox", inputs: ["disabled", "value", "index", "inputId", "name", "required", "ariaLabel"] }, { kind: "component", type: i6$4.TableHeaderCheckbox, selector: "p-tableHeaderCheckbox", inputs: ["disabled", "inputId", "name", "ariaLabel"] }, { kind: "component", type: i7$3.Skeleton, selector: "p-skeleton", inputs: ["styleClass", "style", "shape", "animation", "borderRadius", "size", "width", "height"] }, { kind: "directive", type: MngComponentDirective, selector: "[mngComponent]", inputs: ["mngComponent", "inputs"], outputs: ["instanceCreated"] }, { kind: "component", type: MngTableColumnValueComponent, selector: "mng-table-column-value", inputs: ["descriptor", "item"] }, { kind: "component", type: MngTableColumnFilterComponent, selector: "mng-table-column-filter", inputs: ["descriptor", "display"] }, { kind: "component", type: MngActionComponent, selector: "mng-action", inputs: ["action", "item", "itemId", "actionData", "queryParam", "dataProvider", "disabled", "loading", "viewContainer"], outputs: ["finish"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "pipe", type: i1$2.TranslatePipe, name: "translate" }, { kind: "pipe", type: MngI18nPropertyPipe, name: "i18nProperty" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+MngTableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngTableComponent, selector: "mng-table", inputs: { initialDescriptor: ["descriptor", "initialDescriptor"], items: "items", queryResult: "queryResult", loading: "loading", dataProvider: "dataProvider", useQueryParams: "useQueryParams", selectionMode: "selectionMode", selectionEnabled: "selectionEnabled", actions: "actions", isColumnClickable: "isColumnClickable", viewContainerInit: ["viewContainer", "viewContainerInit"], captionComponent: "captionComponent", columnActionComponent: "columnActionComponent", columnActionMinWidth: "columnActionMinWidth" }, outputs: { loadEventEmitter: "tableLoad", cellClickEventEmitter: "cellClick", selectionChangeEventEmitter: "selectionChange", captionCmpInstEventEmitter: "captionComponentInstance", columnActionCmpInstEventEmitter: "columnActionComponentInstance" }, queries: [{ propertyName: "templates", predicate: MngTemplateDirective }], viewQueries: [{ propertyName: "primeTable", first: true, predicate: Table, descendants: true }, { propertyName: "components", predicate: MngComponentDirective, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div [style.height]=\"scrollHeight === 'flex' ? 'calc(100vh - ' + tableFullHeightOffset + 'px)' : null\">\n    <!-- MUST NOT use observable for value when using virtual scroll - does not work for some reason -->\n    <p-table\n        *ngIf=\"!useQueryParams || (useQueryParamsInitialized$ | async)\"\n        [value]=\"infiniteScroll ? dataProviderInfiniteScrollItems : (queryResult$ | async)?.pageData ?? []\"\n        [dataKey]=\"$any(descriptor?.dataKeyProperty ?? null)\"\n        [lazy]=\"useDataProvider\"\n        [loading]=\"(loading$ | async) ?? false\"\n        [paginator]=\"useDataProvider && !infiniteScroll\"\n        [rows]=\"$any(infiniteScroll ? 20 : rows)\"\n        [first]=\"$any(infiniteScroll ? 0 : offset)\"\n        [totalRecords]=\"$any(infiniteScroll ? null : (queryResult$ | async)?.allDataCount ?? 0)\"\n        [rowsPerPageOptions]=\"$any(infiniteScroll ? null : rowsPerPageOptions)\"\n        [showCurrentPageReport]=\"!infiniteScroll\"\n        [currentPageReportTemplate]=\"'mngTable.paginationMsg' | translate\"\n        [multiSortMeta]=\"$any(multiSortMeta)\"\n        [filters]=\"filterMetadata\"\n        [(selection)]=\"selection\"\n        (selectionChange)=\"onSelectionChange($event)\"\n        [scrollable]=\"infiniteScroll\"\n        [virtualScroll]=\"infiniteScroll\"\n        [virtualRowHeight]=\"$any(rowHeight)\"\n        [scrollHeight]=\"$any(scrollHeight)\"\n        [selectionMode]=\"$any(selectionEnabled ? selectionMode : null)\"\n        [rowHover]=\"descriptor?.hasHover ?? true\"\n        [styleClass]=\"className\"\n        (onLazyLoad)=\"onTableLazyLoad($event)\"\n        (onSort)=\"onTableSort($event)\"\n        (onFilter)=\"onTableFilter($event)\"\n        sortMode=\"multiple\"\n        responsiveLayout=\"scroll\"\n        [resizableColumns]=\"true\"\n        [autoLayout]=\"true\">\n        <ng-template *ngIf=\"captionTemplate || captionComponent || descriptor?.title\" pTemplate=\"caption\">\n            <ng-container *ngIf=\"captionTemplate; else componentOrDefaultCaption\">\n                <ng-container *ngTemplateOutlet=\"captionTemplate\"></ng-container>\n            </ng-container>\n            <ng-template #componentOrDefaultCaption>\n                <div *ngIf=\"captionComponent; else defaultCaption\" [mngComponent]=\"captionComponent\" (instanceCreated)=\"onCaptionCmpInst($event)\"></div>\n                <ng-template #defaultCaption>\n                    <h5 class=\"p-0 m-0\">{{ descriptor?.title }}</h5>\n                </ng-template>\n            </ng-template>\n        </ng-template>\n\n        <ng-template pTemplate=\"header\">\n            <tr *ngIf=\"!descriptor?.hideHeader\" class=\"mng-table-header\" [class]=\"descriptor?.headerClassName\">\n                <th *ngIf=\"selectionEnabled && selectionMode === 'multiple'\">\n                    <p-tableHeaderCheckbox></p-tableHeaderCheckbox>\n                </th>\n                <!-- We need the line below, because otherwise p-tableRadioButton shifts the rest of the columns in table -->\n                <th *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"min-width: 36px\"></th>\n                <ng-container *ngFor=\"let col of descriptor?.columns\">\n                    <th *ngIf=\"col.isSortEnabled\" [pSortableColumn]=\"col.property\" [style.width.%]=\"col.width\" [style.min-width.px]=\"col.minWidth\" [class]=\"col.headerClassName\">\n                        <div class=\"flex justify-content-between align-items-center\">\n                            {{ col.title ?? (col.property | i18nProperty: descriptor!.model) | translate }}\n                            <p-sortIcon [field]=\"col.property\"></p-sortIcon>\n                            <mng-table-column-filter\n                                *ngIf=\"col.filterDescriptor && descriptor!.filterDisplay === filterDisplayMenu\"\n                                class=\"ml-auto\"\n                                [display]=\"descriptor!.filterDisplay\"\n                                [descriptor]=\"col.filterDescriptor\">\n                            </mng-table-column-filter>\n                        </div>\n                    </th>\n                    <th *ngIf=\"!col.isSortEnabled\">\n                        {{ col.title ?? (col.property | i18nProperty: descriptor!.model) | translate }}\n                        <ng-container>\n                            <mng-table-column-filter\n                                *ngIf=\"col.filterDescriptor && descriptor!.filterDisplay === filterDisplayMenu\"\n                                class=\"ml-auto\"\n                                [display]=\"descriptor!.filterDisplay\"\n                                [descriptor]=\"col.filterDescriptor\">\n                            </mng-table-column-filter>\n                        </ng-container>\n                    </th>\n                </ng-container>\n                <th *ngIf=\"showInlineActionsColumn\"></th>\n            </tr>\n            <tr *ngIf=\"descriptor?.filterDisplay === filterDisplayRow && hasColumnFilters\" class=\"mng-column-filter-row\">\n                <!-- We need the line below, because otherwise p-tableRadioButton shifts the rest of the columns in table -->\n                <th *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"min-width: 36px\"></th>\n                <th\n                    *ngFor=\"let col of descriptor?.columns\"\n                    [class]=\"(col.filterDescriptor ? 'mng-column-filter-' + col.filterDescriptor.filterType + ' ' : ' ') + col.filterDescriptor?.columnClassName\"\n                    [style.width.%]=\"col.filterDescriptor?.columnWidth ?? col.width\"\n                    [style.min-width.px]=\"col.filterDescriptor?.columnMinWidth ?? col.minWidth\">\n                    <div class=\"flex\" *ngIf=\"col.filterDescriptor\">\n                        <mng-table-column-filter [display]=\"descriptor!.filterDisplay\" [descriptor]=\"col.filterDescriptor\"></mng-table-column-filter>\n                    </div>\n                </th>\n                <th *ngIf=\"showInlineActionsColumn\"></th>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"body\" let-item let-idx=\"rowIndex\">\n            <tr [style.height.px]=\"rowHeight\" [class]=\"descriptor?.rowClassName | mngClassMapPipe: descriptor?.rowClassNameMapFn:item\">\n                <td *ngIf=\"selectionEnabled && selectionMode === 'multiple'\" style=\"width: 3rem\">\n                    <p-tableCheckbox [value]=\"item\"></p-tableCheckbox>\n                </td>\n                <td *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"width: 3rem\">\n                    <p-tableRadioButton [value]=\"item\"></p-tableRadioButton>\n                </td>\n                <td\n                    *ngFor=\"let col of descriptor?.columns\"\n                    (click)=\"onCellClick($event, col, item, idx)\"\n                    [class]=\"col.className\"\n                    [class.clickable]=\"isColumnClickable\"\n                    [style.width.%]=\"col.width\"\n                    [style.min-width.px]=\"col.minWidth\">\n                    <mng-table-column-value [descriptor]=\"col\" [item]=\"item\"></mng-table-column-value>\n                </td>\n                <td *ngIf=\"showInlineActionsColumn\" class=\"column-action text-right\" [style.min-width.px]=\"columnActionMinWidth\">\n                    <ng-container *ngIf=\"columnActionTemplate; else showColumnActionComponentOrDefault\">\n                        <ng-container *ngTemplateOutlet=\"columnActionTemplate; context: {rowItem: item, rowIndex: idx}\"></ng-container>\n                    </ng-container>\n                    <ng-template #showColumnActionComponentOrDefault>\n                        <span\n                            *ngIf=\"columnActionComponent; else defaultColumnActions\"\n                            [mngComponent]=\"columnActionComponent!\"\n                            (instanceCreated)=\"onColumnActionCmpInst($event)\"></span>\n                    </ng-template>\n                    <ng-template #defaultColumnActions>\n                        <mng-action\n                            *ngFor=\"let action of rowInlineActions\"\n                            [action]=\"action\"\n                            [item]=\"item\"\n                            [itemId]=\"descriptor?.model?.idPropertyName ? item[descriptor!.model!.idPropertyName!] : null\"\n                            [actionData]=\"{itemIndex: idx}\"\n                            (finish)=\"onActionFinish($event)\">\n                        </mng-action>\n                    </ng-template>\n                </td>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"loadingbody\">\n            <tr [style.height.px]=\"rowHeight\">\n                <td [attr.colspan]=\"(descriptor?.columns?.length ?? 0) + (showInlineActionsColumn ? 1 : 0) + (selectionEnabled ? 1 : 0)\">\n                    <div class=\"loading-text\"></div>\n                    <p-skeleton [ngStyle]=\"{width: '100%'}\"></p-skeleton>\n                </td>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"emptymessage\">\n            <tr [style.height.px]=\"rowHeight\">\n                <td [attr.colspan]=\"(descriptor?.columns?.length ?? 0) + (showInlineActionsColumn ? 1 : 0) + (selectionEnabled ? 1 : 0)\">\n                    {{ 'mngTable.noItems' | translate }}\n                </td>\n            </tr>\n        </ng-template>\n    </p-table>\n</div>\n", dependencies: [{ kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1$1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i1$1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i2.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "component", type: i6$4.Table, selector: "p-table", inputs: ["frozenColumns", "frozenValue", "style", "styleClass", "tableStyle", "tableStyleClass", "paginator", "pageLinks", "rowsPerPageOptions", "alwaysShowPaginator", "paginatorPosition", "paginatorDropdownAppendTo", "paginatorDropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showJumpToPageDropdown", "showJumpToPageInput", "showFirstLastIcon", "showPageLinks", "defaultSortOrder", "sortMode", "resetPageOnSort", "selectionMode", "selectionPageOnly", "contextMenuSelection", "contextMenuSelectionMode", "dataKey", "metaKeySelection", "rowSelectable", "rowTrackBy", "lazy", "lazyLoadOnInit", "compareSelectionBy", "csvSeparator", "exportFilename", "filters", "globalFilterFields", "filterDelay", "filterLocale", "expandedRowKeys", "editingRowKeys", "rowExpandMode", "scrollable", "scrollDirection", "rowGroupMode", "scrollHeight", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "virtualScrollDelay", "frozenWidth", "responsive", "contextMenu", "resizableColumns", "columnResizeMode", "reorderableColumns", "loading", "loadingIcon", "showLoader", "rowHover", "customSort", "showInitialSortBadge", "autoLayout", "exportFunction", "exportHeader", "stateKey", "stateStorage", "editMode", "groupRowsBy", "groupRowsByOrder", "responsiveLayout", "breakpoint", "virtualRowHeight", "value", "columns", "first", "rows", "totalRecords", "sortField", "sortOrder", "multiSortMeta", "selection", "selectAll"], outputs: ["selectAllChange", "selectionChange", "contextMenuSelectionChange", "onRowSelect", "onRowUnselect", "onPage", "onSort", "onFilter", "onLazyLoad", "onRowExpand", "onRowCollapse", "onContextMenuSelect", "onColResize", "onColReorder", "onRowReorder", "onEditInit", "onEditComplete", "onEditCancel", "onHeaderCheckboxToggle", "sortFunction", "firstChange", "rowsChange", "onStateSave", "onStateRestore"] }, { kind: "directive", type: i6$4.SortableColumn, selector: "[pSortableColumn]", inputs: ["pSortableColumn", "pSortableColumnDisabled"] }, { kind: "component", type: i6$4.SortIcon, selector: "p-sortIcon", inputs: ["field"] }, { kind: "component", type: i6$4.TableRadioButton, selector: "p-tableRadioButton", inputs: ["disabled", "value", "index", "inputId", "name", "ariaLabel"] }, { kind: "component", type: i6$4.TableCheckbox, selector: "p-tableCheckbox", inputs: ["disabled", "value", "index", "inputId", "name", "required", "ariaLabel"] }, { kind: "component", type: i6$4.TableHeaderCheckbox, selector: "p-tableHeaderCheckbox", inputs: ["disabled", "inputId", "name", "ariaLabel"] }, { kind: "component", type: i7$3.Skeleton, selector: "p-skeleton", inputs: ["styleClass", "style", "shape", "animation", "borderRadius", "size", "width", "height"] }, { kind: "directive", type: MngComponentDirective, selector: "[mngComponent]", inputs: ["mngComponent", "inputs"], outputs: ["instanceCreated"] }, { kind: "component", type: MngTableColumnValueComponent, selector: "mng-table-column-value", inputs: ["descriptor", "item"] }, { kind: "component", type: MngTableColumnFilterComponent, selector: "mng-table-column-filter", inputs: ["descriptor", "display"] }, { kind: "component", type: MngActionComponent, selector: "mng-action", inputs: ["action", "item", "itemId", "actionData", "queryParam", "dataProvider", "disabled", "loading", "viewContainer", "selectedItems"], outputs: ["finish"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "pipe", type: i1$2.TranslatePipe, name: "translate" }, { kind: "pipe", type: MngI18nPropertyPipe, name: "i18nProperty" }, { kind: "pipe", type: MngClassMapPipe, name: "mngClassMapPipe" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngTableComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'mng-table', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div [style.height]=\"scrollHeight === 'flex' ? 'calc(100vh - ' + tableFullHeightOffset + 'px)' : null\">\n    <!-- MUST NOT use observable for value when using virtual scroll - does not work for some reason -->\n    <p-table\n        *ngIf=\"!useQueryParams || (useQueryParamsInitialized$ | async)\"\n        [value]=\"infiniteScroll ? dataProviderInfiniteScrollItems : (queryResult$ | async)?.pageData ?? []\"\n        [dataKey]=\"$any(descriptor.dataKeyProperty)\"\n        [lazy]=\"useDataProvider\"\n        [loading]=\"(loading$ | async) ?? false\"\n        [paginator]=\"useDataProvider && !infiniteScroll\"\n        [rows]=\"$any(infiniteScroll ? 20 : rows)\"\n        [first]=\"$any(infiniteScroll ? 0 : offset)\"\n        [totalRecords]=\"$any(infiniteScroll ? null : (queryResult$ | async)?.allDataCount ?? 0)\"\n        [rowsPerPageOptions]=\"$any(infiniteScroll ? null : rowsPerPageOptions)\"\n        [showCurrentPageReport]=\"!infiniteScroll\"\n        [currentPageReportTemplate]=\"'mngTable.paginationMsg' | translate\"\n        [multiSortMeta]=\"$any(multiSortMeta)\"\n        [filters]=\"filterMetadata\"\n        [(selection)]=\"selection\"\n        (selectionChange)=\"onSelectionChange($event)\"\n        [scrollable]=\"infiniteScroll\"\n        [virtualScroll]=\"infiniteScroll\"\n        [virtualRowHeight]=\"$any(rowHeight)\"\n        [scrollHeight]=\"$any(scrollHeight)\"\n        [selectionMode]=\"$any(selectionEnabled ? selectionMode : null)\"\n        [rowHover]=\"descriptor.hasHover\"\n        [styleClass]=\"className\"\n        (onLazyLoad)=\"onTableLazyLoad($event)\"\n        (onSort)=\"onTableSort($event)\"\n        (onFilter)=\"onTableFilter($event)\"\n        sortMode=\"multiple\"\n        responsiveLayout=\"scroll\"\n        [resizableColumns]=\"true\"\n        [autoLayout]=\"true\">\n        <ng-template *ngIf=\"captionTemplate || captionComponent || descriptor.title\" pTemplate=\"caption\">\n            <ng-container *ngIf=\"captionTemplate; else componentOrDefaultCaption\">\n                <ng-container *ngTemplateOutlet=\"captionTemplate\"></ng-container>\n            </ng-container>\n            <ng-template #componentOrDefaultCaption>\n                <div *ngIf=\"captionComponent; else defaultCaption\" [mngComponent]=\"captionComponent\" (instanceCreated)=\"onCaptionCmpInst($event)\"></div>\n                <ng-template #defaultCaption>\n                    <h5 class=\"p-0 m-0\">{{ descriptor.title }}</h5>\n                </ng-template>\n            </ng-template>\n        </ng-template>\n\n        <ng-template pTemplate=\"header\">\n            <tr *ngIf=\"!descriptor.hideHeader\">\n                <th *ngIf=\"selectionEnabled && selectionMode === 'multiple'\">\n                    <p-tableHeaderCheckbox></p-tableHeaderCheckbox>\n                </th>\n                <!-- We need the line below, because otherwise p-tableRadioButton shifts the rest of the columns in table -->\n                <th *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"min-width: 36px\"></th>\n                <ng-container *ngFor=\"let col of descriptor.columns\">\n                    <th *ngIf=\"col.isSortEnabled\" [pSortableColumn]=\"col.property\" [class]=\"col.headerClassName\" [style.width.%]=\"col.width\" [style.min-width.px]=\"col.minWidth\">\n                        <div class=\"flex justify-content-between align-items-center\">\n                            {{ col.title ?? (col.property | i18nProperty: descriptor.model) | translate }}\n                            <p-sortIcon [field]=\"col.property\"></p-sortIcon>\n                            <mng-table-column-filter\n                                *ngIf=\"col.filterDescriptor && descriptor.filterDisplay === filterDisplayMenu\"\n                                class=\"ml-auto\"\n                                [display]=\"descriptor.filterDisplay\"\n                                [descriptor]=\"col.filterDescriptor\">\n                            </mng-table-column-filter>\n                        </div>\n                    </th>\n                    <th *ngIf=\"!col.isSortEnabled\">\n                        {{ col.title ?? (col.property | i18nProperty: descriptor.model) | translate }}\n                        <ng-container>\n                            <mng-table-column-filter\n                                *ngIf=\"col.filterDescriptor && descriptor.filterDisplay === filterDisplayMenu\"\n                                class=\"ml-auto\"\n                                [display]=\"descriptor.filterDisplay\"\n                                [descriptor]=\"col.filterDescriptor\">\n                            </mng-table-column-filter>\n                        </ng-container>\n                    </th>\n                </ng-container>\n                <th *ngIf=\"showInlineActionsColumn\"></th>\n            </tr>\n            <tr *ngIf=\"descriptor.filterDisplay === filterDisplayRow\" class=\"mng-column-filter-row\">\n                <!-- We need the line below, because otherwise p-tableRadioButton shifts the rest of the columns in table -->\n                <th *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"min-width: 36px\"></th>\n                <th\n                    *ngFor=\"let col of descriptor.columns\"\n                    [class]=\"(col.filterDescriptor ? 'mng-column-filter-' + col.filterDescriptor.filterType + ' ' : ' ') + col.filterDescriptor?.columnClassName\"\n                    [style.width.%]=\"col.filterDescriptor?.columnWidth ?? col.width\"\n                    [style.min-width.px]=\"col.filterDescriptor?.columnMinWidth ?? col.minWidth\">\n                    <div class=\"flex\" *ngIf=\"col.filterDescriptor\">\n                        <mng-table-column-filter [display]=\"descriptor.filterDisplay\" [descriptor]=\"col.filterDescriptor\"></mng-table-column-filter>\n                    </div>\n                </th>\n                <th *ngIf=\"showInlineActionsColumn\"></th>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"body\" let-item let-idx=\"rowIndex\">\n            <tr [style.height.px]=\"rowHeight\">\n                <td *ngIf=\"selectionEnabled && selectionMode === 'multiple'\" style=\"width: 3rem\">\n                    <p-tableCheckbox [value]=\"item\"></p-tableCheckbox>\n                </td>\n                <td *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"width: 3rem\">\n                    <p-tableRadioButton [value]=\"item\"></p-tableRadioButton>\n                </td>\n                <td\n                    *ngFor=\"let col of descriptor.columns\"\n                    (click)=\"onCellClick($event, col, item, idx)\"\n                    [class]=\"col.className\"\n                    [class.clickable]=\"isColumnClickable\"\n                    [style.width.%]=\"col.width\"\n                    [style.min-width.px]=\"col.minWidth\">\n                    <mng-table-column-value [descriptor]=\"col\" [item]=\"item\"></mng-table-column-value>\n                </td>\n                <td *ngIf=\"showInlineActionsColumn\" class=\"column-action text-right\" [style.min-width.px]=\"columnActionMinWidth\">\n                    <ng-container *ngIf=\"columnActionTemplate; else showColumnActionComponentOrDefault\">\n                        <ng-container *ngTemplateOutlet=\"columnActionTemplate; context: {rowItem: item, rowIndex: idx}\"></ng-container>\n                    </ng-container>\n                    <ng-template #showColumnActionComponentOrDefault>\n                        <span\n                            *ngIf=\"columnActionComponent; else defaultColumnActions\"\n                            [mngComponent]=\"columnActionComponent!\"\n                            (instanceCreated)=\"onColumnActionCmpInst($event)\"></span>\n                    </ng-template>\n                    <ng-template #defaultColumnActions>\n                        <mng-action\n                            *ngFor=\"let action of rowInlineActions\"\n                            [action]=\"action\"\n                            [item]=\"item\"\n                            [itemId]=\"descriptor.model.idPropertyName ? item[descriptor.model.idPropertyName] : null\"\n                            [actionData]=\"{itemIndex: idx}\"\n                            (finish)=\"onActionFinish($event)\">\n                        </mng-action>\n                    </ng-template>\n                </td>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"loadingbody\">\n            <tr [style.height.px]=\"rowHeight\">\n                <td [attr.colspan]=\"descriptor.columns.length + (showInlineActionsColumn ? 1 : 0) + (selectionEnabled ? 1 : 0)\">\n                    <div class=\"loading-text\"></div>\n                    <p-skeleton [ngStyle]=\"{width: '100%'}\"></p-skeleton>\n                </td>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"emptymessage\">\n            <tr [style.height.px]=\"rowHeight\">\n                <td [attr.colspan]=\"descriptor.columns.length + (showInlineActionsColumn ? 1 : 0) + (selectionEnabled ? 1 : 0)\">\n                    {{ 'mngTable.noItems' | translate }}\n                </td>\n            </tr>\n        </ng-template>\n    </p-table>\n</div>\n" }]
+            args: [{ selector: 'mng-table', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div [style.height]=\"scrollHeight === 'flex' ? 'calc(100vh - ' + tableFullHeightOffset + 'px)' : null\">\n    <!-- MUST NOT use observable for value when using virtual scroll - does not work for some reason -->\n    <p-table\n        *ngIf=\"!useQueryParams || (useQueryParamsInitialized$ | async)\"\n        [value]=\"infiniteScroll ? dataProviderInfiniteScrollItems : (queryResult$ | async)?.pageData ?? []\"\n        [dataKey]=\"$any(descriptor?.dataKeyProperty ?? null)\"\n        [lazy]=\"useDataProvider\"\n        [loading]=\"(loading$ | async) ?? false\"\n        [paginator]=\"useDataProvider && !infiniteScroll\"\n        [rows]=\"$any(infiniteScroll ? 20 : rows)\"\n        [first]=\"$any(infiniteScroll ? 0 : offset)\"\n        [totalRecords]=\"$any(infiniteScroll ? null : (queryResult$ | async)?.allDataCount ?? 0)\"\n        [rowsPerPageOptions]=\"$any(infiniteScroll ? null : rowsPerPageOptions)\"\n        [showCurrentPageReport]=\"!infiniteScroll\"\n        [currentPageReportTemplate]=\"'mngTable.paginationMsg' | translate\"\n        [multiSortMeta]=\"$any(multiSortMeta)\"\n        [filters]=\"filterMetadata\"\n        [(selection)]=\"selection\"\n        (selectionChange)=\"onSelectionChange($event)\"\n        [scrollable]=\"infiniteScroll\"\n        [virtualScroll]=\"infiniteScroll\"\n        [virtualRowHeight]=\"$any(rowHeight)\"\n        [scrollHeight]=\"$any(scrollHeight)\"\n        [selectionMode]=\"$any(selectionEnabled ? selectionMode : null)\"\n        [rowHover]=\"descriptor?.hasHover ?? true\"\n        [styleClass]=\"className\"\n        (onLazyLoad)=\"onTableLazyLoad($event)\"\n        (onSort)=\"onTableSort($event)\"\n        (onFilter)=\"onTableFilter($event)\"\n        sortMode=\"multiple\"\n        responsiveLayout=\"scroll\"\n        [resizableColumns]=\"true\"\n        [autoLayout]=\"true\">\n        <ng-template *ngIf=\"captionTemplate || captionComponent || descriptor?.title\" pTemplate=\"caption\">\n            <ng-container *ngIf=\"captionTemplate; else componentOrDefaultCaption\">\n                <ng-container *ngTemplateOutlet=\"captionTemplate\"></ng-container>\n            </ng-container>\n            <ng-template #componentOrDefaultCaption>\n                <div *ngIf=\"captionComponent; else defaultCaption\" [mngComponent]=\"captionComponent\" (instanceCreated)=\"onCaptionCmpInst($event)\"></div>\n                <ng-template #defaultCaption>\n                    <h5 class=\"p-0 m-0\">{{ descriptor?.title }}</h5>\n                </ng-template>\n            </ng-template>\n        </ng-template>\n\n        <ng-template pTemplate=\"header\">\n            <tr *ngIf=\"!descriptor?.hideHeader\" class=\"mng-table-header\" [class]=\"descriptor?.headerClassName\">\n                <th *ngIf=\"selectionEnabled && selectionMode === 'multiple'\">\n                    <p-tableHeaderCheckbox></p-tableHeaderCheckbox>\n                </th>\n                <!-- We need the line below, because otherwise p-tableRadioButton shifts the rest of the columns in table -->\n                <th *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"min-width: 36px\"></th>\n                <ng-container *ngFor=\"let col of descriptor?.columns\">\n                    <th *ngIf=\"col.isSortEnabled\" [pSortableColumn]=\"col.property\" [style.width.%]=\"col.width\" [style.min-width.px]=\"col.minWidth\" [class]=\"col.headerClassName\">\n                        <div class=\"flex justify-content-between align-items-center\">\n                            {{ col.title ?? (col.property | i18nProperty: descriptor!.model) | translate }}\n                            <p-sortIcon [field]=\"col.property\"></p-sortIcon>\n                            <mng-table-column-filter\n                                *ngIf=\"col.filterDescriptor && descriptor!.filterDisplay === filterDisplayMenu\"\n                                class=\"ml-auto\"\n                                [display]=\"descriptor!.filterDisplay\"\n                                [descriptor]=\"col.filterDescriptor\">\n                            </mng-table-column-filter>\n                        </div>\n                    </th>\n                    <th *ngIf=\"!col.isSortEnabled\">\n                        {{ col.title ?? (col.property | i18nProperty: descriptor!.model) | translate }}\n                        <ng-container>\n                            <mng-table-column-filter\n                                *ngIf=\"col.filterDescriptor && descriptor!.filterDisplay === filterDisplayMenu\"\n                                class=\"ml-auto\"\n                                [display]=\"descriptor!.filterDisplay\"\n                                [descriptor]=\"col.filterDescriptor\">\n                            </mng-table-column-filter>\n                        </ng-container>\n                    </th>\n                </ng-container>\n                <th *ngIf=\"showInlineActionsColumn\"></th>\n            </tr>\n            <tr *ngIf=\"descriptor?.filterDisplay === filterDisplayRow && hasColumnFilters\" class=\"mng-column-filter-row\">\n                <!-- We need the line below, because otherwise p-tableRadioButton shifts the rest of the columns in table -->\n                <th *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"min-width: 36px\"></th>\n                <th\n                    *ngFor=\"let col of descriptor?.columns\"\n                    [class]=\"(col.filterDescriptor ? 'mng-column-filter-' + col.filterDescriptor.filterType + ' ' : ' ') + col.filterDescriptor?.columnClassName\"\n                    [style.width.%]=\"col.filterDescriptor?.columnWidth ?? col.width\"\n                    [style.min-width.px]=\"col.filterDescriptor?.columnMinWidth ?? col.minWidth\">\n                    <div class=\"flex\" *ngIf=\"col.filterDescriptor\">\n                        <mng-table-column-filter [display]=\"descriptor!.filterDisplay\" [descriptor]=\"col.filterDescriptor\"></mng-table-column-filter>\n                    </div>\n                </th>\n                <th *ngIf=\"showInlineActionsColumn\"></th>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"body\" let-item let-idx=\"rowIndex\">\n            <tr [style.height.px]=\"rowHeight\" [class]=\"descriptor?.rowClassName | mngClassMapPipe: descriptor?.rowClassNameMapFn:item\">\n                <td *ngIf=\"selectionEnabled && selectionMode === 'multiple'\" style=\"width: 3rem\">\n                    <p-tableCheckbox [value]=\"item\"></p-tableCheckbox>\n                </td>\n                <td *ngIf=\"selectionEnabled && selectionMode === 'single'\" style=\"width: 3rem\">\n                    <p-tableRadioButton [value]=\"item\"></p-tableRadioButton>\n                </td>\n                <td\n                    *ngFor=\"let col of descriptor?.columns\"\n                    (click)=\"onCellClick($event, col, item, idx)\"\n                    [class]=\"col.className\"\n                    [class.clickable]=\"isColumnClickable\"\n                    [style.width.%]=\"col.width\"\n                    [style.min-width.px]=\"col.minWidth\">\n                    <mng-table-column-value [descriptor]=\"col\" [item]=\"item\"></mng-table-column-value>\n                </td>\n                <td *ngIf=\"showInlineActionsColumn\" class=\"column-action text-right\" [style.min-width.px]=\"columnActionMinWidth\">\n                    <ng-container *ngIf=\"columnActionTemplate; else showColumnActionComponentOrDefault\">\n                        <ng-container *ngTemplateOutlet=\"columnActionTemplate; context: {rowItem: item, rowIndex: idx}\"></ng-container>\n                    </ng-container>\n                    <ng-template #showColumnActionComponentOrDefault>\n                        <span\n                            *ngIf=\"columnActionComponent; else defaultColumnActions\"\n                            [mngComponent]=\"columnActionComponent!\"\n                            (instanceCreated)=\"onColumnActionCmpInst($event)\"></span>\n                    </ng-template>\n                    <ng-template #defaultColumnActions>\n                        <mng-action\n                            *ngFor=\"let action of rowInlineActions\"\n                            [action]=\"action\"\n                            [item]=\"item\"\n                            [itemId]=\"descriptor?.model?.idPropertyName ? item[descriptor!.model!.idPropertyName!] : null\"\n                            [actionData]=\"{itemIndex: idx}\"\n                            (finish)=\"onActionFinish($event)\">\n                        </mng-action>\n                    </ng-template>\n                </td>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"loadingbody\">\n            <tr [style.height.px]=\"rowHeight\">\n                <td [attr.colspan]=\"(descriptor?.columns?.length ?? 0) + (showInlineActionsColumn ? 1 : 0) + (selectionEnabled ? 1 : 0)\">\n                    <div class=\"loading-text\"></div>\n                    <p-skeleton [ngStyle]=\"{width: '100%'}\"></p-skeleton>\n                </td>\n            </tr>\n        </ng-template>\n\n        <ng-template pTemplate=\"emptymessage\">\n            <tr [style.height.px]=\"rowHeight\">\n                <td [attr.colspan]=\"(descriptor?.columns?.length ?? 0) + (showInlineActionsColumn ? 1 : 0) + (selectionEnabled ? 1 : 0)\">\n                    {{ 'mngTable.noItems' | translate }}\n                </td>\n            </tr>\n        </ng-template>\n    </p-table>\n</div>\n" }]
         }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.Router }, { type: i1.ActivatedRoute }, { type: i1$2.TranslateService }, { type: MngActionExecutorService }, { type: MngViewContainerComponentService, decorators: [{
                     type: Optional
-                }] }]; }, propDecorators: { descriptor: [{
-                type: Input
+                }] }]; }, propDecorators: { initialDescriptor: [{
+                type: Input,
+                args: ['descriptor']
             }], items: [{
                 type: Input
             }], queryResult: [{
@@ -8671,6 +9599,8 @@ class MngTableviewComponent {
         this.toolbarLeftActions = [];
         this.toolbarRightActions = [];
         this.subscriptions = [];
+        this.hasItemSelectionAction = false;
+        this.selectedItems = [];
     }
     ngOnInit() {
         this.viewContainerService.actions = this.actions;
@@ -8698,6 +9628,7 @@ class MngTableviewComponent {
             }
         }
         this.toolbarRightActions = this.toolbarRightActions.reverse();
+        this.hasItemSelectionAction = [...this.toolbarLeftActions, ...this.toolbarRightActions].some(e => e.hasItemsSelection);
     }
     ngOnDestroy() {
         this.subscriptions.forEach(s => s.unsubscribe());
@@ -8714,12 +9645,15 @@ class MngTableviewComponent {
     onTableLoad(event) {
         this.tableQueryParam = event.queryParam;
     }
+    selectionChange(selectedItems) {
+        this.selectedItems = selectedItems;
+    }
 }
 MngTableviewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngTableviewComponent, deps: [{ token: i1.ActivatedRoute }, { token: i2.MessageService }, { token: i1$2.TranslateService }, { token: i3.DialogService }, { token: i2.ConfirmationService }, { token: MngActionExecutorService }, { token: MngViewContainerComponentService }], target: i0.ɵɵFactoryTarget.Component });
-MngTableviewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngTableviewComponent, selector: "mng-tableview", inputs: { descriptor: "descriptor", dataProvider: "dataProvider", actions: "actions" }, providers: [MessageService, ConfirmationService, MngViewContainerComponentService], viewQueries: [{ propertyName: "tableComponent", first: true, predicate: MngTableComponent, descendants: true }], ngImport: i0, template: "<div class=\"mng-tableview\">\n    <p-toast></p-toast>\n\n    <div class=\"card\">\n        <p-toolbar styleClass=\"mb-4\" *ngIf=\"toolbarLeftActions.length > 0 || toolbarRightActions.length > 0\">\n            <ng-template pTemplate=\"left\">\n                <mng-action *ngFor=\"let action of toolbarLeftActions\" [action]=\"action\" [queryParam]=\"tableQueryParam\"> </mng-action>\n            </ng-template>\n\n            <ng-template pTemplate=\"right\">\n                <mng-action *ngFor=\"let action of toolbarRightActions\" [action]=\"action\" [queryParam]=\"tableQueryParam\"> </mng-action>\n            </ng-template>\n        </p-toolbar>\n\n        <mng-table [descriptor]=\"descriptor.table\" [dataProvider]=\"dataProvider\" [useQueryParams]=\"true\" [actions]=\"actions\" (tableLoad)=\"onTableLoad($event)\">\n            <ng-template mngTemplate=\"caption\">\n                <div class=\"flex flex-column md:flex-row md:justify-content-between table-header\">\n                    <h5 class=\"p-0 m-0\">{{ descriptor.tableTitle | translate }}</h5>\n                </div>\n            </ng-template>\n        </mng-table>\n    </div>\n\n    <router-outlet></router-outlet>\n</div>\n", dependencies: [{ kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }, { kind: "directive", type: i2.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "component", type: i7$4.Toast, selector: "p-toast", inputs: ["key", "autoZIndex", "baseZIndex", "style", "styleClass", "position", "preventOpenDuplicates", "preventDuplicates", "showTransformOptions", "hideTransformOptions", "showTransitionOptions", "hideTransitionOptions", "breakpoints"], outputs: ["onClose"] }, { kind: "component", type: i6$2.Toolbar, selector: "p-toolbar", inputs: ["style", "styleClass"] }, { kind: "directive", type: MngTemplateDirective, selector: "[mngTemplate]", inputs: ["type", "mngTemplate"] }, { kind: "component", type: MngTableComponent, selector: "mng-table", inputs: ["descriptor", "items", "queryResult", "loading", "dataProvider", "useQueryParams", "selectionMode", "selectionEnabled", "actions", "isColumnClickable", "viewContainer", "captionComponent", "columnActionComponent", "columnActionMinWidth"], outputs: ["tableLoad", "cellClick", "selectionChange", "captionComponentInstance", "columnActionComponentInstance"] }, { kind: "component", type: MngActionComponent, selector: "mng-action", inputs: ["action", "item", "itemId", "actionData", "queryParam", "dataProvider", "disabled", "loading", "viewContainer"], outputs: ["finish"] }, { kind: "pipe", type: i1$2.TranslatePipe, name: "translate" }] });
+MngTableviewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngTableviewComponent, selector: "mng-tableview", inputs: { descriptor: "descriptor", dataProvider: "dataProvider", actions: "actions" }, providers: [MessageService, ConfirmationService, MngViewContainerComponentService], viewQueries: [{ propertyName: "tableComponent", first: true, predicate: MngTableComponent, descendants: true }], ngImport: i0, template: "<div class=\"mng-tableview\">\n    <p-toast></p-toast>\n\n    <div class=\"card\">\n        <p-toolbar styleClass=\"mb-4\" *ngIf=\"toolbarLeftActions.length > 0 || toolbarRightActions.length > 0\">\n            <ng-template pTemplate=\"left\">\n                <mng-action *ngFor=\"let action of toolbarLeftActions\" [action]=\"action\" [queryParam]=\"tableQueryParam\" [selectedItems]=\"selectedItems\"></mng-action>\n            </ng-template>\n\n            <ng-template pTemplate=\"right\">\n                <mng-action *ngFor=\"let action of toolbarRightActions\" [action]=\"action\" [queryParam]=\"tableQueryParam\" [selectedItems]=\"selectedItems\"></mng-action>\n            </ng-template>\n        </p-toolbar>\n\n        <mng-table\n            [descriptor]=\"descriptor.table\"\n            [dataProvider]=\"dataProvider\"\n            [useQueryParams]=\"true\"\n            [actions]=\"actions\"\n            [selectionEnabled]=\"hasItemSelectionAction\"\n            [selectionMode]=\"'multiple'\"\n            (tableLoad)=\"onTableLoad($event)\"\n            (selectionChange)=\"selectionChange($event)\">\n            <ng-template mngTemplate=\"caption\">\n                <div class=\"flex flex-column md:flex-row md:justify-content-between table-header\">\n                    <h5 class=\"p-0 m-0\">{{ descriptor.tableTitle ?? '' | translate }}</h5>\n                </div>\n            </ng-template>\n        </mng-table>\n    </div>\n\n    <router-outlet></router-outlet>\n</div>\n", dependencies: [{ kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }, { kind: "directive", type: i2.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "component", type: i7$4.Toast, selector: "p-toast", inputs: ["key", "autoZIndex", "baseZIndex", "style", "styleClass", "position", "preventOpenDuplicates", "preventDuplicates", "showTransformOptions", "hideTransformOptions", "showTransitionOptions", "hideTransitionOptions", "breakpoints"], outputs: ["onClose"] }, { kind: "component", type: i6$2.Toolbar, selector: "p-toolbar", inputs: ["style", "styleClass"] }, { kind: "directive", type: MngTemplateDirective, selector: "[mngTemplate]", inputs: ["type", "mngTemplate"] }, { kind: "component", type: MngTableComponent, selector: "mng-table", inputs: ["descriptor", "items", "queryResult", "loading", "dataProvider", "useQueryParams", "selectionMode", "selectionEnabled", "actions", "isColumnClickable", "viewContainer", "captionComponent", "columnActionComponent", "columnActionMinWidth"], outputs: ["tableLoad", "cellClick", "selectionChange", "captionComponentInstance", "columnActionComponentInstance"] }, { kind: "component", type: MngActionComponent, selector: "mng-action", inputs: ["action", "item", "itemId", "actionData", "queryParam", "dataProvider", "disabled", "loading", "viewContainer", "selectedItems"], outputs: ["finish"] }, { kind: "pipe", type: i1$2.TranslatePipe, name: "translate" }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngTableviewComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'mng-tableview', providers: [MessageService, ConfirmationService, MngViewContainerComponentService], template: "<div class=\"mng-tableview\">\n    <p-toast></p-toast>\n\n    <div class=\"card\">\n        <p-toolbar styleClass=\"mb-4\" *ngIf=\"toolbarLeftActions.length > 0 || toolbarRightActions.length > 0\">\n            <ng-template pTemplate=\"left\">\n                <mng-action *ngFor=\"let action of toolbarLeftActions\" [action]=\"action\" [queryParam]=\"tableQueryParam\"> </mng-action>\n            </ng-template>\n\n            <ng-template pTemplate=\"right\">\n                <mng-action *ngFor=\"let action of toolbarRightActions\" [action]=\"action\" [queryParam]=\"tableQueryParam\"> </mng-action>\n            </ng-template>\n        </p-toolbar>\n\n        <mng-table [descriptor]=\"descriptor.table\" [dataProvider]=\"dataProvider\" [useQueryParams]=\"true\" [actions]=\"actions\" (tableLoad)=\"onTableLoad($event)\">\n            <ng-template mngTemplate=\"caption\">\n                <div class=\"flex flex-column md:flex-row md:justify-content-between table-header\">\n                    <h5 class=\"p-0 m-0\">{{ descriptor.tableTitle | translate }}</h5>\n                </div>\n            </ng-template>\n        </mng-table>\n    </div>\n\n    <router-outlet></router-outlet>\n</div>\n" }]
+            args: [{ selector: 'mng-tableview', providers: [MessageService, ConfirmationService, MngViewContainerComponentService], template: "<div class=\"mng-tableview\">\n    <p-toast></p-toast>\n\n    <div class=\"card\">\n        <p-toolbar styleClass=\"mb-4\" *ngIf=\"toolbarLeftActions.length > 0 || toolbarRightActions.length > 0\">\n            <ng-template pTemplate=\"left\">\n                <mng-action *ngFor=\"let action of toolbarLeftActions\" [action]=\"action\" [queryParam]=\"tableQueryParam\" [selectedItems]=\"selectedItems\"></mng-action>\n            </ng-template>\n\n            <ng-template pTemplate=\"right\">\n                <mng-action *ngFor=\"let action of toolbarRightActions\" [action]=\"action\" [queryParam]=\"tableQueryParam\" [selectedItems]=\"selectedItems\"></mng-action>\n            </ng-template>\n        </p-toolbar>\n\n        <mng-table\n            [descriptor]=\"descriptor.table\"\n            [dataProvider]=\"dataProvider\"\n            [useQueryParams]=\"true\"\n            [actions]=\"actions\"\n            [selectionEnabled]=\"hasItemSelectionAction\"\n            [selectionMode]=\"'multiple'\"\n            (tableLoad)=\"onTableLoad($event)\"\n            (selectionChange)=\"selectionChange($event)\">\n            <ng-template mngTemplate=\"caption\">\n                <div class=\"flex flex-column md:flex-row md:justify-content-between table-header\">\n                    <h5 class=\"p-0 m-0\">{{ descriptor.tableTitle ?? '' | translate }}</h5>\n                </div>\n            </ng-template>\n        </mng-table>\n    </div>\n\n    <router-outlet></router-outlet>\n</div>\n" }]
         }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i2.MessageService }, { type: i1$2.TranslateService }, { type: i3.DialogService }, { type: i2.ConfirmationService }, { type: MngActionExecutorService }, { type: MngViewContainerComponentService }]; }, propDecorators: { descriptor: [{
                 type: Input
             }], dataProvider: [{
@@ -8732,6 +9666,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImpor
             }] } });
 
 class AMngTableviewRouteComponent {
+    constructor() {
+        this.route = inject(ActivatedRoute);
+    }
+    get routeData() {
+        return this.route.snapshot.data;
+    }
     ngOnInit() {
         this.descriptor = this.createTableviewDescriptor();
         this.dataProvider = this.createTableviewDataProvider();
@@ -8745,25 +9685,25 @@ class AMngTableviewRouteComponent {
             this.createActionDescriptorForDelete(),
             this.createActionDescriptorForRefresh(),
             this.createActionDescriptorForExport()
-        ];
+        ].filter(e => e != null);
     }
     createActionDescriptorForDetails(descriptor = this.descriptor.viewEditor) {
-        return new ActionEditorDetailsDescriptor(descriptor);
+        return !this.routeData.tableviewActions || this.routeData.tableviewActions.hasDetails ? new ActionEditorDetailsDescriptor(descriptor) : null;
     }
     createActionDescriptorForAdd(descriptor = this.descriptor.addEditor) {
-        return new ActionEditorAddDescriptor(descriptor);
+        return !this.routeData.tableviewActions || this.routeData.tableviewActions.hasAdd ? new ActionEditorAddDescriptor(descriptor) : null;
     }
     createActionDescriptorForEdit(descriptor = this.descriptor.editEditor) {
-        return new ActionEditorEditDescriptor(descriptor);
+        return !this.routeData.tableviewActions || this.routeData.tableviewActions.hasEdit ? new ActionEditorEditDescriptor(descriptor) : null;
     }
     createActionDescriptorForDelete(descriptor = this.descriptor.model) {
-        return new ActionDeleteDescriptor(descriptor);
+        return !this.routeData.tableviewActions || this.routeData.tableviewActions.hasDelete ? new ActionDeleteDescriptor(descriptor) : null;
     }
     createActionDescriptorForExport(descriptor = this.descriptor.model) {
         const action = new ActionDescriptor(descriptor, 'export')
             .withRunFunction(ctx => {
             const queryParamBuilder = ctx.parameters.queryParam ? MediusQueryParamBuilder.createFromExisting(ctx.parameters.queryParam) : MediusQueryParamBuilder.create();
-            queryParamBuilder.withItemsOffset(0).withItemsPerPage(1000);
+            queryParamBuilder.withItemsOffset(0).withItemsPerPage(500);
             ctx.parameters.withQueryParam(queryParamBuilder.build());
             return ActionDataProviderUtil.runGetAllOrFail(ctx).pipe(map(res => {
                 const blob = new Blob([JSON.stringify(res.pageData, undefined, 4)], { type: 'application/json;charset=utf-8' });
@@ -8781,7 +9721,7 @@ class AMngTableviewRouteComponent {
             .withPosition(ActionPositionEnum.ToolbarRight)
             .withPermissionsRouteType(Permissions.ActionTypes.READ)
             .withRunNotificationSuccess(undefined, undefined, false)
-            .withRunFunction(ctx => {
+            .withRunFunction((ctx) => {
             ctx.parameters.viewContainer.triggerTableReload({});
             return of(null);
         });
@@ -8793,16 +9733,9 @@ AMngTableviewRouteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.
 AMngTableviewRouteComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0", type: AMngTableviewRouteComponent, ngImport: i0 });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: AMngTableviewRouteComponent, decorators: [{
             type: Directive
-        }] });
+        }], ctorParameters: function () { return []; } });
 
 class MngTableviewRouteComponent extends AMngTableviewRouteComponent {
-    constructor(route) {
-        super();
-        this.route = route;
-    }
-    get routeData() {
-        return this.route.snapshot.data;
-    }
     createTableviewDescriptor() {
         if (this.descriptorInit) {
             return this.descriptorInit;
@@ -8831,12 +9764,12 @@ class MngTableviewRouteComponent extends AMngTableviewRouteComponent {
         this.tableviewComponent?.reloadTable();
     }
 }
-MngTableviewRouteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngTableviewRouteComponent, deps: [{ token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
+MngTableviewRouteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngTableviewRouteComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
 MngTableviewRouteComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngTableviewRouteComponent, selector: "mng-tableview-route", inputs: { descriptorInit: ["descriptor", "descriptorInit"], dataProviderInit: ["dataProvider", "dataProviderInit"], actionsInit: ["actions", "actionsInit"] }, viewQueries: [{ propertyName: "tableviewComponent", first: true, predicate: MngTableviewComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: "<div class=\"grid\">\n    <div class=\"col-12\">\n        <mng-tableview [descriptor]=\"descriptor\" [dataProvider]=\"dataProvider\" [actions]=\"actions\"></mng-tableview>\n    </div>\n</div>\n", dependencies: [{ kind: "component", type: MngTableviewComponent, selector: "mng-tableview", inputs: ["descriptor", "dataProvider", "actions"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngTableviewRouteComponent, decorators: [{
             type: Component,
             args: [{ selector: 'mng-tableview-route', template: "<div class=\"grid\">\n    <div class=\"col-12\">\n        <mng-tableview [descriptor]=\"descriptor\" [dataProvider]=\"dataProvider\" [actions]=\"actions\"></mng-tableview>\n    </div>\n</div>\n" }]
-        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }]; }, propDecorators: { descriptorInit: [{
+        }], propDecorators: { descriptorInit: [{
                 type: Input,
                 args: ['descriptor']
             }], dataProviderInit: [{
@@ -9160,7 +10093,7 @@ class MngFormlyFieldTableDialogFormComponent extends FieldType {
     }
 }
 MngFormlyFieldTableDialogFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngFormlyFieldTableDialogFormComponent, deps: [{ token: MngActionExecutorService }], target: i0.ɵɵFactoryTarget.Component });
-MngFormlyFieldTableDialogFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngFormlyFieldTableDialogFormComponent, selector: "mng-formly-table-dialog-form-field", usesInheritance: true, ngImport: i0, template: "<mng-table [descriptor]=\"descriptor.tableDescriptor\" [items]=\"items$\" [actions]=\"actions\">\n    <ng-template mngTemplate=\"caption\">\n        <div class=\"flex flex-column md:flex-row md:justify-content-end align-items-center table-header\">\n            <label class=\"mng-datatable-form-label p-0 m-0\" [for]=\"key\">{{ to?.label! | translate }} <span *ngIf=\"to.required && to['hideRequiredMarker'] !== true\">*</span></label>\n            <mng-action *ngFor=\"let action of toolbarRightActions\" [action]=\"action\"></mng-action>\n        </div>\n    </ng-template>\n</mng-table>\n", styles: [".submit-button{display:none!important;visibility:hidden}\n"], dependencies: [{ kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: MngTemplateDirective, selector: "[mngTemplate]", inputs: ["type", "mngTemplate"] }, { kind: "component", type: MngTableComponent, selector: "mng-table", inputs: ["descriptor", "items", "queryResult", "loading", "dataProvider", "useQueryParams", "selectionMode", "selectionEnabled", "actions", "isColumnClickable", "viewContainer", "captionComponent", "columnActionComponent", "columnActionMinWidth"], outputs: ["tableLoad", "cellClick", "selectionChange", "captionComponentInstance", "columnActionComponentInstance"] }, { kind: "component", type: MngActionComponent, selector: "mng-action", inputs: ["action", "item", "itemId", "actionData", "queryParam", "dataProvider", "disabled", "loading", "viewContainer"], outputs: ["finish"] }, { kind: "pipe", type: i1$2.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+MngFormlyFieldTableDialogFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: MngFormlyFieldTableDialogFormComponent, selector: "mng-formly-table-dialog-form-field", usesInheritance: true, ngImport: i0, template: "<mng-table [descriptor]=\"descriptor.tableDescriptor\" [items]=\"items$\" [actions]=\"actions\">\n    <ng-template mngTemplate=\"caption\">\n        <div class=\"flex flex-column md:flex-row md:justify-content-end align-items-center table-header\">\n            <label class=\"mng-datatable-form-label p-0 m-0\" [for]=\"key\">{{ to?.label! | translate }} <span *ngIf=\"to.required && to['hideRequiredMarker'] !== true\">*</span></label>\n            <mng-action *ngFor=\"let action of toolbarRightActions\" [action]=\"action\"></mng-action>\n        </div>\n    </ng-template>\n</mng-table>\n", styles: [".submit-button{display:none!important;visibility:hidden}\n"], dependencies: [{ kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: MngTemplateDirective, selector: "[mngTemplate]", inputs: ["type", "mngTemplate"] }, { kind: "component", type: MngTableComponent, selector: "mng-table", inputs: ["descriptor", "items", "queryResult", "loading", "dataProvider", "useQueryParams", "selectionMode", "selectionEnabled", "actions", "isColumnClickable", "viewContainer", "captionComponent", "columnActionComponent", "columnActionMinWidth"], outputs: ["tableLoad", "cellClick", "selectionChange", "captionComponentInstance", "columnActionComponentInstance"] }, { kind: "component", type: MngActionComponent, selector: "mng-action", inputs: ["action", "item", "itemId", "actionData", "queryParam", "dataProvider", "disabled", "loading", "viewContainer", "selectedItems"], outputs: ["finish"] }, { kind: "pipe", type: i1$2.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: MngFormlyFieldTableDialogFormComponent, decorators: [{
             type: Component,
             args: [{ selector: 'mng-formly-table-dialog-form-field', changeDetection: ChangeDetectionStrategy.OnPush, template: "<mng-table [descriptor]=\"descriptor.tableDescriptor\" [items]=\"items$\" [actions]=\"actions\">\n    <ng-template mngTemplate=\"caption\">\n        <div class=\"flex flex-column md:flex-row md:justify-content-end align-items-center table-header\">\n            <label class=\"mng-datatable-form-label p-0 m-0\" [for]=\"key\">{{ to?.label! | translate }} <span *ngIf=\"to.required && to['hideRequiredMarker'] !== true\">*</span></label>\n            <mng-action *ngFor=\"let action of toolbarRightActions\" [action]=\"action\"></mng-action>\n        </div>\n    </ng-template>\n</mng-table>\n", styles: [".submit-button{display:none!important;visibility:hidden}\n"] }]
@@ -10273,6 +11206,7 @@ const declarations = [
     MngParametrizePipe,
     MngGetterPipe,
     MngTemplatePipe,
+    MngClassMapPipe,
     // layout components
     MngBreadcrumbComponent,
     MngFooterComponent,
@@ -10396,6 +11330,7 @@ MngCommonsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", versio
         MngParametrizePipe,
         MngGetterPipe,
         MngTemplatePipe,
+        MngClassMapPipe,
         // layout components
         MngBreadcrumbComponent,
         MngFooterComponent,
@@ -10515,6 +11450,7 @@ MngCommonsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", versio
         MngParametrizePipe,
         MngGetterPipe,
         MngTemplatePipe,
+        MngClassMapPipe,
         // layout components
         MngBreadcrumbComponent,
         MngFooterComponent,
@@ -11213,6 +12149,7 @@ class TableviewRouteBuilder {
         this.editPath = ':itemId/edit';
         this.hasAdd = true;
         this.addPath = 'add';
+        this.hasDelete = true;
     }
     static fromComponent(path, component) {
         const inst = new TableviewRouteBuilder(path);
@@ -11240,6 +12177,15 @@ class TableviewRouteBuilder {
         }
         return inst;
     }
+    withReadOnly(permissions) {
+        if (permissions) {
+            this.withPermissions(permissions);
+        }
+        this.withAdd(false);
+        this.withEdit(false);
+        this.withDelete(false);
+        return this;
+    }
     withDetails(hasDetails = true, permissions, path) {
         this.hasDetails = hasDetails;
         if (permissions) {
@@ -11270,24 +12216,31 @@ class TableviewRouteBuilder {
         }
         return this;
     }
+    withDelete(hasDelete = true, permissions) {
+        this.hasDelete = hasDelete;
+        if (permissions) {
+            this.withPermissions(undefined, undefined, undefined, permissions);
+        }
+        return this;
+    }
     withPermissions(read, add, edit, delet, details) {
         if (!this.permissions) {
             this.permissions = {};
         }
         if (read) {
-            this.permissions[Permissions.ActionTypes.READ] = read;
+            this.permissions[TableviewActionDefaultCategories.READ] = read;
         }
         if (add) {
-            this.permissions[Permissions.ActionTypes.ADD] = add;
+            this.permissions[TableviewActionDefaultCategories.ADD] = add;
         }
         if (edit) {
-            this.permissions[Permissions.ActionTypes.EDIT] = edit;
+            this.permissions[TableviewActionDefaultCategories.EDIT] = edit;
         }
         if (delet) {
-            this.permissions[Permissions.ActionTypes.DELETE] = delet;
+            this.permissions[TableviewActionDefaultCategories.DELETE] = delet;
         }
         if (details) {
-            this.permissions[Permissions.ActionTypes.DETAILS] = details;
+            this.permissions[TableviewActionDefaultCategories.DETAILS] = details;
         }
         return this;
     }
@@ -11323,35 +12276,42 @@ class TableviewRouteBuilder {
         if (this.permissions) {
             routeData.tableviewPermissions = { ...this.permissions };
         }
+        routeData.tableviewActions = {
+            hasAdd: this.hasAdd,
+            hasEdit: this.hasEdit,
+            hasDetails: this.hasDetails,
+            hasDelete: this.hasDelete
+        };
         tableviewRouteBuilder.withData(routeData);
-        if (this.permissions?.[Permissions.ActionTypes.READ]) {
-            tableviewRouteBuilder.withPermissions(this.permissions[Permissions.ActionTypes.READ]);
+        if (this.permissions?.[TableviewActionDefaultCategories.READ]) {
+            tableviewRouteBuilder.withPermissions(this.permissions[TableviewActionDefaultCategories.READ]);
         }
         // list route
         const rootChildRouteBuilder = RouteBuilder.create('', MngActionRouteComponent);
-        if (this.permissions?.[Permissions.ActionTypes.READ]) {
-            rootChildRouteBuilder.withPermissions(this.permissions[Permissions.ActionTypes.READ]);
+        rootChildRouteBuilder.withData({ ...routeData });
+        if (this.permissions?.[TableviewActionDefaultCategories.READ]) {
+            rootChildRouteBuilder.withPermissions(this.permissions[TableviewActionDefaultCategories.READ]);
         }
         tableviewRouteBuilder.addChildBuilder(rootChildRouteBuilder);
         // add route
         if (this.hasAdd) {
             const routeBuilder = RouteBuilder.create(this.addPath, MngActionRouteComponent);
-            if (this.permissions?.[Permissions.ActionTypes.ADD]) {
-                routeBuilder.withPermissions(this.permissions[Permissions.ActionTypes.ADD]);
+            if (this.permissions?.[TableviewActionDefaultCategories.ADD]) {
+                routeBuilder.withPermissions(this.permissions[TableviewActionDefaultCategories.ADD]);
             }
             tableviewRouteBuilder.addChildBuilder(routeBuilder);
         }
         if (this.hasDetails) {
             const routeBuilder = RouteBuilder.create(this.detailsPath, MngActionRouteComponent);
-            if (this.permissions?.[Permissions.ActionTypes.DETAILS]) {
-                routeBuilder.withPermissions(this.permissions[Permissions.ActionTypes.DETAILS]);
+            if (this.permissions?.[TableviewActionDefaultCategories.DETAILS]) {
+                routeBuilder.withPermissions(this.permissions[TableviewActionDefaultCategories.DETAILS]);
             }
             tableviewRouteBuilder.addChildBuilder(routeBuilder);
         }
         if (this.hasEdit) {
             const routeBuilder = RouteBuilder.create(this.editPath, MngActionRouteComponent);
-            if (this.permissions?.[Permissions.ActionTypes.EDIT]) {
-                routeBuilder.withPermissions(this.permissions[Permissions.ActionTypes.EDIT]);
+            if (this.permissions?.[TableviewActionDefaultCategories.EDIT]) {
+                routeBuilder.withPermissions(this.permissions[TableviewActionDefaultCategories.EDIT]);
             }
             tableviewRouteBuilder.addChildBuilder(routeBuilder);
         }
@@ -11367,5 +12327,5 @@ class TableviewRouteBuilder {
  * Generated bundle index. Do not edit.
  */
 
-export { ACTION_EDITOR_DIALOG_COMPONENT_SETTING, AFieldDescriptor, AFieldGroupDescriptor, AGenericFieldDescriptor, AMngApiService, AMngBaseApiService, AMngCrudApiService, AMngGetAllApiService, AMngTableviewRouteComponent, APermissions, ActionActivationTriggerEnum, ActionConfirmationDialogDescriptor, ActionContext, ActionContextValidation, ActionDataProviderUtil, ActionDeleteDescriptor, ActionDescriptor, ActionEditorAddDescriptor, ActionEditorDescriptor, ActionEditorDetailsDescriptor, ActionEditorDialogSizeEnum, ActionEditorEditDescriptor, ActionEditorSubmitDescriptor, ActionEditorSubmitTypeEnum, ActionError, ActionInstance, ActionInstanceStateEnum, ActionLevelEnum, ActionLinkDescriptor, ActionParameters, ActionPositionEnum, ActionSimpleDescriptor, ActionSizeEnum, ActionTypeEnum, AuthorizationTypeEnum, AuthorizationUtil, ButtonDescriptor, ButtonStyleBuilder, ButtonStyleRoundedEnum, ColumnDescriptor, ColumnTypeEnum, DataProvider, DefaultMngErrorMapperService, EditorDataProvider, EditorDescriptor, EditorFormlyUtil, EnumName, EnumUtil, FieldGroupDescriptor, FieldGroupTypeEnum, FieldInputDescriptor, FieldInputTypeEnum, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupTypeEnum, FieldManyEditorActionEnum, FieldManyEditorDescriptor, FieldManyEditorTypeEnum, FieldManyToManyEditorActionEnum, FieldManyToManyEditorDescriptor, FieldManyToManyEditorTypeEnum, FieldSizeEnum, FieldTabGroupDescriptor, FieldValidationDescriptor, FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor, FilterLookupTypeEnum, FilterMatchModeEnum, FilterTypeEnum, I18nUtils, JsonPathPipe, LookupDataProvider, MNG_AUTOCOMPLETE_VALUE_ACCESSOR, MNG_BROWSER_STORAGE_IT, MNG_COMMONS_INITIALIZER_IT, MNG_DROPDOWN_VALUE_ACCESSOR, MNG_MODULE_CONFIG_IT, MediusFilterMatchType, MediusFilterParam, MediusQueryMode, MediusQueryParam, MediusQueryParamBuilder, MediusQueryResult, MediusRestUtil, MngActionComponent, MngActionEditorComponent, MngActionExecutorService, MngActionRouteComponent, MngAuthorizationGuard, MngAuthorizationService, MngAutocompleteComponent, MngBooleanPipe, MngBreadcrumbComponent, MngButtonComponent, MngCommonsModule, MngCommonsService, MngComponentDirective, MngConfigurationService, MngDropdownComponent, MngEnumPipe, MngErrorMapperService, MngFooterComponent, MngFormEditorComponent, MngFormEditorSubmitEvent, MngFormFieldEvent, MngFormFieldEventComponentSubtype, MngFormFieldEventDialogSubtype, MngFormFieldEventTypeEnum, MngFormlyFieldAutocompleteComponent, MngFormlyFieldDropdownComponent, MngFormlyFieldFieldsetComponent, MngFormlyFieldInputComponent, MngFormlyFieldLabelComponent, MngFormlyFieldLookupDialogComponent, MngFormlyFieldTableDialogFormComponent, MngFormlyFieldTableDialogMultiselectComponent, MngFormlyFieldTabsComponent, MngFormlyFieldWrapperComponent, MngFormlyTableWrapperComponent, MngGetterPipe, MngI18nPropertyPipe, MngMainLayoutComponent, MngMainLayoutComponentService, MngMenuComponent, MngMenuItemComponent, MngNavigationService, MngParametrizePipe, MngTableCellClickEvent, MngTableColumnFilterComponent, MngTableColumnValueComponent, MngTableComponent, MngTableLoadEvent, MngTableReloadEvent, MngTableviewComponent, MngTableviewRouteComponent, MngTemplateDirective, MngTemplatePipe, MngTopbarComponent, MngVersionComponent, MngViewContainerComponentService, ModelDescriptor, ModelUtil, NotificationUtil, ObjectSerializer, Permissions, RouteBuilder, RoutesBuilder, StringUtil, StylesUtil, TableDataProvider, TableDescriptor, TableFilterDisplayEnum, TablePaginationModeEnum, TableSizeEnum, TableviewCrudDataProvider, TableviewDataProvider, TableviewDescriptor, TableviewRouteBuilder, TableviewTypeEnum, TypeName, TypeUtil, enumNameDecoratorPropertyName, enumsMapBase, formlyTypesConfig, formlyWrappersConfig, getEmailValidationMessage, getFormlyValidationMessages, getMaxLengthValidationMessage, getMinLengthValidationMessage, getRequiredValidationMessage, getTextPatternValidationMessage, mngConfigJsonAppInitializerProvider, mngConfigurationServiceProvider, mngFormlyConfigProvider, primeNgModules, typeMapBase, typeNameDecoratorPropertyName };
+export { ACTION_EDITOR_DIALOG_COMPONENT_SETTING, AFieldDescriptor, AFieldGroupDescriptor, AGenericFieldDescriptor, AMngApiService, AMngBaseApiService, AMngCrudApiService, AMngGetAllApiService, AMngTableviewRouteComponent, APermissions, ActionActivationTriggerEnum, ActionConfirmationDialogDescriptor, ActionContext, ActionContextValidation, ActionDataProviderUtil, ActionDeleteDescriptor, ActionDescriptor, ActionEditorAddDescriptor, ActionEditorDescriptor, ActionEditorDetailsDescriptor, ActionEditorDialogSizeEnum, ActionEditorEditDescriptor, ActionEditorSubmitDescriptor, ActionEditorSubmitTypeEnum, ActionError, ActionInstance, ActionInstanceStateEnum, ActionLevelEnum, ActionLinkDescriptor, ActionParameters, ActionPositionEnum, ActionSimpleDescriptor, ActionSizeEnum, ActionTypeEnum, AuthorizationTypeEnum, AuthorizationUtil, ButtonDescriptor, ButtonStyleBuilder, ButtonStyleRoundedEnum, ColumnDescriptor, ColumnDynamicDescriptor, ColumnTypeEnum, DataProvider, DefaultMngErrorMapperService, DynamicTableviewDataProvider, EditorDataProvider, EditorDescriptor, EditorFormlyUtil, EnumName, EnumUtil, FieldGroupDescriptor, FieldGroupTypeEnum, FieldInputDescriptor, FieldInputTypeEnum, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupTypeEnum, FieldManyEditorActionEnum, FieldManyEditorDescriptor, FieldManyEditorTypeEnum, FieldManyToManyEditorActionEnum, FieldManyToManyEditorDescriptor, FieldManyToManyEditorTypeEnum, FieldSizeEnum, FieldTabGroupDescriptor, FieldValidationDescriptor, FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor, FilterLookupTypeEnum, FilterMatchModeEnum, FilterTypeEnum, I18nUtils, JsonPathPipe, LookupDataProvider, MNG_AUTOCOMPLETE_VALUE_ACCESSOR, MNG_BROWSER_STORAGE_IT, MNG_COMMONS_INITIALIZER_IT, MNG_DROPDOWN_VALUE_ACCESSOR, MNG_MODULE_CONFIG_IT, MediusFilterMatchType, MediusFilterParam, MediusQueryMode, MediusQueryParam, MediusQueryParamBuilder, MediusQueryResult, MediusRestUtil, MngActionComponent, MngActionEditorComponent, MngActionExecutorService, MngActionRouteComponent, MngAuthorizationGuard, MngAuthorizationService, MngAutocompleteComponent, MngBooleanPipe, MngBreadcrumbComponent, MngButtonComponent, MngClassMapPipe, MngCommonsModule, MngCommonsService, MngComponentDirective, MngConfigurationService, MngDropdownComponent, MngEnumPipe, MngErrorMapperService, MngFooterComponent, MngFormEditorComponent, MngFormEditorSubmitEvent, MngFormFieldEvent, MngFormFieldEventComponentSubtype, MngFormFieldEventDialogSubtype, MngFormFieldEventTypeEnum, MngFormlyFieldAutocompleteComponent, MngFormlyFieldDropdownComponent, MngFormlyFieldFieldsetComponent, MngFormlyFieldInputComponent, MngFormlyFieldLabelComponent, MngFormlyFieldLookupDialogComponent, MngFormlyFieldTableDialogFormComponent, MngFormlyFieldTableDialogMultiselectComponent, MngFormlyFieldTabsComponent, MngFormlyFieldWrapperComponent, MngFormlyTableWrapperComponent, MngGetterPipe, MngI18nPropertyPipe, MngMainLayoutComponent, MngMainLayoutComponentService, MngMenuComponent, MngMenuItemComponent, MngNavigationService, MngParametrizePipe, MngTableCellClickEvent, MngTableColumnFilterComponent, MngTableColumnValueComponent, MngTableComponent, MngTableLoadEvent, MngTableReloadEvent, MngTableviewComponent, MngTableviewRouteComponent, MngTemplateDirective, MngTemplatePipe, MngTopbarComponent, MngVersionComponent, MngViewContainerComponentService, ModelDescriptor, ModelUtil, NotificationUtil, ObjectSerializer, Permissions, RouteBuilder, RoutesBuilder, StringUtil, StylesUtil, TableDataProvider, TableDescriptor, TableDynamicColumnsModeEnum, TableDynamicDescriptor, TableFilterDisplayEnum, TablePaginationModeEnum, TableSizeEnum, TableviewActionDefaultCategories, TableviewCrudDataProvider, TableviewDataProvider, TableviewDescriptor, TableviewDynamicDescriptor, TableviewRouteBuilder, TableviewTypeEnum, TypeName, TypeUtil, enumNameDecoratorPropertyName, enumsMapBase, formlyTypesConfig, formlyWrappersConfig, getEmailValidationMessage, getFormlyValidationMessages, getMaxLengthValidationMessage, getMinLengthValidationMessage, getRequiredValidationMessage, getTextPatternValidationMessage, mngConfigJsonAppInitializerProvider, mngConfigurationServiceProvider, mngFormlyConfigProvider, primeNgModules, typeMapBase, typeNameDecoratorPropertyName };
 //# sourceMappingURL=mediusinc-mng-commons.mjs.map