@mediusinc/mng-commons 5.5.0-rc.4 → 6.0.0-rc.2

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

@@ -1,15 +1,15 @@
-import { of, Subject, throwError, isObservable, tap } from 'rxjs';
-import { StyleLevelEnum, CommonsInternalError, DataProviderInst, LoggerService, findReflectTypeName, StyleSizeEnum, ACommonsErrorBase, toObservable, fromEnumValuesAsValueArray, fromEnumConstantsAsValueArray, getEnumConstantName, TypeRegistry, GetterPipe, copyDataListParams } from '@mediusinc/mng-commons/core';
+import { of, Subject, isObservable, throwError, map, tap } from 'rxjs';
+import { StyleLevelEnum, CommonsInternalError, DataProviderInst, LoggerService, findReflectTypeName, StyleSizeEnum, ACommonsErrorBase, toObservable, fromEnumValuesAsValueArray, fromEnumConstantsAsValueArray, getEnumConstantName, 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 { TableDataProviderInst, ColumnTypeEnum, ColumnDisplayTypeEnum, getColumnTypeFromClassAttributeDefType, getColumnDisplayTypeFromColumnType, TableDescriptorInst, TableDynamicDescriptorInst, tableDescriptorFromClassAttrsDef, modifyTableClassAttributeColumnTypeUnsafe, tableDescriptorModifyEnumColumnUnsafe, modifyTableColumnFilterLookupUnsafe } from '@mediusinc/mng-commons/table/api';
+import { TableDataProviderInst, TableDescriptorInst, TableDynamicDescriptorInst } from '@mediusinc/mng-commons/table/api';
+import { model, ModelDescriptor } from '@mediusinc/mng-commons/model';
 import '@angular/forms';
 import { FieldType } from '@ngx-formly/core';
 import { ActivatedRoute } from '@angular/router';
 import { TranslateService } from '@ngx-translate/core';
-import { map } from 'rxjs/operators';
+import { map as map$1 } from 'rxjs/operators';
 
 var ActionPositionEnum;
 (function (ActionPositionEnum) {
@@ -37,17 +37,6 @@ var ActionEditorSubmitTypeEnum;
     ActionEditorSubmitTypeEnum[ActionEditorSubmitTypeEnum["Cancel"] = 1] = "Cancel";
 })(ActionEditorSubmitTypeEnum || (ActionEditorSubmitTypeEnum = {}));
 
-/**
- * Default categories for tableview actions
- */
-class TableviewActionDefaultCategories {
-    static { this.READ = 'read'; }
-    static { this.ADD = 'add'; }
-    static { this.EDIT = 'edit'; }
-    static { this.DELETE = 'delete'; }
-    static { this.DETAILS = 'details'; }
-}
-
 class ActionConfirmationDescriptor {
     constructor() {
         this._closeOnEscape = true; // Defines if dialog closes when esc key is pressed.
@@ -159,7 +148,7 @@ class ActionDescriptorInst {
         this._parentProperty = cfg?.parentProperty;
         this.setI18nModelActionBaseKey();
         if (cfg?.serviceType) {
-            this._dataProvider = new DataProviderInst(this._model?.type, cfg.serviceType);
+            this._dataProvider = new DataProviderInst(cfg.serviceType);
         }
         else if (cfg?.dataProvider) {
             this._dataProvider = cfg.dataProvider;
@@ -355,8 +344,8 @@ class ActionDescriptorInst {
         this._permissions = permissions;
         return this;
     }
-    withTableviewCategory(permissionsRouteType) {
-        this._tableviewCategory = permissionsRouteType;
+    withTableviewCategory(category) {
+        this._tableviewCategory = category;
         return this;
     }
     withButtonDescriptor(button) {
@@ -426,7 +415,7 @@ class ActionDescriptorInst {
             descriptor._afterRunAction = typeof this._afterRunAction === 'function' ? this._afterRunAction : this._afterRunAction.copy();
         }
         if (this._onRunErrorAction != null) {
-            descriptor._onRunErrorAction = typeof this._onRunErrorAction === 'function' ? this._afterRunAction : this._onRunErrorAction.copy();
+            descriptor._onRunErrorAction = typeof this._onRunErrorAction === 'function' ? this._onRunErrorAction : this._onRunErrorAction.copy();
         }
         descriptor._permissions = this._permissions;
         descriptor._button = this._button.copy();
@@ -448,28 +437,6 @@ 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');
-    }
-    copy() {
-        if (!this.model) {
-            throw new CommonsInternalError(`Model should be defined on action ${this.actionName} of instance ActionDeleteDescriptorInst`);
-        }
-        const descriptor = new ActionDeleteDescriptorInst(this.model.copy(), {
-            dataProvider: this._dataProvider
-        });
-        this.copyFieldsTo(descriptor);
-        return descriptor;
-    }
-}
 
 const actionGetProviderCfgObj = (serviceOrDataProvider) => {
     const cfg = {};
@@ -484,115 +451,24 @@ const actionGetProviderCfgObj = (serviceOrDataProvider) => {
     }
     return cfg;
 };
-class ActionDescriptor extends ActionDescriptorInst {
-    constructor() {
-        super('internal');
-    }
-    static create(actionName, cfg) {
-        return action(actionName, {
-            ...cfg
-        });
-    }
-    static createWithProvider(serviceProvider, actionName, cfg) {
-        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
-        });
-    }
-}
-function actionWithProvider(typeOrServiceProvider, serviceProviderOrActionName, actionNameOrCfg, cfg) {
-    const actionName = typeof serviceProviderOrActionName === 'string' ? serviceProviderOrActionName : typeof actionNameOrCfg === 'string' ? actionNameOrCfg : 'default';
-    if (typeOrServiceProvider instanceof TypeDescriptor) {
-        return new ActionDescriptorInst(actionName, {
-            ...(typeof serviceProviderOrActionName === 'string' ? {} : actionGetProviderCfgObj(serviceProviderOrActionName)),
-            ...(typeof actionNameOrCfg === 'string' ? {} : actionNameOrCfg),
-            ...cfg
-        });
-    }
-    else {
-        return new ActionDescriptorInst(actionName, {
-            ...actionGetProviderCfgObj(typeOrServiceProvider),
-            ...cfg
-        });
-    }
-}
-function actionFromModel(model, actionNameOrServiceProvider, cfgOrActionName, cfg) {
-    if (typeof actionNameOrServiceProvider === 'string') {
-        // no provider
-        return new ActionDescriptorInst(actionNameOrServiceProvider, {
-            model,
-            ...(typeof cfgOrActionName === 'object' ? cfgOrActionName : {}),
-            ...cfg
-        });
-    }
-    else {
-        return new ActionDescriptorInst(typeof cfgOrActionName === 'string' ? cfgOrActionName : 'default', {
-            model,
-            ...actionGetProviderCfgObj(actionNameOrServiceProvider),
-            ...cfg
-        });
-    }
-}
-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 actionDelete(model);
-    }
-    static createWithProvider(model, serviceProvider) {
-        return actionDelete(model, serviceProvider);
-    }
-}
-function actionDelete(model, serviceProvider) {
-    return new ActionDeleteDescriptorInst(model, {
-        ...(serviceProvider ? actionGetProviderCfgObj(serviceProvider) : {})
+/**
+ * Creates and returns an instance of ActionDescriptorInst, allowing customization of the action's behavior through configuration options.
+ *
+ * @param {string} actionName - The unique name of the action.
+ * @param {ActionDescriptorCreateFromModelOptsType<Model, Service, RunInput, RunResult, ValidationInput>} [opts] - Optional configuration object to define the action's behavior, including model, service provider and other.
+ * @return {ActionDescriptorInst<Model, Service, RunInput, RunResult, ValidationInput>} An instance of ActionDescriptorInst configured with the provided parameters.
+ */
+function action(actionName, opts) {
+    return new ActionDescriptorInst(actionName, {
+        ...(opts?.serviceProvider ? actionGetProviderCfgObj(opts.serviceProvider) : {}),
+        ...opts
     });
 }
 
 class EditorDataProviderInst extends DataProviderInst {
-    constructor(type, serviceType) {
-        super(type, serviceType);
+    constructor(serviceType) {
+        super(serviceType);
         this._editorResetSubject = new Subject();
-        this._fetch = id => throwError(() => new CommonsInternalError(`No fetch function provided for id ${id}.`));
     }
     get fetch() {
         return this._fetch;
@@ -606,6 +482,12 @@ class EditorDataProviderInst extends DataProviderInst {
     get delete() {
         return this._delete;
     }
+    get mapFetchItemToCreateItem() {
+        return this._mapFetchItemToCreateItem;
+    }
+    get mapFetchItemToUpdateItem() {
+        return this._mapFetchItemToUpdateItem;
+    }
     get editorReset$() {
         return this._editorResetSubject.asObservable();
     }
@@ -625,7 +507,7 @@ class EditorDataProviderInst extends DataProviderInst {
     /**
      * Sets the create function for the EditorDataProvider.
      *
-     * @param {EditorDataProviderCreateFnType<Model, Service>} fn - The function used for creating new items.
+     * @param {EditorDataProviderCreateFnType<CreateModel, Model, Service>} fn - The function used for creating new items.
      * @returns {this} - Returns the instance of the class.
      *
      * @typeparam Model The type of data this DataProvider will handle.
@@ -662,16 +544,43 @@ class EditorDataProviderInst extends DataProviderInst {
         this._delete = fn;
         return this;
     }
+    /**
+     * Sets the function to map data from fetch function to create model.
+     *
+     * @param {EditorDataProviderFetchMapToFnType<Model, CreateModel>} fn - The map function to be set.
+     *
+     * @returns {this} - Returns the instance of the current class.
+     *
+     * @typeparam Model The type of data from fetch function to map from.
+     * @typeparam CreateModel The type of data to map to.
+     */
+    withMapFetchItemToCreateItem(fn) {
+        this._mapFetchItemToCreateItem = fn;
+        return this;
+    }
+    /**
+     * Sets the function to map data from fetch function to update model.
+     *
+     * @param {EditorDataProviderFetchMapToFnType<Model, UpdateModel>} fn - The map function to be set.
+     *
+     * @returns {this} - Returns the instance of the current class.
+     *
+     * @typeparam Model The type of data from fetch function to map from.
+     * @typeparam UpdateModel The type of data to map to.
+     */
+    withMapFetchItemToUpdateItem(fn) {
+        this._mapFetchItemToUpdateItem = fn;
+        return this;
+    }
     resetEditor(event) {
         this._editorResetSubject.next(event ?? {});
     }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 class ActionEditorDescriptorInst extends ActionDescriptorInst {
     constructor(editorDescriptor, actionName, cfg) {
         super(actionName, {
-            model: editorDescriptor.model,
+            model: cfg?.model ?? editorDescriptor.model,
             ...cfg
         });
         this._dataProvider = undefined;
@@ -682,9 +591,8 @@ class ActionEditorDescriptorInst extends ActionDescriptorInst {
         this._dialogSize = StyleSizeEnum.Normal;
         this._resubmitRefetch = true;
         this._unsavedChangesConfirmation = false;
-        this._isTableviewMainEditor = cfg?.isTableviewMainEditor ?? false;
         if (cfg?.serviceType) {
-            this._dataProvider = new EditorDataProviderInst(this._model?.type, cfg.serviceType);
+            this._dataProvider = new EditorDataProviderInst(cfg.serviceType);
         }
         else if (cfg?.dataProvider) {
             this._dataProvider = cfg.dataProvider;
@@ -693,9 +601,6 @@ class ActionEditorDescriptorInst extends ActionDescriptorInst {
         this._editorDescriptor = editorDescriptor;
         this._editorActions.push(actionEditorSubmit(this), actionEditorCancel(this));
     }
-    get isTableviewMainEditor() {
-        return this._isTableviewMainEditor;
-    }
     get editorTitle() {
         return this._editorTitle;
     }
@@ -876,60 +781,6 @@ function actionEditorSubmit(editorAction, submitType = ActionEditorSubmitTypeEnu
 function actionEditorCancel(editorAction, submitType = ActionEditorSubmitTypeEnum.Cancel) {
     return new ActionEditorSubmitDescriptorInst(editorAction.actionName, editorAction.model, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withTextButton().withActionLevel(editorAction.level)));
 }
-class ActionEditorDetailsDescriptorInst extends ActionEditorDescriptorInst {
-    static { this.ACTION_NAME = 'details'; }
-    constructor(editorDescriptor, cfg) {
-        super(editorDescriptor, ActionEditorDetailsDescriptorInst.ACTION_NAME, { ...cfg, isTableviewMainEditor: true });
-        this.withPosition(ActionPositionEnum.RowClick);
-        this.withRouteTrigger(':itemId');
-        this.withEditorActions([actionEditorCancel(this)]);
-        this.withTableviewCategory(TableviewActionDefaultCategories.DETAILS);
-    }
-    copy() {
-        const descriptor = new ActionEditorDetailsDescriptorInst(this.editorDescriptor.copy(), {
-            dataProvider: this._dataProvider
-        });
-        this.copyFieldsTo(descriptor);
-        return descriptor;
-    }
-}
-class ActionEditorAddDescriptorInst extends ActionEditorDescriptorInst {
-    static { this.ACTION_NAME = 'add'; }
-    constructor(editorDescriptor, cfg) {
-        super(editorDescriptor, ActionEditorAddDescriptorInst.ACTION_NAME, { ...cfg, isTableviewMainEditor: true });
-        this.withPosition(ActionPositionEnum.ToolbarLeft);
-        this.withRouteTrigger('add');
-        this.button.withIcon('pi pi-plus');
-        this.withTableviewCategory(TableviewActionDefaultCategories.ADD);
-        this.withUnsavedChangesConfirmation();
-    }
-    copy() {
-        const descriptor = new ActionEditorAddDescriptorInst(this.editorDescriptor.copy(), {
-            dataProvider: this._dataProvider
-        });
-        this.copyFieldsTo(descriptor);
-        return descriptor;
-    }
-}
-class ActionEditorEditDescriptorInst extends ActionEditorDescriptorInst {
-    static { this.ACTION_NAME = 'edit'; }
-    constructor(editorDescriptor, cfg) {
-        super(editorDescriptor, ActionEditorEditDescriptorInst.ACTION_NAME, { ...cfg, isTableviewMainEditor: true });
-        this.withPosition(ActionPositionEnum.RowInline);
-        this.button.styleClass.withSize(StyleSizeEnum.Small);
-        this.withRouteTrigger(':itemId/edit');
-        this.withTableviewCategory(TableviewActionDefaultCategories.EDIT);
-        this.button.withLabel(null).withIcon('pi pi-pencil');
-        this.withUnsavedChangesConfirmation();
-    }
-    copy() {
-        const descriptor = new ActionEditorEditDescriptorInst(this.editorDescriptor.copy(), {
-            dataProvider: this._dataProvider
-        });
-        this.copyFieldsTo(descriptor);
-        return descriptor;
-    }
-}
 
 const actionEditorGetProviderCfgObj = (serviceOrDataProvider) => {
     const cfg = {};
@@ -944,66 +795,19 @@ const actionEditorGetProviderCfgObj = (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 actionEditorEdit(editor);
-    }
-    static createWithProvider(editor, serviceProvider) {
-        return actionEditorEdit(editor, serviceProvider);
-    }
-}
-function actionEditorEdit(editor, serviceProvider) {
-    return new ActionEditorEditDescriptorInst(editor, {
-        ...(serviceProvider ? actionEditorGetProviderCfgObj(serviceProvider) : {})
+/**
+ * Creates an ActionEditorDescriptorInst instance with the provided editor descriptor and options.
+ *
+ * @param {string} actionName - The name of the action to associate with the editor.
+ * @param {EditorDescriptorInst<EditorModel, any>} editor - The editor descriptor instance to be used.
+ * @param {ActionEditorDescriptorOptsType<Model, Service, FetchInput, SubmitReturn, ValidationInput>} [opts] - Optional configuration options for the ActionEditor.
+ * @return {ActionEditorDescriptorInst<Model, Service, EditorModel, FetchInput, SubmitReturn, ValidationInput>} An instance of ActionEditorDescriptor with the configured parameters.
+ */
+function actionEditor(actionName, editor, opts) {
+    return new ActionEditorDescriptorInst(editor, actionName, {
+        ...opts,
+        ...(opts?.serviceProvider ? actionEditorGetProviderCfgObj(opts.serviceProvider) : {}),
+        model: opts?.model
     });
 }
 
@@ -1080,37 +884,25 @@ class ActionLinkDescriptorInst extends ActionDescriptorInst {
     }
 }
 
-class ActionLinkDescriptor {
-    static create(actionName, cfg) {
-        return actionLink(actionName, cfg);
-    }
-    static fromModel(model, actionName, cfg) {
-        return actionLinkFromModel(model, actionName, cfg);
-    }
-    static fromClass(type, actionName, cfg) {
-        return actionLinkFromClass(type, actionName, cfg);
-    }
-    static fromAction(action) {
-        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) {
+/**
+ * Creates an instance of ActionLinkDescriptorInst with the provided action name and options.
+ *
+ * @param {string} actionName - The unique name of the action.
+ * @param {ActionLinkCreateOptsType<Model, ValidationInput>} [opts] - Optional parameters for configuring the action link, including the model and validation type.
+ * @return {ActionLinkDescriptorInst<Model, ValidationInput>} An instance of ActionLinkDescriptorInst initialized with the action name and options.
+ */
+function actionLink(actionName, opts) {
     return new ActionLinkDescriptorInst(actionName, {
-        model: ModelDescriptor.fromClass(type, cfg?.idProperty, cfg?.titleProperty, cfg?.i18nBaseKey),
-        ...cfg
+        ...opts,
+        model: opts?.model
     });
 }
+/**
+ * Generates an ActionLinkDescriptorInst from the provided ActionDescriptorInst.
+ *
+ * @param {ActionDescriptorInst<Model, any, any, any, ValidationInput>} action - The action descriptor instance that serves as the basis for the action link.
+ * @return {ActionLinkDescriptorInst<Model, ValidationInput>} A newly created ActionLinkDescriptorInst configured with the provided action parameters.
+ */
 function actionLinkFromAction(action) {
     const descriptor = new ActionLinkDescriptorInst(action.actionName, { model: action.model });
     action.copyFieldsTo(descriptor);
@@ -1123,6 +915,113 @@ function actionLinkFromAction(action) {
     return descriptor;
 }
 
+/**
+ * Defines an action to be positioned on a specified editor with editor-specific execution context.
+ *
+ * @param {string} actionName - The name identifying the action to be performed.
+ * @param {EditorDescriptorInst<EditorModel>} editor - The descriptor of the editor on which the action will be placed and executed.
+ * @param {Object} [opts] - Options for configuring the action behavior.
+ * @param {ModelDescriptor<Model>} [opts.model] - The model descriptor associated with the action.
+ * @param {ActionProviderType<Model, Service>} [opts.serviceProvider] - The service provider type for execution context.
+ * @param {ActionPositionEnum.FooterLeft | ActionPositionEnum.FooterRight | ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight} [opts.position] - The position of action on editor.
+ * @return {ActionDescriptorInst<Model, Service, EditorModel, Model, EditorModel>} - An instance representing the configured action descriptor for the specified editor and model.
+ */
+function actionOnEditor(actionName, editor, opts) {
+    return new ActionDescriptorInst(actionName, {
+        model: opts?.model,
+        ...(opts?.serviceProvider ? actionGetProviderCfgObj(opts?.serviceProvider) : {})
+    }).withPosition(opts?.position ?? ActionPositionEnum.FooterLeft);
+}
+
+/**
+ * Creates and returns an instance of `ActionEditorDescriptorInst` when positioned on another (parent) editor.
+ *
+ * @param {string} actionName - The name of the action associated with the editor.
+ * @param {EditorDescriptorInst<EditorModel, ParentEditor>} editor - The editor descriptor defining editor on action.
+ * @param {Object} [opts] - Optional parameters for configuring the action editor.
+ * @param {ModelDescriptor<Model>} [opts.model] - The descriptor for the model associated with the action.
+ * @param {ActionEditorProviderType<Model, Service>} [opts.serviceProvider] - The service provider type for the action editor.
+ * @param {ActionPositionEnum.FooterLeft | ActionPositionEnum.FooterRight | ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight} [opts.position] - The desired position of action on the editor.
+ * @return {ActionEditorDescriptorInst<Model, Service, EditorModel, ParentEditor, EditorModel, ParentEditor>} A configured instance of `ActionEditorDescriptorInst` representing the action editor.
+ */
+function actionEditorOnEditor(actionName, editor, opts) {
+    return new ActionEditorDescriptorInst(editor, actionName, {
+        model: opts?.model,
+        ...(opts?.serviceProvider ? actionEditorGetProviderCfgObj(opts.serviceProvider) : {})
+    }).withPosition(opts?.position ?? ActionPositionEnum.FooterLeft);
+}
+
+/**
+ * Defines an action to be positioned on a specified table with table row execution context.
+ *
+ * @param {string} actionName - The name identifying the action to be performed.
+ * @param {TableDescriptorInst<TableModel, any, any>} table - The descriptor of the table on which the action will be placed and executed.
+ * @param {Object} [opts] - Options for configuring the action behavior.
+ * @param {ModelDescriptor<Model>} [opts.model] - The model descriptor associated with the action.
+ * @param {ActionProviderType<Model, Service>} [opts.serviceProvider] - The service provider type for execution context.
+ * @param {ActionPositionEnum.RowInline | ActionPositionEnum.RowClick} [opts.position] - The position of action on table.
+ * @return {ActionDescriptorInst<Model, Service, TableModel, Model, TableModel>} - An instance representing the configured action descriptor for the specified table row and model.
+ */
+function actionOnTableRow(actionName, table, opts) {
+    return new ActionDescriptorInst(actionName, {
+        model: opts?.model,
+        ...(opts?.serviceProvider ? actionGetProviderCfgObj(opts?.serviceProvider) : {})
+    }).withPosition(opts?.position ?? ActionPositionEnum.RowInline);
+}
+/**
+ * Defines an action to be positioned on a specified table with table header or footer execution context.
+ *
+ * @param {string} actionName - The name identifying the action to be performed.
+ * @param {Object} [opts] - Options for configuring the action behavior.
+ * @param {ModelDescriptor<Model>} [opts.model] - The model descriptor associated with the action.
+ * @param {ActionProviderType<Model, Service>} [opts.serviceProvider] - The service provider type for execution context.
+ * @param {ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight | ActionPositionEnum.TableHeader} [opts.position] - The position of action on table.
+ * @return {ActionDescriptorInst<Model, Service, TableModel, Model, TableModel>} - An instance representing the configured action descriptor for the specified table top and model.
+ */
+function actionOnTableTop(actionName, opts) {
+    return new ActionDescriptorInst(actionName, {
+        model: opts?.model,
+        ...(opts?.serviceProvider ? actionGetProviderCfgObj(opts?.serviceProvider) : {})
+    }).withPosition(opts?.position ?? ActionPositionEnum.ToolbarLeft);
+}
+
+/**
+ * Creates and returns an ActionEditorDescriptorInst for displaying editor action on table row.
+ *
+ * @param {string} actionName - The name of the action.
+ * @param {EditorDescriptorInst<EditorModel, any>} editor - The editor descriptor instance responsible for configuring the editor behavior.
+ * @param {TableDescriptorInst<TableModel, any, any>} table - The table descriptor instance representing the table on which the action is positioned.
+ * @param {Object} [opts] - Optional configurations for the action editor.
+ * @param {ModelDescriptor<Model>} [opts.model] - The model descriptor associated with the action editor.
+ * @param {ActionEditorProviderType<Model, Service>} [opts.serviceProvider] - The service provider for additional configurations or services for the action editor.
+ * @param {ActionPositionEnum.RowInline | ActionPositionEnum.RowClick} [opts.position] - The position where the action should be displayed on the table row.
+ * @return {ActionEditorDescriptorInst<Model, Service, EditorModel, TableModel, EditorModel, TableModel>} The configured action editor descriptor instance.
+ */
+function actionEditorOnTableRow(actionName, editor, table, opts) {
+    return new ActionEditorDescriptorInst(editor, actionName, {
+        model: opts?.model,
+        ...(opts?.serviceProvider ? actionEditorGetProviderCfgObj(opts.serviceProvider) : {})
+    }).withPosition(opts?.position ?? ActionPositionEnum.RowInline);
+}
+/**
+ * Creates and returns an action editor descriptor configured with the given parameters.
+ * This is used to define an action editor positioned relative to a table.
+ *
+ * @param {string} actionName - The name of the action.
+ * @param {EditorDescriptorInst<EditorModel, any>} editor - The editor descriptor instance responsible for configuring the editor behavior.
+ * @param {Object} [opts] - Optional configurations for the action editor.
+ * @param {ModelDescriptor<Model>} [opts.model] - The model descriptor associated with the action editor.
+ * @param {ActionEditorProviderType<Model, Service>} [opts.serviceProvider] - The service provider for additional configurations or services for the action editor.
+ * @param {ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight | ActionPositionEnum.TableHeader} [opts.position] - The position of the action on the table.
+ * @return {ActionEditorDescriptorInst<Model, Service, EditorModel, undefined, EditorModel, undefined>} The configured action editor descriptor instance.
+ */
+function actionEditorOnTableTop(actionName, editor, opts) {
+    return new ActionEditorDescriptorInst(editor, actionName, {
+        model: opts?.model,
+        ...(opts?.serviceProvider ? actionEditorGetProviderCfgObj(opts.serviceProvider) : {})
+    }).withPosition(opts?.position ?? ActionPositionEnum.ToolbarLeft);
+}
+
 class CommonsActionError extends ACommonsErrorBase {
     constructor(message, actionName, options) {
         super(message, {
@@ -1158,11 +1057,31 @@ function runGetAllFromDataProvider(ctx) {
     }
     return null;
 }
-function runFetchFromDataProvider(ctx) {
+function runFetchFromDataProvider(ctx, opts) {
     if (typeof ctx.dataProvider !== 'undefined') {
         const editorDataProvider = ctx.dataProvider;
         if (typeof editorDataProvider.fetch === 'function') {
-            return ctx.parameters?.itemId ? toObservable(editorDataProvider.fetch(ctx.parameters.itemId, ctx.serviceInstance, ctx.parameters.locale)) : null;
+            return ctx.parameters?.itemId
+                ? toObservable(editorDataProvider.fetch(ctx.parameters.itemId, ctx.serviceInstance, ctx.parameters.locale)).pipe(map(res => {
+                    if (opts?.reason === 'update') {
+                        if (opts?.strict && typeof editorDataProvider.mapFetchItemToUpdateItem !== 'function') {
+                            throw new CommonsInternalError(`mapFetchToUpdate function must be provided in data provider`);
+                        }
+                        else if (typeof editorDataProvider.mapFetchItemToUpdateItem === 'function') {
+                            return editorDataProvider.mapFetchItemToUpdateItem(res);
+                        }
+                    }
+                    else if (opts?.reason === 'create') {
+                        if (opts?.strict && typeof editorDataProvider.mapFetchItemToCreateItem !== 'function') {
+                            throw new CommonsInternalError(`mapFetchToCreate function must be provided in data provider`);
+                        }
+                        else if (typeof editorDataProvider.mapFetchItemToCreateItem === 'function') {
+                            return editorDataProvider.mapFetchItemToCreateItem(res);
+                        }
+                    }
+                    return res;
+                }))
+                : null;
         }
     }
     return null;
@@ -1189,7 +1108,7 @@ function runDeleteFromDataProvider(ctx) {
     if (typeof ctx.dataProvider !== 'undefined') {
         const editorDataProvider = ctx.dataProvider;
         if (typeof editorDataProvider.delete === 'function') {
-            return ctx.parameters?.itemId ? toObservable(editorDataProvider.delete(ctx.parameters.itemId, ctx.parameters.item, ctx.serviceInstance)) : null;
+            return ctx.parameters?.itemId ? toObservable(editorDataProvider.delete(ctx.parameters.itemId, ctx.serviceInstance, ctx.parameters.item)) : null; // this is not exactly correct cast as the delete function should never receive Item, but in many cases it ain't so
         }
     }
     return null;
@@ -1245,14 +1164,25 @@ var ActionInstanceStateEnum;
     ActionInstanceStateEnum[ActionInstanceStateEnum["FinishRouteUntriggerTimeoutFinal"] = 24] = "FinishRouteUntriggerTimeoutFinal";
 })(ActionInstanceStateEnum || (ActionInstanceStateEnum = {}));
 
+/**
+ * Default categories for tableview actions
+ */
+class TableviewActionDefaultCategories {
+    static { this.READ = '_defaultTwRead'; }
+    static { this.ADD = '_defaultTwAdd'; }
+    static { this.EDIT = '_defaultTwEdit'; }
+    static { this.DELETE = '_defaultTwDelete'; }
+    static { this.DETAILS = '_defaultTwDetails'; }
+}
+
 const DATA_LANGUAGE_DROPDOWN_COMPONENT_IT = new InjectionToken('DATA_LANGUAGE_DROPDOWN_COMPONENT');
 
 class DataProviderExecutor {
     runGetAllOrFail(ctx) {
         return runFnFromDataProviderOrFail(ctx, this.runGetAll.bind(this));
     }
-    runFetchOrFail(ctx) {
-        return runFnFromDataProviderOrFail(ctx, this.runFetch.bind(this));
+    runFetchOrFail(ctx, fetchReason) {
+        return runFnFromDataProviderOrFail(ctx, ctx => this.runFetch(ctx, fetchReason));
     }
     runCreateOrFail(ctx) {
         return runFnFromDataProviderOrFail(ctx, this.runCreate.bind(this));
@@ -1274,36 +1204,68 @@ class DataProviderExecutor {
     }
 }
 
-class EditorDataProvider extends EditorDataProviderInst {
-    constructor() {
-        super(undefined, undefined);
+/**
+ * Creates and returns an instance of `EditorDataProviderInst` with the specified options for managing editor data.
+ *
+ * @param {Object} [opts] - The options object to configure the data provider.
+ * @param {TypeDescriptor<Model> | ModelDescriptor<Model>} [opts.type] - The descriptor defining the type of model.
+ * @param {ServiceClassType<Service>} [opts.service] - The service class type associated with the data provider.
+ * @param {TypeDescriptor<CreateModel> | ModelDescriptor<CreateModel>} [opts.createType] - The descriptor defining the create type.
+ * @param {TypeDescriptor<UpdateModel> | ModelDescriptor<UpdateModel>} [opts.updateType] - The descriptor defining the update type.
+ * @return {EditorDataProviderInst<Model, Service, ServiceClass, CreateModel, UpdateModel>} An instance of `EditorDataProviderInst` configured according to the provided options.
+ */
+function editorDataProvider(opts) {
+    return new EditorDataProviderInst(opts?.service);
+}
+
+/**
+ * @experimental
+ */
+class EditorDescriptorNestedObjectWrapper {
+    #path;
+    #editor;
+    constructor(editor, basePath) {
+        this.#editor = editor;
+        this.#path = basePath;
     }
-    static create() {
-        return editorDataProvider();
+    nested(property) {
+        return new EditorDescriptorNestedObjectWrapper(this.#editor, this.getNestedPropertyPath(property));
     }
-    static fromClass(type) {
-        return editorDataProviderFromClass(type);
+    getNestedPropertyPath(p) {
+        return `${this.#path}.${p}`;
     }
-    static fromClassWithService(type, serviceType) {
-        return editorDataProviderFromClass(type, serviceType);
+    getField(property) {
+        return this.#editor.getFieldUnsafe(this.getNestedPropertyPath(property));
     }
-    static fromService(serviceType) {
-        return editorDataProviderWithService(serviceType);
+    removeField(property) {
+        this.#editor.removeFieldUnsafe(this.getNestedPropertyPath(property));
+    }
+    addField(property) {
+        return this.#editor.addFieldUnsafe(this.getNestedPropertyPath(property));
+    }
+    withFields(...properties) {
+        properties.forEach(p => this.#editor.addFieldUnsafe(this.getNestedPropertyPath(p)));
+        return this;
+    }
+    addFieldLookup(property, opts) {
+        return this.#editor.addFieldLookupUnsafe(this.getNestedPropertyPath(property), opts);
+    }
+    addFieldLookupEnum(property, enumModel, options) {
+        return this.#editor.addFieldLookupEnumUnsafe(this.getNestedPropertyPath(property), enumModel, options);
+    }
+    addFieldManyEditor(property, tableviewDescriptor) {
+        return this.#editor.addFieldManyEditorUnsafe(this.getNestedPropertyPath(property), tableviewDescriptor);
+    }
+    addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider) {
+        return this.#editor.addFieldManyToManyEditorUnsafe(this.getNestedPropertyPath(property), mainTableDescriptor, lookupTableDescriptor, lookupDataProvider);
+    }
+    addFieldDescriptor(field) {
+        if (!field.property.startsWith(this.#path)) {
+            throw new CommonsInternalError(`Field ${field.property} cannot be added to nested object property ${this.#path}: Paths do not match.`);
+        }
+        this.#editor.addFieldDescriptor(field);
+        return this;
     }
-}
-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;
@@ -1444,6 +1406,9 @@ class AFieldDescriptor extends AGenericFieldDescriptor {
     get label() {
         return this._label;
     }
+    get labelUseModelBase() {
+        return this._labelUseModelBase;
+    }
     get placeholder() {
         return this._placeholder;
     }
@@ -1537,8 +1502,14 @@ class AFieldDescriptor extends AGenericFieldDescriptor {
     get isLocalized() {
         return this._isLocalized;
     }
-    withLabel(label) {
+    /**
+     * Set label for field.
+     * @param label Full label (i18n path or other string). If null, no label will be used.
+     * @param useModelBase If set to true, label will be appended to model's i18n base path.
+     */
+    withLabel(label, useModelBase) {
         this._label = label;
+        this._labelUseModelBase = useModelBase;
         return this;
     }
     withPlaceholder(placeholder) {
@@ -1863,10 +1834,9 @@ class FieldLookupDescriptor extends AFieldDescriptor {
             this._dataProvider = cfg.dataProvider;
         }
         else {
-            this._dataProvider = new LookupDataProviderInst(cfg?.type, cfg?.serviceType);
+            this._dataProvider = new LookupDataProviderInst(cfg?.serviceType);
         }
         this._optionsValueProperty = cfg?.optionsValueProperty;
-        trySetLookupItemsProperties(this);
     }
     get lookupType() {
         return this._lookupType;
@@ -1992,7 +1962,7 @@ class FieldLookupDescriptor extends AFieldDescriptor {
 class FieldLookupEnumDescriptor extends FieldLookupDescriptor {
     constructor(property, enumModel, options) {
         super(property, {
-            dataProvider: new LookupDataProviderInst(undefined, undefined),
+            dataProvider: new LookupDataProviderInst(undefined),
             optionsValueProperty: 'value'
         });
         this._enumModel = enumModel;
@@ -2075,7 +2045,7 @@ class FieldManyToManyEditorDescriptor extends AFieldDescriptor {
             this._lookupTableDataProvider = cfg.lookupDataProvider;
         }
         else {
-            this._lookupTableDataProvider = new TableDataProviderInst(lookupTableDescriptor.model.type, cfg?.lookupServiceType);
+            this._lookupTableDataProvider = new TableDataProviderInst(cfg?.lookupServiceType);
         }
     }
     get fieldType() {
@@ -2119,22 +2089,6 @@ class FieldManyToManyEditorDescriptor extends AFieldDescriptor {
         this._excludeValueProperty = valueProperty;
         return this;
     }
-    /**
-     * @deprecated Use directly on lookup table descriptor.
-     */
-    withSearch(enabled = true, searchFields) {
-        return this.withSearchUnsafe(enabled, searchFields);
-    }
-    /**
-     * @deprecated Use directly on lookup table descriptor.
-     */
-    withSearchUnsafe(enabled = true, searchFields) {
-        this.lookupTableDescriptor.withSearchUnsafe(enabled, {
-            fields: searchFields,
-            limitMaxWords: 100
-        });
-        return this;
-    }
     copy() {
         const field = new FieldManyToManyEditorDescriptor(this._property, this._mainTableDescriptor.copy(), this._lookupTableDescriptor.copy(), {
             lookupDataProvider: this.lookupTableDataProvider
@@ -2670,28 +2624,58 @@ class EditorDescriptorInst {
     get autofocusOnField() {
         return this._autofocusOnField;
     }
+    /**
+     * Dives into nested object to add fields from the nested object on property.
+     *
+     * @experimental
+     *
+     * @param property Model property name.
+     */
+    nested(property) {
+        return new EditorDescriptorNestedObjectWrapper(this, property);
+    }
     /**
      * Creates new tab group. Next added fields are added to newly created tab group.
      * @param name Name of the group.
-     * @param title Title key for the tab.
+     * @param title Title key for the tab.7@return Newly created group descriptor.
+     * @return Newly created group descriptor.
      */
-    createTabGroup(name, title) {
+    addTabGroup(name, title) {
         const tabGroup = new FieldTabGroupDescriptor(name);
         tabGroup.withTitle(title);
         this.createTabGroupDescriptor(tabGroup);
         return tabGroup;
     }
+    /**
+     * Creates new tab group. Next added fields are added to newly created tab group.
+     * @param name Name of the group.
+     * @param title Title key for the tab.7@return Newly created group descriptor.
+     */
+    withTabGroup(name, title) {
+        this.addTabGroup(name, title);
+        return this;
+    }
     /**
      * Creates new field group. Next added fields are added to newly created field group.
      * @param name Name of the group.
      * @param title Title key for the group.
+     * @return Newly created group descriptor.
      */
-    createFieldGroup(name, title) {
+    addFieldGroup(name, title) {
         const fieldGroup = new FieldGroupDescriptor(name);
         fieldGroup.withTitle(title);
         this.createFieldGroupDescriptor(fieldGroup);
         return fieldGroup;
     }
+    /**
+     * Creates new field group. Next added fields are added to newly created field group.
+     * @param name Name of the group.
+     * @param title Title key for the group.
+     */
+    withFieldGroup(name, title) {
+        this.addFieldGroup(name, title);
+        return this;
+    }
     /**
      * Gets field by the model property name.
      * @param property Model property name.
@@ -2761,7 +2745,7 @@ class EditorDescriptorInst {
         this.addFieldDescriptor(field);
         return field;
     }
-    addFields(...properties) {
+    withFields(...properties) {
         properties.forEach(p => this.addField(p));
         return this;
     }
@@ -2774,155 +2758,39 @@ class EditorDescriptorInst {
      * Adds lookup field.
      *
      * @param {Property} property - The property key of the editor.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
+     * @param {FieldsManageAddFieldLookupOpts<LookupModel, Service>} opts - Optional parameters configuring type and/or service provider.
      * @typeparam Property - The property key of the EditorModel.
      * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
+     * @typeparam Service - Service used for data provider.
      * @typeparam FieldValue - The value type of field on editor.
      *
-     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, undefined, FieldValue>} - The field lookup descriptor.
+     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>} - The field lookup descriptor.
      */
-    addFieldLookup(property, type) {
-        return this.addFieldLookupUnsafe(property, type);
+    addFieldLookup(property, opts) {
+        return this.addFieldLookupUnsafe(property, opts);
     }
     /**
      * [UNSAFE] Adds lookup field.
      * This function is UNSAFE because property is not type-checked.
      *
      * @param {string} property Model property name.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model (defines 2nd generic).
+     * @param {FieldsManageAddFieldLookupOpts<LookupModel, Service>} opts - Optional parameters configuring type and/or service provider.
      * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
+     * @typeparam Service - Service used for data provider.
      * @typeparam FieldValue - The value type of field on editor.
      *
-     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, undefined, FieldValue>} - The field lookup descriptor.
+     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>} - The field lookup descriptor.
      */
-    addFieldLookupUnsafe(property, type) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    addFieldLookupUnsafe(property, opts) {
         const field = new FieldLookupDescriptor(property, {
-            type: type?.classType
+            ...(opts?.serviceProvider ? fieldLookupGetProviderCfgObj(opts.serviceProvider) : {})
         });
         this.addFieldDescriptor(field);
         return field;
     }
-    /**
-     * Adds a field lookup with options value property for lookup model.
-     *
-     * @param {Property} property - The property key of the editor.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
-     * @param {LookupValueProperty} lookupOptionsValueProperty - The value property used as value in the lookup options.
-     * @typeparam Property - The property key of the EditorModel.
-     * @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.
-     *
-     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, undefined, FieldValue>} - The field lookup descriptor.
-     */
-    addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty) {
-        return this.addFieldLookupWithOptionsValuePropertyUnsafe(property, type, lookupOptionsValueProperty);
-    }
-    /**
-     * [UNSAFE] Adds a field lookup with options value property for lookup model.
-     * This function is UNSAFE because property is not type-checked.
-     *
-     * @param {Property} property - The property key of the editor.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
-     * @param {LookupValueProperty} lookupOptionsValueProperty - The value property used as value in the lookup options.
-     * @typeparam Property - The property key of the EditorModel.
-     * @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, ParentEditorModel>} - The field lookup descriptor.
-     */
-    addFieldLookupWithOptionsValuePropertyUnsafe(property, type, lookupOptionsValueProperty) {
-        const field = new FieldLookupDescriptor(property, {
-            type: type?.classType,
-            optionsValueProperty: lookupOptionsValueProperty
-        });
-        this.addFieldDescriptor(field);
-        return field;
-    }
-    /**
-     * Adds a field lookup with a data provider or service to the editor model.
-     *
-     * @param {Property} property - The property key of the editor.
-     * @param {FieldLookupProviderType<LookupModel, Service>} provider - The field lookup data provider or service.
-     * @param {TypeDescriptor<LookupModel>} [type] - The type of lookup - if data provider is passed as previous parameter, type can be omitted. If service is provider, type parameter is proposed in favour of correct typing.
-     * @typeparam Property - The property key of the EditorModel.
-     * @typeparam Service - The lookup service type.
-     * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
-     * @typeparam FieldValue - The field value type, defaults to the editor's property type.
-     *
-     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>} Created field lookup descriptor.
-     */
-    addFieldLookupWithProvider(property, provider, type) {
-        return this.addFieldLookupWithProviderUnsafe(property, provider, type);
-    }
-    /**
-     * [UNSAFE] Adds a field lookup with a data provider or service to the editor model.
-     * This function is UNSAFE because property is not type-checked.
-     *
-     * @param {string} property - The property key of the editor.
-     * @param {FieldLookupProviderType<LookupModel, Service>} provider - The lookup provider or service for the field lookup.
-     * @param {TypeDescriptor<LookupModel>?} type - Optional type descriptor for the field lookup.
-     * @typeparam LookupModel - The field lookup model type.
-     * @typeparam Service - The lookup service type.
-     * @typeparam FieldValue - The value type of field on editor.
-     *
-     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>} - The field lookup descriptor added to the instance.
-     */
-    addFieldLookupWithProviderUnsafe(property, provider, type) {
-        const cfg = fieldLookupGetProviderCfgObj(provider);
-        const field = new FieldLookupDescriptor(property, {
-            type: type?.classType,
-            ...cfg
-        });
-        this.addFieldDescriptor(field);
-        return field;
-    }
-    /**
-     * Adds a field lookup with data provider or service and options value property for lookup model.
-     *
-     * @param {Property} property - The property key of the editor.
-     * @param {FieldLookupProviderType<FieldModel, Service>} provider - The lookup provider.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
-     * @param {LookupValueProperty} lookupOptionsValueProperty - The value property used as value in the lookup options.
-     * @typeparam Property - The property key of the EditorModel.
-     * @typeparam Service - The lookup service type.
-     * @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.
-     *
-     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue, ParentEditorModel>} - The field lookup descriptor.
-     */
-    addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty) {
-        return this.addFieldLookupWithProviderAndOptionsValuePropertyUnsafe(property, provider, type, lookupOptionsValueProperty);
-    }
-    /**
-     * [UNSAFE] Adds a field lookup with data provider or service and options value property for lookup model.
-     * This function is UNSAFE because property is not type-checked.
-     *
-     * @param {string} property - The property key of the editor.
-     * @param {FieldLookupProviderType<FieldModel, Service>} provider - The lookup provider.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
-     * @param {string} lookupOptionsValueProperty - The value property used in the lookup options.
-     * @typeparam Service - The service type.
-     * @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, EditorModel, Service, FieldValue, ParentEditorModel>} - The field lookup descriptor.
-     */
-    addFieldLookupWithProviderAndOptionsValuePropertyUnsafe(property, provider, type, lookupOptionsValueProperty) {
-        const cfg = fieldLookupGetProviderCfgObj(provider);
-        const field = new FieldLookupDescriptor(property, {
-            type: type?.classType,
-            optionsValueProperty: lookupOptionsValueProperty,
-            ...cfg
-        });
-        this.addFieldDescriptor(field);
-        return field;
-    }
-    addFieldLookupEnum(property, enumDesc, options) {
-        return this.addFieldLookupEnumUnsafe(property, enumDesc, options);
+    addFieldLookupEnum(property, enumDesc, options) {
+        return this.addFieldLookupEnumUnsafe(property, enumDesc, options);
     }
     /**
      * Adds enum lookup field.
@@ -3074,7 +2942,7 @@ class EditorDescriptorInst {
     createDefaultGroup() {
         this.createDefaultTabGroup();
         if (this._currentTabGroup?.fields.length === 0) {
-            this.createFieldGroup(EditorDescriptorInst.defaultGroupName, null);
+            this.addFieldGroup(EditorDescriptorInst.defaultGroupName, null);
         }
     }
     /**
@@ -3083,7 +2951,7 @@ class EditorDescriptorInst {
      */
     createDefaultTabGroup() {
         if (this._tabs.length === 0) {
-            this.createTabGroup(EditorDescriptorInst.defaultGroupName, 'general.general');
+            this.addTabGroup(EditorDescriptorInst.defaultGroupName, 'general.general');
         }
     }
     /**
@@ -3115,252 +2983,18 @@ class EditorDescriptorInst {
     }
 }
 
-/**
- * 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));
-        }
-        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 ?? 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 editorDescriptor({ id: idProperty, title: titleProperty, i18nBase: i18nBaseKey, tableviewEditorType: tableviewEditorType });
-    }
-    static fromClass(type, idProperty, titleProperty, i18nBaseKey, tableviewEditorType = TableviewEditorTypeEnum.None) {
-        return editorDescriptorFromClass(type, {
-            id: idProperty,
-            title: titleProperty,
-            i18nBase: i18nBaseKey,
-            tableviewEditorType: tableviewEditorType
-        });
-    }
-    static fromModel(model, tableviewEditorType = TableviewEditorTypeEnum.None) {
-        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.
-     * @param type Model's class.
-     * @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).
-     */
-    static fromClassWithAutoAttrsDef(type, idProperty, titleProperty, tableEditorType = TableviewEditorTypeEnum.None) {
-        return EditorDescriptor.fromClassWithCustomAttrsDef(type, getEditorClassAttributeDef(type), idProperty, titleProperty, tableEditorType);
-    }
-    /**
-     * Creates editor descriptor automatically based on openapi model's attributes definition provided in parameters. Only fields for provided attributes will be included.
-     * @param type Model's class.
-     * @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 tableviewEditorType Type of editor in tableview (add, edit, view or none).
-     */
-    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) {
+function editorDescriptor(modelOrOpts, opts) {
+    if (modelOrOpts == 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 if (modelOrOpts instanceof ModelDescriptor) {
+        return new EditorDescriptorInst(modelOrOpts, opts?.tableviewEditorType);
     }
     else {
         // this could have autoGenerated if model descriptor is class
-        return new EditorDescriptorInst(model(typeOrModelOrClassOrOpts), typeOrModelOrClassOrOpts?.tableviewEditorType);
+        return new EditorDescriptorInst(model(modelOrOpts), modelOrOpts?.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;
 (function (FormFieldEventTypeEnum) {
@@ -3457,10 +3091,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImpo
             }] } });
 
 class TableviewDataProviderInst extends DataProviderInst {
-    constructor(type, serviceType) {
-        super(type, serviceType);
-        this.editorDataProvider = new EditorDataProviderInst(type, serviceType);
-        this.tableDataProvider = new TableDataProviderInst(type, serviceType);
+    constructor(serviceType) {
+        super(serviceType);
+        this.editorDataProvider = new EditorDataProviderInst(serviceType);
+        this.tableDataProvider = new TableDataProviderInst(serviceType);
     }
     get isLazy() {
         return this.tableDataProvider.isLazy;
@@ -3486,6 +3120,12 @@ class TableviewDataProviderInst extends DataProviderInst {
     get delete() {
         return this.editorDataProvider.delete;
     }
+    get mapFetchItemToCreateItem() {
+        return this.editorDataProvider.mapFetchItemToCreateItem;
+    }
+    get mapFetchItemToUpdateItem() {
+        return this.editorDataProvider.mapFetchItemToUpdateItem;
+    }
     withGetAll(fn) {
         this.tableDataProvider.withGetAll(fn);
         return this;
@@ -3510,11 +3150,13 @@ class TableviewDataProviderInst extends DataProviderInst {
         this.editorDataProvider.withDelete(fn);
         return this;
     }
-    /**
-     * @deprecated Use ${reloadTable} instead.
-     */
-    getAllReload(params) {
-        this.tableDataProvider.getAllReload(params);
+    withMapFetchItemToCreateItem(fn) {
+        this.editorDataProvider.withMapFetchItemToCreateItem(fn);
+        return this;
+    }
+    withMapFetchItemToUpdateItem(fn) {
+        this.editorDataProvider.withMapFetchItemToUpdateItem(fn);
+        return this;
     }
     reloadTable(event) {
         this.tableDataProvider.reloadTable(event);
@@ -3525,75 +3167,37 @@ class TableviewDataProviderInst extends DataProviderInst {
 }
 class DynamicTableviewDataProviderInst extends TableviewDataProviderInst {
     constructor(serviceType) {
-        super(undefined, serviceType);
+        super(serviceType);
     }
 }
 
-class TableviewDataProvider extends TableviewDataProviderInst {
-    constructor() {
-        super(undefined, undefined);
-    }
-    static create() {
-        return tableviewDataProvider();
-    }
-    static fromClass(type) {
-        return tableviewDataProviderFromClass(type);
-    }
-    static fromClassWithService(type, serviceType) {
-        return tableviewDataProviderFromClass(type, serviceType);
-    }
-    static fromService(serviceType) {
-        return tableviewDataProviderWithService(serviceType);
-    }
-}
-function tableviewDataProvider(type, serviceTypeOrOpts, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-opts) {
-    if (serviceTypeOrOpts === undefined || typeof serviceTypeOrOpts === 'function') {
-        return new TableviewDataProviderInst(undefined, serviceTypeOrOpts);
-    }
-    else {
-        return new TableviewDataProviderInst(undefined, undefined);
-    }
-}
-function tableviewDataProviderWithService(serviceType, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-opts) {
-    return new TableviewDataProviderInst(undefined, serviceType);
-}
-function tableviewDataProviderFromClass(type, serviceType) {
-    return new TableviewDataProviderInst(type, serviceType);
-}
-function tableviewDataProviderFromModel(model, serviceTypeOrOpts, opts) {
-    return typeof serviceTypeOrOpts === 'function'
-        ? new TableviewDataProviderInst(model.type, serviceTypeOrOpts)
-        : new TableviewDataProviderInst(model.type, undefined);
-}
-class DynamicTableviewDataProvider extends DynamicTableviewDataProviderInst {
-    constructor() {
-        super(undefined);
-    }
-    static create() {
-        return tableviewDynamicDataProvider();
-    }
-    static fromService(serviceType) {
-        return tableviewDynamicDataProvider(serviceType);
-    }
+/**
+ * Creates and returns an instance of `TableviewDataProviderInst` with the specified options for managing tableview data.
+ *
+ * @param {Object} [opts] - The options object to configure the data provider.
+ * @param {TypeDescriptor<Model> | ModelDescriptor<Model>} [opts.type] - The descriptor defining the type of model.
+ * @param {ServiceClassType<Service>} [opts.service] - The service class type associated with the data provider.
+ * @param {TypeDescriptor<CreateModel> | ModelDescriptor<CreateModel>} [opts.filtersType] - The descriptor defining the filters type.
+ * @param {TypeDescriptor<UpdateModel> | ModelDescriptor<UpdateModel>} [opts.sortsType] - The descriptor defining the sorts type.
+ * @return {TableviewDataProviderInst<Model, Service, Sorts, Filters, ServiceClass, TableModel, CreateModel, UpdateModel>} An instance of `TableviewDataProviderInst` configured according to the provided options.
+ */
+function tableviewDataProvider(opts) {
+    return new TableviewDataProviderInst(opts?.service);
 }
 function tableviewDynamicDataProvider(serviceType) {
     return new DynamicTableviewDataProviderInst(serviceType);
 }
 
 class TableviewDescriptorInst {
-    constructor(model) {
+    constructor(model, opts) {
         this._isLocalized = false;
         this._model = model;
-        this._table = new TableDescriptorInst(model);
+        this._table = new TableDescriptorInst(opts?.tableModel ?? model);
         this._table.withTitle(`${this._model.i18nBaseKey}.name`);
         this._detailsEditor = new EditorDescriptorInst(model, TableviewEditorTypeEnum.Details);
         this._detailsEditor.withDisabled();
-        this._addEditor = new EditorDescriptorInst(model, TableviewEditorTypeEnum.Add);
-        this._editEditor = new EditorDescriptorInst(model, TableviewEditorTypeEnum.Edit);
+        this._addEditor = new EditorDescriptorInst(opts?.addModel ?? model, TableviewEditorTypeEnum.Add);
+        this._editEditor = new EditorDescriptorInst(opts?.editModel ?? model, TableviewEditorTypeEnum.Edit);
     }
     get table() {
         return this._table;
@@ -3652,14 +3256,6 @@ class TableviewDescriptorInst {
         }
         return this;
     }
-    /**
-     * @deprecated Use {table.withTitle} directly
-     * @param title
-     */
-    withTableTitle(title) {
-        this._table.withTitle(title);
-        return this;
-    }
     withValidation(name, expression, message, opts) {
         return this.withValidationUnsafe(name, expression, message, opts);
     }
@@ -3800,21 +3396,6 @@ class TableviewDescriptorInst {
         this._table.withFilterUnsafe(filter);
         return this;
     }
-    getField(property, editorType) {
-        return this.getFieldUnsafe(property, editorType);
-    }
-    getFieldUnsafe(property, editorType) {
-        switch (editorType) {
-            case TableviewEditorTypeEnum.Edit:
-                return this._editEditor.getFieldUnsafe(property);
-            case TableviewEditorTypeEnum.Add:
-                return this._addEditor.getFieldUnsafe(property);
-            case TableviewEditorTypeEnum.Details:
-                return this._detailsEditor.getFieldUnsafe(property);
-            case TableviewEditorTypeEnum.None:
-                return null;
-        }
-    }
     removeField(property) {
         this.removeFieldUnsafe(property);
     }
@@ -3830,16 +3411,14 @@ class TableviewDescriptorInst {
         return this;
     }
     addField(property) {
-        const field = this._detailsEditor.addField(property);
-        this.addFieldToEditAndAdd(field);
-        return field;
+        return this.addFieldUnsafe(property);
     }
     addFieldUnsafe(property) {
         const field = this._detailsEditor.addFieldUnsafe(property);
         this.addFieldToEditAndAdd(field);
         return field;
     }
-    addFields(...properties) {
+    withFields(...properties) {
         properties.forEach(p => this.addField(p));
         return this;
     }
@@ -3856,150 +3435,36 @@ class TableviewDescriptorInst {
      * Adds lookup field.
      *
      * @param {Property} property - The property key of the editor.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
+     * @param {FieldsManageAddFieldLookupOpts<LookupModel, Service>} opts - Optional parameters configuring type and/or service provider.
      * @typeparam Property - The property key of the EditorModel.
      * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
+     * @typeparam Service - Service used for data provider.
      * @typeparam FieldValue - The value type of field on editor.
      *
-     * @returns {FieldLookupDescriptor<LookupModel, TableviewModel, undefined, FieldValue, ParentEditorModel>} - The field lookup descriptor.
+     * @returns {FieldLookupDescriptor<LookupModel, FieldsManageModel, Service, FieldValue>} - The field lookup descriptor.
      */
-    addFieldLookup(property, type) {
-        const field = this._detailsEditor.addFieldLookup(property, type);
-        this.addFieldToEditAndAdd(field);
-        return field;
+    addFieldLookup(property, opts) {
+        return this.addFieldLookupUnsafe(property, opts);
     }
     /**
      * [UNSAFE] Adds lookup field.
      * This function is UNSAFE because property is not type-checked.
      *
      * @param {string} property Model property name.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model (defines 2nd generic).
-     * @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, ParentEditorModel>} - The field lookup descriptor.
-     */
-    addFieldLookupUnsafe(property, type) {
-        const field = this._detailsEditor.addFieldLookupUnsafe(property, type);
-        this.addFieldToEditAndAdd(field);
-        return field;
-    }
-    /**
-     * Adds a field lookup with options value property for lookup model.
-     *
-     * @param {Property} property - The property key of the editor.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
-     * @param {LookupValueProperty} lookupOptionsValueProperty - The value property used as value in the lookup options.
-     * @typeparam Property - The property key of the EditorModel.
-     * @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.
-     *
-     * @returns {FieldLookupDescriptor<LookupModel, TableviewModel, undefined, FieldValue>} - The field lookup descriptor.
-     */
-    addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty) {
-        const field = this._detailsEditor.addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty);
-        this.addFieldToEditAndAdd(field);
-        return field;
-    }
-    /**
-     * [UNSAFE] Adds a field lookup with options value property for lookup model.
-     * This function is UNSAFE because property is not type-checked.
-     *
-     * @param {Property} property - The property key of the editor.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
-     * @param {LookupValueProperty} lookupOptionsValueProperty - The value property used as value in the lookup options.
-     * @typeparam Property - The property key of the EditorModel.
-     * @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.
-     *
-     * @returns {FieldLookupDescriptor<LookupModel, TableviewModel, undefined, FieldValue>} - The field lookup descriptor.
-     */
-    addFieldLookupWithOptionsValuePropertyUnsafe(property, type, lookupOptionsValueProperty) {
-        const field = this._detailsEditor.addFieldLookupWithOptionsValuePropertyUnsafe(property, type, lookupOptionsValueProperty);
-        this.addFieldToEditAndAdd(field);
-        return field;
-    }
-    /**
-     * Adds a field lookup with a data provider or service to the editor model.
-     *
-     * @param {Property} property - The property key of the editor.
-     * @param {FieldLookupProviderType<LookupModel, Service>} provider - The field lookup data provider or service.
-     * @param {TypeDescriptor<LookupModel>} [type] - The type of lookup - if data provider is passed as previous parameter, type can be omitted. If service is provider, type parameter is proposed in favour of correct typing.
-     * @typeparam Property - The property key of the EditorModel.
-     * @typeparam Service - The lookup service type.
-     * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
-     * @typeparam FieldValue - The field value type, defaults to the editor's property type.
-     *
-     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>} Created field lookup descriptor.
-     */
-    addFieldLookupWithProvider(property, provider, type) {
-        const field = this._detailsEditor.addFieldLookupWithProvider(property, provider, type);
-        this.addFieldToEditAndAdd(field);
-        return field;
-    }
-    /**
-     * [UNSAFE] Adds a field lookup with a data provider or service to the editor model.
-     * This function is UNSAFE because property is not type-checked.
-     *
-     * @param {string} property - The property key of the editor.
-     * @param {FieldLookupProviderType<LookupModel, Service>} provider - The lookup provider or service for the field lookup.
-     * @param {TypeDescriptor<LookupModel>?} type - Optional type descriptor for the field lookup.
-     * @typeparam LookupModel - The field lookup model type.
-     * @typeparam Service - The lookup service type.
-     * @typeparam FieldValue - The value type of field on editor.
-     *
-     * @returns {FieldLookupDescriptor<LookupModel, TableviewModel, Service, FieldValue>} - The field lookup descriptor added to the instance.
-     */
-    addFieldLookupWithProviderUnsafe(property, provider, type) {
-        const field = this._detailsEditor.addFieldLookupWithProviderUnsafe(property, provider, type);
-        this.addFieldToEditAndAdd(field);
-        return field;
-    }
-    /**
-     * Adds a field lookup with data provider or service and options value property for lookup model.
-     *
-     * @param {Property} property - The property key of the editor.
-     * @param {FieldLookupProviderType<FieldModel, Service>} provider - The lookup provider.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
-     * @param {LookupValueProperty} lookupOptionsValueProperty - The value property used as value in the lookup options.
-     * @typeparam Property - The property key of the EditorModel.
-     * @typeparam Service - The lookup service type.
+     * @param {FieldsManageAddFieldLookupOpts<LookupModel, Service>} opts - Optional parameters configuring type and/or service provider.
      * @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 Service - Service used for data provider.
      * @typeparam FieldValue - The value type of field on editor.
      *
-     * @returns {FieldLookupDescriptor<LookupModel, TableviewModel, Service, FieldValue, ParentEditorModel>} - The field lookup descriptor.
+     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>} - The field lookup descriptor.
      */
-    addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty) {
-        const field = this._detailsEditor.addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty);
-        this.addFieldToEditAndAdd(field);
-        return field;
-    }
-    /**
-     * [UNSAFE] Adds a field lookup with data provider or service and options value property for lookup model.
-     * This function is UNSAFE because property is not type-checked.
-     *
-     * @param {string} property - The property key of the editor.
-     * @param {FieldLookupProviderType<FieldModel, Service>} provider - The lookup provider.
-     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
-     * @param {string} lookupOptionsValueProperty - The value property used in the lookup options.
-     * @typeparam Service - The service type.
-     * @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, EditorModel, Service, FieldValue, ParentEditorModel>} - The field lookup descriptor.
-     */
-    addFieldLookupWithProviderAndOptionsValuePropertyUnsafe(property, provider, type, lookupOptionsValueProperty) {
-        const field = this._detailsEditor.addFieldLookupWithProviderAndOptionsValuePropertyUnsafe(property, provider, type, lookupOptionsValueProperty);
+    addFieldLookupUnsafe(property, opts) {
+        const field = this._detailsEditor.addFieldLookupUnsafe(property, opts);
         this.addFieldToEditAndAdd(field);
         return field;
     }
     addFieldLookupEnum(property, enumDesc, options) {
-        const field = this._detailsEditor.addFieldLookupEnum(property, enumDesc, options);
-        this.addFieldToEditAndAdd(field);
-        return field;
+        return this.addFieldLookupEnumUnsafe(property, enumDesc, options);
     }
     addFieldLookupEnumUnsafe(property, enumDesc, options) {
         const field = this._detailsEditor.addFieldLookupEnumUnsafe(property, enumDesc, options);
@@ -4007,47 +3472,33 @@ class TableviewDescriptorInst {
         return field;
     }
     addFieldManyEditor(property, tableviewDescriptor) {
-        const field = this._detailsEditor.addFieldManyEditor(property, tableviewDescriptor);
-        this.addFieldToEditAndAdd(field);
-        return field;
+        return this.addFieldManyEditorUnsafe(property, tableviewDescriptor);
     }
     addFieldManyEditorUnsafe(property, tableviewDescriptor) {
-        const field = this._detailsEditor.addFieldManyEditorUnsafe(property, tableviewDescriptor);
+        const field = this._detailsEditor.addFieldManyEditorUnsafe(property, 
+        // cast is needed, because the parent model of TableviewDescriptorInst is expected to be TableviewModel, but it cannot be in case there are different types across details, add or edit
+        tableviewDescriptor);
         this.addFieldToEditAndAdd(field);
         return field;
     }
     addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider) {
-        const field = this._detailsEditor.addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider);
-        this.addFieldToEditAndAdd(field);
-        return field;
+        return this.addFieldManyToManyEditorUnsafe(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider);
     }
     addFieldManyToManyEditorUnsafe(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider) {
         const field = this._detailsEditor.addFieldManyToManyEditorUnsafe(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider);
         this.addFieldToEditAndAdd(field);
         return field;
     }
-    /**
-     * @deprecated Use withTabGroup config instead
-     */
-    createTabGroup(name, title) {
-        return this.withTabGroup(name, title);
-    }
-    /**
-     * @deprecated Use withTabGroup config instead
-     */
-    createFieldGroup(name, title) {
-        return this.withFieldGroup(name, title);
-    }
     withTabGroup(name, title) {
-        this._detailsEditor.createTabGroup(name, title);
-        this._addEditor.createTabGroup(name, title);
-        this._editEditor.createTabGroup(name, title);
+        this._detailsEditor.addTabGroup(name, title);
+        this._addEditor.addTabGroup(name, title);
+        this._editEditor.addTabGroup(name, title);
         return this;
     }
     withFieldGroup(name, title) {
-        this._detailsEditor.createFieldGroup(name, title);
-        this._addEditor.createFieldGroup(name, title);
-        this._editEditor.createFieldGroup(name, title);
+        this._detailsEditor.addFieldGroup(name, title);
+        this._addEditor.addFieldGroup(name, title);
+        this._editEditor.addFieldGroup(name, title);
         return this;
     }
     copy() {
@@ -4111,141 +3562,36 @@ class TableviewDynamicDescriptorInt extends TableviewDescriptorInst {
     }
 }
 
-class TableviewDescriptor extends TableviewDescriptorInst {
-    constructor() {
-        super(ModelDescriptor.create());
-    }
-    static create(idProperty, titleProperty, i18nBaseKey) {
-        return new TableviewDescriptorInst(ModelDescriptor.create(idProperty, titleProperty, i18nBaseKey));
-    }
-    static fromClass(type, idProperty, titleProperty, i18nBaseKey) {
-        return new TableviewDescriptorInst(ModelDescriptor.fromClass(type, idProperty, titleProperty, i18nBaseKey));
-    }
-    static fromModel(model) {
-        return new TableviewDescriptorInst(model);
-    }
-    /**
-     * generates descriptor from attribute definition of openapi model
-     * @param type class type
-     * @param idProperty
-     * @param titleProperty
-     */
-    static fromClassWithAutoAttrsDef(type, idProperty, titleProperty) {
-        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;
-    }
-    /**
-     * generates descriptor from given attribute definition
-     * @param type class type
-     * @param columnAttributes attribute definition to generate columns
-     * @param fieldAttributes attribute definition to generate fields, if undefined columnDefinition is used, if null editors are not generated
-     * @param idProperty
-     * @param titleProperty
-     */
-    static fromClassWithCustomAttrsDef(type, columnAttributes, fieldAttributes, 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(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;
-    }
-}
-function tableviewDescriptor(typeOrModelOrClassOrOpts, opts) {
-    if (typeOrModelOrClassOrOpts == null) {
+function tableviewDescriptor(modelOrOpts, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+opts) {
+    if (modelOrOpts == null) {
         return new TableviewDescriptorInst(model());
     }
-    else if (typeOrModelOrClassOrOpts instanceof TypeDescriptor) {
-        return new TableviewDescriptorInst(model(opts ?? {}));
-    }
-    else if (typeOrModelOrClassOrOpts instanceof ModelDescriptor) {
-        return new TableviewDescriptorInst(typeOrModelOrClassOrOpts);
+    else if (modelOrOpts instanceof ModelDescriptor) {
+        return new TableviewDescriptorInst(modelOrOpts);
     }
     else {
-        // this could have autoGenerated if model descriptor is class
-        return new TableviewDescriptorInst(model(typeOrModelOrClassOrOpts));
+        return new TableviewDescriptorInst(model(modelOrOpts));
     }
 }
-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());
+function tableviewDescriptorMultiModel(modelOrOpts, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+opts) {
+    if (modelOrOpts == null) {
+        return new TableviewDescriptorInst(model());
     }
-    static create(idProperty, titleProperty, i18nBaseKey) {
-        return tableviewDynamicDescriptor({ id: idProperty, title: titleProperty, i18nBase: i18nBaseKey });
+    else if (modelOrOpts instanceof ModelDescriptor) {
+        return new TableviewDescriptorInst(modelOrOpts);
     }
-    static fromModel(model) {
-        return tableviewDynamicDescriptor(model);
+    else {
+        return new TableviewDescriptorInst(model(modelOrOpts));
     }
 }
 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));
+        : new TableviewDynamicDescriptorInt(new ModelDescriptor(modelOrOpts?.id, modelOrOpts?.title, modelOrOpts?.i18nBase));
 }
 
 function convertDataToStringWithDelimiter(data, delimiter, descriptor, translate) {
@@ -4308,44 +3654,42 @@ const tableviewDefaultActions = [
     TableviewDefaultActionsEnum.ExportCsv,
     TableviewDefaultActionsEnum.LocalizationLanguageSelect
 ];
-function getTableviewDefaultActions() {
+function tableviewGetDefaultActions() {
     return [...tableviewDefaultActions];
 }
-function createTableviewActions(tableview, defaultActions, defaultActionsOverrides, injector) {
-    return (defaultActions ?? getTableviewDefaultActions())
-        .map(t => createTableviewAction(t, tableview, defaultActions, defaultActionsOverrides, injector))
+function tableviewCreateDefaultActions(tableview, defaultActions, defaultActionsOverrides, injector) {
+    return (defaultActions ?? tableviewGetDefaultActions())
+        .map(t => tableviewCreateDefaultAction(t, tableview, defaultActions, defaultActionsOverrides, injector))
         .filter(e => e != null);
 }
-function createTableviewAction(type, tableview, defaultActions, defaultActionsOverrides, injector) {
+function tableviewCreateDefaultAction(type, tableview, defaultActions, defaultActionsOverrides, injector) {
     if (defaultActionsOverrides != null && defaultActionsOverrides[type] !== undefined) {
         return defaultActionsOverrides[type];
     }
     switch (type) {
         // table row actions
         case TableviewDefaultActionsEnum.Details:
-            return tableviewDetailsAction(tableview.detailsEditor, injector);
+            return tableviewActionDetailsOnTable(tableview.detailsEditor, { injector });
         case TableviewDefaultActionsEnum.Edit:
-            return tableviewEditAction(tableview.editEditor, injector);
+            return tableviewActionEditOnTable(tableview.model, tableview.editEditor, { table: tableview.table, injector });
         case TableviewDefaultActionsEnum.Delete:
-            return tableviewDeleteAction(tableview.model, injector);
+            return tableviewActionDeleteOnTable(tableview.model, { table: tableview.table, injector });
         // table toolbar actions
         case TableviewDefaultActionsEnum.Add:
-            return tableviewAddAction(tableview.addEditor, injector);
+            return tableviewActionAddOnTable(tableview.model, tableview.addEditor, { injector });
         case TableviewDefaultActionsEnum.LocalizationLanguageSelect:
-            return tableviewLocalizationLanguageSelectAction(tableview);
+            return tableviewActionLocalizationLangSelectOnTable(tableview);
         case TableviewDefaultActionsEnum.Refresh:
-            return tableviewRefreshAction(tableview.model);
+            return tableviewActionRefreshOnTable(tableview.model);
         case TableviewDefaultActionsEnum.Export:
             return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportJson) || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv)
-                ? tableviewExportAction(tableview, injector, defaultActions)
+                ? tableviewActionExportOnTable(tableview, { injector: injector, defaultActions: defaultActions })
                 : null;
         //details actions
         case TableviewDefaultActionsEnum.EditOnDetails:
-            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Edit)
-                ? tableviewEditOnDetailsAction(tableview.model, tableviewEditAction(tableview.editEditor, injector), injector)
-                : null;
+            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Edit) ? tableviewActionEditOnDetails(tableview.model, { injector }) : null;
         case TableviewDefaultActionsEnum.DeleteOnDetails:
-            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Delete) ? tableviewDeleteOnDetailsAction(tableview.model, injector) : null;
+            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Delete) ? tableviewActionDeleteOnDetails(tableview.model, { injector }) : null;
         // subactions
         case TableviewDefaultActionsEnum.ExportJson:
         case TableviewDefaultActionsEnum.ExportCsv:
@@ -4360,81 +3704,100 @@ function getInjector(injector) {
 function getRouteData(injector) {
     return getInjector(injector)?.get(ActivatedRoute)?.snapshot.data;
 }
-function tableviewDetailsAction(descriptor, injector) {
-    const routeData = getRouteData(injector);
-    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
-        ? new ActionEditorDetailsDescriptorInst(descriptor, {
-            ...actionEditorGetProviderCfgObj(serviceProvider)
-        })
-        : null;
-}
-function tableviewAddAction(descriptor, injector) {
-    const routeData = getRouteData(injector);
-    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
-        ? new ActionEditorAddDescriptorInst(descriptor, {
-            ...actionEditorGetProviderCfgObj(serviceProvider)
-        })
-        : null;
+const tableviewActionEditorDetailsActionName = 'details';
+const tableviewActionEditorDetailsRoute = ':itemId';
+function tableviewActionDetailsOnTable(descriptor, opts) {
+    const routeData = getRouteData(opts?.injector);
+    if (!routeData?.tableviewActions || routeData.tableviewActions.hasDetails) {
+        const action = new ActionEditorDescriptorInst(descriptor, tableviewActionEditorDetailsActionName, {
+            ...(opts?.serviceProvider ? actionEditorGetProviderCfgObj(opts?.serviceProvider) : {}),
+            isTableviewMainEditor: true
+        });
+        action.withPosition(opts?.position ?? ActionPositionEnum.RowClick);
+        action.withPosition(ActionPositionEnum.RowClick);
+        action.withRouteTrigger(tableviewActionEditorDetailsRoute);
+        action.withEditorActions([actionEditorCancel(action)]);
+        action.withTableviewCategory(TableviewActionDefaultCategories.DETAILS);
+        return action;
+    }
+    return null;
 }
-function tableviewEditAction(descriptor, injector) {
-    const routeData = getRouteData(injector);
-    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit ? new ActionEditorEditDescriptorInst(descriptor) : null;
+const tableviewActionEditorAddActionName = 'add';
+const tableviewActionEditorAddRoute = 'add';
+function tableviewActionAddOnTable(model, descriptor, opts) {
+    const routeData = getRouteData(opts?.injector);
+    if (!routeData?.tableviewActions || routeData.tableviewActions.hasAdd) {
+        const action = new ActionEditorDescriptorInst(descriptor, tableviewActionEditorAddActionName, {
+            ...(opts?.serviceProvider ? actionEditorGetProviderCfgObj(opts.serviceProvider) : {}),
+            isTableviewMainEditor: true,
+            model: model
+        });
+        action.withPosition(opts?.position ?? ActionPositionEnum.ToolbarLeft);
+        action.withRouteTrigger(tableviewActionEditorAddRoute);
+        action.button.withIcon('pi pi-plus');
+        action.withTableviewCategory(TableviewActionDefaultCategories.ADD);
+        action.withUnsavedChangesConfirmation();
+        return action;
+    }
+    return null;
 }
-function tableviewEditActionWithProvider(descriptor, serviceProvider, injector) {
-    const routeData = getRouteData(injector);
-    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit
-        ? new ActionEditorEditDescriptorInst(descriptor, {
-            ...actionEditorGetProviderCfgObj(serviceProvider)
-        })
-        : null;
+const tableviewActionEditorEditActionName = 'edit';
+const tableviewActionEditorEditRoute = ':itemId/edit';
+function tableviewActionEditOnTable(model, descriptor, opts) {
+    const routeData = getRouteData(opts?.injector);
+    if (!routeData?.tableviewActions || routeData.tableviewActions.hasEdit) {
+        const action = new ActionEditorDescriptorInst(descriptor, tableviewActionEditorEditActionName, {
+            ...(opts?.serviceProvider ? actionEditorGetProviderCfgObj(opts.serviceProvider) : {}),
+            isTableviewMainEditor: true,
+            model: model
+        });
+        action.withPosition(opts?.position ?? ActionPositionEnum.RowInline);
+        action.button.styleClass.withSize(StyleSizeEnum.Small);
+        action.withRouteTrigger(tableviewActionEditorEditRoute);
+        action.withTableviewCategory(TableviewActionDefaultCategories.EDIT);
+        action.button.withLabel(null).withIcon('pi pi-pencil');
+        action.withUnsavedChangesConfirmation();
+        return action;
+    }
+    return null;
 }
-function tableviewEditOnDetailsAction(descriptor, editDescriptor, injector) {
-    const routeData = getRouteData(injector);
+function tableviewActionEditOnDetails(model, opts) {
+    const routeData = getRouteData(opts?.injector);
     if (routeData?.tableviewActions && !routeData.tableviewActions.hasEdit) {
         return null;
     }
-    const action = editDescriptor
-        ? actionLinkFromAction(editDescriptor)
-        : new ActionLinkDescriptorInst(ActionEditorEditDescriptorInst.ACTION_NAME, {
-            model: descriptor
-        });
-    action
+    const linkAction = actionLink(tableviewActionEditorEditActionName, { model: model });
+    linkAction
         .withTableviewCategory(TableviewActionDefaultCategories.EDIT)
         .withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS])
-        .withPosition(ActionPositionEnum.FooterLeft)
+        .withPosition(opts?.position ?? ActionPositionEnum.FooterLeft)
         .withRouterLink('./edit')
         .withQueryParams({}, 'merge');
-    action.button.styleClass.withActionLevel(StyleLevelEnum.Secondary);
-    action.button.styleClass.withSize(StyleSizeEnum.Normal);
-    action.button.styleClass.withRoundedButton(ButtonStyleRoundedEnum.DEFAULT);
-    action.button.withLabel();
-    if (!editDescriptor)
-        action.button.withIcon('pi pi-pencil');
-    return action;
-}
-function tableviewDeleteAction(descriptor, injector) {
-    const routeData = getRouteData(injector);
-    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
-        ? new ActionDeleteDescriptorInst(descriptor, {
-            ...actionGetProviderCfgObj(serviceProvider)
-        })
-        : null;
+    linkAction.button.styleClass.withActionLevel(StyleLevelEnum.Secondary);
+    linkAction.button.styleClass.withSize(StyleSizeEnum.Normal);
+    linkAction.button.styleClass.withRoundedButton(ButtonStyleRoundedEnum.DEFAULT);
+    linkAction.button.withLabel();
+    linkAction.button.withIcon('pi pi-pencil');
+    return linkAction;
+}
+const tableviewActionDeleteActionName = 'delete';
+function tableviewActionDeleteOnTable(model, opts) {
+    const routeData = getRouteData(opts?.injector);
+    if (!routeData?.tableviewActions || routeData.tableviewActions.hasDelete) {
+        const action = new ActionDescriptorInst(tableviewActionDeleteActionName, opts?.serviceProvider ? actionGetProviderCfgObj(opts.serviceProvider) : {});
+        action.withPosition(opts?.position ?? ActionPositionEnum.RowInline);
+        action.button.styleClass.withSize(StyleSizeEnum.Small);
+        action.button.styleClass.withActionLevel(StyleLevelEnum.Danger);
+        action.withRunConfirmation();
+        action.withTableviewCategory(TableviewActionDefaultCategories.DELETE);
+        action.button.withLabel(null).withIcon('pi pi-trash');
+        return action;
+    }
+    return null;
 }
-function tableviewDeleteOnDetailsAction(model, injector) {
-    const action = tableviewDeleteAction(model, injector);
-    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
+function tableviewActionDeleteOnDetails(model, opts) {
+    const action = tableviewActionDeleteOnTable(model, opts);
+    const dataProviderExecutor = getInjector(opts?.injector)?.get(DataProviderExecutor);
     if (action) {
         action
             .withTableviewCategory(TableviewActionDefaultCategories.DELETE)
@@ -4452,22 +3815,23 @@ function tableviewDeleteOnDetailsAction(model, injector) {
     }
     return null;
 }
-function tableviewExportAction(descriptor, injector, defaultActions) {
+function tableviewActionExportOnTable(descriptor, opts) {
     const exportAction = new ActionDescriptorInst('export', {
         model: descriptor.model
     })
         .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-download'))
         .withSubactionsAsMenu();
     const subactions = [];
-    if (defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportJson))
-        subactions.push(tableviewExportJsonAction(descriptor, injector));
-    if (defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv))
-        subactions.push(tableviewExportCsvAction(descriptor, injector));
+    if (opts?.defaultActions == null || opts?.defaultActions.includes(TableviewDefaultActionsEnum.ExportJson))
+        subactions.push(tableviewActionExportJsonOnTable(descriptor, opts));
+    if (opts?.defaultActions == null || opts?.defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv))
+        subactions.push(tableviewActionExportCsvOnTable(descriptor, opts));
     exportAction.withSubactions(...subactions);
+    exportAction.withPosition(opts?.position ?? ActionPositionEnum.ToolbarRight);
     return exportAction;
 }
-function tableviewExportJsonAction(descriptor, injector) {
-    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
+function tableviewActionExportJsonOnTable(descriptor, opts) {
+    const dataProviderExecutor = getInjector(opts?.injector)?.get(DataProviderExecutor);
     return new ActionDescriptorInst('exportJson', {
         model: descriptor.model
     })
@@ -4477,7 +3841,7 @@ function tableviewExportJsonAction(descriptor, injector) {
         params.limit = 500;
         ctx.parameters.dataListParams = params;
         return dataProviderExecutor
-            ? dataProviderExecutor.runGetAllOrFail(ctx).pipe(map(res => {
+            ? dataProviderExecutor.runGetAllOrFail(ctx).pipe(map$1(res => {
                 const blob = new Blob([JSON.stringify(res.data, undefined, 4)], { type: 'application/json;charset=utf-8' });
                 const typeName = ctx.instance.action.model?.i18nBaseKey ?? '';
                 saveFileAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.json`);
@@ -4486,10 +3850,10 @@ function tableviewExportJsonAction(descriptor, injector) {
             : ctx.parameters.item;
     })
         .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-code'))
-        .withPosition(ActionPositionEnum.ToolbarRight);
+        .withPosition(opts?.position ?? ActionPositionEnum.ToolbarRight);
 }
-function tableviewExportCsvAction(descriptor, injector) {
-    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
+function tableviewActionExportCsvOnTable(descriptor, opts) {
+    const dataProviderExecutor = getInjector(opts?.injector)?.get(DataProviderExecutor);
     return new ActionDescriptorInst('exportCsv', {
         model: descriptor.model
     })
@@ -4499,7 +3863,7 @@ function tableviewExportCsvAction(descriptor, injector) {
         params.limit = 500;
         ctx.parameters.dataListParams = params;
         return dataProviderExecutor
-            ? dataProviderExecutor.runGetAllOrFail(ctx).pipe(map(res => {
+            ? dataProviderExecutor.runGetAllOrFail(ctx).pipe(map$1(res => {
                 if (!res.data) {
                     return undefined;
                 }
@@ -4513,9 +3877,9 @@ function tableviewExportCsvAction(descriptor, injector) {
             : ctx.parameters.item;
     })
         .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-file'))
-        .withPosition(ActionPositionEnum.ToolbarRight);
+        .withPosition(opts?.position ?? ActionPositionEnum.ToolbarRight);
 }
-function tableviewRefreshAction(descriptor) {
+function tableviewActionRefreshOnTable(descriptor, opts) {
     const action = new ActionDescriptorInst('refresh', {
         model: descriptor
     })
@@ -4525,16 +3889,17 @@ function tableviewRefreshAction(descriptor) {
         .withRunFunction(ctx => {
         ctx.viewContainer?.reloadTable({});
         return of(null);
-    });
+    })
+        .withPosition(opts?.position ?? ActionPositionEnum.ToolbarRight);
     action.button.withIcon('pi pi-refresh').styleClass.withActionLevel(StyleLevelEnum.Secondary);
     return action;
 }
-function tableviewLocalizationLanguageSelectAction(descriptor) {
+function tableviewActionLocalizationLangSelectOnTable(descriptor, opts) {
     return descriptor.isLocalized()
         ? new ActionDescriptorInst('translator', {
             model: descriptor.model
         })
-            .withPosition(ActionPositionEnum.ToolbarLeft)
+            .withPosition(opts?.position ?? ActionPositionEnum.ToolbarLeft)
             .withComponentFromDi(DATA_LANGUAGE_DROPDOWN_COMPONENT_IT)
         : null;
 }
@@ -4556,7 +3921,7 @@ class TableviewInputBuilder {
         this._descriptor = _descriptor;
         this._dataProvider = _dataProvider;
         this.injector = injector;
-        this.defaultActions = getTableviewDefaultActions().map(a => ({ type: a, descriptor: undefined }));
+        this.defaultActions = tableviewGetDefaultActions().map(a => ({ type: a, descriptor: undefined }));
         this._customActions = [];
     }
     prepareSetterParams() {
@@ -4612,6 +3977,73 @@ class TableviewInputBuilder {
         adjustFn(this.prepareSetterParams());
         return this;
     }
+    /**
+     * Associates a fetch function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the fetch API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} fnItemIdParamName The parameter name for itemId used as the key within the request object of fetch function on API service.
+     */
+    withDataServiceFetchFn(serviceFn, itemIdParamName) {
+        if (this._dataProvider instanceof TableviewDataProviderInst) {
+            this._dataProvider.withFetch((itemId, service) => service[serviceFn]({ [itemIdParamName]: itemId }));
+        }
+        return this;
+    }
+    /**
+     * Associates a create function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the create API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, Undefined<EditModel>>} serviceFnItemParamName The parameter name for item used as the key within the request object of create function on API service.
+     * @param {EditorDataProviderFetchMapToFnType<Model, AddModel>} [mapFetchItem] Map function to transform model from fetch to form's add model.
+     */
+    withDataServiceCreateFn(serviceFn, serviceFnItemParamName, mapFetchItem) {
+        if (this._dataProvider instanceof TableviewDataProviderInst) {
+            this._dataProvider.withCreate((item, service) => service[serviceFn]({ [serviceFnItemParamName]: item }));
+            if (mapFetchItem) {
+                this._dataProvider.withMapFetchItemToCreateItem(mapFetchItem);
+            }
+        }
+        return this;
+    }
+    /**
+     * Associates an update function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the update API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, Undefined<EditModel>>} fnItemParamName The parameter name for item used as the key within the request object of update function on API service.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} [fnItemIdParamName] The parameter name for itemId used as the key within the request object of update function on API service.
+     * @param {EditorDataProviderFetchMapToFnType<Model, EditModel>} [mapFetchItem] Map function to transform model from fetch to form' edit model.
+     */
+    withDataServiceUpdateFn(serviceFn, fnItemParamName, fnItemIdParamName, mapFetchItem) {
+        if (this._dataProvider instanceof TableviewDataProviderInst) {
+            this._dataProvider.withUpdate((id, item, service) => {
+                const params = { [fnItemParamName]: item };
+                if (fnItemIdParamName) {
+                    params[fnItemIdParamName] = id;
+                }
+                return service[serviceFn](params);
+            });
+            if (mapFetchItem) {
+                this._dataProvider.withMapFetchItemToUpdateItem(mapFetchItem);
+            }
+        }
+        return this;
+    }
+    /**
+     * Associates a delete function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the delete API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} fnItemIdParamName The parameter name for itemId used as the key within the request object of delete function on API service.
+     */
+    withDataServiceDeleteFn(serviceFn, fnItemIdParamName) {
+        if (this._dataProvider instanceof TableviewDataProviderInst) {
+            this._dataProvider.withDelete((itemId, service) => service[serviceFn]({ [fnItemIdParamName]: itemId }));
+        }
+        return this;
+    }
     /**
      * Removes all the default tableview actions.
      *
@@ -4655,7 +4087,7 @@ class TableviewInputBuilder {
      * Overrides the default action.
      *
      * @param {TableviewDefaultActionsEnum} type - The default actions to override.
-     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {TvBuilderActionSetterFnType<Model, ActionService , ActionRunInput, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
      * @typeParam ActionService - The service type (same as build `Service` by default).
      * @returns {this} - Returns the current instance of the builder.
      */
@@ -4669,7 +4101,9 @@ class TableviewInputBuilder {
     /**
      * Adds a custom action.
      *
-     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @deprecated Use on of {withActionOnTable}, {withActionOnDetailsEditor}, {withActionOnEditEditor} or {withActionOnAddEditor} instead.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunInput, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
      * @typeParam ActionService - The service type (same as build `Service` by default).
      * @returns {this} - Returns the current instance of the builder.
      */
@@ -4681,14 +4115,98 @@ class TableviewInputBuilder {
         return this;
     }
     /**
+     * Adds a custom action on table row or top (header or toolbar).
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnTable(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            action.withPositionTableviewCategories([TableviewActionDefaultCategories.READ]);
+            if (![
+                ActionPositionEnum.ToolbarLeft,
+                ActionPositionEnum.ToolbarRight,
+                ActionPositionEnum.TableHeader,
+                ActionPositionEnum.RowInline,
+                ActionPositionEnum.RowClick
+            ].includes(action.position)) {
+                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on table (${action.position}), define valid position.`);
+            }
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * Adds a custom action on details editor.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnDetailsEditor(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            action.withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS]);
+            if (![ActionPositionEnum.ToolbarLeft, ActionPositionEnum.ToolbarRight, ActionPositionEnum.FooterLeft, ActionPositionEnum.FooterRight].includes(action.position)) {
+                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on details (${action.position}), define valid position.`);
+            }
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * Adds a custom action on edit editor.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnEditEditor(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            action.withPositionTableviewCategories([TableviewActionDefaultCategories.EDIT]);
+            if (![ActionPositionEnum.ToolbarLeft, ActionPositionEnum.ToolbarRight, ActionPositionEnum.FooterLeft, ActionPositionEnum.FooterRight].includes(action.position)) {
+                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on edit (${action.position}), define valid position.`);
+            }
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * Adds a custom action on add editor.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnAddEditor(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            action.withPositionTableviewCategories([TableviewActionDefaultCategories.ADD]);
+            if (![ActionPositionEnum.ToolbarLeft, ActionPositionEnum.ToolbarRight, ActionPositionEnum.FooterLeft, ActionPositionEnum.FooterRight].includes(action.position)) {
+                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on add (${action.position}), define valid position.`);
+            }
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * @internal
+     *
      * Builds and returns an instance of ITableview.
      * DO NOT CALL this within tableview create callback function!
      *
-     * @return {TableviewInput<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.
+     * @return {TableviewInput<Model, Service, Sorts, Filters, TableModel, AddModel, EditModel, Descriptor, DataProvider>} - The built ITableview instance.
      */
     build() {
         return {
-            actions: createTableviewActions(this._descriptor, this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type), this.defaultActions
+            actions: tableviewCreateDefaultActions(this._descriptor, this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type), this.defaultActions
                 .filter(a => a.descriptor != null)
                 .reduce((acc, a) => ({
                 ...acc,
@@ -4704,129 +4222,28 @@ class TableviewInputBuilder {
  * Creates a tableview with the given model, service.
  *
  * @param {ModelDescriptor<Model>} model - The model descriptor.
- * @param {ServiceClassType<Service>} service - The class type of the service.
+ * @param {ServiceClassType<Service>} [opts.service] - The class type of the service.
+ * @param {TypeDescriptor<Sorts> | ModelDescriptor<Sorts>} [opts.sortsType] - Type of sorts
+ * @param {TypeDescriptor<Filters> | ModelDescriptor<Filters>} [opts.filtersType] - Type of filters.
  * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.
  *
  * @returns A tableview instance with descriptor, data provider and actions.
  */
-function tableview(model, service, buildFn) {
-    const builder = new TableviewInputBuilder(new TableviewDescriptorInst(model), new TableviewDataProviderInst(undefined, service), inject(Injector));
+function tableview(model, opts, buildFn) {
+    const builder = new TableviewInputBuilder(new TableviewDescriptorInst(model), new TableviewDataProviderInst(opts?.service), inject(Injector));
     buildFn?.(builder);
     return builder.build();
 }
-function tableviewWithSortAndFilter(model, service, sorts, filters, buildFn) {
-    const builder = new TableviewInputBuilder(new TableviewDescriptorInst(model), new TableviewDataProviderInst(undefined, service), inject(Injector));
+function tableviewMultiModel(model, opts, buildFn) {
+    const builder = new TableviewInputBuilder(new TableviewDescriptorInst(model, opts), new TableviewDataProviderInst(opts?.service), inject(Injector));
     buildFn?.(builder);
     return builder.build();
 }
 
-function tableviewToDataProvider(descriptor, serviceType) {
+function tableviewDataProviderFromDescriptor(descriptor, serviceType) {
     return typeof serviceType !== 'undefined'
-        ? new TableviewDataProviderInst(undefined, serviceType)
-        : new TableviewDataProviderInst(undefined, undefined);
-}
-
-/**
- * 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;
+        ? new TableviewDataProviderInst(serviceType)
+        : new TableviewDataProviderInst(undefined);
 }
 
 // action descriptors
@@ -4835,5 +4252,5 @@ function modifyTableviewLookupUnsafe(descriptor, property, type, lookupProvider,
  * 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, 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, expandClassAttributeDefWithEditorDef, expandClassAttributeDefWithTableviewDef, fieldLookupGetProviderCfgObj, fieldManyToManyGetProviderCfgObj, getDataProviderService, getEditorClassAttributeDef, getFieldInputTypeFromClassAttributeDefType, getFieldInputTypeFromColumnType, getTableviewClassAttributeDef, getTableviewDefaultActions, 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, tableviewToDataProvider, tableviewWithSortAndFilter, upsertEditorFieldFromAttributeDef };
+export { AFieldDescriptor, AFieldGroupDescriptor, AFormlyCustomFieldComponent, AGenericFieldDescriptor, ActionActivationTriggerEnum, ActionConfirmationDescriptor, ActionDescriptorInst, ActionEditorDescriptorInst, ActionEditorSubmitDescriptorInst, ActionEditorSubmitTypeEnum, ActionInstanceStateEnum, ActionLinkDescriptorInst, ActionPositionEnum, ActionTypeEnum, CommonsActionError, DATA_LANGUAGE_DROPDOWN_COMPONENT_IT, DataProviderExecutor, DynamicTableviewDataProviderInst, EDITOR_DEFAULT_GROUP_NAME, EditorDataProviderInst, EditorDescriptorInst, EditorDescriptorNestedObjectWrapper, FieldActionDescriptor, FieldGroupDescriptor, FieldGroupTypeEnum, FieldInputDescriptor, FieldInputTypeEnum, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupTypeEnum, FieldManyEditorActionEnum, FieldManyEditorDescriptor, FieldManyEditorTypeEnum, FieldManyToManyEditorActionEnum, FieldManyToManyEditorDescriptor, FieldManyToManyEditorTypeEnum, FieldSizeEnum, FieldTabGroupDescriptor, FieldValidationDescriptor, FormEventTypeEnum, FormFieldEventComponentSubtype, FormFieldEventDialogSubtype, FormFieldEventTypeEnum, TableviewActionDefaultCategories, TableviewDataProviderInst, TableviewDefaultActionsEnum, TableviewDescriptorInst, TableviewDynamicDescriptorInt, TableviewEditorTypeEnum, TableviewInputBuilder, action, actionEditor, actionEditorCancel, actionEditorGetProviderCfgObj, actionEditorOnEditor, actionEditorOnTableRow, actionEditorOnTableTop, actionEditorSubmit, actionGetProviderCfgObj, actionLink, actionLinkFromAction, actionOnEditor, actionOnTableRow, actionOnTableTop, convertDataToStringWithDelimiter, editorDataProvider, editorDescriptor, fieldLookupGetProviderCfgObj, fieldManyToManyGetProviderCfgObj, getDataProviderService, runCreateFromDataProvider, runDeleteFromDataProvider, runFetchFromDataProvider, runFnFromDataProviderOrFail, runFnFromDataProviderOrFallback, runGetAllFromDataProvider, runUpdateFromDataProvider, saveFileAs, tableview, tableviewActionAddOnTable, tableviewActionDeleteActionName, tableviewActionDeleteOnDetails, tableviewActionDeleteOnTable, tableviewActionDetailsOnTable, tableviewActionEditOnDetails, tableviewActionEditOnTable, tableviewActionEditorAddActionName, tableviewActionEditorAddRoute, tableviewActionEditorDetailsActionName, tableviewActionEditorDetailsRoute, tableviewActionEditorEditActionName, tableviewActionEditorEditRoute, tableviewActionExportCsvOnTable, tableviewActionExportJsonOnTable, tableviewActionExportOnTable, tableviewActionLocalizationLangSelectOnTable, tableviewActionRefreshOnTable, tableviewCreateDefaultAction, tableviewCreateDefaultActions, tableviewDataProvider, tableviewDataProviderFromDescriptor, tableviewDescriptor, tableviewDescriptorMultiModel, tableviewDynamicDataProvider, tableviewDynamicDescriptor, tableviewGetDefaultActions, tableviewMultiModel };
 //# sourceMappingURL=mediusinc-mng-commons-tableview-api.mjs.map