@mediusinc/mng-commons 5.0.0-rc.2 → 5.0.0-rc.4

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

@@ -1,10 +1,10 @@
 import { of, throwError, isObservable, Subject, tap } from 'rxjs';
-import { StyleLevelEnum, CommonsInternalError, findReflectTypeName, DataProvider, LoggerService, StyleSizeEnum, DataProviderInst, ACommonsErrorBase, toObservable, TypeRegistry, getI18nTypePropertyKey, fromEnumValuesAsValueArray, fromEnumConstantsAsValueArray, getEnumConstantName, getI18nTypeTabKey, getI18nTypeGroupKey, GetterPipe, copyDataListParams } from '@mediusinc/mng-commons/core';
-import { ActionButtonDescriptor, ButtonStyleBuilder, LookupDataProvider, ButtonStyleRoundedEnum } from '@mediusinc/mng-commons/form/api';
-import { ModelDescriptor, trySetLookupItemsProperties, enumModelGeneric, findClassTitleAttribute } from '@mediusinc/mng-commons/model';
+import { StyleLevelEnum, CommonsInternalError, findReflectTypeName, DataProviderInst, LoggerService, StyleSizeEnum, ACommonsErrorBase, toObservable, getI18nTypePropertyKey, fromEnumValuesAsValueArray, fromEnumConstantsAsValueArray, getEnumConstantName, getI18nTypeTabKey, getI18nTypeGroupKey, TypeRegistry, GetterPipe, copyDataListParams } from '@mediusinc/mng-commons/core';
+import { ActionButtonDescriptor, ButtonStyleBuilder, LookupDataProviderInst, ButtonStyleRoundedEnum } from '@mediusinc/mng-commons/form/api';
+import { TypeDescriptor, ModelDescriptor, trySetLookupItemsProperties, enumModelGeneric, model, findClassTitleAttribute } from '@mediusinc/mng-commons/model';
 import * as i0 from '@angular/core';
 import { InjectionToken, Directive, Input, inject, Injector } from '@angular/core';
-import { ColumnTypeEnum, ColumnDisplayTypeEnum, TableDataProvider, getColumnTypeFromClassAttributeDefType, getColumnDisplayTypeFromColumnType, TableDescriptor, TableDynamicDescriptor } from '@mediusinc/mng-commons/table/api';
+import { TableDataProviderInst, ColumnTypeEnum, ColumnDisplayTypeEnum, getColumnTypeFromClassAttributeDefType, getColumnDisplayTypeFromColumnType, TableDescriptorInst, TableDynamicDescriptorInst, tableDescriptorFromClassAttrsDef, modifyTableClassAttributeColumnTypeUnsafe, tableDescriptorModifyEnumColumnUnsafe, modifyTableColumnFilterLookupUnsafe } from '@mediusinc/mng-commons/table/api';
 import { Validators } from '@angular/forms';
 import { FieldType } from '@ngx-formly/core';
 import { ActivatedRoute } from '@angular/router';
@@ -122,19 +122,6 @@ class ActionConfirmationDescriptor {
     }
 }
 
-const actionGetProviderCfgObj = (serviceOrDataProvider) => {
-    const cfg = {};
-    if (serviceOrDataProvider) {
-        if (serviceOrDataProvider.isDataProvider) {
-            // type casting needed, cause there was no other way found to differentiate the types
-            cfg.dataProvider = serviceOrDataProvider;
-        }
-        else {
-            cfg.serviceType = serviceOrDataProvider;
-        }
-    }
-    return cfg;
-};
 class ActionDescriptorInst {
     constructor(actionName, cfg) {
         this._type = ActionTypeEnum.Direct;
@@ -161,7 +148,7 @@ class ActionDescriptorInst {
         this._parentProperty = cfg?.parentProperty;
         this.setI18nModelActionBaseKey();
         if (cfg?.serviceType) {
-            this._dataProvider = DataProvider.fromAnyParam(this._model?.type, cfg.serviceType);
+            this._dataProvider = new DataProviderInst(this._model?.type, cfg.serviceType);
         }
         else if (cfg?.dataProvider) {
             this._dataProvider = cfg.dataProvider;
@@ -435,70 +422,135 @@ class ActionDescriptorInst {
         return descriptor;
     }
 }
+class ActionDeleteDescriptorInst extends ActionDescriptorInst {
+    static { this.ACTION_NAME = 'delete'; }
+    constructor(model, cfg) {
+        super(ActionDeleteDescriptorInst.ACTION_NAME, { model, ...cfg });
+        this.withPosition(ActionPositionEnum.RowInline);
+        this.button.styleClass.withSize(StyleSizeEnum.Small);
+        this.button.styleClass.withActionLevel(StyleLevelEnum.Danger);
+        this.withRunConfirmation();
+        this.withTableviewCategory(TableviewActionDefaultCategories.DELETE);
+        this.button.withLabel(null).withIcon('pi pi-trash');
+    }
+}
+
+const actionGetProviderCfgObj = (serviceOrDataProvider) => {
+    const cfg = {};
+    if (serviceOrDataProvider) {
+        if (serviceOrDataProvider.isDataProvider) {
+            // type casting needed, cause there was no other way found to differentiate the types
+            cfg.dataProvider = serviceOrDataProvider;
+        }
+        else {
+            cfg.serviceType = serviceOrDataProvider;
+        }
+    }
+    return cfg;
+};
 class ActionDescriptor extends ActionDescriptorInst {
     constructor() {
         super('internal');
     }
     static create(actionName, cfg) {
-        return new ActionDescriptorInst(actionName, {
+        return action(actionName, {
             ...cfg
         });
     }
     static createWithProvider(serviceProvider, actionName, cfg) {
-        return new ActionDescriptorInst(actionName, {
-            ...actionGetProviderCfgObj(serviceProvider),
+        return actionWithProvider(serviceProvider, actionName, cfg);
+    }
+    static fromModel(model, actionName, cfg) {
+        return actionFromModel(model, actionName, cfg);
+    }
+    static fromModelWithProvider(model, serviceProvider, actionName, cfg) {
+        return actionFromModel(model, serviceProvider, actionName, cfg);
+    }
+    static fromClass(type, actionName, cfg) {
+        return actionFromClass(type, actionName, cfg);
+    }
+    static fromClassWithProvider(type, serviceProvider, actionName, cfg) {
+        return actionFromClass(type, serviceProvider, actionName, cfg);
+    }
+}
+function action(typeOrActionName, actionNameOrCfg, cfg) {
+    if (typeof typeOrActionName === 'string') {
+        return new ActionDescriptorInst(typeOrActionName, typeof actionNameOrCfg === 'string'
+            ? undefined
+            : {
+                ...actionNameOrCfg
+            });
+    }
+    else {
+        return new ActionDescriptorInst(typeof actionNameOrCfg === 'string' ? actionNameOrCfg : 'default', {
             ...cfg
         });
     }
-    static fromModel(model, actionName, cfg) {
+}
+function actionWithProvider(typeOrServiceProvider, serviceProviderOrActionName, actionNameOrCfg, cfg) {
+    const actionName = serviceProviderOrActionName === 'string' ? serviceProviderOrActionName : typeof actionNameOrCfg === 'string' ? actionNameOrCfg : 'default';
+    if (typeOrServiceProvider instanceof TypeDescriptor) {
         return new ActionDescriptorInst(actionName, {
-            model,
+            ...(typeof serviceProviderOrActionName === 'string' ? {} : actionGetProviderCfgObj(serviceProviderOrActionName)),
+            ...(typeof actionNameOrCfg === 'string' ? {} : actionNameOrCfg),
             ...cfg
         });
     }
-    static fromModelWithProvider(model, serviceProvider, actionName, cfg) {
+    else {
         return new ActionDescriptorInst(actionName, {
-            model,
-            ...actionGetProviderCfgObj(serviceProvider),
+            ...actionGetProviderCfgObj(typeOrServiceProvider),
             ...cfg
         });
     }
-    static fromClass(type, actionName, cfg) {
-        return new ActionDescriptorInst(actionName, {
-            model: ModelDescriptor.fromClass(type, cfg?.idProperty, cfg?.titleProperty, cfg?.i18nBaseKey),
+}
+function actionFromModel(model, actionNameOrServiceProvider, cfgOrActionName, cfg) {
+    if (typeof actionNameOrServiceProvider === 'string') {
+        // no provider
+        return new ActionDescriptorInst(actionNameOrServiceProvider, {
+            model,
+            ...(typeof cfgOrActionName === 'object' ? cfgOrActionName : {}),
             ...cfg
         });
     }
-    static fromClassWithProvider(classType, serviceProvider, actionName, cfg) {
-        return new ActionDescriptorInst(actionName, {
-            model: ModelDescriptor.fromClass(classType, cfg?.idProperty, cfg?.titleProperty, cfg?.i18nBaseKey),
-            ...actionGetProviderCfgObj(serviceProvider),
+    else {
+        return new ActionDescriptorInst(typeof cfgOrActionName === 'string' ? cfgOrActionName : 'default', {
+            model,
+            ...actionGetProviderCfgObj(actionNameOrServiceProvider),
             ...cfg
         });
     }
 }
-class ActionDeleteDescriptorInst extends ActionDescriptorInst {
-    static { this.ACTION_NAME = 'delete'; }
-    constructor(model, cfg) {
-        super(ActionDeleteDescriptorInst.ACTION_NAME, { model, ...cfg });
-        this.withPosition(ActionPositionEnum.RowInline);
-        this.button.styleClass.withSize(StyleSizeEnum.Small);
-        this.button.styleClass.withActionLevel(StyleLevelEnum.Danger);
-        this.withRunConfirmation();
-        this.withTableviewCategory(TableviewActionDefaultCategories.DELETE);
-        this.button.withLabel(null).withIcon('pi pi-trash');
+function actionFromClass(type, actionNameOrServiceProvider, cfgOrActionName, cfg) {
+    if (typeof actionNameOrServiceProvider === 'string') {
+        // no provider
+        const finalCfg = typeof cfgOrActionName === 'object' ? cfgOrActionName : cfg;
+        return new ActionDescriptorInst(actionNameOrServiceProvider, {
+            model: new ModelDescriptor(type, finalCfg?.idProperty, finalCfg?.titleProperty, finalCfg?.i18nBaseKey),
+            ...(typeof cfgOrActionName === 'object' ? cfgOrActionName : {}),
+            ...cfg
+        });
+    }
+    else {
+        return new ActionDescriptorInst(typeof cfgOrActionName === 'string' ? cfgOrActionName : 'default', {
+            model: new ModelDescriptor(type, cfg?.idProperty, cfg?.titleProperty, cfg?.i18nBaseKey),
+            ...actionGetProviderCfgObj(actionNameOrServiceProvider),
+            ...cfg
+        });
     }
 }
 class ActionDeleteDescriptor {
     static create(model) {
-        return new ActionDeleteDescriptorInst(model);
+        return actionDelete(model);
     }
     static createWithProvider(model, serviceProvider) {
-        return new ActionDeleteDescriptorInst(model, {
-            ...actionGetProviderCfgObj(serviceProvider)
-        });
+        return actionDelete(model, serviceProvider);
     }
 }
+function actionDelete(model, serviceProvider) {
+    return new ActionDeleteDescriptorInst(model, {
+        ...(serviceProvider ? actionGetProviderCfgObj(serviceProvider) : {})
+    });
+}
 
 class EditorDataProviderInst extends DataProviderInst {
     constructor(type, serviceType) {
@@ -571,50 +623,7 @@ class EditorDataProviderInst extends DataProviderInst {
         return this;
     }
 }
-class EditorDataProvider extends EditorDataProviderInst {
-    constructor() {
-        super(undefined, undefined);
-    }
-    static create() {
-        return new EditorDataProviderInst(undefined, undefined);
-    }
-    static fromClass(type) {
-        return new EditorDataProviderInst(type, undefined);
-    }
-    static fromClassWithService(type, serviceType) {
-        return new EditorDataProviderInst(type, serviceType);
-    }
-    static fromService(serviceType) {
-        return new EditorDataProviderInst(undefined, serviceType);
-    }
-    static fromAnyParam(type, serviceType) {
-        if (typeof type !== 'undefined') {
-            return typeof serviceType !== 'undefined'
-                ? EditorDataProvider.fromClassWithService(type, serviceType)
-                : EditorDataProvider.fromClass(type);
-        }
-        else if (typeof serviceType !== 'undefined') {
-            return EditorDataProvider.fromService(serviceType);
-        }
-        else {
-            return EditorDataProvider.create();
-        }
-    }
-}
 
-const actionEditorGetProviderCfgObj = (serviceOrDataProvider) => {
-    const cfg = {};
-    if (serviceOrDataProvider) {
-        if (serviceOrDataProvider.isDataProvider) {
-            // type casting needed, cause there was no other way found to differentiate the types
-            cfg.dataProvider = serviceOrDataProvider;
-        }
-        else {
-            cfg.serviceType = serviceOrDataProvider;
-        }
-    }
-    return cfg;
-};
 class ActionEditorDescriptorInst extends ActionDescriptorInst {
     constructor(editorDescriptor, actionName, cfg) {
         super(actionName, {
@@ -630,14 +639,14 @@ class ActionEditorDescriptorInst extends ActionDescriptorInst {
         this._resubmitRefetch = true;
         this._unsavedChangesConfirmation = false;
         if (cfg?.serviceType) {
-            this._dataProvider = EditorDataProvider.fromAnyParam(this._model?.type, cfg.serviceType);
+            this._dataProvider = new EditorDataProviderInst(this._model?.type, cfg.serviceType);
         }
         else if (cfg?.dataProvider) {
             this._dataProvider = cfg.dataProvider;
         }
         this._type = ActionTypeEnum.Editor;
         this._editorDescriptor = editorDescriptor;
-        this._editorActions.push(ActionEditorSubmitDescriptor.forPrimary(this), ActionEditorSubmitDescriptor.forSecondary(this));
+        this._editorActions.push(actionEditorSubmit(this), actionEditorCancel(this));
     }
     get editorTitle() {
         return this._editorTitle;
@@ -759,21 +768,6 @@ class ActionEditorDescriptorInst extends ActionDescriptorInst {
         return this;
     }
 }
-class ActionEditorDescriptor {
-    static create(editor, actionName, cfg) {
-        return new ActionEditorDescriptorInst(editor, actionName, {
-            parentType: cfg?.parentType,
-            parentProperty: cfg?.parentProperty
-        });
-    }
-    static createWithProvider(editor, serviceProvider, actionName, cfg) {
-        return new ActionEditorDescriptorInst(editor, actionName, {
-            ...actionEditorGetProviderCfgObj(serviceProvider),
-            parentType: cfg?.parentType,
-            parentProperty: cfg?.parentProperty
-        });
-    }
-}
 class ActionEditorSubmitDescriptorInst extends ActionDescriptorInst {
     constructor(editorAction, submitType = ActionEditorSubmitTypeEnum.Submit) {
         super(submitType === ActionEditorSubmitTypeEnum.Submit ? `${editorAction.actionName}.submit` : `${editorAction.actionName}.cancel`, { model: editorAction.model });
@@ -786,23 +780,21 @@ class ActionEditorSubmitDescriptorInst extends ActionDescriptorInst {
         return this._submitType;
     }
 }
-class ActionEditorSubmitDescriptor {
-    /**
-     * creates primary action with primary button style
-     * @param editorAction
-     * @param submitType
-     */
-    static forPrimary(editorAction, submitType = ActionEditorSubmitTypeEnum.Submit) {
-        return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder()));
-    }
-    /**
-     * creates secondary button with text button style
-     * @param editorAction
-     * @param submitType
-     */
-    static forSecondary(editorAction, submitType = ActionEditorSubmitTypeEnum.Cancel) {
-        return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withTextButton()));
-    }
+/**
+ * creates primary action with primary button style
+ * @param editorAction
+ * @param submitType
+ */
+function actionEditorSubmit(editorAction, submitType = ActionEditorSubmitTypeEnum.Submit) {
+    return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder()));
+}
+/**
+ * creates secondary button with text button style
+ * @param editorAction
+ * @param submitType
+ */
+function actionEditorCancel(editorAction, submitType = ActionEditorSubmitTypeEnum.Cancel) {
+    return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withTextButton()));
 }
 class ActionEditorDetailsDescriptorInst extends ActionEditorDescriptorInst {
     static { this.ACTION_NAME = 'details'; }
@@ -810,20 +802,10 @@ class ActionEditorDetailsDescriptorInst extends ActionEditorDescriptorInst {
         super(editorDescriptor, ActionEditorDetailsDescriptorInst.ACTION_NAME, cfg);
         this.withPosition(ActionPositionEnum.RowClick);
         this.withRouteTrigger(':itemId');
-        this.withEditorActions([ActionEditorSubmitDescriptor.forSecondary(this, ActionEditorSubmitTypeEnum.Cancel)]);
+        this.withEditorActions([actionEditorCancel(this)]);
         this.withTableviewCategory(TableviewActionDefaultCategories.DETAILS);
     }
 }
-class ActionEditorDetailsDescriptor {
-    static create(editor) {
-        return new ActionEditorDetailsDescriptorInst(editor);
-    }
-    static createWithProvider(editor, serviceProvider) {
-        return new ActionEditorDetailsDescriptorInst(editor, {
-            ...actionEditorGetProviderCfgObj(serviceProvider)
-        });
-    }
-}
 class ActionEditorAddDescriptorInst extends ActionEditorDescriptorInst {
     static { this.ACTION_NAME = 'add'; }
     constructor(editorDescriptor, cfg) {
@@ -835,16 +817,6 @@ class ActionEditorAddDescriptorInst extends ActionEditorDescriptorInst {
         this.withUnsavedChangesConfirmation();
     }
 }
-class ActionEditorAddDescriptor {
-    static create(editor) {
-        return new ActionEditorAddDescriptorInst(editor);
-    }
-    static createWithProvider(editor, serviceProvider) {
-        return new ActionEditorAddDescriptorInst(editor, {
-            ...actionEditorGetProviderCfgObj(serviceProvider)
-        });
-    }
-}
 class ActionEditorEditDescriptorInst extends ActionEditorDescriptorInst {
     static { this.ACTION_NAME = 'edit'; }
     constructor(editorDescriptor, cfg) {
@@ -857,16 +829,82 @@ class ActionEditorEditDescriptorInst extends ActionEditorDescriptorInst {
         this.withUnsavedChangesConfirmation();
     }
 }
+
+const actionEditorGetProviderCfgObj = (serviceOrDataProvider) => {
+    const cfg = {};
+    if (serviceOrDataProvider) {
+        if (serviceOrDataProvider.isDataProvider) {
+            // type casting needed, cause there was no other way found to differentiate the types
+            cfg.dataProvider = serviceOrDataProvider;
+        }
+        else {
+            cfg.serviceType = serviceOrDataProvider;
+        }
+    }
+    return cfg;
+};
+class ActionEditorDescriptor {
+    static create(editor, actionName, cfg) {
+        return actionEditor(editor, actionName, cfg);
+    }
+    static createWithProvider(editor, serviceProvider, actionName, cfg) {
+        return actionEditor(editor, serviceProvider, actionName, cfg);
+    }
+}
+function actionEditor(editor, actionNameOrServiceProvider, cfgOrActionName, cfg) {
+    if (typeof actionNameOrServiceProvider === 'string') {
+        // no provider
+        return new ActionEditorDescriptorInst(editor, actionNameOrServiceProvider, {
+            ...(typeof cfgOrActionName === 'object' ? cfgOrActionName : {}),
+            ...cfg
+        });
+    }
+    else {
+        return new ActionEditorDescriptorInst(editor, typeof cfgOrActionName === 'string' ? cfgOrActionName : 'default', {
+            ...actionEditorGetProviderCfgObj(actionNameOrServiceProvider),
+            ...cfg
+        });
+    }
+}
+class ActionEditorDetailsDescriptor {
+    static create(editor) {
+        return actionEditorDetails(editor);
+    }
+    static createWithProvider(editor, serviceProvider) {
+        return actionEditorDetails(editor, serviceProvider);
+    }
+}
+function actionEditorDetails(editor, serviceProvider) {
+    return new ActionEditorDetailsDescriptorInst(editor, {
+        ...(serviceProvider ? actionEditorGetProviderCfgObj(serviceProvider) : {})
+    });
+}
+class ActionEditorAddDescriptor {
+    static create(editor) {
+        return actionEditorAdd(editor);
+    }
+    static createWithProvider(editor, serviceProvider) {
+        return actionEditorAdd(editor, serviceProvider);
+    }
+}
+function actionEditorAdd(editor, serviceProvider) {
+    return new ActionEditorAddDescriptorInst(editor, {
+        ...(serviceProvider ? actionEditorGetProviderCfgObj(serviceProvider) : {})
+    });
+}
 class ActionEditorEditDescriptor {
     static create(editor) {
-        return new ActionEditorEditDescriptorInst(editor);
+        return actionEditorEdit(editor);
     }
     static createWithProvider(editor, serviceProvider) {
-        return new ActionEditorEditDescriptorInst(editor, {
-            ...actionEditorGetProviderCfgObj(serviceProvider)
-        });
+        return actionEditorEdit(editor, serviceProvider);
     }
 }
+function actionEditorEdit(editor, serviceProvider) {
+    return new ActionEditorEditDescriptorInst(editor, {
+        ...(serviceProvider ? actionEditorGetProviderCfgObj(serviceProvider) : {})
+    });
+}
 
 class ActionLinkDescriptorInst extends ActionDescriptorInst {
     constructor(actionName = 'link', cfg) {
@@ -924,36 +962,49 @@ class ActionLinkDescriptorInst extends ActionDescriptorInst {
         return this;
     }
 }
+
 class ActionLinkDescriptor {
     static create(actionName, cfg) {
-        return new ActionLinkDescriptorInst(actionName, {
-            ...cfg
-        });
+        return actionLink(actionName, cfg);
     }
     static fromModel(model, actionName, cfg) {
-        return new ActionLinkDescriptorInst(actionName, {
-            model,
-            ...cfg
-        });
+        return actionLinkFromModel(model, actionName, cfg);
     }
     static fromClass(type, actionName, cfg) {
-        return new ActionLinkDescriptorInst(actionName, {
-            model: ModelDescriptor.fromClass(type, cfg?.idProperty, cfg?.titleProperty, cfg?.i18nBaseKey),
-            ...cfg
-        });
+        return actionLinkFromClass(type, actionName, cfg);
     }
     static fromAction(action) {
-        const descriptor = new ActionLinkDescriptorInst(action.actionName, { model: action.model });
-        action.copyTo(descriptor);
-        descriptor.withRunConfirmationDescriptor();
-        descriptor.withRunNotificationSuccess(undefined, undefined, false);
-        descriptor.withRunNotificationError(undefined, undefined, false);
-        descriptor.withAfterRunAction();
-        descriptor.withOnRunErrorAction();
-        descriptor.withSubactionsAsMenu(false);
-        return descriptor;
+        return actionLinkFromAction(action);
     }
 }
+function actionLink(actionName, cfg) {
+    return new ActionLinkDescriptorInst(actionName, {
+        ...cfg
+    });
+}
+function actionLinkFromModel(model, actionName, cfg) {
+    return new ActionLinkDescriptorInst(actionName, {
+        model,
+        ...cfg
+    });
+}
+function actionLinkFromClass(type, actionName, cfg) {
+    return new ActionLinkDescriptorInst(actionName, {
+        model: ModelDescriptor.fromClass(type, cfg?.idProperty, cfg?.titleProperty, cfg?.i18nBaseKey),
+        ...cfg
+    });
+}
+function actionLinkFromAction(action) {
+    const descriptor = new ActionLinkDescriptorInst(action.actionName, { model: action.model });
+    action.copyTo(descriptor);
+    descriptor.withRunConfirmationDescriptor();
+    descriptor.withRunNotificationSuccess(undefined, undefined, false);
+    descriptor.withRunNotificationError(undefined, undefined, false);
+    descriptor.withAfterRunAction();
+    descriptor.withOnRunErrorAction();
+    descriptor.withSubactionsAsMenu(false);
+    return descriptor;
+}
 
 class CommonsActionError extends ACommonsErrorBase {
     constructor(message, actionName, options) {
@@ -1106,6 +1157,47 @@ class DataProviderExecutor {
     }
 }
 
+class EditorDataProvider extends EditorDataProviderInst {
+    constructor() {
+        super(undefined, undefined);
+    }
+    static create() {
+        return editorDataProvider();
+    }
+    static fromClass(type) {
+        return editorDataProviderFromClass(type);
+    }
+    static fromClassWithService(type, serviceType) {
+        return editorDataProviderFromClass(type, serviceType);
+    }
+    static fromService(serviceType) {
+        return editorDataProviderWithService(serviceType);
+    }
+}
+function editorDataProvider(type, serviceType) {
+    return new EditorDataProviderInst(undefined, serviceType);
+}
+function editorDataProviderWithService(serviceType) {
+    return new EditorDataProviderInst(undefined, serviceType);
+}
+function editorDataProviderFromClass(type, serviceType) {
+    return new EditorDataProviderInst(type, serviceType);
+}
+function editorDataProviderFromModel(model, serviceType) {
+    return typeof serviceType !== 'undefined'
+        ? new EditorDataProviderInst(model.type, serviceType)
+        : new EditorDataProviderInst(model.type, undefined);
+}
+
+var TableviewEditorTypeEnum;
+(function (TableviewEditorTypeEnum) {
+    TableviewEditorTypeEnum[TableviewEditorTypeEnum["None"] = 0] = "None";
+    TableviewEditorTypeEnum[TableviewEditorTypeEnum["Details"] = 1] = "Details";
+    TableviewEditorTypeEnum[TableviewEditorTypeEnum["Edit"] = 2] = "Edit";
+    TableviewEditorTypeEnum[TableviewEditorTypeEnum["Add"] = 3] = "Add";
+})(TableviewEditorTypeEnum || (TableviewEditorTypeEnum = {}));
+const EDITOR_DEFAULT_GROUP_NAME = '_default';
+
 var FieldSizeEnum;
 (function (FieldSizeEnum) {
     FieldSizeEnum[FieldSizeEnum["Small"] = 0] = "Small";
@@ -1162,97 +1254,6 @@ var FieldGroupTypeEnum;
     FieldGroupTypeEnum[FieldGroupTypeEnum["Logical"] = 1] = "Logical";
 })(FieldGroupTypeEnum || (FieldGroupTypeEnum = {}));
 
-/**
- * converts string type to type enum, default is text
- * @param attributeType
- */
-function getFieldInputTypeFromClassAttributeDefType(attributeType) {
-    switch (attributeType) {
-        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
- * @param displayType column display type
- */
-function getFieldInputTypeFromColumnType(type, displayType) {
-    switch (type) {
-        case ColumnTypeEnum.Number:
-            return displayType === ColumnDisplayTypeEnum.Currency ? FieldInputTypeEnum.Currency : FieldInputTypeEnum.Number;
-        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;
-    }
-}
-function expandClassAttributeDefWithEditorDef(attributes) {
-    if (!attributes) {
-        throw new CommonsInternalError('Class attribute definition is null, problem with TypeRegistry::findAttributesDefinitionByClassType?', { name: 'TableviewUtilsError' });
-    }
-    const typeRegistry = TypeRegistry.get();
-    const editorClassAttributeDef = [];
-    for (const attribute of attributes) {
-        editorClassAttributeDef.push({
-            name: attribute.name,
-            baseName: attribute.baseName,
-            type: attribute.type,
-            subtype: attribute.subtype,
-            fieldType: getFieldInputTypeFromClassAttributeDefType(attribute.type),
-            classType: typeRegistry.findType(attribute.type),
-            enumType: typeRegistry.findEnum(attribute.type)
-        });
-    }
-    return editorClassAttributeDef;
-}
-/**
- * returns attributes from class type and extends to typed def with column and field enum type
- * @param type class type
- */
-function getEditorClassAttributeDef(type) {
-    return expandClassAttributeDefWithEditorDef(TypeRegistry.get().findAttributesDefinitionByClassType(type));
-}
-
-var TableviewEditorTypeEnum;
-(function (TableviewEditorTypeEnum) {
-    TableviewEditorTypeEnum[TableviewEditorTypeEnum["None"] = 0] = "None";
-    TableviewEditorTypeEnum[TableviewEditorTypeEnum["Details"] = 1] = "Details";
-    TableviewEditorTypeEnum[TableviewEditorTypeEnum["Edit"] = 2] = "Edit";
-    TableviewEditorTypeEnum[TableviewEditorTypeEnum["Add"] = 3] = "Add";
-})(TableviewEditorTypeEnum || (TableviewEditorTypeEnum = {}));
-const EDITOR_DEFAULT_GROUP_NAME = '_default';
-
 class FieldValidationDescriptor {
     constructor(name, validator, message, options) {
         this._name = name;
@@ -1370,6 +1371,9 @@ class AFieldDescriptor extends AGenericFieldDescriptor {
     get hiddenExpression() {
         return this._hiddenExpression;
     }
+    get hiddenResetOnHide() {
+        return this._hiddenResetOnHide;
+    }
     get updateOn() {
         return this._updateOn;
     }
@@ -1442,8 +1446,9 @@ class AFieldDescriptor extends AGenericFieldDescriptor {
         }
         return this;
     }
-    withHidden(hiddenExpression) {
+    withHidden(hiddenExpression, resetOnHide) {
         this._hiddenExpression = hiddenExpression;
+        this._hiddenResetOnHide = resetOnHide;
         return this;
     }
     withUpdateOn(updateOn) {
@@ -1524,11 +1529,14 @@ class AFieldDescriptor extends AGenericFieldDescriptor {
         this._isLocalized = true;
         return this;
     }
-    nextEvent(type, cmpType, cmpInstance, data) {
+    nextEvent(type, component, data) {
         this._eventsSubject.next({
             type: type,
-            componentType: cmpType,
-            componentInstance: cmpInstance,
+            fieldComponent: component,
+            formComponent: component.props.formEditorComponent,
+            form: component?.form,
+            fieldFormControl: component.formControl,
+            fieldFormlyConfig: component.field,
             data: data
         });
     }
@@ -1544,6 +1552,7 @@ class AFieldDescriptor extends AGenericFieldDescriptor {
         obj._defaultValue = this._defaultValue;
         obj._requiredExpression = this._requiredExpression;
         obj._hiddenExpression = this._hiddenExpression;
+        obj._hiddenResetOnHide = this._hiddenResetOnHide;
         obj._updateOn = this._updateOn;
         obj._onInit = this._onInit;
         obj._onChanges = this._onChanges;
@@ -1724,7 +1733,7 @@ class FieldLookupDescriptor extends AFieldDescriptor {
             this._dataProvider = cfg.dataProvider;
         }
         else {
-            this._dataProvider = LookupDataProvider.fromAnyParam(cfg?.type, cfg?.serviceType);
+            this._dataProvider = new LookupDataProviderInst(cfg?.type, cfg?.serviceType);
         }
         this._optionsValueProperty = cfg?.optionsValueProperty;
         trySetLookupItemsProperties(this);
@@ -1853,7 +1862,7 @@ class FieldLookupDescriptor extends AFieldDescriptor {
 class FieldLookupEnumDescriptor extends FieldLookupDescriptor {
     constructor(editor, property, enumModel, options) {
         super(editor, property, {
-            dataProvider: LookupDataProvider.create(),
+            dataProvider: new LookupDataProviderInst(undefined, undefined),
             optionsValueProperty: 'value'
         });
         this._enumModel = enumModel;
@@ -1936,7 +1945,7 @@ class FieldManyToManyEditorDescriptor extends AFieldDescriptor {
             this._lookupTableDataProvider = cfg.lookupDataProvider;
         }
         else {
-            this._lookupTableDataProvider = TableDataProvider.fromAnyParam(lookupTableDescriptor.model.type, cfg?.lookupServiceType);
+            this._lookupTableDataProvider = new TableDataProviderInst(lookupTableDescriptor.model.type, cfg?.lookupServiceType);
         }
     }
     get fieldType() {
@@ -2060,22 +2069,22 @@ class FieldManyEditorDescriptor extends AFieldDescriptor {
 
 const minDateValidationName = 'minDate';
 const minDateValidator = (min) => {
-    return (c) => {
-        const date = c?.value == null ? undefined : new Date(c.value);
+    return ({ fieldFormControl }) => {
+        const date = fieldFormControl?.value == null ? undefined : new Date(fieldFormControl.value);
         return !date || date >= min;
     };
 };
 const maxDateValidationName = 'maxDate';
 const maxDateValidator = (max) => {
-    return (c) => {
-        const date = c?.value == null ? undefined : new Date(c.value);
+    return ({ fieldFormControl }) => {
+        const date = fieldFormControl?.value == null ? undefined : new Date(fieldFormControl.value);
         return !date || date <= max;
     };
 };
 const emailValidationName = 'email';
 const emailValidator = () => {
-    return (c) => {
-        const error = Validators.email(c);
+    return ({ fieldFormControl }) => {
+        const error = fieldFormControl ? Validators.email(fieldFormControl) : null;
         return error === null;
     };
 };
@@ -2673,8 +2682,9 @@ class EditorDescriptorInst {
      * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
      * @typeparam LookupValueProperty - The property of lookup model type.
      * @typeparam FieldValue - The value type of field on editor.
+     * @typeparam ParentEditorModel - The value type of parent form.
      *
-     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, undefined, FieldValue>} - The field lookup descriptor.
+     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, undefined, FieldValue, ParentEditorModel>} - The field lookup descriptor.
      */
     addFieldLookupWithOptionsValuePropertyUnsafe(property, type, lookupOptionsValueProperty) {
         const field = new FieldLookupDescriptor(this, property, {
@@ -2898,66 +2908,6 @@ class EditorDescriptorInst {
             this.createTabGroup(EditorDescriptorInst.defaultGroupName, 'general.general');
         }
     }
-    /**
-     * Modifies selected field by field property. For enums use {withFieldModifiedEnum} instead.
-     * @param property Model's property name.
-     * @param fieldType new field type for selected field
-     * @param args additional parameters for field
-     */
-    withFieldModifiedType(property, fieldType, ...args) {
-        return this.withFieldModifiedTypeUnsafe(property, fieldType, ...args);
-    }
-    withFieldModifiedTypeUnsafe(property, fieldType, ...args) {
-        if (!this.model.type) {
-            throw new CommonsInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model type is not defined.`);
-        }
-        const attribute = getEditorClassAttributeDef(this.model.type).find(attribute => attribute.name === property);
-        if (attribute) {
-            attribute.fieldType = fieldType;
-            EditorDescriptorInst.upsertFieldFromAttributeDef(this, attribute, this.fields.find(fi => fi.property === property), ...args);
-        }
-        return this;
-    }
-    /**
-     * Modifies selected field with enum type.
-     * @param property Model's property name.
-     * @param enumModel Enum descriptor.
-     * @param values
-     */
-    withFieldModifiedEnum(property, enumModel, values) {
-        return this.withFieldModifiedEnumUnsafe(property, enumModel, values);
-    }
-    withFieldModifiedEnumUnsafe(property, enumDesc, values) {
-        if (!this.model.type) {
-            throw new CommonsInternalError(`withFieldModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);
-        }
-        const attribute = getEditorClassAttributeDef(this.model.type).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(enumDesc ?? enumModelGeneric(TypeRegistry.get().findEnum(attribute.type)), values);
-            }
-        }
-        return this;
-    }
-    /**
-     * Modifies selected field with lookup field.
-     * @param property Model's property name.
-     * @param lookupProvider provider to be added to field
-     * @param titleProperty
-     */
-    withFieldModifiedLookupWithProvider(property, lookupProvider, titleProperty) {
-        return this.withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, titleProperty);
-    }
-    withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, titleProperty) {
-        this.removeFieldUnsafe(property);
-        const field = this.addFieldLookupWithProviderUnsafe(property, lookupProvider).asAutocomplete();
-        if (titleProperty) {
-            field.withOptionsLabelProperty(titleProperty);
-        }
-        return this;
-    }
     /**
      * This method takes care of displaying correct/localized data in the editor
      * @param property property that tells us where on the model are localizations accessible
@@ -2974,54 +2924,207 @@ class EditorDescriptorInst {
         this._isLocalized = true;
         return this;
     }
-    nextEvent(type, cmpType, cmpInstance, data) {
+    nextEvent(type, component, data) {
         this._eventsSubject.next({
             type: type,
-            componentType: cmpType,
-            componentInstance: cmpInstance,
+            formComponent: component,
+            form: component.form,
             data: data
         });
     }
     get events$() {
         return this._eventsSubject.asObservable();
     }
-    /**
-     * Generates field based on attribute definition, used for auto model
-     * @param descriptor Editor descriptor instance.
-     * @param attribute Attribute definition.
-     * @param field Optional, if defined will be replaced, otherwise new will be generated.
-     * @param args Optional additional arguments mapped to filed type. Arguments depend on possible arguments on fields.
-     * @internal
-     */
-    static upsertFieldFromAttributeDef(descriptor, attribute, field, ...args) {
-        if (field == null) {
-            field = descriptor.addFieldUnsafe(attribute.name);
+}
+
+/**
+ * converts string type to type enum, default is text
+ * @param attributeType
+ */
+function getFieldInputTypeFromClassAttributeDefType(attributeType) {
+    switch (attributeType) {
+        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
+ * @param displayType column display type
+ */
+function getFieldInputTypeFromColumnType(type, displayType) {
+    switch (type) {
+        case ColumnTypeEnum.Number:
+            return displayType === ColumnDisplayTypeEnum.Currency ? FieldInputTypeEnum.Currency : FieldInputTypeEnum.Number;
+        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;
+    }
+}
+function expandClassAttributeDefWithEditorDef(attributes) {
+    if (!attributes) {
+        throw new CommonsInternalError('Class attribute definition is null, problem with TypeRegistry::findAttributesDefinitionByClassType?', { name: 'TableviewUtilsError' });
+    }
+    const typeRegistry = TypeRegistry.get();
+    const editorClassAttributeDef = [];
+    for (const attribute of attributes) {
+        editorClassAttributeDef.push({
+            name: attribute.name,
+            baseName: attribute.baseName,
+            type: attribute.type,
+            subtype: attribute.subtype,
+            fieldType: getFieldInputTypeFromClassAttributeDefType(attribute.type),
+            classType: typeRegistry.findType(attribute.type),
+            enumType: typeRegistry.findEnum(attribute.type)
+        });
+    }
+    return editorClassAttributeDef;
+}
+/**
+ * returns attributes from class type and extends to typed def with column and field enum type
+ * @param type class type
+ */
+function getEditorClassAttributeDef(type) {
+    return expandClassAttributeDefWithEditorDef(TypeRegistry.get().findAttributesDefinitionByClassType(type));
+}
+
+/**
+ * Generates field based on attribute definition, used for auto model
+ * @param descriptor Editor descriptor instance.
+ * @param attribute Attribute definition.
+ * @param field Optional, if defined will be replaced, otherwise new will be generated.
+ * @param args Optional additional arguments mapped to filed type. Arguments depend on possible arguments on fields.
+ * @internal
+ */
+function upsertEditorFieldFromAttributeDef(descriptor, attribute, field, ...args) {
+    if (field == null) {
+        field = descriptor.addFieldUnsafe(attribute.name);
+    }
+    if (field instanceof FieldInputDescriptor) {
+        if (attribute.enumType) {
+            return field.asRadioFromEnum(enumModelGeneric(attribute.enumType));
         }
-        if (field instanceof FieldInputDescriptor) {
-            if (attribute.enumType) {
-                return field.asRadioFromEnum(enumModelGeneric(attribute.enumType));
-            }
-            else {
-                const tableColumnType = getColumnTypeFromClassAttributeDefType(attribute.type);
-                const tableColumnDisplayType = getColumnDisplayTypeFromColumnType(tableColumnType, attribute.type);
-                return field.asType(attribute.fieldType ?? getFieldInputTypeFromColumnType(tableColumnType, tableColumnDisplayType), ...args);
-            }
+        else {
+            const tableColumnType = getColumnTypeFromClassAttributeDefType(attribute.type);
+            const tableColumnDisplayType = getColumnDisplayTypeFromColumnType(tableColumnType, attribute.type);
+            return field.asType(attribute.fieldType ?? getFieldInputTypeFromColumnType(tableColumnType, tableColumnDisplayType), ...args);
+        }
+    }
+    return field;
+}
+/**
+ * Modifies selected field by field property. For enums use {withFieldModifiedEnum} instead.
+ * @param descriptor Editor descriptor.
+ * @param property Model's property name.
+ * @param fieldType new field type for selected field
+ * @param args additional parameters for field
+ */
+function modifyEditorClassAttributeFieldType(descriptor, property, fieldType, ...args) {
+    return modifyEditorClassAttributeFieldTypeUnsafe(descriptor, property, fieldType, ...args);
+}
+function modifyEditorClassAttributeFieldTypeUnsafe(descriptor, property, fieldType, ...args) {
+    if (!descriptor.model.type) {
+        throw new CommonsInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model type is not defined.`);
+    }
+    const attribute = getEditorClassAttributeDef(descriptor.model.type).find(attribute => attribute.name === property);
+    if (attribute) {
+        attribute.fieldType = fieldType;
+        return upsertEditorFieldFromAttributeDef(descriptor, attribute, descriptor.fields.find(fi => fi.property === property), ...args);
+    }
+    return null;
+}
+/**
+ * Modifies selected field with enum type.
+ * @param descriptor Editor descriptor.
+ * @param property Model's property name.
+ * @param enumModel Enum descriptor.
+ * @param values
+ */
+function modifyEditorClassAttributeFieldEnum(descriptor, property, enumModel, values) {
+    return modifyEditorClassAttributeFieldEnumUnsafe(descriptor, property, enumModel, values);
+}
+function modifyEditorClassAttributeFieldEnumUnsafe(descriptor, property, enumDesc, values) {
+    if (!descriptor.model.type) {
+        throw new CommonsInternalError(`withFieldModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);
+    }
+    const attribute = getEditorClassAttributeDef(descriptor.model.type).find(a => a.name === property);
+    if (attribute) {
+        attribute.fieldType = FieldInputTypeEnum.Radio;
+        const field = descriptor.fields.find(f => f.property === property);
+        if (field && field instanceof FieldInputDescriptor) {
+            field.asRadioFromEnum(enumDesc ?? enumModelGeneric(TypeRegistry.get().findEnum(attribute.type)), values);
         }
-        return field;
+        return field ?? null;
+    }
+    return null;
+}
+/**
+ * Modifies selected field with lookup field.
+ * @param descriptor Editor descriptor.
+ * @param property Model's property name.
+ * @param lookupProvider provider to be added to field
+ * @param titleProperty
+ */
+function modifyEditorFieldLookup(descriptor, property, lookupProvider, titleProperty) {
+    return modifyEditorFieldLookupUnsafe(descriptor, property, lookupProvider, titleProperty);
+}
+function modifyEditorFieldLookupUnsafe(descriptor, property, lookupProvider, titleProperty) {
+    descriptor.removeFieldUnsafe(property);
+    const field = descriptor.addFieldLookupWithProviderUnsafe(property, lookupProvider).asAutocomplete();
+    if (titleProperty) {
+        field.withOptionsLabelPropertyUnsafe(titleProperty);
     }
+    return field;
 }
+
 class EditorDescriptor extends EditorDescriptorInst {
     constructor() {
         super(ModelDescriptor.create());
     }
     static create(idProperty, titleProperty, i18nBaseKey, tableviewEditorType = TableviewEditorTypeEnum.None) {
-        return new EditorDescriptorInst(ModelDescriptor.create(idProperty, titleProperty, i18nBaseKey), tableviewEditorType);
+        return editorDescriptor({ id: idProperty, title: titleProperty, i18nBase: i18nBaseKey, tableviewEditorType: tableviewEditorType });
     }
     static fromClass(type, idProperty, titleProperty, i18nBaseKey, tableviewEditorType = TableviewEditorTypeEnum.None) {
-        return new EditorDescriptorInst(ModelDescriptor.fromClass(type, idProperty, titleProperty, i18nBaseKey), tableviewEditorType);
+        return editorDescriptorFromClass(type, {
+            id: idProperty,
+            title: titleProperty,
+            i18nBase: i18nBaseKey,
+            tableviewEditorType: tableviewEditorType
+        });
     }
     static fromModel(model, tableviewEditorType = TableviewEditorTypeEnum.None) {
-        return new EditorDescriptorInst(model, tableviewEditorType);
+        return editorDescriptor(model, { tableviewEditorType: tableviewEditorType });
     }
     /**
      * Creates editor descriptor automatically based on openapi model's attributes definition which is automatically extracted. All fields will be included.
@@ -3039,15 +3142,46 @@ class EditorDescriptor extends EditorDescriptorInst {
      * @param attributes List of attribute definitions from which fields should be created.
      * @param idProperty Id property representing model (optional).
      * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
-     * @param tableEditorType Type of editor in tableview (add, edit, view or none).
+     * @param tableviewEditorType Type of editor in tableview (add, edit, view or none).
      */
-    static fromClassWithCustomAttrsDef(type, attributes, idProperty, titleProperty, tableEditorType = TableviewEditorTypeEnum.None) {
-        const descriptor = EditorDescriptor.fromClass(type, idProperty, titleProperty, undefined, tableEditorType);
-        attributes
-            .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))
-            .forEach(attr => EditorDescriptorInst.upsertFieldFromAttributeDef(descriptor, attr, descriptor.fields.find(col => col.property === attr.name)));
-        return descriptor;
+    static fromClassWithCustomAttrsDef(type, attributes, idProperty, titleProperty, tableviewEditorType = TableviewEditorTypeEnum.None) {
+        return editorDescriptorFromClassAttrsDef(type, attributes, {
+            id: idProperty,
+            title: titleProperty,
+            tableviewEditorType: tableviewEditorType
+        });
+    }
+}
+function editorDescriptor(typeOrModelOrClassOrOpts, opts) {
+    if (typeOrModelOrClassOrOpts == null) {
+        return new EditorDescriptorInst(model(), opts?.tableviewEditorType);
+    }
+    else if (typeOrModelOrClassOrOpts instanceof TypeDescriptor) {
+        return new EditorDescriptorInst(model(opts ?? {}), opts?.tableviewEditorType);
     }
+    else if (typeOrModelOrClassOrOpts instanceof ModelDescriptor) {
+        return new EditorDescriptorInst(typeOrModelOrClassOrOpts, opts?.tableviewEditorType);
+    }
+    else {
+        // this could have autoGenerated if model descriptor is class
+        return new EditorDescriptorInst(model(typeOrModelOrClassOrOpts), typeOrModelOrClassOrOpts?.tableviewEditorType);
+    }
+}
+function editorDescriptorFromClass(type, opts) {
+    return new EditorDescriptorInst(model(type, opts), opts?.tableviewEditorType);
+}
+/**
+ * Generates descriptor based on type attribute definition
+ * @param type class type
+ * @param attributes
+ * @param opts
+ */
+function editorDescriptorFromClassAttrsDef(type, attributes, opts) {
+    const descriptor = new EditorDescriptorInst(model(type, opts), opts?.tableviewEditorType);
+    (attributes ?? getEditorClassAttributeDef(type))
+        .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))
+        .forEach(attr => upsertEditorFieldFromAttributeDef(descriptor, attr));
+    return descriptor;
 }
 
 var FormFieldEventTypeEnum;
@@ -3145,8 +3279,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImpor
 class TableviewDataProviderInst extends DataProviderInst {
     constructor(type, serviceType) {
         super(type, serviceType);
-        this.editorDataProvider = EditorDataProvider.fromAnyParam(type, serviceType);
-        this.tableDataProvider = TableDataProvider.fromAnyParam(type, serviceType);
+        this.editorDataProvider = new EditorDataProviderInst(type, serviceType);
+        this.tableDataProvider = new TableDataProviderInst(type, serviceType);
     }
     get isLazy() {
         return this.tableDataProvider.isLazy;
@@ -3197,94 +3331,68 @@ class TableviewDataProviderInst extends DataProviderInst {
         return this;
     }
 }
+class DynamicTableviewDataProviderInst extends TableviewDataProviderInst {
+    constructor(serviceType) {
+        super(undefined, serviceType);
+    }
+}
+
 class TableviewDataProvider extends TableviewDataProviderInst {
     constructor() {
         super(undefined, undefined);
     }
     static create() {
-        return new TableviewDataProviderInst(undefined, undefined);
+        return tableviewDataProvider();
     }
     static fromClass(type) {
-        return new TableviewDataProviderInst(type, undefined);
+        return tableviewDataProviderFromClass(type);
     }
     static fromClassWithService(type, serviceType) {
-        return new TableviewDataProviderInst(type, serviceType);
+        return tableviewDataProviderFromClass(type, serviceType);
     }
     static fromService(serviceType) {
-        return new TableviewDataProviderInst(undefined, serviceType);
-    }
-    static fromAnyParam(type, serviceType) {
-        if (typeof type !== 'undefined') {
-            return typeof serviceType !== 'undefined'
-                ? TableviewDataProvider.fromClassWithService(type, serviceType)
-                : TableviewDataProvider.fromClass(type);
-        }
-        else if (typeof serviceType !== 'undefined') {
-            return TableviewDataProvider.fromService(serviceType);
-        }
-        else {
-            return TableviewDataProvider.create();
-        }
+        return tableviewDataProviderWithService(serviceType);
     }
 }
-class DynamicTableviewDataProviderInst extends TableviewDataProviderInst {
-    constructor(serviceType) {
-        super(undefined, serviceType);
-    }
+function tableviewDataProvider(type, serviceType) {
+    return new TableviewDataProviderInst(undefined, serviceType);
+}
+function tableviewDataProviderWithService(serviceType) {
+    return new TableviewDataProviderInst(undefined, serviceType);
+}
+function tableviewDataProviderFromClass(type, serviceType) {
+    return new TableviewDataProviderInst(type, serviceType);
+}
+function tableviewDataProviderFromModel(model, serviceType) {
+    return typeof serviceType !== 'undefined'
+        ? new TableviewDataProviderInst(model.type, serviceType)
+        : new TableviewDataProviderInst(model.type, undefined);
 }
 class DynamicTableviewDataProvider extends DynamicTableviewDataProviderInst {
     constructor() {
         super(undefined);
     }
     static create() {
-        return new DynamicTableviewDataProviderInst(undefined);
+        return tableviewDynamicDataProvider();
     }
     static fromService(serviceType) {
-        return new DynamicTableviewDataProviderInst(serviceType);
-    }
-}
-
-function expandClassAttributeDefWithTableviewDef(attributes) {
-    if (!attributes) {
-        throw new CommonsInternalError('Class attribute definition is null, problem with TypeRegistry::findAttributesDefinitionByClassType?', { name: 'TableviewUtilsError' });
-    }
-    const typeRegistry = TypeRegistry.get();
-    const tableClassAttributeDef = [];
-    for (const attribute of attributes) {
-        const enumType = typeRegistry.findEnum(attribute.type);
-        const columnType = enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type);
-        tableClassAttributeDef.push({
-            name: attribute.name,
-            baseName: attribute.baseName,
-            type: attribute.type,
-            subtype: attribute.subtype,
-            columnType: enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type),
-            columnDisplayType: getColumnDisplayTypeFromColumnType(columnType, attribute.type),
-            fieldType: getFieldInputTypeFromClassAttributeDefType(attribute.type),
-            enumType: typeRegistry.findEnum(attribute.type),
-            classType: typeRegistry.findType(attribute.type)
-        });
+        return tableviewDynamicDataProvider(serviceType);
     }
-    return tableClassAttributeDef;
 }
-/**
- * returns attributes from class type and extends to typed def with column and field enum type
- * @param type class type
- */
-function getTableviewClassAttributeDef(type) {
-    return expandClassAttributeDefWithTableviewDef(TypeRegistry.get().findAttributesDefinitionByClassType(type));
+function tableviewDynamicDataProvider(serviceType) {
+    return new DynamicTableviewDataProviderInst(serviceType);
 }
 
 class TableviewDescriptorInst {
     constructor(model) {
         this._isLocalized = false;
         this._model = model;
-        this._table = TableDescriptor.fromModel(model);
+        this._table = new TableDescriptorInst(model);
         this._tableTitle = `${this._model.i18nBaseKey}.name`;
-        this._detailsEditor = EditorDescriptor.fromModel(model, TableviewEditorTypeEnum.Details);
+        this._detailsEditor = new EditorDescriptorInst(model, TableviewEditorTypeEnum.Details);
         this._detailsEditor.withDisabled();
-        this._addEditor = EditorDescriptor.fromModel(model, TableviewEditorTypeEnum.Add);
-        this._editEditor = EditorDescriptor.fromModel(model, TableviewEditorTypeEnum.Edit);
+        this._addEditor = new EditorDescriptorInst(model, TableviewEditorTypeEnum.Add);
+        this._editEditor = new EditorDescriptorInst(model, TableviewEditorTypeEnum.Edit);
     }
     get table() {
         return this._table;
@@ -3525,6 +3633,11 @@ class TableviewDescriptorInst {
         properties.forEach(p => this.addField(p));
         return this;
     }
+    addFieldAction(actionName) {
+        const field = this._detailsEditor.addFieldAction(actionName);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
     addFieldToEditAndAdd(field) {
         this._addEditor.addFieldDescriptor(field);
         this._editEditor.addFieldDescriptor(field);
@@ -3538,7 +3651,7 @@ class TableviewDescriptorInst {
      * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
      * @typeparam FieldValue - The value type of field on editor.
      *
-     * @returns {FieldLookupDescriptor<LookupModel, TableviewModel, undefined, FieldValue>} - The field lookup descriptor.
+     * @returns {FieldLookupDescriptor<LookupModel, TableviewModel, undefined, FieldValue, ParentEditorModel>} - The field lookup descriptor.
      */
     addFieldLookup(property, type) {
         const field = this._detailsEditor.addFieldLookup(property, type);
@@ -3554,7 +3667,7 @@ class TableviewDescriptorInst {
      * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
      * @typeparam FieldValue - The value type of field on editor.
      *
-     * @returns {FieldLookupDescriptor<LookupModel, TableviewModel, undefined, FieldValue>} - The field lookup descriptor.
+     * @returns {FieldLookupDescriptor<LookupModel, TableviewModel, undefined, FieldValue, ParentEditorModel>} - The field lookup descriptor.
      */
     addFieldLookupUnsafe(property, type) {
         const field = this._detailsEditor.addFieldLookupUnsafe(property, type);
@@ -3725,113 +3838,60 @@ class TableviewDescriptorInst {
         tableview._isLocalized = this._isLocalized;
         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
-     * @param columnDisplayType optional
-     */
-    withModifiedType(property, columnType, fieldType, columnDisplayType) {
-        return this.withModifiedTypeUnsafe(property, columnType, fieldType, columnDisplayType);
+    localized(property, model, localeProperty) {
+        return this.localizedUnsafe(property, model, localeProperty);
     }
-    withModifiedTypeUnsafe(property, columnType, fieldType, columnDisplayType) {
-        if (!this.model.type) {
-            throw new CommonsInternalError(`withModifiedType cannot be executed for property ${property}: Model type is not defined.`);
-        }
-        if (columnType === ColumnTypeEnum.Enum) {
-            throw new CommonsInternalError('Do not use with types where args are required', { name: 'TableviewDescriptorError' });
-        }
-        const attributeDef = getTableviewClassAttributeDef(this.model.type).find(attr => attr.name === property);
-        if (attributeDef != null) {
-            fieldType ??= getFieldInputTypeFromColumnType(columnType, columnDisplayType);
-            attributeDef.fieldType = fieldType;
-            this._table.withColumnModifiedTypeUnsafe(property, columnType, columnDisplayType);
-            this._editEditor.withFieldModifiedTypeUnsafe(property, fieldType);
-            this._addEditor.withFieldModifiedTypeUnsafe(property, fieldType);
-            this._detailsEditor.withFieldModifiedTypeUnsafe(property, fieldType);
-        }
+    localizedUnsafe(property, model, localeProperty) {
+        this._isLocalized = true;
+        this._table.withLocalizationLocaleProperty(localeProperty);
+        this.detailsEditor.localizedUnsafe(property, model, localeProperty);
+        this.addEditor.localizedUnsafe(property, model, localeProperty);
+        this.editEditor.localizedUnsafe(property, model, localeProperty);
         return this;
     }
+}
+class TableviewDynamicDescriptorInt extends TableviewDescriptorInst {
+    constructor(model) {
+        super(model);
+        this._table = new TableDynamicDescriptorInst(this.model);
+        this._tableTitle = undefined;
+    }
+    get table() {
+        return this._table;
+    }
     /**
-     * creates column with enum type
-     * if fields exists, it is replaced
-     * @param property property name
-     * @param enumDesc type of enum
-     * @param fieldType type of field, optional, default is Text
+     * sets custom table descriptor
+     * @param descriptor
      */
-    withModifiedEnum(property, enumDesc, fieldType) {
-        return this.withModifiedEnumUnsafe(property, enumDesc, fieldType);
-    }
-    withModifiedEnumUnsafe(property, enumDesc, fieldType) {
-        if (!this.model.type) {
-            throw new CommonsInternalError(`withModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);
-        }
-        const attributeDef = getTableviewClassAttributeDef(this.model.type).find(attr => attr.name === property);
-        if (attributeDef != null) {
-            attributeDef.fieldType = fieldType ?? FieldInputTypeEnum.Text;
-            this._table.withColumnModifiedEnumUnsafe(property, enumDesc);
-            this._editEditor.withFieldModifiedEnumUnsafe(property, enumDesc);
-            this._detailsEditor.withFieldModifiedEnumUnsafe(property, enumDesc);
-            this._addEditor.withFieldModifiedEnumUnsafe(property, enumDesc);
-        }
+    withTableDescriptor(descriptor) {
+        this._table = descriptor;
         return this;
     }
     /**
-     * generates column with custom class type
-     * field is generated only if lookupProvider is provided
-     * @param property property name
-     * @param type class type of object
-     * @param titleProperty
-     * @param lookupProvider
-     * @param optionsLabelProperty
-     * @param filterProperty
+     * sets visibility hidden state to column with given property
+     * equals to be removing in auto and base tableview descriptor
+     * * @param property column's property
      */
-    withModifiedLookup(property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty) {
-        return this.withModifiedLookupUnsafe(property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty);
-    }
-    withModifiedLookupUnsafe(property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty) {
-        if (!this.model.type) {
-            throw new CommonsInternalError(`withModifiedLookup cannot be executed for property ${property}: Model type is not defined.`);
-        }
-        const attributeDef = getTableviewClassAttributeDef(this.model.type).find(attr => attr.name === property);
-        if (attributeDef != null) {
-            type ??= attributeDef.classType ?? TypeRegistry.get().findType(attributeDef.type);
-            titleProperty ??= type ? findClassTitleAttribute(type) ?? undefined : undefined;
-            optionsLabelProperty ??= titleProperty;
-            attributeDef.columnType = ColumnTypeEnum.String;
-            attributeDef.fieldType = FieldInputTypeEnum.Text;
-            if (lookupProvider != null) {
-                this._table.withColumnModifiedLookupUnsafe(property, lookupProvider, optionsLabelProperty, filterProperty);
-                this._addEditor.withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, optionsLabelProperty);
-                this._detailsEditor.withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, optionsLabelProperty);
-                this._editEditor.withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, optionsLabelProperty);
-            }
-            else {
-                const column = this._table.getColumnUnsafe(property) ?? this.addColumnUnsafe(property);
-                if (titleProperty) {
-                    column.withGetter(value => value?.[titleProperty]);
-                }
-            }
-        }
+    removeColumn(property) {
+        this._table.removeColumn(property);
         return this;
     }
-    localized(property, model, localeProperty) {
-        return this.localizedUnsafe(property, model, localeProperty);
-    }
-    localizedUnsafe(property, model, localeProperty) {
-        this._isLocalized = true;
-        this._table.withLocalizationLocaleProperty(localeProperty);
-        this.detailsEditor.localizedUnsafe(property, model, localeProperty);
-        this.addEditor.localizedUnsafe(property, model, localeProperty);
-        this.editEditor.localizedUnsafe(property, model, localeProperty);
+    withEntityForTranslations(i18nBaseKey) {
+        this._table.model.withI18nBase(i18nBaseKey);
+        this._detailsEditor.model.withI18nBase(i18nBaseKey);
         return this;
     }
+    /**
+     * creates deep copy of tableview object and its children
+     */
+    copy() {
+        const descriptor = new TableviewDynamicDescriptorInt(this.model.copy());
+        descriptor._table = this._table.copy();
+        descriptor._tableTitle = this._tableTitle;
+        return descriptor;
+    }
 }
+
 class TableviewDescriptor extends TableviewDescriptorInst {
     constructor() {
         super(ModelDescriptor.create());
@@ -3852,12 +3912,12 @@ class TableviewDescriptor extends TableviewDescriptorInst {
      * @param titleProperty
      */
     static fromClassWithAutoAttrsDef(type, idProperty, titleProperty) {
-        const model = ModelDescriptor.fromClass(type, idProperty, titleProperty);
-        const descriptor = TableviewDescriptor.fromModel(model);
-        descriptor.withTableDescriptor(TableDescriptor.fromClassWithAutoAttrsDef(type, idProperty, titleProperty));
-        descriptor.withEditDescriptor(EditorDescriptor.fromClassWithAutoAttrsDef(type, idProperty, titleProperty, TableviewEditorTypeEnum.Edit));
-        descriptor.withDetailsDescriptor(EditorDescriptor.fromClassWithAutoAttrsDef(type, idProperty, titleProperty, TableviewEditorTypeEnum.Details).withDisabled());
-        descriptor.withAddDescriptor(EditorDescriptor.fromClassWithAutoAttrsDef(type, idProperty, titleProperty, TableviewEditorTypeEnum.Add));
+        const descriptor = tableviewDescriptor(model(type, { id: idProperty, title: titleProperty }));
+        const optsBase = { id: idProperty, title: titleProperty };
+        descriptor.withTableDescriptor(tableDescriptorFromClassAttrsDef(type, undefined, optsBase));
+        descriptor.withEditDescriptor(editorDescriptorFromClassAttrsDef(type, undefined, { ...optsBase, tableviewEditorType: TableviewEditorTypeEnum.Edit }));
+        descriptor.withDetailsDescriptor(editorDescriptorFromClassAttrsDef(type, undefined, { ...optsBase, tableviewEditorType: TableviewEditorTypeEnum.Details }).withDisabled());
+        descriptor.withAddDescriptor(editorDescriptorFromClassAttrsDef(type, undefined, { ...optsBase, tableviewEditorType: TableviewEditorTypeEnum.Add }));
         return descriptor;
     }
     /**
@@ -3869,74 +3929,111 @@ class TableviewDescriptor extends TableviewDescriptorInst {
      * @param titleProperty
      */
     static fromClassWithCustomAttrsDef(type, columnAttributes, fieldAttributes, idProperty, titleProperty) {
-        const descriptor = TableviewDescriptor.fromModel(ModelDescriptor.fromClass(type, idProperty, titleProperty));
-        descriptor.withTableDescriptor(TableDescriptor.fromClassWithCustomAttrsDef(type, columnAttributes, idProperty, titleProperty));
+        const optsBase = { id: idProperty, title: titleProperty };
+        const descriptor = tableviewDescriptor(model(type, optsBase));
+        descriptor.withTableDescriptor(tableDescriptorFromClassAttrsDef(type, columnAttributes, optsBase));
         if (fieldAttributes !== null) {
-            descriptor.withEditDescriptor(EditorDescriptor.fromClassWithCustomAttrsDef(type, fieldAttributes ?? columnAttributes, idProperty, titleProperty, TableviewEditorTypeEnum.Edit));
-            descriptor.withDetailsDescriptor(EditorDescriptor.fromClassWithCustomAttrsDef(type, fieldAttributes ?? columnAttributes, idProperty, titleProperty, TableviewEditorTypeEnum.Details));
-            descriptor.withAddDescriptor(EditorDescriptor.fromClassWithCustomAttrsDef(type, fieldAttributes ?? columnAttributes, idProperty, titleProperty, TableviewEditorTypeEnum.Add));
+            descriptor.withEditDescriptor(editorDescriptorFromClassAttrsDef(type, fieldAttributes ?? columnAttributes, { ...optsBase, tableviewEditorType: TableviewEditorTypeEnum.Edit }));
+            descriptor.withDetailsDescriptor(editorDescriptorFromClassAttrsDef(type, fieldAttributes ?? columnAttributes, { ...optsBase, tableviewEditorType: TableviewEditorTypeEnum.Details }));
+            descriptor.withAddDescriptor(editorDescriptorFromClassAttrsDef(type, fieldAttributes ?? columnAttributes, { ...optsBase, tableviewEditorType: TableviewEditorTypeEnum.Add }));
         }
         return descriptor;
     }
 }
-class TableviewDynamicDescriptorInt extends TableviewDescriptorInst {
-    constructor(model) {
-        super(model);
-        this._table = TableDynamicDescriptor.fromModel(this.model);
-        this._tableTitle = undefined;
-    }
-    get table() {
-        return this._table;
-    }
-    /**
-     * sets custom table descriptor
-     * @param descriptor
-     */
-    withTableDescriptor(descriptor) {
-        this._table = descriptor;
-        return this;
+function tableviewDescriptor(typeOrModelOrClassOrOpts, opts) {
+    if (typeOrModelOrClassOrOpts == null) {
+        return new TableviewDescriptorInst(model());
     }
-    /**
-     * 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;
+    else if (typeOrModelOrClassOrOpts instanceof TypeDescriptor) {
+        return new TableviewDescriptorInst(model(opts ?? {}));
     }
-    withEntityForTranslations(i18nBaseKey) {
-        this._table.model.withI18nBase(i18nBaseKey);
-        this._detailsEditor.model.withI18nBase(i18nBaseKey);
-        return this;
+    else if (typeOrModelOrClassOrOpts instanceof ModelDescriptor) {
+        return new TableviewDescriptorInst(typeOrModelOrClassOrOpts);
     }
-    /**
-     * creates deep copy of tableview object and its children
-     */
-    copy() {
-        const descriptor = new TableviewDynamicDescriptorInt(this.model.copy());
-        descriptor._table = this._table.copy();
-        descriptor._tableTitle = this._tableTitle;
-        return descriptor;
+    else {
+        // this could have autoGenerated if model descriptor is class
+        return new TableviewDescriptorInst(model(typeOrModelOrClassOrOpts));
     }
 }
+function tableviewDescriptorFromClass(type, opts) {
+    return new TableviewDescriptorInst(model(type, opts));
+}
+/**
+ * generates descriptor based on type attribute definition
+ * @param type class type
+ * @param columnAttributes
+ * @param fieldAttributes
+ * @param opts
+ */
+function tableviewDescriptorFromClassAttrsDef(type, columnAttributes, fieldAttributes, opts) {
+    const model = new ModelDescriptor(type, opts?.id, opts?.title, opts?.i18nBase);
+    const descriptor = new TableviewDescriptorInst(model);
+    descriptor.withTableDescriptor(tableDescriptorFromClassAttrsDef(type, columnAttributes, opts));
+    if (fieldAttributes !== null) {
+        descriptor.withEditDescriptor(editorDescriptorFromClassAttrsDef(type, fieldAttributes ?? columnAttributes, { ...opts, tableviewEditorType: TableviewEditorTypeEnum.Edit }));
+        descriptor.withDetailsDescriptor(editorDescriptorFromClassAttrsDef(type, fieldAttributes ?? columnAttributes, { ...opts, tableviewEditorType: TableviewEditorTypeEnum.Details }).withDisabled());
+        descriptor.withAddDescriptor(editorDescriptorFromClassAttrsDef(type, fieldAttributes ?? columnAttributes, { ...opts, tableviewEditorType: TableviewEditorTypeEnum.Add }));
+    }
+    return descriptor;
+}
+function tableviewDescriptorFromParent(descriptor, classOrType, idProperty, titleProperty, i18nBaseKey) {
+    return classOrType instanceof ModelDescriptor
+        ? new TableviewDescriptorInst(classOrType)
+        : new TableviewDescriptorInst(model(classOrType, { id: idProperty, title: titleProperty, i18nBase: i18nBaseKey }));
+}
 class TableviewDynamicDescriptor extends TableviewDynamicDescriptorInt {
     constructor() {
         super(ModelDescriptor.create());
     }
     static create(idProperty, titleProperty, i18nBaseKey) {
-        return new TableviewDynamicDescriptorInt(ModelDescriptor.create(idProperty, titleProperty, i18nBaseKey));
+        return tableviewDynamicDescriptor({ id: idProperty, title: titleProperty, i18nBase: i18nBaseKey });
     }
     static fromModel(model) {
-        return new TableviewDynamicDescriptorInt(model);
+        return tableviewDynamicDescriptor(model);
+    }
+}
+function tableviewDynamicDescriptor(modelOrOpts) {
+    return modelOrOpts instanceof ModelDescriptor
+        ? new TableviewDynamicDescriptorInt(modelOrOpts)
+        : new TableviewDynamicDescriptorInt(new ModelDescriptor(undefined, modelOrOpts?.id, modelOrOpts?.title, modelOrOpts?.i18nBase));
+}
+
+function expandClassAttributeDefWithTableviewDef(attributes) {
+    if (!attributes) {
+        throw new CommonsInternalError('Class attribute definition is null, problem with TypeRegistry::findAttributesDefinitionByClassType?', { name: 'TableviewUtilsError' });
+    }
+    const typeRegistry = TypeRegistry.get();
+    const tableClassAttributeDef = [];
+    for (const attribute of attributes) {
+        const enumType = typeRegistry.findEnum(attribute.type);
+        const columnType = enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type);
+        tableClassAttributeDef.push({
+            name: attribute.name,
+            baseName: attribute.baseName,
+            type: attribute.type,
+            subtype: attribute.subtype,
+            columnType: enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type),
+            columnDisplayType: getColumnDisplayTypeFromColumnType(columnType, attribute.type),
+            fieldType: getFieldInputTypeFromClassAttributeDefType(attribute.type),
+            enumType: typeRegistry.findEnum(attribute.type),
+            classType: typeRegistry.findType(attribute.type)
+        });
     }
+    return tableClassAttributeDef;
+}
+/**
+ * returns attributes from class type and extends to typed def with column and field enum type
+ * @param type class type
+ */
+function getTableviewClassAttributeDef(type) {
+    return expandClassAttributeDefWithTableviewDef(TypeRegistry.get().findAttributesDefinitionByClassType(type));
 }
 
 function convertDataToStringWithDelimiter(data, delimiter, descriptor, translate) {
     const replaceNullValue = (key, value) => (value === null ? '' : value);
     const getterPipe = new GetterPipe();
     return [
-        descriptor.table.columns.map(col => translate.instant(descriptor.model.typeName + '.properties.' + col.property)).join(delimiter),
+        descriptor.table.columns.map(col => translate.instant(descriptor.model.i18nBaseKey + '.properties.' + col.property)).join(delimiter),
         ...data.map((row) => descriptor.table.columns
             .map(column => {
             if (typeof column.getter === 'function') {
@@ -4046,34 +4143,50 @@ function getRouteData(injector) {
 }
 function tableviewDetailsAction(descriptor, injector) {
     const routeData = getRouteData(injector);
-    return !routeData?.tableviewActions || routeData.tableviewActions.hasDetails ? ActionEditorDetailsDescriptor.create(descriptor) : null;
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasDetails ? new ActionEditorDetailsDescriptorInst(descriptor) : null;
 }
 function tableviewDetailsActionWithProvider(descriptor, serviceProvider, injector) {
     const routeData = getRouteData(injector);
-    return !routeData?.tableviewActions || routeData.tableviewActions.hasDetails ? ActionEditorDetailsDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasDetails
+        ? new ActionEditorDetailsDescriptorInst(descriptor, {
+            ...actionEditorGetProviderCfgObj(serviceProvider)
+        })
+        : null;
 }
 function tableviewAddAction(descriptor, injector) {
     const routeData = getRouteData(injector);
-    return !routeData?.tableviewActions || routeData.tableviewActions.hasAdd ? ActionEditorAddDescriptor.create(descriptor) : null;
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasAdd ? new ActionEditorAddDescriptorInst(descriptor) : null;
 }
 function tableviewAddActionWithProvider(descriptor, serviceProvider, injector) {
     const routeData = getRouteData(injector);
-    return !routeData?.tableviewActions || routeData.tableviewActions.hasAdd ? ActionEditorAddDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasAdd
+        ? new ActionEditorAddDescriptorInst(descriptor, {
+            ...actionEditorGetProviderCfgObj(serviceProvider)
+        })
+        : null;
 }
 function tableviewEditAction(descriptor, injector) {
     const routeData = getRouteData(injector);
-    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit ? ActionEditorEditDescriptor.create(descriptor) : null;
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit ? new ActionEditorEditDescriptorInst(descriptor) : null;
 }
 function tableviewEditActionWithProvider(descriptor, serviceProvider, injector) {
     const routeData = getRouteData(injector);
-    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit ? ActionEditorEditDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit
+        ? new ActionEditorEditDescriptorInst(descriptor, {
+            ...actionEditorGetProviderCfgObj(serviceProvider)
+        })
+        : null;
 }
 function tableviewEditOnDetailsAction(descriptor, editDescriptor, injector) {
     const routeData = getRouteData(injector);
     if (routeData?.tableviewActions && !routeData.tableviewActions.hasEdit) {
         return null;
     }
-    const action = editDescriptor ? ActionLinkDescriptor.fromAction(editDescriptor) : ActionLinkDescriptor.fromModel(descriptor, ActionEditorEditDescriptorInst.ACTION_NAME);
+    const action = editDescriptor
+        ? actionLinkFromAction(editDescriptor)
+        : new ActionLinkDescriptorInst(ActionEditorEditDescriptorInst.ACTION_NAME, {
+            model: descriptor
+        });
     action
         .withTableviewCategory(TableviewActionDefaultCategories.EDIT)
         .withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS])
@@ -4089,11 +4202,15 @@ function tableviewEditOnDetailsAction(descriptor, editDescriptor, injector) {
 }
 function tableviewDeleteAction(descriptor, injector) {
     const routeData = getRouteData(injector);
-    return !routeData?.tableviewActions || routeData.tableviewActions.hasDelete ? ActionDeleteDescriptor.create(descriptor) : null;
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasDelete ? new ActionDeleteDescriptorInst(descriptor) : null;
 }
 function tableviewDeleteActionWithProvider(descriptor, serviceProvider, injector) {
     const routeData = getRouteData(injector);
-    return !routeData?.tableviewActions || routeData.tableviewActions.hasDelete ? ActionDeleteDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasDelete
+        ? new ActionDeleteDescriptorInst(descriptor, {
+            ...actionGetProviderCfgObj(serviceProvider)
+        })
+        : null;
 }
 function tableviewDeleteOnDetailsAction(model, injector) {
     const action = tableviewDeleteAction(model, injector);
@@ -4116,7 +4233,9 @@ function tableviewDeleteOnDetailsAction(model, injector) {
     return null;
 }
 function tableviewExportAction(descriptor, injector, defaultActions) {
-    const exportAction = ActionDescriptor.fromModel(descriptor.model, 'export')
+    const exportAction = new ActionDescriptorInst('export', {
+        model: descriptor.model
+    })
         .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-download'))
         .withSubactionsAsMenu();
     const subactions = [];
@@ -4129,7 +4248,9 @@ function tableviewExportAction(descriptor, injector, defaultActions) {
 }
 function tableviewExportJsonAction(descriptor, injector) {
     const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
-    return ActionDescriptor.fromModel(descriptor.model, 'exportJson')
+    return new ActionDescriptorInst('exportJson', {
+        model: descriptor.model
+    })
         .withRunFunction(ctx => {
         const params = ctx.parameters.dataListParams ? copyDataListParams(ctx.parameters.dataListParams) : {};
         params.offset = 0;
@@ -4149,7 +4270,9 @@ function tableviewExportJsonAction(descriptor, injector) {
 }
 function tableviewExportCsvAction(descriptor, injector) {
     const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
-    return ActionDescriptor.fromModel(descriptor.model, 'exportCsv')
+    return new ActionDescriptorInst('exportCsv', {
+        model: descriptor.model
+    })
         .withRunFunction(ctx => {
         const params = ctx.parameters.dataListParams ? copyDataListParams(ctx.parameters.dataListParams) : {};
         params.offset = 0;
@@ -4173,7 +4296,9 @@ function tableviewExportCsvAction(descriptor, injector) {
         .withPosition(ActionPositionEnum.ToolbarRight);
 }
 function tableviewRefreshAction(descriptor) {
-    const action = ActionDescriptor.fromModel(descriptor, 'refresh')
+    const action = new ActionDescriptorInst('refresh', {
+        model: descriptor
+    })
         .withPosition(ActionPositionEnum.ToolbarRight)
         .withTableviewCategory(TableviewActionDefaultCategories.READ)
         .withRunNotificationSuccess(undefined, undefined, false)
@@ -4186,7 +4311,11 @@ function tableviewRefreshAction(descriptor) {
 }
 function tableviewLocalizationLanguageSelectAction(descriptor) {
     return descriptor.isLocalized()
-        ? ActionDescriptor.fromModel(descriptor.model, 'translator').withPosition(ActionPositionEnum.ToolbarLeft).withComponentFromDi(DATA_LANGUAGE_DROPDOWN_COMPONENT_IT)
+        ? new ActionDescriptorInst('translator', {
+            model: descriptor.model
+        })
+            .withPosition(ActionPositionEnum.ToolbarLeft)
+            .withComponentFromDi(DATA_LANGUAGE_DROPDOWN_COMPONENT_IT)
         : null;
 }
 
@@ -4335,7 +4464,7 @@ class TableviewInputBuilder {
      * Builds and returns an instance of ITableview.
      * DO NOT CALL this within tableview create callback function!
      *
-     * @return {ITableview<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.
+     * @return {TableviewInput<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.
      */
     build() {
         return {
@@ -4361,21 +4490,124 @@ class TableviewInputBuilder {
  * @returns A tableview instance with descriptor, data provider and actions.
  */
 function tableview(model, service, buildFn) {
-    const builder = new TableviewInputBuilder(TableviewDescriptor.fromModel(model), TableviewDataProvider.fromService(service), inject(Injector));
+    const builder = new TableviewInputBuilder(new TableviewDescriptorInst(model), new TableviewDataProviderInst(undefined, service), inject(Injector));
     buildFn?.(builder);
     return builder.build();
 }
 function tableviewWithSortAndFilter(model, service, sorts, filters, buildFn) {
-    const builder = new TableviewInputBuilder(TableviewDescriptor.fromModel(model), TableviewDataProvider.fromService(service), inject(Injector));
+    const builder = new TableviewInputBuilder(new TableviewDescriptorInst(model), new TableviewDataProviderInst(undefined, service), inject(Injector));
     buildFn?.(builder);
     return builder.build();
 }
 
+/**
+ * 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 descriptor Tableview descriptor
+ * @param property name of field
+ * @param columnType required column type
+ * @param fieldType optional, if not provided it is converted from column type
+ * @param columnDisplayType optional
+ */
+function modifyTableviewClassAttributeType(descriptor, property, columnType, fieldType, columnDisplayType) {
+    return modifyTableviewClassAttributeTypeUnsafe(descriptor, property, columnType, fieldType, columnDisplayType);
+}
+function modifyTableviewClassAttributeTypeUnsafe(descriptor, property, columnType, fieldType, columnDisplayType) {
+    if (!descriptor.model.type) {
+        throw new CommonsInternalError(`withModifiedType cannot be executed for property ${property}: Model type is not defined.`);
+    }
+    if (columnType === ColumnTypeEnum.Enum) {
+        throw new CommonsInternalError('Do not use with types where args are required', { name: 'TableviewDescriptorError' });
+    }
+    const attributeDef = getTableviewClassAttributeDef(descriptor.model.type).find(attr => attr.name === property);
+    if (attributeDef != null) {
+        fieldType ??= getFieldInputTypeFromColumnType(columnType, columnDisplayType);
+        attributeDef.fieldType = fieldType;
+        modifyTableClassAttributeColumnTypeUnsafe(descriptor.table, property, columnType, columnDisplayType);
+        modifyEditorClassAttributeFieldTypeUnsafe(descriptor.editEditor, property, fieldType);
+        modifyEditorClassAttributeFieldTypeUnsafe(descriptor.addEditor, property, fieldType);
+        modifyEditorClassAttributeFieldTypeUnsafe(descriptor.detailsEditor, property, fieldType);
+        return true;
+    }
+    return false;
+}
+/**
+ * creates column with enum type
+ * if fields exists, it is replaced
+ * @param descriptor Tableview descriptor
+ * @param property property name
+ * @param enumDesc type of enum
+ * @param fieldType type of field, optional, default is Text
+ */
+function modifyTableviewClassAttributeEnum(descriptor, property, enumDesc, fieldType) {
+    return modifyTableviewClassAttributeEnumUnsafe(descriptor, property, enumDesc, fieldType);
+}
+function modifyTableviewClassAttributeEnumUnsafe(descriptor, property, enumDesc, fieldType) {
+    if (!descriptor.model.type) {
+        throw new CommonsInternalError(`withModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);
+    }
+    const attributeDef = getTableviewClassAttributeDef(descriptor.model.type).find(attr => attr.name === property);
+    if (attributeDef != null) {
+        attributeDef.fieldType = fieldType ?? FieldInputTypeEnum.Text;
+        tableDescriptorModifyEnumColumnUnsafe(descriptor.table, property, enumDesc);
+        modifyEditorClassAttributeFieldEnumUnsafe(descriptor.editEditor, property, enumDesc);
+        modifyEditorClassAttributeFieldEnumUnsafe(descriptor.addEditor, property, enumDesc);
+        modifyEditorClassAttributeFieldEnumUnsafe(descriptor.detailsEditor, property, enumDesc);
+        return true;
+    }
+    return false;
+}
+/**
+ * generates column with custom class type
+ * field is generated only if lookupProvider is provided
+ * @param descriptor Tableview descriptor
+ * @param property property name
+ * @param type class type of object
+ * @param titleProperty
+ * @param lookupProvider
+ * @param optionsLabelProperty
+ * @param filterProperty
+ */
+function modifyTableviewLookup(descriptor, property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty) {
+    return modifyTableviewLookupUnsafe(descriptor, property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty);
+}
+function modifyTableviewLookupUnsafe(descriptor, property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty) {
+    if (!descriptor.model.type) {
+        throw new CommonsInternalError(`withModifiedLookup cannot be executed for property ${property}: Model type is not defined.`);
+    }
+    const attributeDef = getTableviewClassAttributeDef(descriptor.model.type).find(attr => attr.name === property);
+    if (attributeDef != null) {
+        type ??= attributeDef.classType ?? TypeRegistry.get().findType(attributeDef.type);
+        titleProperty ??= type ? findClassTitleAttribute(type) ?? undefined : undefined;
+        optionsLabelProperty ??= titleProperty;
+        attributeDef.columnType = ColumnTypeEnum.String;
+        attributeDef.fieldType = FieldInputTypeEnum.Text;
+        if (lookupProvider != null) {
+            modifyTableColumnFilterLookupUnsafe(descriptor.table, property, lookupProvider, optionsLabelProperty, filterProperty);
+            modifyEditorFieldLookupUnsafe(descriptor.addEditor, property, lookupProvider, optionsLabelProperty);
+            modifyEditorFieldLookupUnsafe(descriptor.detailsEditor, property, lookupProvider, optionsLabelProperty);
+            modifyEditorFieldLookupUnsafe(descriptor.editEditor, property, lookupProvider, optionsLabelProperty);
+            return true;
+        }
+        else {
+            const column = descriptor.table.getColumnUnsafe(property) ?? descriptor.addColumnUnsafe(property);
+            if (titleProperty) {
+                column.withGetter(value => value?.[titleProperty]);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
 // action descriptors
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AFieldDescriptor, AFieldGroupDescriptor, AFormlyCustomFieldComponent, AGenericFieldDescriptor, ActionActivationTriggerEnum, ActionConfirmationDescriptor, ActionDeleteDescriptor, ActionDeleteDescriptorInst, ActionDescriptor, ActionDescriptorInst, ActionEditorAddDescriptor, ActionEditorAddDescriptorInst, ActionEditorDescriptor, ActionEditorDescriptorInst, ActionEditorDetailsDescriptor, ActionEditorDetailsDescriptorInst, ActionEditorEditDescriptor, ActionEditorEditDescriptorInst, ActionEditorSubmitDescriptor, ActionEditorSubmitDescriptorInst, ActionEditorSubmitTypeEnum, ActionInstanceStateEnum, ActionLinkDescriptor, ActionLinkDescriptorInst, ActionPositionEnum, ActionTypeEnum, CommonsActionError, DATA_LANGUAGE_DROPDOWN_COMPONENT_IT, DataProviderExecutor, DynamicTableviewDataProvider, DynamicTableviewDataProviderInst, EDITOR_DEFAULT_GROUP_NAME, EditorDataProvider, EditorDataProviderInst, EditorDescriptor, EditorDescriptorInst, FieldActionDescriptor, FieldGroupDescriptor, FieldGroupTypeEnum, FieldInputDescriptor, FieldInputTypeEnum, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupTypeEnum, FieldManyEditorActionEnum, FieldManyEditorDescriptor, FieldManyEditorTypeEnum, FieldManyToManyEditorActionEnum, FieldManyToManyEditorDescriptor, FieldManyToManyEditorTypeEnum, FieldSizeEnum, FieldTabGroupDescriptor, FieldValidationDescriptor, FormEventTypeEnum, FormFieldEventComponentSubtype, FormFieldEventDialogSubtype, FormFieldEventTypeEnum, TableviewActionDefaultCategories, TableviewDataProvider, TableviewDataProviderInst, TableviewDefaultActionsEnum, TableviewDescriptor, TableviewDescriptorInst, TableviewDynamicDescriptor, TableviewDynamicDescriptorInt, TableviewEditorTypeEnum, TableviewInputBuilder, actionEditorGetProviderCfgObj, actionGetProviderCfgObj, convertDataToStringWithDelimiter, createTableviewAction, createTableviewActions, emailValidationName, emailValidator, expandClassAttributeDefWithEditorDef, expandClassAttributeDefWithTableviewDef, fieldLookupGetProviderCfgObj, fieldManyToManyGetProviderCfgObj, getDataProviderService, getEditorClassAttributeDef, getFieldInputTypeFromClassAttributeDefType, getFieldInputTypeFromColumnType, getTableviewClassAttributeDef, getTableviewDefaultActions, maxDateValidationName, maxDateValidator, minDateValidationName, minDateValidator, runCreateFromDataProvider, runDeleteFromDataProvider, runFetchFromDataProvider, runFnFromDataProviderOrFail, runFnFromDataProviderOrFallback, runGetAllFromDataProvider, runUpdateFromDataProvider, saveFileAs, tableview, tableviewAddAction, tableviewAddActionWithProvider, tableviewDeleteAction, tableviewDeleteActionWithProvider, tableviewDeleteOnDetailsAction, tableviewDetailsAction, tableviewDetailsActionWithProvider, tableviewEditAction, tableviewEditActionWithProvider, tableviewEditOnDetailsAction, tableviewExportAction, tableviewExportCsvAction, tableviewExportJsonAction, tableviewLocalizationLanguageSelectAction, tableviewRefreshAction, tableviewWithSortAndFilter };
+export { AFieldDescriptor, AFieldGroupDescriptor, AFormlyCustomFieldComponent, AGenericFieldDescriptor, ActionActivationTriggerEnum, ActionConfirmationDescriptor, ActionDeleteDescriptor, ActionDeleteDescriptorInst, ActionDescriptor, ActionDescriptorInst, ActionEditorAddDescriptor, ActionEditorAddDescriptorInst, ActionEditorDescriptor, ActionEditorDescriptorInst, ActionEditorDetailsDescriptor, ActionEditorDetailsDescriptorInst, ActionEditorEditDescriptor, ActionEditorEditDescriptorInst, ActionEditorSubmitDescriptorInst, ActionEditorSubmitTypeEnum, ActionInstanceStateEnum, ActionLinkDescriptor, ActionLinkDescriptorInst, ActionPositionEnum, ActionTypeEnum, CommonsActionError, DATA_LANGUAGE_DROPDOWN_COMPONENT_IT, DataProviderExecutor, DynamicTableviewDataProvider, DynamicTableviewDataProviderInst, EDITOR_DEFAULT_GROUP_NAME, EditorDataProvider, EditorDataProviderInst, EditorDescriptor, EditorDescriptorInst, FieldActionDescriptor, FieldGroupDescriptor, FieldGroupTypeEnum, FieldInputDescriptor, FieldInputTypeEnum, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupTypeEnum, FieldManyEditorActionEnum, FieldManyEditorDescriptor, FieldManyEditorTypeEnum, FieldManyToManyEditorActionEnum, FieldManyToManyEditorDescriptor, FieldManyToManyEditorTypeEnum, FieldSizeEnum, FieldTabGroupDescriptor, FieldValidationDescriptor, FormEventTypeEnum, FormFieldEventComponentSubtype, FormFieldEventDialogSubtype, FormFieldEventTypeEnum, TableviewActionDefaultCategories, TableviewDataProvider, TableviewDataProviderInst, TableviewDefaultActionsEnum, TableviewDescriptor, TableviewDescriptorInst, TableviewDynamicDescriptor, TableviewDynamicDescriptorInt, TableviewEditorTypeEnum, TableviewInputBuilder, action, actionDelete, actionEditor, actionEditorAdd, actionEditorCancel, actionEditorDetails, actionEditorEdit, actionEditorGetProviderCfgObj, actionEditorSubmit, actionFromClass, actionFromModel, actionGetProviderCfgObj, actionLink, actionLinkFromAction, actionLinkFromClass, actionLinkFromModel, actionWithProvider, convertDataToStringWithDelimiter, createTableviewAction, createTableviewActions, editorDataProvider, editorDataProviderFromClass, editorDataProviderFromModel, editorDataProviderWithService, editorDescriptor, editorDescriptorFromClass, editorDescriptorFromClassAttrsDef, emailValidationName, emailValidator, expandClassAttributeDefWithEditorDef, expandClassAttributeDefWithTableviewDef, fieldLookupGetProviderCfgObj, fieldManyToManyGetProviderCfgObj, getDataProviderService, getEditorClassAttributeDef, getFieldInputTypeFromClassAttributeDefType, getFieldInputTypeFromColumnType, getTableviewClassAttributeDef, getTableviewDefaultActions, maxDateValidationName, maxDateValidator, minDateValidationName, minDateValidator, modifyEditorClassAttributeFieldEnum, modifyEditorClassAttributeFieldEnumUnsafe, modifyEditorClassAttributeFieldType, modifyEditorClassAttributeFieldTypeUnsafe, modifyEditorFieldLookup, modifyEditorFieldLookupUnsafe, modifyTableviewClassAttributeEnum, modifyTableviewClassAttributeEnumUnsafe, modifyTableviewClassAttributeType, modifyTableviewClassAttributeTypeUnsafe, modifyTableviewLookup, modifyTableviewLookupUnsafe, runCreateFromDataProvider, runDeleteFromDataProvider, runFetchFromDataProvider, runFnFromDataProviderOrFail, runFnFromDataProviderOrFallback, runGetAllFromDataProvider, runUpdateFromDataProvider, saveFileAs, tableview, tableviewAddAction, tableviewAddActionWithProvider, tableviewDataProvider, tableviewDataProviderFromClass, tableviewDataProviderFromModel, tableviewDataProviderWithService, tableviewDeleteAction, tableviewDeleteActionWithProvider, tableviewDeleteOnDetailsAction, tableviewDescriptor, tableviewDescriptorFromClass, tableviewDescriptorFromClassAttrsDef, tableviewDescriptorFromParent, tableviewDetailsAction, tableviewDetailsActionWithProvider, tableviewDynamicDataProvider, tableviewDynamicDescriptor, tableviewEditAction, tableviewEditActionWithProvider, tableviewEditOnDetailsAction, tableviewExportAction, tableviewExportCsvAction, tableviewExportJsonAction, tableviewLocalizationLanguageSelectAction, tableviewRefreshAction, tableviewWithSortAndFilter, upsertEditorFieldFromAttributeDef };
 //# sourceMappingURL=mediusinc-mng-commons-tableview-api.mjs.map