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

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

@@ -0,0 +1,4372 @@
+import { of, throwError, isObservable, Subject, tap } from 'rxjs';
+import { StyleLevelEnum, CommonsInternalError, findReflectTypeName, DataProvider, LoggerService, StyleSizeEnum, DataProviderInst, ACommonsErrorBase, toObservable, TypeRegistry, I18nUtils, EnumUtil, GetterPipe, DataListParamsUtil } from '@mediusinc/mng-commons/core';
+import { ActionButtonDescriptor, ButtonStyleBuilder, LookupDataProvider, ButtonStyleRoundedEnum } from '@mediusinc/mng-commons/form/api';
+import { ModelDescriptor, ModelUtil, enumModelGeneric } from '@mediusinc/mng-commons/model';
+import * as i0 from '@angular/core';
+import { InjectionToken, Directive, Input, inject, Injector } from '@angular/core';
+import { ColumnTypeEnum, ColumnDisplayTypeEnum, TableDataProvider, getColumnTypeFromClassAttributeDefType, getColumnDisplayTypeFromColumnType, TableDescriptor, TableDynamicDescriptor } from '@mediusinc/mng-commons/table/api';
+import { Validators } from '@angular/forms';
+import { FieldType } from '@ngx-formly/core';
+import { ActivatedRoute } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { map } from 'rxjs/operators';
+
+var ActionPositionEnum;
+(function (ActionPositionEnum) {
+    ActionPositionEnum[ActionPositionEnum["ToolbarLeft"] = 0] = "ToolbarLeft";
+    ActionPositionEnum[ActionPositionEnum["ToolbarRight"] = 1] = "ToolbarRight";
+    ActionPositionEnum[ActionPositionEnum["TableHeader"] = 2] = "TableHeader";
+    ActionPositionEnum[ActionPositionEnum["RowInline"] = 3] = "RowInline";
+    ActionPositionEnum[ActionPositionEnum["RowClick"] = 4] = "RowClick";
+    ActionPositionEnum[ActionPositionEnum["FooterLeft"] = 5] = "FooterLeft";
+    ActionPositionEnum[ActionPositionEnum["FooterRight"] = 6] = "FooterRight";
+})(ActionPositionEnum || (ActionPositionEnum = {}));
+var ActionActivationTriggerEnum;
+(function (ActionActivationTriggerEnum) {
+    ActionActivationTriggerEnum[ActionActivationTriggerEnum["OnClick"] = 0] = "OnClick";
+    ActionActivationTriggerEnum[ActionActivationTriggerEnum["OnRoute"] = 1] = "OnRoute"; // action is triggered for activation by route url
+})(ActionActivationTriggerEnum || (ActionActivationTriggerEnum = {}));
+var ActionTypeEnum;
+(function (ActionTypeEnum) {
+    ActionTypeEnum[ActionTypeEnum["Direct"] = 0] = "Direct";
+    ActionTypeEnum[ActionTypeEnum["Editor"] = 1] = "Editor"; // editor providing middle step for activation
+})(ActionTypeEnum || (ActionTypeEnum = {}));
+var ActionEditorSubmitTypeEnum;
+(function (ActionEditorSubmitTypeEnum) {
+    ActionEditorSubmitTypeEnum[ActionEditorSubmitTypeEnum["Submit"] = 0] = "Submit";
+    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.
+        this._closable = true; // Defines if dialog is closable.
+        this._acceptButton = new ActionButtonDescriptor().withIcon('pi pi-check').withStyleClass(new ButtonStyleBuilder(StyleLevelEnum.Default));
+        this._rejectButton = new ActionButtonDescriptor().withIcon('pi pi-times').withStyleClass(new ButtonStyleBuilder(StyleLevelEnum.Default).withTextButton());
+        this._icon = 'pi pi-exclamation-triangle';
+    }
+    withIcon(icon) {
+        this._icon = icon;
+        return this;
+    }
+    withTitle(title) {
+        this._title = title;
+        return this;
+    }
+    withMessage(message) {
+        this._message = message;
+        return this;
+    }
+    withAcceptButton(actionButtonDescriptor) {
+        this._acceptButton = actionButtonDescriptor;
+        return this;
+    }
+    withRejectButton(actionButtonDescriptor) {
+        this._rejectButton = actionButtonDescriptor;
+        return this;
+    }
+    /**
+     * set if dialog can be closed on escaped pressed
+     * if true, then closable is also set to true
+     * @param closeOnEscape
+     */
+    withCloseOnEscape(closeOnEscape) {
+        if (closeOnEscape) {
+            this._closable = true;
+        }
+        this._closeOnEscape = closeOnEscape;
+        return this;
+    }
+    withClosable(closable) {
+        this._closable = closable;
+        return this;
+    }
+    withRunConfirmationConfigMapFn(runConfirmationConfigMapFn) {
+        this._runConfirmationConfigMapFn = runConfirmationConfigMapFn;
+        return this;
+    }
+    get icon() {
+        return this._icon;
+    }
+    get title() {
+        return this._title;
+    }
+    get message() {
+        return this._message;
+    }
+    get closeOnEscape() {
+        return this._closeOnEscape;
+    }
+    get closable() {
+        return this._closable;
+    }
+    get runConfirmationConfigMapFn() {
+        return this._runConfirmationConfigMapFn;
+    }
+    get acceptButton() {
+        return this._acceptButton;
+    }
+    get rejectButton() {
+        return this._rejectButton;
+    }
+}
+
+const actionGetProviderCfgObj = (serviceOrDataProvider) => {
+    const cfg = {};
+    if (serviceOrDataProvider) {
+        if (serviceOrDataProvider.isDataProvider) {
+            // type casting needed, cause there was no other way found to differentiate the types
+            cfg.dataProvider = serviceOrDataProvider;
+        }
+        else {
+            cfg.serviceType = serviceOrDataProvider;
+        }
+    }
+    return cfg;
+};
+class ActionDescriptorInst {
+    constructor(actionName, cfg) {
+        this._type = ActionTypeEnum.Direct;
+        this._activationTrigger = ActionActivationTriggerEnum.OnClick;
+        this._position = ActionPositionEnum.ToolbarRight;
+        this._level = StyleLevelEnum.Default;
+        this._routeUrl = null;
+        this._hasRunNotificationSuccess = true;
+        this._hasRunNotificationError = true;
+        //button
+        this._button = new ActionButtonDescriptor();
+        // multiple row selection
+        this._hasItemsSelection = false;
+        // subactions
+        this._subactionsAsMenu = false;
+        this._subactions = [];
+        this._model = cfg?.model;
+        this._actionName = actionName;
+        if ((cfg?.parentType && !cfg?.parentProperty) || (!cfg?.parentProperty && cfg?.parentProperty)) {
+            throw new CommonsInternalError(`Provide both the parent type and parent property or none: ${this._actionName}, ${cfg?.parentType}, ${cfg?.parentProperty}.`);
+        }
+        this._parentType = cfg?.parentType;
+        this._parentTypeName = cfg?.parentType ? findReflectTypeName(cfg?.parentType) ?? undefined : undefined;
+        this._parentProperty = cfg?.parentProperty;
+        this.setI18nModelActionBaseKey();
+        if (cfg?.serviceType) {
+            this._dataProvider = DataProvider.fromAnyParam(this._model?.type, cfg.serviceType);
+        }
+        else if (cfg?.dataProvider) {
+            this._dataProvider = cfg.dataProvider;
+        }
+        let displayName = actionName;
+        if (this._model)
+            displayName = `${this._model.typeName ?? this._model.i18nBaseKey ?? 'NoModelName'}.${displayName}`;
+        if (this._parentTypeName) {
+            displayName = `${this._parentTypeName}.${this._parentProperty}_${displayName}`;
+        }
+        this._actionNameLong = displayName;
+    }
+    get model() {
+        return this._model;
+    }
+    get parentTypeName() {
+        return this._parentTypeName;
+    }
+    get parentProperty() {
+        return this._parentProperty;
+    }
+    get i18nModelActionBaseKey() {
+        return this._i18nModelActionBaseKey;
+    }
+    get type() {
+        return this._type;
+    }
+    get activationTrigger() {
+        return this._activationTrigger;
+    }
+    get position() {
+        return this._position;
+    }
+    get level() {
+        return this._level;
+    }
+    get routeUrl() {
+        return this._routeUrl;
+    }
+    get dataProvider() {
+        return this._dataProvider;
+    }
+    get hasRunFunction() {
+        return typeof this._runFunction === 'function';
+    }
+    get runFunction() {
+        if (!this._runFunction) {
+            throw new CommonsInternalError(`Run function is not defined for action ${this._actionNameLong} and cannot be invoked`);
+        }
+        return this._runFunction;
+    }
+    get isVisibleFunction() {
+        return this._isVisibleFunction;
+    }
+    get isEnabledFunction() {
+        return this._isEnabledFunction;
+    }
+    get actionName() {
+        return this._actionName;
+    }
+    get actionNameLong() {
+        return this._actionNameLong;
+    }
+    get className() {
+        return this.button.styleClass.customClass;
+    }
+    get runConfirmationDialogDescriptor() {
+        return this._runConfirmationDialogDescriptor;
+    }
+    get hasRunConfirmation() {
+        return this._runConfirmationDialogDescriptor !== null && this._runConfirmationDialogDescriptor !== undefined;
+    }
+    get hasRunNotificationSuccess() {
+        return this._hasRunNotificationSuccess;
+    }
+    get runNotificationSuccessTitle() {
+        return this._runNotificationSuccessTitle;
+    }
+    get runNotificationSuccessMessage() {
+        return this._runNotificationSuccessMessage;
+    }
+    get hasRunNotificationError() {
+        return this._hasRunNotificationError;
+    }
+    get runNotificationErrorTitle() {
+        return this._runNotificationErrorTitle;
+    }
+    get runNotificationErrorMessage() {
+        return this._runNotificationErrorMessage;
+    }
+    get afterRunAction() {
+        return this._afterRunAction;
+    }
+    get onRunErrorAction() {
+        return this._onRunErrorAction;
+    }
+    get permissions() {
+        return this._permissions;
+    }
+    get tableviewCategory() {
+        return this._tableviewCategory;
+    }
+    get hasItemsSelection() {
+        return this._hasItemsSelection;
+    }
+    get button() {
+        return this._button;
+    }
+    get component() {
+        return this._component;
+    }
+    get componentFromDi() {
+        return this._componentFromDi;
+    }
+    get positionTableviewCategories() {
+        return this._positionTableviewCategories;
+    }
+    get subactionsAsMenu() {
+        return this._subactionsAsMenu;
+    }
+    get subactions() {
+        return this._subactions;
+    }
+    setI18nModelActionBaseKey(base) {
+        if (this._parentTypeName || this._model) {
+            this._i18nModelActionBaseKey = this._parentTypeName
+                ? `${this._parentTypeName}.actions.${this._parentProperty}_${this._actionName}`
+                : `${base ?? this._model.i18nBaseKey}.actions.${this._actionName}`;
+        }
+    }
+    withRunFunction(fn) {
+        this._runFunction = fn;
+        return this;
+    }
+    withIsVisibleFunction(fn) {
+        this._isVisibleFunction = fn;
+        return this;
+    }
+    withIsEnabledFunction(fn) {
+        this._isEnabledFunction = fn;
+        return this;
+    }
+    withRouteTrigger(routeUrl) {
+        this._activationTrigger = ActionActivationTriggerEnum.OnRoute;
+        this._routeUrl = routeUrl;
+        return this;
+    }
+    withPosition(position) {
+        this._position = position;
+        return this;
+    }
+    /**
+     * creates confirmation action with default style based on action descriptor
+     */
+    withRunConfirmation() {
+        this._runConfirmationDialogDescriptor = new ActionConfirmationDescriptor();
+        this._runConfirmationDialogDescriptor.acceptButton.styleClass.withActionLevel(this._level);
+        this._runConfirmationDialogDescriptor.rejectButton?.styleClass.withActionLevel(this._level);
+        return this._runConfirmationDialogDescriptor;
+    }
+    /**
+     * Add a configuration dialogue to action using ActionConfigurationDescriptor
+     * @param runConfirmationDialogDescriptor descriptor with customizable information for dialog
+     */
+    withRunConfirmationDescriptor(runConfirmationDialogDescriptor) {
+        this._runConfirmationDialogDescriptor = runConfirmationDialogDescriptor;
+        return this;
+    }
+    withRunNotificationSuccess(title, message, hasNotification = true) {
+        this._hasRunNotificationSuccess = hasNotification;
+        this._runNotificationSuccessTitle = title;
+        this._runNotificationSuccessMessage = message;
+        return this;
+    }
+    withRunNotificationError(title, message, hasNotification = true) {
+        this._hasRunNotificationError = hasNotification;
+        this._runNotificationErrorTitle = title;
+        this._runNotificationErrorMessage = message;
+        return this;
+    }
+    withAfterRunAction(action) {
+        this._afterRunAction = action;
+        return this;
+    }
+    withOnRunErrorAction(action) {
+        this._onRunErrorAction = action;
+        return this;
+    }
+    withPermissions(permissions) {
+        if (this._tableviewCategory) {
+            LoggerService.get().debug(`WARNING: Permissions set on action ${this._actionNameLong} with route type '${this._tableviewCategory}' will be omitted in route guard validation.`);
+        }
+        this._permissions = permissions;
+        return this;
+    }
+    withTableviewCategory(permissionsRouteType) {
+        this._tableviewCategory = permissionsRouteType;
+        return this;
+    }
+    withButtonDescriptor(button) {
+        this._button = button;
+        return this;
+    }
+    withButton(label, icon = null, styleLevel = StyleLevelEnum.Default, styleText = false) {
+        this._button = new ActionButtonDescriptor().withLabel(label).withIcon(icon).withStyleClass(new ButtonStyleBuilder(styleLevel).withTextButton(styleText));
+        return this;
+    }
+    withItemsSelection(hasSelection = true) {
+        this._hasItemsSelection = hasSelection;
+        this._isEnabledFunction = this._isEnabledFunction ?? (ctx => of((ctx.parameters.selectedItems?.length ?? 0) > 0));
+        return this;
+    }
+    withComponent(component) {
+        this._component = component;
+        return this;
+    }
+    withComponentFromDi(injectionToken) {
+        this._componentFromDi = injectionToken;
+        return this;
+    }
+    withPositionTableviewCategories(positionTableviewCategories) {
+        this._positionTableviewCategories = positionTableviewCategories;
+        return this;
+    }
+    withI18nBase(base) {
+        if (typeof base !== 'string') {
+            const typeName = findReflectTypeName(base);
+            if (!typeName) {
+                throw new CommonsInternalError(`Could not find define i18nBaseKey for ${base} on action ${this.actionNameLong}`);
+            }
+            base = typeName;
+        }
+        this.setI18nModelActionBaseKey(base);
+        return this;
+    }
+    withSubactionsAsMenu(subactionsAsMenu = true) {
+        this._subactionsAsMenu = subactionsAsMenu;
+        return this;
+    }
+    withSubactions(...subactions) {
+        this._subactions.push(...subactions);
+        return this;
+    }
+    copyTo(descriptor) {
+        descriptor._i18nModelActionBaseKey = this._i18nModelActionBaseKey;
+        descriptor._type = this._type;
+        descriptor._activationTrigger = this._activationTrigger;
+        descriptor._position = this._position;
+        descriptor._level = this._level;
+        descriptor._positionTableviewCategories = this._positionTableviewCategories;
+        descriptor._tableviewCategory = this._tableviewCategory;
+        descriptor._routeUrl = this._routeUrl;
+        descriptor._runFunction = this._runFunction;
+        descriptor._isVisibleFunction = this._isVisibleFunction;
+        descriptor._isEnabledFunction = this._isEnabledFunction;
+        descriptor._runConfirmationDialogDescriptor = this._runConfirmationDialogDescriptor;
+        descriptor._hasRunNotificationSuccess = this._hasRunNotificationSuccess;
+        descriptor._runNotificationSuccessTitle = this._runNotificationSuccessTitle;
+        descriptor._runNotificationSuccessMessage = this._runNotificationSuccessMessage;
+        descriptor._hasRunNotificationError = this._hasRunNotificationError;
+        descriptor._runNotificationErrorTitle = this._runNotificationErrorTitle;
+        descriptor._runNotificationErrorMessage = this._runNotificationErrorMessage;
+        descriptor._afterRunAction = this._afterRunAction;
+        descriptor._onRunErrorAction = this._onRunErrorAction;
+        descriptor._permissions = this._permissions;
+        descriptor._button = this._button.copy();
+        descriptor._hasItemsSelection = this._hasItemsSelection;
+        descriptor._component = this._component;
+        descriptor._subactionsAsMenu = this._subactionsAsMenu;
+        descriptor._subactions = this._subactions;
+        return descriptor;
+    }
+}
+class ActionDescriptor extends ActionDescriptorInst {
+    constructor() {
+        super('internal');
+    }
+    static create(actionName, cfg) {
+        return new ActionDescriptorInst(actionName, {
+            ...cfg
+        });
+    }
+    static createWithProvider(serviceProvider, actionName, cfg) {
+        return new ActionDescriptorInst(actionName, {
+            ...actionGetProviderCfgObj(serviceProvider),
+            ...cfg
+        });
+    }
+    static fromModel(model, actionName, cfg) {
+        return new ActionDescriptorInst(actionName, {
+            model,
+            ...cfg
+        });
+    }
+    static fromModelWithProvider(model, serviceProvider, actionName, cfg) {
+        return new ActionDescriptorInst(actionName, {
+            model,
+            ...actionGetProviderCfgObj(serviceProvider),
+            ...cfg
+        });
+    }
+    static fromClass(type, actionName, cfg) {
+        return new ActionDescriptorInst(actionName, {
+            model: ModelDescriptor.fromClass(type, cfg?.idProperty, cfg?.titleProperty, cfg?.i18nBaseKey),
+            ...cfg
+        });
+    }
+    static fromClassWithProvider(classType, serviceProvider, actionName, cfg) {
+        return new ActionDescriptorInst(actionName, {
+            model: ModelDescriptor.fromClass(classType, cfg?.idProperty, cfg?.titleProperty, cfg?.i18nBaseKey),
+            ...actionGetProviderCfgObj(serviceProvider),
+            ...cfg
+        });
+    }
+}
+class ActionDeleteDescriptorInst extends ActionDescriptorInst {
+    static { this.ACTION_NAME = 'delete'; }
+    constructor(model, cfg) {
+        super(ActionDeleteDescriptorInst.ACTION_NAME, { model, ...cfg });
+        this.withPosition(ActionPositionEnum.RowInline);
+        this.button.styleClass.withSize(StyleSizeEnum.Small);
+        this.button.styleClass.withActionLevel(StyleLevelEnum.Danger);
+        this.withRunConfirmation();
+        this.withTableviewCategory(TableviewActionDefaultCategories.DELETE);
+        this.button.withLabel(null).withIcon('pi pi-trash');
+    }
+}
+class ActionDeleteDescriptor {
+    static create(model) {
+        return new ActionDeleteDescriptorInst(model);
+    }
+    static createWithProvider(model, serviceProvider) {
+        return new ActionDeleteDescriptorInst(model, {
+            ...actionGetProviderCfgObj(serviceProvider)
+        });
+    }
+}
+
+class EditorDataProviderInst extends DataProviderInst {
+    constructor(type, serviceType) {
+        super(type, serviceType);
+        this._fetch = id => throwError(() => new CommonsInternalError(`No fetch function provided for id ${id}.`));
+    }
+    get fetch() {
+        return this._fetch;
+    }
+    get create() {
+        return this._create;
+    }
+    get update() {
+        return this._update;
+    }
+    get delete() {
+        return this._delete;
+    }
+    /**
+     * Sets the fetch function for the EditorDataProvider instance.
+     *
+     * @param {EditorDataProviderFetchFnType<Model, Service>} fn - The fetch function to be set.
+     * @returns {this} - The instance of the EditorDataProvider with the fetch function set.
+     *
+     * @typeparam Model The type of data this DataProvider will handle.
+     * @typeparam Service The type of service used by this DataProvider.
+     */
+    withFetch(fn) {
+        this._fetch = fn;
+        return this;
+    }
+    /**
+     * Sets the create function for the EditorDataProvider.
+     *
+     * @param {EditorDataProviderCreateFnType<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.
+     * @typeparam Service The type of service used by this DataProvider.
+     */
+    withCreate(fn) {
+        this._create = fn;
+        return this;
+    }
+    /**
+     * Sets the update function for the EditorDataProvider.
+     *
+     * @param {EditorDataProviderUpdateFnType<Model, Service>} fn - The update function to be set.
+     * @returns {this} - Returns the instance of the object calling this method.
+     *
+     * @typeparam Model The type of data this DataProvider will handle.
+     * @typeparam Service The type of service used by this DataProvider.
+     */
+    withUpdate(fn) {
+        this._update = fn;
+        return this;
+    }
+    /**
+     * Sets the delete function for the editor data provider.
+     *
+     * @param {EditorDataProviderDeleteFnType<Model, Service>} fn - The delete function to be set.
+     *
+     * @returns {this} - Returns the instance of the current class.
+     *
+     * @typeparam Model The type of data this DataProvider will handle.
+     * @typeparam Service The type of service used by this DataProvider.
+     */
+    withDelete(fn) {
+        this._delete = fn;
+        return this;
+    }
+}
+class EditorDataProvider extends EditorDataProviderInst {
+    constructor() {
+        super(undefined, undefined);
+    }
+    static create() {
+        return new EditorDataProviderInst(undefined, undefined);
+    }
+    static fromClass(type) {
+        return new EditorDataProviderInst(type, undefined);
+    }
+    static fromClassWithService(type, serviceType) {
+        return new EditorDataProviderInst(type, serviceType);
+    }
+    static fromService(serviceType) {
+        return new EditorDataProviderInst(undefined, serviceType);
+    }
+    static fromAnyParam(type, serviceType) {
+        if (typeof type !== 'undefined') {
+            return typeof serviceType !== 'undefined'
+                ? EditorDataProvider.fromClassWithService(type, serviceType)
+                : EditorDataProvider.fromClass(type);
+        }
+        else if (typeof serviceType !== 'undefined') {
+            return EditorDataProvider.fromService(serviceType);
+        }
+        else {
+            return EditorDataProvider.create();
+        }
+    }
+}
+
+const actionEditorGetProviderCfgObj = (serviceOrDataProvider) => {
+    const cfg = {};
+    if (serviceOrDataProvider) {
+        if (serviceOrDataProvider.isDataProvider) {
+            // type casting needed, cause there was no other way found to differentiate the types
+            cfg.dataProvider = serviceOrDataProvider;
+        }
+        else {
+            cfg.serviceType = serviceOrDataProvider;
+        }
+    }
+    return cfg;
+};
+class ActionEditorDescriptorInst extends ActionDescriptorInst {
+    constructor(editorDescriptor, actionName, cfg) {
+        super(actionName, {
+            model: editorDescriptor.model,
+            ...cfg
+        });
+        this._dataProvider = undefined;
+        this._editorActions = [];
+        this._editorTitle = undefined;
+        this._editorTitleParams = undefined;
+        this._hasFetchNotificationSuccess = false;
+        this._dialogSize = StyleSizeEnum.Normal;
+        this._resubmitRefetch = true;
+        this._unsavedChangesConfirmation = false;
+        if (cfg?.serviceType) {
+            this._dataProvider = EditorDataProvider.fromAnyParam(this._model?.type, cfg.serviceType);
+        }
+        else if (cfg?.dataProvider) {
+            this._dataProvider = cfg.dataProvider;
+        }
+        this._type = ActionTypeEnum.Editor;
+        this._editorDescriptor = editorDescriptor;
+        this._editorActions.push(ActionEditorSubmitDescriptor.forPrimary(this), ActionEditorSubmitDescriptor.forSecondary(this));
+    }
+    get editorTitle() {
+        return this._editorTitle;
+    }
+    get editorTitleParams() {
+        return this._editorTitleParams;
+    }
+    get editorDescriptor() {
+        return this._editorDescriptor;
+    }
+    get dialogSize() {
+        return this._dialogSize;
+    }
+    get dialogClassName() {
+        return this._dialogClassName;
+    }
+    get hasFetchNotificationSuccess() {
+        return this._hasFetchNotificationSuccess;
+    }
+    get fetchNotificationSuccessTitle() {
+        return this._fetchNotificationSuccessTitle;
+    }
+    get fetchNotificationSuccessMessage() {
+        return this._fetchNotificationSuccessMessage;
+    }
+    get dataProvider() {
+        return this._dataProvider;
+    }
+    get hasRunFunction() {
+        throw new CommonsInternalError(`Run function cannot be used in editor action for ${this._actionNameLong}. Use submit function instead`);
+    }
+    get runFunction() {
+        throw new CommonsInternalError(`Run function cannot be used in editor action for ${this._actionNameLong}. Use submit function instead`);
+    }
+    get hasFetchFunction() {
+        return typeof this._fetchFunction === 'function';
+    }
+    get fetchFunction() {
+        return this._fetchFunction;
+    }
+    get hasSubmitFunction() {
+        return typeof this._fetchFunction === 'function';
+    }
+    get submitFunction() {
+        return this._submitFunction;
+    }
+    get editorActions() {
+        return this._editorActions;
+    }
+    get editorComponent() {
+        return this._editorComponent;
+    }
+    get resubmitEnabled() {
+        return this._resubmitEnabled;
+    }
+    get resubmitRefetch() {
+        return this._resubmitRefetch;
+    }
+    get unsavedChangesConfirmation() {
+        return this._unsavedChangesConfirmation;
+    }
+    withEditorTitle(title, params) {
+        this._editorTitle = title;
+        this._editorTitleParams = params;
+        return this;
+    }
+    withDialogSize(size = StyleSizeEnum.Normal) {
+        this._dialogSize = size;
+        return this;
+    }
+    withDialogClassName(className) {
+        this._dialogClassName = className;
+        return this;
+    }
+    withRunFunction(fn) {
+        return this.withSubmitFunction(fn);
+    }
+    withFetchFunction(fn) {
+        this._fetchFunction = fn;
+        return this;
+    }
+    withSubmitFunction(fn) {
+        this._submitFunction = fn;
+        return this;
+    }
+    withFetchNotificationError(title, message, hasNotification = true) {
+        this._hasFetchNotificationSuccess = hasNotification;
+        this._fetchNotificationSuccessTitle = title;
+        this._fetchNotificationSuccessMessage = message;
+        return this;
+    }
+    withEditorAction(action) {
+        this._editorActions.push(action);
+        return this;
+    }
+    withEditorActions(actions) {
+        this._editorActions = actions;
+        return this;
+    }
+    withEditorComponent(editorComponent) {
+        this._editorComponent = editorComponent;
+        return this;
+    }
+    withResubmit(enabled, refetch = true) {
+        this._resubmitEnabled = enabled;
+        this._resubmitRefetch = refetch;
+        return this;
+    }
+    withUnsavedChangesConfirmation(unsavedChangesConfirmation = true) {
+        this._unsavedChangesConfirmation = unsavedChangesConfirmation;
+        return this;
+    }
+}
+class ActionEditorDescriptor {
+    static create(editor, actionName, cfg) {
+        return new ActionEditorDescriptorInst(editor, actionName, {
+            parentType: cfg?.parentType,
+            parentProperty: cfg?.parentProperty
+        });
+    }
+    static createWithProvider(editor, serviceProvider, actionName, cfg) {
+        return new ActionEditorDescriptorInst(editor, actionName, {
+            ...actionEditorGetProviderCfgObj(serviceProvider),
+            parentType: cfg?.parentType,
+            parentProperty: cfg?.parentProperty
+        });
+    }
+}
+class ActionEditorSubmitDescriptorInst extends ActionDescriptorInst {
+    constructor(editorAction, submitType = ActionEditorSubmitTypeEnum.Submit) {
+        super(submitType === ActionEditorSubmitTypeEnum.Submit ? `${editorAction.actionName}.submit` : `${editorAction.actionName}.cancel`, { model: editorAction.model });
+        this._editorAction = editorAction;
+        this._submitType = submitType;
+        this._position = ActionPositionEnum.FooterRight;
+        this.button.styleClass.withActionLevel(editorAction.level).withTextButton();
+    }
+    get submitType() {
+        return this._submitType;
+    }
+}
+class ActionEditorSubmitDescriptor {
+    /**
+     * creates primary action with primary button style
+     * @param editorAction
+     * @param submitType
+     */
+    static forPrimary(editorAction, submitType = ActionEditorSubmitTypeEnum.Submit) {
+        return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder()));
+    }
+    /**
+     * creates secondary button with text button style
+     * @param editorAction
+     * @param submitType
+     */
+    static forSecondary(editorAction, submitType = ActionEditorSubmitTypeEnum.Cancel) {
+        return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withTextButton()));
+    }
+}
+class ActionEditorDetailsDescriptorInst extends ActionEditorDescriptorInst {
+    static { this.ACTION_NAME = 'details'; }
+    constructor(editorDescriptor, cfg) {
+        super(editorDescriptor, ActionEditorDetailsDescriptorInst.ACTION_NAME, cfg);
+        this.withPosition(ActionPositionEnum.RowClick);
+        this.withRouteTrigger(':itemId');
+        this.withEditorActions([ActionEditorSubmitDescriptor.forSecondary(this, ActionEditorSubmitTypeEnum.Cancel)]);
+        this.withTableviewCategory(TableviewActionDefaultCategories.DETAILS);
+    }
+}
+class ActionEditorDetailsDescriptor {
+    static create(editor) {
+        return new ActionEditorDetailsDescriptorInst(editor);
+    }
+    static createWithProvider(editor, serviceProvider) {
+        return new ActionEditorDetailsDescriptorInst(editor, {
+            ...actionEditorGetProviderCfgObj(serviceProvider)
+        });
+    }
+}
+class ActionEditorAddDescriptorInst extends ActionEditorDescriptorInst {
+    static { this.ACTION_NAME = 'add'; }
+    constructor(editorDescriptor, cfg) {
+        super(editorDescriptor, ActionEditorAddDescriptorInst.ACTION_NAME, cfg);
+        this.withPosition(ActionPositionEnum.ToolbarLeft);
+        this.withRouteTrigger('add');
+        this.button.withIcon('pi pi-plus');
+        this.withTableviewCategory(TableviewActionDefaultCategories.ADD);
+        this.withUnsavedChangesConfirmation();
+    }
+}
+class ActionEditorAddDescriptor {
+    static create(editor) {
+        return new ActionEditorAddDescriptorInst(editor);
+    }
+    static createWithProvider(editor, serviceProvider) {
+        return new ActionEditorAddDescriptorInst(editor, {
+            ...actionEditorGetProviderCfgObj(serviceProvider)
+        });
+    }
+}
+class ActionEditorEditDescriptorInst extends ActionEditorDescriptorInst {
+    static { this.ACTION_NAME = 'edit'; }
+    constructor(editorDescriptor, cfg) {
+        super(editorDescriptor, ActionEditorEditDescriptorInst.ACTION_NAME, cfg);
+        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();
+    }
+}
+class ActionEditorEditDescriptor {
+    static create(editor) {
+        return new ActionEditorEditDescriptorInst(editor);
+    }
+    static createWithProvider(editor, serviceProvider) {
+        return new ActionEditorEditDescriptorInst(editor, {
+            ...actionEditorGetProviderCfgObj(serviceProvider)
+        });
+    }
+}
+
+class ActionLinkDescriptorInst extends ActionDescriptorInst {
+    constructor(actionName = 'link', cfg) {
+        super(actionName, cfg);
+        this._url = '';
+        this._pathSegments = [];
+        this._replaceUrl = false;
+        this._target = '_self';
+        this._isStyleLink = false;
+    }
+    get url() {
+        return this._url;
+    }
+    get pathSegments() {
+        return this._pathSegments;
+    }
+    get queryParams() {
+        return this._queryParams;
+    }
+    get queryParamsHandling() {
+        return this._queryParamsHandling;
+    }
+    get replaceUrl() {
+        return this._replaceUrl;
+    }
+    get target() {
+        return this._target;
+    }
+    get isStyleLink() {
+        return this._isStyleLink;
+    }
+    withHref(url) {
+        this._url = url;
+        return this;
+    }
+    withRouterLink(...pathSegments) {
+        this._pathSegments = pathSegments;
+        return this;
+    }
+    withQueryParams(queryParams, queryParamsHandling) {
+        this._queryParams = queryParams;
+        this._queryParamsHandling = queryParamsHandling;
+        return this;
+    }
+    withReplaceUrl(replaceUrl = false) {
+        this._replaceUrl = replaceUrl;
+        return this;
+    }
+    withTarget(target = '_self') {
+        this._target = target;
+        return this;
+    }
+    withStyleLink(isStyleLink) {
+        this._isStyleLink = isStyleLink;
+        return this;
+    }
+}
+class ActionLinkDescriptor {
+    static create(actionName, cfg) {
+        return new ActionLinkDescriptorInst(actionName, {
+            ...cfg
+        });
+    }
+    static fromModel(model, actionName, cfg) {
+        return new ActionLinkDescriptorInst(actionName, {
+            model,
+            ...cfg
+        });
+    }
+    static fromClass(type, actionName, cfg) {
+        return new ActionLinkDescriptorInst(actionName, {
+            model: ModelDescriptor.fromClass(type, cfg?.idProperty, cfg?.titleProperty, cfg?.i18nBaseKey),
+            ...cfg
+        });
+    }
+    static fromAction(action) {
+        const descriptor = new ActionLinkDescriptorInst(action.actionName, { model: action.model });
+        action.copyTo(descriptor);
+        descriptor.withRunConfirmationDescriptor();
+        descriptor.withRunNotificationSuccess(undefined, undefined, false);
+        descriptor.withRunNotificationError(undefined, undefined, false);
+        descriptor.withAfterRunAction();
+        descriptor.withOnRunErrorAction();
+        descriptor.withSubactionsAsMenu(false);
+        return descriptor;
+    }
+}
+
+class CommonsActionError extends ACommonsErrorBase {
+    constructor(message, actionName, options) {
+        super(message, {
+            name: 'CommonsActionError_' + actionName,
+            ...options
+        });
+        this.type = 'CommonsActionError';
+        this.actionId = actionName;
+        this.actionContext = options?.actionContext;
+        this.httpError = options?.httpError;
+    }
+}
+
+function runFnFromDataProviderOrFallback(ctx, fn, fallback) {
+    const dataProviderExec = fn(ctx);
+    if (isObservable(dataProviderExec)) {
+        return dataProviderExec;
+    }
+    return fallback;
+}
+function runFnFromDataProviderOrFail(ctx, fn) {
+    const dataProviderExec = fn(ctx);
+    if (isObservable(dataProviderExec)) {
+        return dataProviderExec;
+    }
+    return throwError(() => new CommonsActionError(`Data provider could not extract function to execute in action ${ctx.instance.action.actionNameLong} (${ctx.instance.action.model?.typeName}) for item id ${ctx.parameters?.itemId}.`, ctx.contextLongName, { actionContext: ctx }));
+}
+function runGetAllFromDataProvider(ctx) {
+    if (typeof ctx.dataProvider !== 'undefined' && typeof ctx.dataProvider['getAll'] === 'function') {
+        const tableDataProvider = ctx.dataProvider;
+        const queryParam = ctx.parameters?.dataListParams ?? {};
+        return toObservable(tableDataProvider.getAll(queryParam, ctx.serviceInstance));
+    }
+    return null;
+}
+function runFetchFromDataProvider(ctx) {
+    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 null;
+}
+function runCreateFromDataProvider(ctx) {
+    if (typeof ctx.dataProvider !== 'undefined') {
+        const editorDataProvider = ctx.dataProvider;
+        if (typeof editorDataProvider.create === 'function') {
+            return ctx.parameters?.item ? toObservable(editorDataProvider.create(ctx.parameters.item, ctx.serviceInstance)) : null;
+        }
+    }
+    return null;
+}
+function runUpdateFromDataProvider(ctx) {
+    if (typeof ctx.dataProvider !== 'undefined') {
+        const editorDataProvider = ctx.dataProvider;
+        if (typeof editorDataProvider.update === 'function') {
+            return ctx.parameters?.itemId ? toObservable(editorDataProvider.update(ctx.parameters.itemId, ctx.parameters.item, ctx.serviceInstance)) : null;
+        }
+    }
+    return null;
+}
+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 null;
+}
+/**
+ * Gets service instance of data provider.
+ *
+ * @param injector Injector instance
+ * @param dataProvider Data provider instance.
+ */
+function getDataProviderService(injector, dataProvider) {
+    if (dataProvider?.serviceType) {
+        const service = injector.get(dataProvider.serviceType, undefined, { optional: true });
+        if (!service) {
+            throw new CommonsInternalError(`Data provider service type ${dataProvider.serviceType} could not be injected.`);
+        }
+        return service;
+    }
+    else {
+        return null;
+    }
+}
+
+/**
+ * States of action. Enums ending with `*Final` are supposed to be final.
+ */
+var ActionInstanceStateEnum;
+(function (ActionInstanceStateEnum) {
+    ActionInstanceStateEnum[ActionInstanceStateEnum["TriggerStart"] = 0] = "TriggerStart";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["TriggerEnd"] = 1] = "TriggerEnd";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["ActivationStart"] = 2] = "ActivationStart";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["ActivationEnd"] = 3] = "ActivationEnd";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FetchStart"] = 4] = "FetchStart";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FetchEnd"] = 5] = "FetchEnd";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FetchError"] = 6] = "FetchError";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["RunConfirmationStart"] = 7] = "RunConfirmationStart";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["RunConfirmationEndAccept"] = 8] = "RunConfirmationEndAccept";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["RunConfirmationEndReject"] = 9] = "RunConfirmationEndReject";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["RunStart"] = 10] = "RunStart";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["RunEnd"] = 11] = "RunEnd";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["RunError"] = 12] = "RunError";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["NextActionStart"] = 13] = "NextActionStart";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["NextActionEnd"] = 14] = "NextActionEnd";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["ErrorActionStart"] = 15] = "ErrorActionStart";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["ErrorActionEnd"] = 16] = "ErrorActionEnd";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FinishSuccessFinal"] = 17] = "FinishSuccessFinal";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FinishErrorFinal"] = 18] = "FinishErrorFinal";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FinishDismissedFinal"] = 19] = "FinishDismissedFinal";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FinishSuccessReactivateFinal"] = 20] = "FinishSuccessReactivateFinal";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FinishComponentDestroyFinal"] = 21] = "FinishComponentDestroyFinal";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FinishRouteUntriggerStart"] = 22] = "FinishRouteUntriggerStart";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FinishRouteUntriggerEndFinal"] = 23] = "FinishRouteUntriggerEndFinal";
+    ActionInstanceStateEnum[ActionInstanceStateEnum["FinishRouteUntriggerTimeoutFinal"] = 24] = "FinishRouteUntriggerTimeoutFinal";
+})(ActionInstanceStateEnum || (ActionInstanceStateEnum = {}));
+
+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));
+    }
+    runCreateOrFail(ctx) {
+        return runFnFromDataProviderOrFail(ctx, this.runCreate.bind(this));
+    }
+    runUpdateOrFail(ctx) {
+        return runFnFromDataProviderOrFail(ctx, this.runUpdate.bind(this));
+    }
+    runDeleteOrFail(ctx) {
+        return runFnFromDataProviderOrFail(ctx, this.runDelete.bind(this));
+    }
+    /**
+     * Gets service instance of data provider.
+     *
+     * @param injector Injector instance
+     * @param dataProvider Data provider instance.
+     */
+    getDataProviderService(injector, dataProvider) {
+        return getDataProviderService(injector, dataProvider);
+    }
+}
+
+var FieldSizeEnum;
+(function (FieldSizeEnum) {
+    FieldSizeEnum[FieldSizeEnum["Small"] = 0] = "Small";
+    FieldSizeEnum[FieldSizeEnum["Normal"] = 1] = "Normal";
+    FieldSizeEnum[FieldSizeEnum["Large"] = 2] = "Large";
+})(FieldSizeEnum || (FieldSizeEnum = {}));
+var FieldInputTypeEnum;
+(function (FieldInputTypeEnum) {
+    FieldInputTypeEnum[FieldInputTypeEnum["Hidden"] = 0] = "Hidden";
+    FieldInputTypeEnum[FieldInputTypeEnum["Label"] = 1] = "Label";
+    FieldInputTypeEnum[FieldInputTypeEnum["Text"] = 2] = "Text";
+    FieldInputTypeEnum[FieldInputTypeEnum["Textarea"] = 3] = "Textarea";
+    FieldInputTypeEnum[FieldInputTypeEnum["Number"] = 4] = "Number";
+    FieldInputTypeEnum[FieldInputTypeEnum["Currency"] = 5] = "Currency";
+    FieldInputTypeEnum[FieldInputTypeEnum["Switch"] = 6] = "Switch";
+    FieldInputTypeEnum[FieldInputTypeEnum["Radio"] = 7] = "Radio";
+    FieldInputTypeEnum[FieldInputTypeEnum["Datepicker"] = 8] = "Datepicker";
+    FieldInputTypeEnum[FieldInputTypeEnum["Mask"] = 9] = "Mask";
+    FieldInputTypeEnum[FieldInputTypeEnum["File"] = 10] = "File";
+    FieldInputTypeEnum[FieldInputTypeEnum["ImageFile"] = 11] = "ImageFile";
+    FieldInputTypeEnum[FieldInputTypeEnum["ImageUrl"] = 12] = "ImageUrl";
+    FieldInputTypeEnum[FieldInputTypeEnum["Custom"] = 13] = "Custom";
+})(FieldInputTypeEnum || (FieldInputTypeEnum = {}));
+var FieldLookupTypeEnum;
+(function (FieldLookupTypeEnum) {
+    FieldLookupTypeEnum[FieldLookupTypeEnum["Dropdown"] = 0] = "Dropdown";
+    FieldLookupTypeEnum[FieldLookupTypeEnum["Autocomplete"] = 1] = "Autocomplete";
+    FieldLookupTypeEnum[FieldLookupTypeEnum["Dialog"] = 2] = "Dialog";
+    FieldLookupTypeEnum[FieldLookupTypeEnum["Custom"] = 3] = "Custom";
+})(FieldLookupTypeEnum || (FieldLookupTypeEnum = {}));
+var FieldManyToManyEditorTypeEnum;
+(function (FieldManyToManyEditorTypeEnum) {
+    FieldManyToManyEditorTypeEnum[FieldManyToManyEditorTypeEnum["DialogTableMultiselect"] = 0] = "DialogTableMultiselect";
+})(FieldManyToManyEditorTypeEnum || (FieldManyToManyEditorTypeEnum = {}));
+var FieldManyToManyEditorActionEnum;
+(function (FieldManyToManyEditorActionEnum) {
+    FieldManyToManyEditorActionEnum[FieldManyToManyEditorActionEnum["Add"] = 0] = "Add";
+    FieldManyToManyEditorActionEnum[FieldManyToManyEditorActionEnum["Delete"] = 1] = "Delete";
+})(FieldManyToManyEditorActionEnum || (FieldManyToManyEditorActionEnum = {}));
+var FieldManyEditorTypeEnum;
+(function (FieldManyEditorTypeEnum) {
+    FieldManyEditorTypeEnum[FieldManyEditorTypeEnum["DialogEditor"] = 0] = "DialogEditor";
+})(FieldManyEditorTypeEnum || (FieldManyEditorTypeEnum = {}));
+var FieldManyEditorActionEnum;
+(function (FieldManyEditorActionEnum) {
+    FieldManyEditorActionEnum[FieldManyEditorActionEnum["View"] = 0] = "View";
+    FieldManyEditorActionEnum[FieldManyEditorActionEnum["Add"] = 1] = "Add";
+    FieldManyEditorActionEnum[FieldManyEditorActionEnum["Edit"] = 2] = "Edit";
+    FieldManyEditorActionEnum[FieldManyEditorActionEnum["Delete"] = 3] = "Delete";
+})(FieldManyEditorActionEnum || (FieldManyEditorActionEnum = {}));
+var FieldGroupTypeEnum;
+(function (FieldGroupTypeEnum) {
+    FieldGroupTypeEnum[FieldGroupTypeEnum["Fieldset"] = 0] = "Fieldset";
+    FieldGroupTypeEnum[FieldGroupTypeEnum["Logical"] = 1] = "Logical";
+})(FieldGroupTypeEnum || (FieldGroupTypeEnum = {}));
+
+/**
+ * converts string type to type enum, default is text
+ * @param attributeType
+ */
+function getFieldInputTypeFromClassAttributeDefType(attributeType) {
+    switch (attributeType) {
+        case 'hidden':
+            return FieldInputTypeEnum.Hidden;
+        case 'label':
+            return FieldInputTypeEnum.Label;
+        case 'textarea':
+            return FieldInputTypeEnum.Textarea;
+        case 'number':
+            return FieldInputTypeEnum.Number;
+        case 'currency':
+            return FieldInputTypeEnum.Currency;
+        case 'switch':
+        case 'boolean':
+            return FieldInputTypeEnum.Switch;
+        case 'radio':
+            return FieldInputTypeEnum.Radio;
+        case 'datepicker':
+            return FieldInputTypeEnum.Datepicker;
+        case 'mask':
+            return FieldInputTypeEnum.Mask;
+        case 'file':
+            return FieldInputTypeEnum.File;
+        case 'custom':
+            return FieldInputTypeEnum.Custom;
+        case 'text':
+        default:
+            return FieldInputTypeEnum.Text;
+    }
+}
+/**
+ * convert column type to equivalent field input type
+ * @param type column type
+ * @param displayType column display type
+ */
+function getFieldInputTypeFromColumnType(type, displayType) {
+    switch (type) {
+        case ColumnTypeEnum.Number:
+            return displayType === ColumnDisplayTypeEnum.Currency ? FieldInputTypeEnum.Currency : FieldInputTypeEnum.Number;
+        case ColumnTypeEnum.Boolean:
+            return FieldInputTypeEnum.Switch;
+        case ColumnTypeEnum.Date:
+            return FieldInputTypeEnum.Datepicker;
+        case ColumnTypeEnum.Custom:
+            return FieldInputTypeEnum.Custom;
+        case ColumnTypeEnum.String:
+        case ColumnTypeEnum.Enum:
+        default:
+            return FieldInputTypeEnum.Text;
+    }
+}
+function expandClassAttributeDefWithEditorDef(attributes) {
+    if (!attributes) {
+        throw new CommonsInternalError('Class attribute definition is null, problem with TypeRegistry::findAttributesDefinitionByClassType?', { name: 'TableviewUtilsError' });
+    }
+    const typeRegistry = TypeRegistry.get();
+    const editorClassAttributeDef = [];
+    for (const attribute of attributes) {
+        editorClassAttributeDef.push({
+            name: attribute.name,
+            baseName: attribute.baseName,
+            type: attribute.type,
+            subtype: attribute.subtype,
+            fieldType: getFieldInputTypeFromClassAttributeDefType(attribute.type),
+            classType: typeRegistry.findType(attribute.type),
+            enumType: typeRegistry.findEnum(attribute.type)
+        });
+    }
+    return editorClassAttributeDef;
+}
+/**
+ * returns attributes from class type and extends to typed def with column and field enum type
+ * @param type class type
+ */
+function getEditorClassAttributeDef(type) {
+    return expandClassAttributeDefWithEditorDef(TypeRegistry.get().findAttributesDefinitionByClassType(type));
+}
+
+var TableviewEditorTypeEnum;
+(function (TableviewEditorTypeEnum) {
+    TableviewEditorTypeEnum[TableviewEditorTypeEnum["None"] = 0] = "None";
+    TableviewEditorTypeEnum[TableviewEditorTypeEnum["Details"] = 1] = "Details";
+    TableviewEditorTypeEnum[TableviewEditorTypeEnum["Edit"] = 2] = "Edit";
+    TableviewEditorTypeEnum[TableviewEditorTypeEnum["Add"] = 3] = "Add";
+})(TableviewEditorTypeEnum || (TableviewEditorTypeEnum = {}));
+const EDITOR_DEFAULT_GROUP_NAME = '_default';
+
+class FieldValidationDescriptor {
+    constructor(name, validator, message, options) {
+        this._name = name;
+        this._validator = validator;
+        this._message = message;
+        this._options = options;
+    }
+    get name() {
+        return this._name;
+    }
+    get validator() {
+        return this._validator;
+    }
+    get message() {
+        return this._message;
+    }
+    get options() {
+        return this._options;
+    }
+    copy() {
+        const opt = this._options ? { ...this._options } : undefined;
+        return new FieldValidationDescriptor(this._name, this._validator, this._message, opt);
+    }
+}
+
+class AGenericFieldDescriptor {
+    constructor(editor) {
+        this._config = {};
+        this._editor = editor;
+    }
+    get editor() {
+        return this._editor;
+    }
+    get config() {
+        return this._config;
+    }
+    withConfig(config) {
+        this._config = config;
+        return this;
+    }
+    /**
+     * Override toJSON implementation to prevent overflow with circular dependency.
+     * @ignore
+     */
+    toJSON() {
+        const jsonObj = {
+            ...this,
+            _editor: undefined
+        };
+        const jsonObjStr = JSON.stringify(jsonObj);
+        return jsonObjStr;
+    }
+}
+class AFieldDescriptor extends AGenericFieldDescriptor {
+    constructor(editor, property) {
+        super(editor);
+        /** @ignore */ this._required = false;
+        /** @ignore */ this._requiredHideLabelMarker = false;
+        /** @ignore */ this._disabled = false;
+        /** @ignore */ this._validations = [];
+        /** @ignore */ this._asyncValidations = [];
+        /** @ignore */ this._updateOn = 'change';
+        /** @ignore */ this._className = '';
+        /** @ignore */ this._labelClassName = '';
+        /** @ignore */ this._inputClassName = '';
+        /** @ignore */ this._size = FieldSizeEnum.Normal;
+        // localization
+        /** @ignore */ this._isLocalized = false;
+        /** @ignore */ this._eventsSubject = new Subject();
+        this._property = property;
+        this._label = I18nUtils.Type.getPropertyKey(this._editor.model.i18nBaseKey, property);
+    }
+    get property() {
+        return this._property;
+    }
+    get label() {
+        return this._label;
+    }
+    get placeholder() {
+        return this._placeholder;
+    }
+    get helpText() {
+        return this._helpText;
+    }
+    get required() {
+        return this._required;
+    }
+    get requiredHideLabelMarker() {
+        return this._requiredHideLabelMarker;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    get defaultValue() {
+        return this._defaultValue;
+    }
+    get getter() {
+        return this._getter;
+    }
+    get setter() {
+        return this._setter;
+    }
+    get validations() {
+        return this._validations;
+    }
+    get asyncValidations() {
+        return this._asyncValidations;
+    }
+    get requiredExpression() {
+        return this._requiredExpression;
+    }
+    get disabledExpression() {
+        return this._disabledExpression;
+    }
+    get hiddenExpression() {
+        return this._hiddenExpression;
+    }
+    get updateOn() {
+        return this._updateOn;
+    }
+    get onInit() {
+        return this._onInit;
+    }
+    get onChanges() {
+        return this._onChanges;
+    }
+    get afterContentInit() {
+        return this._afterContentInit;
+    }
+    get afterViewInit() {
+        return this._afterViewInit;
+    }
+    get onDestroy() {
+        return this._onDestroy;
+    }
+    get onValueChange() {
+        return this._onValueChange;
+    }
+    get className() {
+        return this._className;
+    }
+    get fieldClassName() {
+        return this._fieldClassName;
+    }
+    get labelClassName() {
+        return this._labelClassName;
+    }
+    get inputClassName() {
+        return this._inputClassName;
+    }
+    get size() {
+        return this._size;
+    }
+    get isSizeSmall() {
+        return this._size === FieldSizeEnum.Small;
+    }
+    get isSizeLarge() {
+        return this._size === FieldSizeEnum.Large;
+    }
+    get isLocalized() {
+        return this._isLocalized;
+    }
+    withLabel(label) {
+        this._label = label;
+        return this;
+    }
+    withPlaceholder(placeholder) {
+        this._placeholder = placeholder;
+        return this;
+    }
+    withHelpText(helpText) {
+        this._helpText = helpText;
+        return this;
+    }
+    withRequired(required = true, requiredExpression, hideLabelMarker = false) {
+        this._required = required;
+        if (requiredExpression) {
+            this._requiredExpression = requiredExpression;
+        }
+        this._requiredHideLabelMarker = hideLabelMarker;
+        return this;
+    }
+    withDisabled(disabled = true, disabledExpression) {
+        this._disabled = disabled;
+        if (disabledExpression) {
+            this._disabledExpression = disabledExpression;
+        }
+        return this;
+    }
+    withHidden(hiddenExpression) {
+        this._hiddenExpression = hiddenExpression;
+        return this;
+    }
+    withUpdateOn(updateOn) {
+        this._updateOn = updateOn;
+        return this;
+    }
+    withOnInit(onInit) {
+        this._onInit = onInit;
+        return this;
+    }
+    withOnChanges(onChanges) {
+        this._onChanges = onChanges;
+        return this;
+    }
+    withAfterContentInit(afterContentInit) {
+        this._afterContentInit = afterContentInit;
+        return this;
+    }
+    withAfterViewInit(afterViewInit) {
+        this._afterViewInit = afterViewInit;
+        return this;
+    }
+    withOnDestroy(onDestroy) {
+        this._onDestroy = onDestroy;
+        return this;
+    }
+    withOnValueChange(onValueChange) {
+        this._onValueChange = onValueChange;
+        return this;
+    }
+    withDefaultValue(defaultValue) {
+        this._defaultValue = defaultValue;
+        return this;
+    }
+    withGetter(fn) {
+        this._getter = fn;
+        return this;
+    }
+    withSetter(fn) {
+        this._setter = fn;
+        return this;
+    }
+    withValidation(name, validator, message) {
+        this._validations.push(new FieldValidationDescriptor(name, validator, message));
+        return this;
+    }
+    removeValidation(name) {
+        this._validations = this._validations.filter(v => v.name !== name);
+        return this;
+    }
+    withAsyncValidation(name, asyncValidator, message) {
+        this._asyncValidations.push(new FieldValidationDescriptor(name, asyncValidator, message));
+        return this;
+    }
+    removeAsyncValidation(name) {
+        this._asyncValidations = this._asyncValidations.filter(v => v.name !== name);
+        return this;
+    }
+    withClassName(className, labelClassName = '', inputClassName = '', fieldClassName) {
+        this._className = className;
+        this._labelClassName = labelClassName;
+        this._inputClassName = inputClassName;
+        this._fieldClassName = fieldClassName;
+        return this;
+    }
+    withSize(size = FieldSizeEnum.Normal) {
+        this._size = size;
+        return this;
+    }
+    /**
+     * This method adds an icon with text Show all translations above the field and after clicking on it, it displays a new dialog with tableview.
+     * This new table view shows all available translations for specific property and allows editing it.
+     */
+    localized() {
+        if (!this.editor.isLocalized) {
+            throw new CommonsInternalError(`Localization cannot be set for field ${this.property}, localization must be enabled on editor first.`);
+        }
+        this._isLocalized = true;
+        return this;
+    }
+    nextEvent(type, cmpType, cmpInstance, data) {
+        this._eventsSubject.next({
+            type: type,
+            componentType: cmpType,
+            componentInstance: cmpInstance,
+            data: data
+        });
+    }
+    get events$() {
+        return this._eventsSubject.asObservable();
+    }
+    copyFieldsTo(obj) {
+        obj._label = this._label;
+        obj._placeholder = this._placeholder;
+        obj._helpText = this._helpText;
+        obj._required = this._required;
+        obj._disabled = this._disabled;
+        obj._defaultValue = this._defaultValue;
+        obj._requiredExpression = this._requiredExpression;
+        obj._hiddenExpression = this._hiddenExpression;
+        obj._updateOn = this._updateOn;
+        obj._onInit = this._onInit;
+        obj._onChanges = this._onChanges;
+        obj._onDestroy = this._onDestroy;
+        obj._afterContentInit = this._afterContentInit;
+        obj._afterViewInit = this._afterViewInit;
+        obj._onValueChange = this._onValueChange;
+        obj._disabledExpression = this._disabledExpression;
+        obj._className = this._className;
+        obj._size = this.size;
+        obj._getter = this._getter;
+        obj._setter = this._setter;
+        obj._isLocalized = this._isLocalized;
+        obj._validations = this._validations.map(value => value.copy());
+        obj._asyncValidations = this._asyncValidations.map(value => value.copy());
+    }
+}
+
+class FieldActionDescriptor extends AFieldDescriptor {
+    constructor(editor, property) {
+        super(editor, property);
+        this._button = new ActionButtonDescriptor();
+        this._wrappers = ['field'];
+        this._fieldActionName = property;
+        let displayName = property;
+        if (this._editor.model)
+            displayName = `${this._editor.model.typeName}.${displayName}`;
+        this._fieldActionNameLong = displayName;
+    }
+    get button() {
+        return this._button;
+    }
+    get runFunction() {
+        return this._runFunction;
+    }
+    get wrappers() {
+        return this._wrappers;
+    }
+    withButtonDescriptor(button) {
+        this._button = button;
+        return this;
+    }
+    withButton(label, icon = null, styleLevel = StyleLevelEnum.Default, styleText = false) {
+        this._button = new ActionButtonDescriptor().withLabel(label).withIcon(icon).withStyleClass(new ButtonStyleBuilder(styleLevel).withTextButton(styleText));
+        return this;
+    }
+    withRunFunction(fn) {
+        this._runFunction = fn;
+        return this;
+    }
+    withWrappers(wrappers) {
+        this._wrappers = wrappers;
+        return this;
+    }
+    copy() {
+        const field = new FieldActionDescriptor(this._editor, this._property);
+        this.copyFieldsTo(field);
+        field._button = this._button.copy();
+        field._runFunction = this._runFunction?.bind(field);
+        field._wrappers = [...this._wrappers];
+        return field;
+    }
+}
+
+class AFieldGroupDescriptor extends AGenericFieldDescriptor {
+    constructor(editor, name) {
+        super(editor);
+        this._fields = [];
+        this._validations = [];
+        this._name = `${this.baseName}${name}`;
+        this._default = name === EDITOR_DEFAULT_GROUP_NAME;
+    }
+    removeField(property, filterFunction) {
+        this._fields = filterFunction(this._fields);
+        return this._fields;
+    }
+    get title() {
+        return this._title;
+    }
+    get validations() {
+        return this._validations;
+    }
+    get baseName() {
+        return `${this.groupName()}_`;
+    }
+    get name() {
+        return this._name;
+    }
+    get default() {
+        return this._default;
+    }
+    withTitle(title) {
+        this._title = title;
+        return this;
+    }
+    withValidation(name, validator, message) {
+        this._validations.push(new FieldValidationDescriptor(name, validator, message));
+        return this;
+    }
+}
+class FieldTabGroupDescriptor extends AFieldGroupDescriptor {
+    constructor(editor, name) {
+        super(editor, name);
+    }
+    get fields() {
+        return this._fields;
+    }
+    groupName() {
+        return 'tab';
+    }
+    addField(field) {
+        this._fields.push(field);
+        return this;
+    }
+    copy() {
+        const tab = new FieldTabGroupDescriptor(this._editor, this.name.substring(this.baseName.length));
+        tab._title = this._title;
+        tab._fields = this.fields.map(f => f.copy());
+        tab._validations = this.validations.map(v => v.copy());
+        return tab;
+    }
+}
+class FieldGroupDescriptor extends AFieldGroupDescriptor {
+    constructor(editor, name) {
+        super(editor, name);
+        this._type = FieldGroupTypeEnum.Fieldset;
+        if (this._default) {
+            this.asLogical();
+        }
+    }
+    get type() {
+        return this._type;
+    }
+    get fields() {
+        return this._fields;
+    }
+    groupName() {
+        return 'group';
+    }
+    addField(field) {
+        this._fields.push(field);
+        return this;
+    }
+    asLogical() {
+        this._type = FieldGroupTypeEnum.Logical;
+        return this;
+    }
+    copy() {
+        const group = new FieldGroupDescriptor(this._editor, this.name.substring(this.baseName.length));
+        group._type = this._type;
+        group._title = this._title;
+        group._fields = this.fields.map(f => f.copy());
+        group._validations = this.validations.map(v => v.copy());
+        return group;
+    }
+}
+
+const fieldLookupGetProviderCfgObj = (serviceOrDataProvider) => {
+    const cfg = {};
+    if (serviceOrDataProvider) {
+        if (serviceOrDataProvider.isDataProvider) {
+            // type casting needed, cause there was no other way found to differentiate the types
+            cfg.dataProvider = serviceOrDataProvider;
+        }
+        else {
+            cfg.serviceType = serviceOrDataProvider;
+        }
+    }
+    return cfg;
+};
+class FieldLookupDescriptor extends AFieldDescriptor {
+    constructor(editor, property, cfg) {
+        super(editor, property);
+        this._lookupType = FieldLookupTypeEnum.Dropdown;
+        this._optionsLabelTranslate = false;
+        this._dropdownClassName = 'mng-filter-lookup-dropdown';
+        if (cfg?.dataProvider) {
+            this._dataProvider = cfg.dataProvider;
+        }
+        else {
+            this._dataProvider = LookupDataProvider.fromAnyParam(cfg?.type, cfg?.serviceType);
+        }
+        this._optionsValueProperty = cfg?.optionsValueProperty;
+        ModelUtil.trySetLookupItemsProperties(this);
+    }
+    get lookupType() {
+        return this._lookupType;
+    }
+    get optionsLabelProperty() {
+        return this._optionsLabelProperty;
+    }
+    get optionsLabelTranslate() {
+        return this._optionsLabelTranslate;
+    }
+    get optionsValueProperty() {
+        return this._optionsValueProperty;
+    }
+    get optionsDisabledProperty() {
+        return this._optionsDisabledProperty;
+    }
+    get optionsTrackProperty() {
+        return this._optionsTrackProperty;
+    }
+    get dataProvider() {
+        return this._dataProvider;
+    }
+    get autocompleteOpenOnFocus() {
+        return this._autocompleteOpenOnFocus;
+    }
+    get autocompleteInlineSearch() {
+        return this._autocompleteInlineSearch;
+    }
+    get autocompleteAutoClear() {
+        return this._autocompleteAutoClear;
+    }
+    get autocompleteSelectFirst() {
+        return this._autocompleteSelectFirst;
+    }
+    get dropdownClassName() {
+        return this._dropdownClassName;
+    }
+    get dialogTableDescriptor() {
+        return this._dialogTableDescriptor;
+    }
+    get dialogTableDataProvider() {
+        return this._dialogTableDataProvider;
+    }
+    get customComponentName() {
+        return this._customComponentName;
+    }
+    get trimOption() {
+        return this._autocompleteInputTrim;
+    }
+    withOptionsLabelProperty(property, translate = false) {
+        return this.withOptionsLabelPropertyUnsafe(property, translate);
+    }
+    withOptionsLabelPropertyUnsafe(property, translate = false) {
+        this._optionsLabelProperty = property;
+        this._optionsLabelTranslate = translate;
+        return this;
+    }
+    withOptionsDisabledProperty(property) {
+        return this.withOptionsDisabledPropertyUnsafe(property);
+    }
+    withOptionsDisabledPropertyUnsafe(property) {
+        this._optionsDisabledProperty = property;
+        return this;
+    }
+    withOptionsTrackProperty(property) {
+        return this.withOptionsTrackPropertyUnsafe(property);
+    }
+    withOptionsTrackPropertyUnsafe(property) {
+        if (this._optionsValueProperty) {
+            return this;
+        }
+        this._optionsTrackProperty = property;
+        return this;
+    }
+    withLookup(lookup) {
+        this._dataProvider.withLookup(lookup);
+        return this;
+    }
+    withInputTrim(trimOption = 'both') {
+        this._autocompleteInputTrim = trimOption;
+        return this;
+    }
+    withConfig(config) {
+        return super.withConfig(config);
+    }
+    asAutocomplete(opts) {
+        this._lookupType = FieldLookupTypeEnum.Autocomplete;
+        this._autocompleteAutoClear = opts?.autoClear;
+        this._autocompleteSelectFirst = opts?.selectFirst;
+        this._autocompleteOpenOnFocus = opts?.openOnFocus;
+        this._autocompleteInlineSearch = opts?.inlineSearch;
+        return this;
+    }
+    asDialog(lookupTableDescriptor, tableDataProvider) {
+        this._lookupType = FieldLookupTypeEnum.Dialog;
+        this._dialogTableDescriptor = lookupTableDescriptor;
+        this._dialogTableDataProvider = tableDataProvider;
+        return this;
+    }
+    asCustomComponent(customComponentName) {
+        this._lookupType = FieldLookupTypeEnum.Custom;
+        this._customComponentName = customComponentName;
+        return this;
+    }
+    copy() {
+        const field = new FieldLookupDescriptor(this._editor, this._property, {
+            dataProvider: this._dataProvider,
+            optionsValueProperty: this._optionsValueProperty
+        });
+        this.copyFieldsTo(field);
+        field._lookupType = this._lookupType;
+        field._optionsLabelProperty = this._optionsLabelProperty;
+        field._optionsLabelTranslate = this._optionsLabelTranslate;
+        field._optionsDisabledProperty = this._optionsDisabledProperty;
+        field._optionsTrackProperty = this._optionsTrackProperty;
+        field._dropdownClassName = this._dropdownClassName;
+        field._autocompleteOpenOnFocus = this._autocompleteOpenOnFocus;
+        field._autocompleteInlineSearch = this._autocompleteInlineSearch;
+        field._dialogTableDescriptor = this._dialogTableDescriptor;
+        return field;
+    }
+}
+class FieldLookupEnumDescriptor extends FieldLookupDescriptor {
+    constructor(editor, property, enumModel, options) {
+        super(editor, property, {
+            dataProvider: LookupDataProvider.create(),
+            optionsValueProperty: 'value'
+        });
+        this._enumModel = enumModel;
+        this._optionEnumValues = Array.isArray(options)
+            ? EnumUtil.fromValuesAsEnumValueArray(this._enumModel.type, options, this._enumModel.nameAsValue, this._enumModel.i18nBaseKey ?? undefined)
+            : EnumUtil.fromConstantsAsEnumValueArray(this._enumModel.type, this._enumModel.nameAsValue, this._enumModel.i18nBaseKey ?? undefined);
+        this.withLookup(() => of(this._optionEnumValues));
+        this.withOptionsLabelProperty('title', this._enumModel.i18nBaseKey !== null);
+        this.withOptionsDisabledProperty('disabled');
+    }
+    get enumModel() {
+        return this._enumModel;
+    }
+    withDisabledOptions(...disabledOptions) {
+        for (const disabledOption of disabledOptions) {
+            const disabledOptionValue = this._enumModel.nameAsValue ? EnumUtil.getConstantName(this._enumModel.type, disabledOption) : disabledOption;
+            if (disabledOptionValue) {
+                const option = this._optionEnumValues.find(o => o.value === disabledOptionValue);
+                if (option) {
+                    option.disabled = true;
+                }
+            }
+        }
+        return this;
+    }
+    withDefaultValueEnum(defaultValue) {
+        const defaultOptionValue = this._enumModel.nameAsValue ? EnumUtil.getConstantName(this._enumModel.type, defaultValue) : defaultValue;
+        if (defaultOptionValue) {
+            const option = this._optionEnumValues.find(o => o.value === defaultOptionValue);
+            if (option) {
+                this.withDefaultValue(option[this._optionsValueProperty]);
+            }
+        }
+        return this;
+    }
+    asAutocomplete(opts) {
+        super.asAutocomplete({
+            ...opts,
+            openOnFocus: opts?.openOnFocus ?? true,
+            inlineSearch: opts?.inlineSearch ?? true
+        });
+        return this;
+    }
+    copy() {
+        const field = new FieldLookupEnumDescriptor(this._editor, this._property, this._enumModel, []);
+        this.copyFieldsTo(field);
+        field._lookupType = this._lookupType;
+        field._optionsLabelProperty = this._optionsLabelProperty;
+        field._optionsDisabledProperty = this._optionsDisabledProperty;
+        field._optionsTrackProperty = this._optionsTrackProperty;
+        return field;
+    }
+}
+
+const fieldManyToManyGetProviderCfgObj = (serviceOrDataProvider) => {
+    const cfg = {};
+    if (serviceOrDataProvider) {
+        if (serviceOrDataProvider.isDataProvider) {
+            // type casting needed, cause there was no other way found to differentiate the types
+            cfg.lookupDataProvider = serviceOrDataProvider;
+        }
+        else {
+            cfg.lookupServiceType = serviceOrDataProvider;
+        }
+    }
+    return cfg;
+};
+class FieldManyToManyEditorDescriptor extends AFieldDescriptor {
+    constructor(editor, property, mainTableDescriptor, lookupTableDescriptor, cfg) {
+        super(editor, property);
+        this._fieldType = FieldManyToManyEditorTypeEnum.DialogTableMultiselect;
+        this._actions = [FieldManyToManyEditorActionEnum.Add, FieldManyToManyEditorActionEnum.Delete];
+        this._hasLookupExcludeValues = false;
+        this._excludeFilterProperty = '';
+        this._excludeValueProperty = '';
+        this._searchEnabled = false;
+        this._mainTableDescriptor = mainTableDescriptor;
+        this._lookupTableDescriptor = lookupTableDescriptor;
+        if (cfg?.lookupDataProvider) {
+            this._lookupTableDataProvider = cfg.lookupDataProvider;
+        }
+        else {
+            this._lookupTableDataProvider = TableDataProvider.fromAnyParam(lookupTableDescriptor.model.type, cfg?.lookupServiceType);
+        }
+    }
+    get fieldType() {
+        return this._fieldType;
+    }
+    get actions() {
+        return this._actions;
+    }
+    get hasLookupExcludeValues() {
+        return this._hasLookupExcludeValues;
+    }
+    get excludeFilterProperty() {
+        return this._excludeFilterProperty;
+    }
+    get excludeValueProperty() {
+        return this._excludeValueProperty;
+    }
+    get mainTableDescriptor() {
+        return this._mainTableDescriptor;
+    }
+    get lookupTableDescriptor() {
+        return this._lookupTableDescriptor;
+    }
+    get lookupTableDataProvider() {
+        return this._lookupTableDataProvider;
+    }
+    get searchEnabled() {
+        return this._searchEnabled;
+    }
+    get searchFields() {
+        return this._searchFields;
+    }
+    withLookup(fn) {
+        this._lookupTableDataProvider.withGetAll(fn);
+        return this;
+    }
+    withActions(actions = []) {
+        this.actions.push(...actions);
+        return this;
+    }
+    withLookupExclude(filterProperty, valueProperty, hasLookupExclude = true) {
+        return this.withLookupExcludeUnsafe(filterProperty, valueProperty, hasLookupExclude);
+    }
+    withLookupExcludeUnsafe(filterProperty, valueProperty, hasLookupExclude = true) {
+        this._hasLookupExcludeValues = hasLookupExclude;
+        this._excludeFilterProperty = filterProperty;
+        this._excludeValueProperty = valueProperty;
+        return this;
+    }
+    withSearch(enabled = true, searchFields) {
+        this._searchEnabled = enabled;
+        this._searchFields = searchFields;
+        return this;
+    }
+    copy() {
+        const field = new FieldManyToManyEditorDescriptor(this._editor, this._property, this._mainTableDescriptor.copy(), this._lookupTableDescriptor.copy(), {
+            lookupDataProvider: this.lookupTableDataProvider
+        });
+        this.copyFieldsTo(field);
+        field._fieldType = this._fieldType;
+        field._actions = this._actions.map(a => a);
+        field._hasLookupExcludeValues = this._hasLookupExcludeValues;
+        field._excludeFilterProperty = this._excludeFilterProperty;
+        field._excludeValueProperty = this._excludeValueProperty;
+        return field;
+    }
+}
+class FieldManyEditorDescriptor extends AFieldDescriptor {
+    constructor(editor, property, tableviewDescriptor) {
+        super(editor, property);
+        this._fieldType = FieldManyEditorTypeEnum.DialogEditor;
+        this._fieldActions = [];
+        this._actions = [];
+        this._tableviewDescriptor = tableviewDescriptor;
+        this._fieldActions.push(FieldManyEditorActionEnum.View, FieldManyEditorActionEnum.Add, FieldManyEditorActionEnum.Edit, FieldManyEditorActionEnum.Delete);
+    }
+    get fieldType() {
+        return this._fieldType;
+    }
+    get fieldActions() {
+        return this._fieldActions;
+    }
+    get actions() {
+        return this._actions;
+    }
+    get tableviewDescriptor() {
+        return this._tableviewDescriptor;
+    }
+    get tableDescriptor() {
+        return this._tableviewDescriptor.table;
+    }
+    get editorForCreate() {
+        return this._tableviewDescriptor.addEditor;
+    }
+    get editorForRead() {
+        return this._tableviewDescriptor.detailsEditor;
+    }
+    get editorForUpdate() {
+        return this._tableviewDescriptor.editEditor;
+    }
+    withFieldAction(action) {
+        this._fieldActions.push(action);
+        return this;
+    }
+    withFieldActions(actions) {
+        this._fieldActions = actions;
+        return this;
+    }
+    withAction(action) {
+        this._actions.push(action);
+        return this;
+    }
+    copy() {
+        const field = new FieldManyEditorDescriptor(this._editor, this._property, this._tableviewDescriptor.copy());
+        this.copyFieldsTo(field);
+        field._fieldType = this._fieldType;
+        field._fieldActions = this._fieldActions.map(a => a);
+        return field;
+    }
+}
+
+const minDateValidator = (min) => {
+    return (c) => {
+        const date = c?.value;
+        const valid = !date || date >= min;
+        if (!valid) {
+            const newErrors = { ...c.errors, minDate: true };
+            c?.markAsDirty();
+            c.setErrors(newErrors);
+            return newErrors;
+        }
+        if (c?.hasError('minDate')) {
+            c.setErrors({ ...c.errors, minDate: null });
+        }
+        return null;
+    };
+};
+const maxDateValidator = (max) => {
+    return (c) => {
+        const date = c?.value;
+        const valid = !date || date <= max;
+        if (!valid) {
+            const newErrors = { ...c.errors, maxDate: true };
+            c?.markAsDirty();
+            c.setErrors(newErrors);
+            return newErrors;
+        }
+        if (c?.hasError('maxDate')) {
+            c.setErrors({ ...c.errors, maxDate: null });
+        }
+        return null;
+    };
+};
+
+class FieldInputDescriptor extends AFieldDescriptor {
+    constructor(editor, property) {
+        super(editor, property);
+        this._fieldType = FieldInputTypeEnum.Text;
+        this._numberUseGrouping = true;
+        this._currencyDisplay = 'symbol';
+        // radio specific properties
+        this._radioOptions = [];
+    }
+    /**
+     * converts field to given type with additional arguments
+     * @param fieldType field type enum
+     * @param args any additional arguments for field (optional)
+     */
+    asType(fieldType, ...args) {
+        switch (fieldType) {
+            case FieldInputTypeEnum.Hidden:
+                return this.asHidden();
+            case FieldInputTypeEnum.Label:
+                return this.asLabel();
+            case FieldInputTypeEnum.Textarea:
+                return this.asTextarea(...args);
+            case FieldInputTypeEnum.Number:
+                return this.asNumber(...args);
+            case FieldInputTypeEnum.Currency:
+                return this.asCurrency(...args);
+            case FieldInputTypeEnum.Switch:
+                return this.asSwitch();
+            case FieldInputTypeEnum.Radio:
+                return this.asRadio(args[0], args[1]);
+            case FieldInputTypeEnum.Datepicker:
+                return this.asDatePicker(...args);
+            case FieldInputTypeEnum.Mask:
+                return this.asMask(args[0], args[1]);
+            case FieldInputTypeEnum.File:
+                return this.asFile(...args);
+            case FieldInputTypeEnum.ImageFile:
+                return this.asImageFile(...args);
+            case FieldInputTypeEnum.ImageUrl:
+                return this.asImageUrl(...args);
+            case FieldInputTypeEnum.Custom:
+                return this.asCustomComponent(args[0], args[1]);
+            case FieldInputTypeEnum.Text:
+                return this.asText(args[0]);
+        }
+    }
+    get fieldType() {
+        return this._fieldType;
+    }
+    get rows() {
+        return this._rows;
+    }
+    get numberMin() {
+        return this._numberMin;
+    }
+    get numberMax() {
+        return this._numberMax;
+    }
+    get numberStep() {
+        return this._numberStep;
+    }
+    get numberAutoCorrect() {
+        return this._numberAutoCorrect;
+    }
+    get numberMinFractionDigits() {
+        return this._numberMinFractionDigits;
+    }
+    get numberMaxFractionDigits() {
+        return this._numberMaxFractionDigits;
+    }
+    get numberUseGrouping() {
+        return this._numberUseGrouping;
+    }
+    get radioOptions() {
+        return this._radioOptions;
+    }
+    get datePickerFormat() {
+        return this._datePickerFormat;
+    }
+    get datePickerMin() {
+        return this._datePickerMin;
+    }
+    get datePickerMax() {
+        return this._datePickerMax;
+    }
+    get datePickerShowTime() {
+        return this._datePickerShowTime;
+    }
+    get datePickerShowSeconds() {
+        return this._datePickerShowSeconds;
+    }
+    get maxLength() {
+        return this._maxLength;
+    }
+    get minLength() {
+        return this._minLength;
+    }
+    get pattern() {
+        return this._pattern;
+    }
+    get trimOption() {
+        return this._inputTrim;
+    }
+    get mask() {
+        return this._mask;
+    }
+    get slotChar() {
+        return this._slotChar;
+    }
+    get fileMultiple() {
+        return this._fileMultiple;
+    }
+    get fileMaxFileSize() {
+        return this._fileMaxFileSize;
+    }
+    get fileAccept() {
+        return this._fileAccept;
+    }
+    get fileOnSelectHandler() {
+        return this._fileOnSelectHandler;
+    }
+    get imagePreview() {
+        return this._imagePreview;
+    }
+    get imageUrlInputVisibleOnDisabled() {
+        return this._imageUrlInputHiddenOnDisabled;
+    }
+    get customComponentType() {
+        return this._customComponentType;
+    }
+    get customComponentInputs() {
+        return this._customComponentInputs;
+    }
+    get customComponentWrappers() {
+        return this._customComponentWrappers;
+    }
+    get locale() {
+        return this._locale;
+    }
+    get currency() {
+        return this._currency;
+    }
+    get currencyFromProperty() {
+        return this._currencyFromProperty;
+    }
+    get currencyDisplay() {
+        return this._currencyDisplay;
+    }
+    asHidden() {
+        this._fieldType = FieldInputTypeEnum.Hidden;
+        return this;
+    }
+    asLabel() {
+        this._fieldType = FieldInputTypeEnum.Label;
+        return this;
+    }
+    asText(opts) {
+        this._fieldType = FieldInputTypeEnum.Text;
+        return this.withTextValidation(opts).withTextValidationEmail(opts?.email ?? false);
+    }
+    asTextarea(opts) {
+        this._fieldType = FieldInputTypeEnum.Textarea;
+        this._rows = opts?.rows;
+        return this.withTextValidation(opts);
+    }
+    asNumber(opts) {
+        this._fieldType = FieldInputTypeEnum.Number;
+        return this.withNumberGrouping(opts?.groupSeparator ?? false)
+            .withNumberFractions(opts)
+            .withNumberValidation(opts)
+            .withLocale(opts?.locale);
+    }
+    asCurrency(opts) {
+        return this.asCurrencyUnsafe({
+            ...opts,
+            currencyProperty: opts?.currencyProperty ? opts.currencyProperty : undefined
+        });
+    }
+    asCurrencyUnsafe(opts) {
+        this._fieldType = FieldInputTypeEnum.Currency;
+        this._currencyFromProperty = opts?.currencyProperty;
+        this._currency = opts?.currency ?? this._currency;
+        this._currencyDisplay = opts?.currencyDisplay ?? this._currencyDisplay;
+        return this.withNumberGrouping(opts?.groupSeparator ?? false)
+            .withNumberFractions({
+            maxFractionDigits: opts?.maxFractionDigits ?? 2,
+            minFractionDigits: opts?.minFractionDigits ?? 2
+        })
+            .withNumberValidation(opts)
+            .withLocale(opts?.locale);
+    }
+    asSwitch() {
+        this._fieldType = FieldInputTypeEnum.Switch;
+        return this;
+    }
+    asRadio(options, optionsTitlePath) {
+        this._fieldType = FieldInputTypeEnum.Radio;
+        this._radioOptions = options.map(o => ({ value: o, title: `${optionsTitlePath ? `${optionsTitlePath}.` : ''}${o}` }));
+        return this;
+    }
+    asRadioFromEnum(enumModel, values) {
+        this._fieldType = FieldInputTypeEnum.Radio;
+        this._radioOptions = Array.isArray(values)
+            ? EnumUtil.fromValuesAsEnumValueArray(enumModel.type, values, enumModel.nameAsValue, enumModel.i18nBaseKey ?? undefined)
+            : EnumUtil.fromConstantsAsEnumValueArray(enumModel.type, enumModel.nameAsValue, enumModel.i18nBaseKey ?? undefined);
+        return this;
+    }
+    asDatePicker(opts) {
+        this._fieldType = FieldInputTypeEnum.Datepicker;
+        this._datePickerFormat = opts?.format;
+        this._datePickerMin = opts?.min;
+        this._datePickerMax = opts?.max;
+        this._datePickerShowTime = opts?.showTime;
+        this._datePickerShowSeconds = opts?.showSeconds;
+        if (opts?.min != undefined) {
+            this.withValidation('minDate', minDateValidator(opts.min));
+        }
+        if (opts?.max !== undefined) {
+            this.withValidation('maxDate', maxDateValidator(opts.max));
+        }
+        return this;
+    }
+    asMask(mask, slotChar) {
+        this._fieldType = FieldInputTypeEnum.Mask;
+        this._mask = mask;
+        this._slotChar = slotChar;
+        return this;
+    }
+    asFile(opts) {
+        this._fieldType = FieldInputTypeEnum.File;
+        this._fileMultiple = opts?.multiple;
+        this._fileMaxFileSize = opts?.maxFileSize;
+        this._fileAccept = opts?.accept;
+        return this.withFileOnSelectHandler(opts?.onFileSelectHandlerFn);
+    }
+    asImageFile(opts) {
+        this.asFile(opts);
+        this._fieldType = FieldInputTypeEnum.ImageFile;
+        return this;
+    }
+    asImageUrl(opts) {
+        this._fieldType = FieldInputTypeEnum.ImageUrl;
+        this._fileMultiple = opts?.multiple;
+        this._imagePreview = opts?.preview;
+        this._imageUrlInputHiddenOnDisabled = opts?.inputVisibleOnDisabled;
+        return this;
+    }
+    asCustomComponent(component, opts) {
+        this._fieldType = FieldInputTypeEnum.Custom;
+        this._customComponentType = component;
+        this._customComponentInputs = opts?.inputs;
+        this._customComponentWrappers = opts?.fieldWrappers;
+        return this;
+    }
+    withNumberValidation(opts) {
+        this._numberStep = opts?.step;
+        this._numberAutoCorrect = opts?.autoCorrect;
+        this._numberMin = opts?.min;
+        this._numberMax = opts?.max;
+        return this;
+    }
+    withLocale(locale) {
+        this._locale = locale;
+        return this;
+    }
+    withNumberFractions(opts) {
+        this._numberMinFractionDigits = opts?.minFractionDigits;
+        this._numberMaxFractionDigits = opts?.maxFractionDigits;
+        return this;
+    }
+    withNumberGrouping(useGrouping = true) {
+        this._numberUseGrouping = useGrouping;
+        return this;
+    }
+    withTextValidation(opts) {
+        this._minLength = opts?.minLength;
+        this._maxLength = opts?.maxLength;
+        this._pattern = opts?.pattern;
+        return this;
+    }
+    withInputTrim(trimOption = 'both') {
+        this._inputTrim = trimOption;
+        return this;
+    }
+    withTextValidationEmail(email = true) {
+        if (this.fieldType === FieldInputTypeEnum.Text && email) {
+            this.withValidation('email', Validators.email);
+        }
+        else if (!email) {
+            this.removeValidation('email');
+        }
+        return this;
+    }
+    withFileOnSelectHandler(fn) {
+        this._fileOnSelectHandler = fn;
+        return this;
+    }
+    copy() {
+        const field = new FieldInputDescriptor(this._editor, this._property);
+        this.copyFieldsTo(field);
+        field._fieldType = this._fieldType;
+        field._rows = this._rows;
+        field._numberMin = this._numberMin;
+        field._numberMax = this._numberMax;
+        field._numberStep = this._numberStep;
+        field._numberAutoCorrect = this._numberAutoCorrect;
+        field._numberMinFractionDigits = this._numberMinFractionDigits;
+        field._numberMaxFractionDigits = this._numberMaxFractionDigits;
+        field._numberUseGrouping = this._numberUseGrouping;
+        field._radioOptions = [...this._radioOptions];
+        field._datePickerFormat = this._datePickerFormat;
+        field._datePickerMin = this._datePickerMin;
+        field._datePickerMax = this._datePickerMax;
+        field._datePickerShowTime = this._datePickerShowTime;
+        field._datePickerShowSeconds = this._datePickerShowSeconds;
+        field._maxLength = this._maxLength;
+        field._minLength = this._minLength;
+        field._pattern = this._pattern;
+        field._mask = this._mask;
+        field._slotChar = this._slotChar;
+        field._fileMultiple = this._fileMultiple;
+        field._fileMaxFileSize = this._fileMaxFileSize;
+        field._fileAccept = this._fileAccept;
+        field._fileOnSelectHandler = this._fileOnSelectHandler;
+        field._imagePreview = this._imagePreview;
+        field._imageUrlInputHiddenOnDisabled = this._imageUrlInputHiddenOnDisabled;
+        field._customComponentType = this._customComponentType;
+        field._customComponentInputs = this._customComponentInputs;
+        field._customComponentWrappers = this._customComponentWrappers;
+        field._locale = this._locale;
+        field._currency = this._currency;
+        field._currencyDisplay = this._currencyDisplay;
+        field._currencyFromProperty = this._currencyFromProperty;
+        field._inputTrim = this._inputTrim;
+        return field;
+    }
+}
+
+class EditorDescriptorInst {
+    static { this.defaultGroupName = EDITOR_DEFAULT_GROUP_NAME; }
+    /**
+     * Creates new instance of editor descriptor.
+     * @param model Model descriptor.
+     * @param tableviewEditorType Type of editor in tableview (add, edit, view or none).
+     */
+    constructor(model, tableviewEditorType = TableviewEditorTypeEnum.None) {
+        /** @ignore */ this._tabs = [];
+        /** @ignore */ this._groups = [];
+        /** @ignore */ this._fields = [];
+        /** @ignore */ this._disabled = false;
+        /** @ignore */ this._isLocalized = false;
+        /** @ignore */ this._eventsSubject = new Subject();
+        this._model = model;
+        this._tableviewEditorType = tableviewEditorType;
+    }
+    /**
+     * Model descriptor for editor.
+     */
+    get model() {
+        return this._model;
+    }
+    /**
+     * Editor's tabs.
+     */
+    get tabs() {
+        return this._tabs;
+    }
+    /**
+     * Editor's fields.
+     */
+    get fields() {
+        return this._fields;
+    }
+    /**
+     * Type of editor for tableview.
+     */
+    get tableviewEditorType() {
+        return this._tableviewEditorType;
+    }
+    /**
+     * If editor is disabled.
+     */
+    get disabled() {
+        return this._disabled;
+    }
+    get isLocalized() {
+        return this._isLocalized;
+    }
+    get localizationLocaleProperty() {
+        return this._localizationLocaleProperty;
+    }
+    get localizationLocalizationProperty() {
+        return this._localizationLocalizationProperty;
+    }
+    get localizationModel() {
+        return this._localizationModel;
+    }
+    /**
+     * 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.
+     */
+    createTabGroup(name, title) {
+        const tabGroup = new FieldTabGroupDescriptor(this, name);
+        if (!title) {
+            title = I18nUtils.Type.getTabKey(this.model.i18nBaseKey, name);
+        }
+        tabGroup.withTitle(title);
+        this.createTabGroupDescriptor(tabGroup);
+        return tabGroup;
+    }
+    /**
+     * 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.
+     */
+    createFieldGroup(name, title) {
+        const fieldGroup = new FieldGroupDescriptor(this, name);
+        if (title !== null) {
+            if (!title) {
+                title = I18nUtils.Type.getGroupKey(this.model.i18nBaseKey, name);
+            }
+            fieldGroup.withTitle(title);
+        }
+        this.createFieldGroupDescriptor(fieldGroup);
+        return fieldGroup;
+    }
+    /**
+     * Gets field by the model property name.
+     * @param property Model property name.
+     */
+    getField(property) {
+        return this.getFieldUnsafe(property);
+    }
+    /**
+     * Gets field by the model property name (UNSAFE).
+     * @param property Model property name.
+     */
+    getFieldUnsafe(property) {
+        return this._fields.find(f => f.property === property) ?? null;
+    }
+    /**
+     * Removes field by the model property name.
+     * @param property Model property name.
+     */
+    removeField(property) {
+        return this.removeFieldUnsafe(property);
+    }
+    /**
+     * Removes field by the model property name (UNSAFE).
+     * @param property Model property name.
+     */
+    removeFieldUnsafe(property) {
+        const fieldIdx = this._fields.findIndex(f => f.property === property);
+        if (fieldIdx < 0) {
+            throw new CommonsInternalError(`Field ${property} does not exist.`, { name: 'EditorDescriptorError' });
+        }
+        for (const group of this._groups) {
+            const groupFieldIdx = group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);
+            if (groupFieldIdx >= 0) {
+                group.fields.splice(groupFieldIdx, 1);
+                break;
+            }
+        }
+        this._fields.splice(fieldIdx, 1);
+    }
+    /**
+     * Adds field by the descriptor.
+     * @param field Field descriptor.
+     */
+    addFieldDescriptor(field) {
+        this.createDefaultGroup();
+        this._fields.push(field);
+        this._currentGroup?.addField(field);
+        return this;
+    }
+    /**
+     * Adds field by the model property name.
+     * @param property Model property name.
+     */
+    addField(property) {
+        const field = new FieldInputDescriptor(this, property);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    /**
+     * Adds field by the model property name (UNSAFE). Property is not checked on editor model.
+     * Use {addField} for safe usage.
+     * @param property Model property name.
+     */
+    addFieldUnsafe(property) {
+        const field = new FieldInputDescriptor(this, property);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFields(...properties) {
+        properties.forEach(p => this.addField(p));
+        return this;
+    }
+    addFieldAction(actionName) {
+        const field = new FieldActionDescriptor(this, actionName);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    /**
+     * Adds lookup field.
+     *
+     * @param {Property} property - The property key of the editor.
+     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
+     * @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 FieldValue - The value type of field on editor.
+     *
+     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, undefined, FieldValue>} - The field lookup descriptor.
+     */
+    addFieldLookup(property, type) {
+        return this.addFieldLookupUnsafe(property, type);
+    }
+    /**
+     * [UNSAFE] Adds lookup field.
+     * This method 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, EditorModel, undefined, FieldValue>} - The field lookup descriptor.
+     */
+    addFieldLookupUnsafe(property, type) {
+        const field = new FieldLookupDescriptor(this, property, {
+            type: type?.classType
+        });
+        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 method 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, EditorModel, undefined, FieldValue>} - The field lookup descriptor.
+     */
+    addFieldLookupWithOptionsValuePropertyUnsafe(property, type, lookupOptionsValueProperty) {
+        const field = new FieldLookupDescriptor(this, 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 method 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(this, 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>} - 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 method 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>} - The field lookup descriptor.
+     */
+    addFieldLookupWithProviderAndOptionsValuePropertyUnsafe(property, provider, type, lookupOptionsValueProperty) {
+        const cfg = fieldLookupGetProviderCfgObj(provider);
+        const field = new FieldLookupDescriptor(this, property, {
+            type: type?.classType,
+            optionsValueProperty: lookupOptionsValueProperty,
+            ...cfg
+        });
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFieldLookupEnum(property, enumDesc, options) {
+        return this.addFieldLookupEnumUnsafe(property, enumDesc, options);
+    }
+    /**
+     * Adds enum lookup field.
+     * @param property Model's property name.
+     * @param enumDesc Type of enum or enum descriptor.
+     * @param options Provides subset of enum's available constants.
+     */
+    addFieldLookupEnumUnsafe(property, enumDesc, options) {
+        const field = new FieldLookupEnumDescriptor(this, property, enumDesc, options);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    /**
+     * Adds table/details/add/edit field for one-to-many (1:n) relations.
+     * @param property Model's property name.
+     * @param tableviewDescriptor Tableview descriptor for related model.
+     */
+    addFieldManyEditor(property, tableviewDescriptor) {
+        return this.addFieldManyEditorUnsafe(property, tableviewDescriptor);
+    }
+    /**
+     * Adds table/details/add/edit field for one-to-many (1:n) relations (UNSAFE).
+     * @param property Model's property name.
+     * @param tableviewDescriptor Tableview descriptor for related model.
+     */
+    addFieldManyEditorUnsafe(property, tableviewDescriptor) {
+        const field = new FieldManyEditorDescriptor(this, property, tableviewDescriptor);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    /**
+     * Adds tables for many-to-many (m:n) relations.
+     * @param property Model's property name.
+     * @param mainTableDescriptor Main table descriptor for displaying items added to main model's property.
+     * @param lookupTableDescriptor Lookup table descriptor for displaying items to be added to main model's property.
+     */
+    addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor) {
+        return this.addFieldManyToManyEditorUnsafe(property, mainTableDescriptor, lookupTableDescriptor);
+    }
+    /**
+     * Adds tables for many-to-many (m:n) relations (UNSAFE).
+     * @param property Model's property name.
+     * @param mainTableDescriptor Main table descriptor for displaying items added to main model's property.
+     * @param lookupTableDescriptor Lookup table descriptor for displaying items to be added to main model's property.
+     */
+    addFieldManyToManyEditorUnsafe(property, mainTableDescriptor, lookupTableDescriptor) {
+        const field = new FieldManyToManyEditorDescriptor(this, property, mainTableDescriptor, lookupTableDescriptor);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFieldManyToManyEditorWithProvider(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider) {
+        return this.addFieldManyToManyEditorWithProviderUnsafe(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider);
+    }
+    addFieldManyToManyEditorWithProviderUnsafe(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider) {
+        const cfg = fieldManyToManyGetProviderCfgObj(lookupDataProvider);
+        const field = new FieldManyToManyEditorDescriptor(this, property, mainTableDescriptor, lookupTableDescriptor, {
+            ...cfg
+        });
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    /**
+     * Disables field on editor.
+     * @param disabled
+     */
+    withDisabled(disabled = true) {
+        this._disabled = disabled;
+        return this;
+    }
+    /**
+     * Adds group validator to editor.
+     * @param name Name of the validation.
+     * @param validator Field validator function.
+     * @param message Field validation message.
+     */
+    addValidation(name, validator, message) {
+        if (this._currentGroup) {
+            this._currentGroup.withValidation(name, validator, message);
+        }
+    }
+    /**
+     * Creates a copy of editor descriptor object.
+     */
+    copy() {
+        const editor = new EditorDescriptorInst(this.model.copy(), this.tableviewEditorType);
+        for (const tabGroup of this._tabs) {
+            editor.createTabGroupDescriptor(tabGroup.copy());
+        }
+        for (const tabGroup of editor._tabs) {
+            for (const fieldGroup of tabGroup.fields) {
+                editor._fields.push(...fieldGroup.fields);
+            }
+            editor._groups.push(...tabGroup.fields);
+        }
+        editor._currentTabGroup = editor._tabs[editor._tabs.length - 1];
+        editor._currentGroup = editor._currentTabGroup.fields[editor._currentTabGroup.fields.length - 1];
+        editor._disabled = this._disabled;
+        return editor;
+    }
+    /**
+     * Created group from field group descriptor.
+     * @param fieldGroup Field group descriptor.
+     * @internal
+     */
+    createFieldGroupDescriptor(fieldGroup) {
+        this.createDefaultTabGroup();
+        this._currentGroup = fieldGroup;
+        this._groups.push(fieldGroup);
+        this._currentTabGroup?.addField(fieldGroup);
+        return this;
+    }
+    /**
+     * Creates tab group from tab group descriptor.
+     * @param tabGroup Tab group descriptor.
+     * @internal
+     */
+    createTabGroupDescriptor(tabGroup) {
+        this._currentTabGroup = tabGroup;
+        this._tabs.push(tabGroup);
+        return this;
+    }
+    /**
+     * Creates default field group.
+     * @internal
+     */
+    createDefaultGroup() {
+        this.createDefaultTabGroup();
+        if (this._currentTabGroup?.fields.length === 0) {
+            this.createFieldGroup(EditorDescriptorInst.defaultGroupName, null);
+        }
+    }
+    /**
+     * Creates default tab group.
+     * @internal
+     */
+    createDefaultTabGroup() {
+        if (this._tabs.length === 0) {
+            this.createTabGroup(EditorDescriptorInst.defaultGroupName, 'general.general');
+        }
+    }
+    /**
+     * Modifies selected field by field property. For enums use {withFieldModifiedEnum} instead.
+     * @param property Model's property name.
+     * @param fieldType new field type for selected field
+     * @param args additional parameters for field
+     */
+    withFieldModifiedType(property, fieldType, ...args) {
+        return this.withFieldModifiedTypeUnsafe(property, fieldType, ...args);
+    }
+    withFieldModifiedTypeUnsafe(property, fieldType, ...args) {
+        if (!this.model.type) {
+            throw new CommonsInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        const attribute = getEditorClassAttributeDef(this.model.type).find(attribute => attribute.name === property);
+        if (attribute) {
+            attribute.fieldType = fieldType;
+            EditorDescriptorInst.upsertFieldFromAttributeDef(this, attribute, this.fields.find(fi => fi.property === property), ...args);
+        }
+        return this;
+    }
+    /**
+     * Modifies selected field with enum type.
+     * @param property Model's property name.
+     * @param enumModel Enum descriptor.
+     * @param values
+     */
+    withFieldModifiedEnum(property, enumModel, values) {
+        return this.withFieldModifiedEnumUnsafe(property, enumModel, values);
+    }
+    withFieldModifiedEnumUnsafe(property, enumDesc, values) {
+        if (!this.model.type) {
+            throw new CommonsInternalError(`withFieldModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        const attribute = getEditorClassAttributeDef(this.model.type).find(a => a.name === property);
+        if (attribute) {
+            attribute.fieldType = FieldInputTypeEnum.Radio;
+            const field = this.fields.find(f => f.property === property);
+            if (field && field instanceof FieldInputDescriptor) {
+                field.asRadioFromEnum(enumDesc ?? enumModelGeneric(TypeRegistry.get().findEnum(attribute.type)), values);
+            }
+        }
+        return this;
+    }
+    /**
+     * Modifies selected field with lookup field.
+     * @param property Model's property name.
+     * @param lookupProvider provider to be added to field
+     * @param titleProperty
+     */
+    withFieldModifiedLookupWithProvider(property, lookupProvider, titleProperty) {
+        return this.withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, titleProperty);
+    }
+    withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, titleProperty) {
+        this.removeFieldUnsafe(property);
+        const field = this.addFieldLookupWithProviderUnsafe(property, lookupProvider).asAutocomplete();
+        if (titleProperty) {
+            field.withOptionsLabelProperty(titleProperty);
+        }
+        return this;
+    }
+    /**
+     * This method takes care of displaying correct/localized data in the editor
+     * @param property property that tells us where on the model are localizations accessible
+     * @param model Model for localizations
+     * @param localeProperty property by which we find the locale
+     */
+    localized(property, model, localeProperty) {
+        return this.localizedUnsafe(property, model, localeProperty);
+    }
+    localizedUnsafe(property, model, localeProperty) {
+        this._localizationLocalizationProperty = property;
+        this._localizationModel = model;
+        this._localizationLocaleProperty = localeProperty;
+        this._isLocalized = true;
+        return this;
+    }
+    nextEvent(type, cmpType, cmpInstance, data) {
+        this._eventsSubject.next({
+            type: type,
+            componentType: cmpType,
+            componentInstance: cmpInstance,
+            data: data
+        });
+    }
+    completeEvents() {
+        this._eventsSubject.complete();
+    }
+    get events$() {
+        return this._eventsSubject.asObservable();
+    }
+    /**
+     * Generates field based on attribute definition, used for auto model
+     * @param descriptor Editor descriptor instance.
+     * @param attribute Attribute definition.
+     * @param field Optional, if defined will be replaced, otherwise new will be generated.
+     * @param args Optional additional arguments mapped to filed type. Arguments depend on possible arguments on fields.
+     * @internal
+     */
+    static upsertFieldFromAttributeDef(descriptor, attribute, field, ...args) {
+        if (field == null) {
+            field = descriptor.addFieldUnsafe(attribute.name);
+        }
+        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;
+    }
+}
+class EditorDescriptor extends EditorDescriptorInst {
+    constructor() {
+        super(ModelDescriptor.create());
+    }
+    static create(idProperty, titleProperty, i18nBaseKey, tableviewEditorType = TableviewEditorTypeEnum.None) {
+        return new EditorDescriptorInst(ModelDescriptor.create(idProperty, titleProperty, i18nBaseKey), tableviewEditorType);
+    }
+    static fromClass(type, idProperty, titleProperty, i18nBaseKey, tableviewEditorType = TableviewEditorTypeEnum.None) {
+        return new EditorDescriptorInst(ModelDescriptor.fromClass(type, idProperty, titleProperty, i18nBaseKey), tableviewEditorType);
+    }
+    static fromModel(model, tableviewEditorType = TableviewEditorTypeEnum.None) {
+        return new EditorDescriptorInst(model, 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 tableEditorType Type of editor in tableview (add, edit, view or none).
+     */
+    static fromClassWithCustomAttrsDef(type, attributes, idProperty, titleProperty, tableEditorType = TableviewEditorTypeEnum.None) {
+        const descriptor = EditorDescriptor.fromClass(type, idProperty, titleProperty, undefined, tableEditorType);
+        attributes
+            .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))
+            .forEach(attr => EditorDescriptorInst.upsertFieldFromAttributeDef(descriptor, attr, descriptor.fields.find(col => col.property === attr.name)));
+        return descriptor;
+    }
+}
+
+var FormFieldEventTypeEnum;
+(function (FormFieldEventTypeEnum) {
+    FormFieldEventTypeEnum["ComponentLifecycle"] = "ComponentLifecycle";
+    FormFieldEventTypeEnum["ValueChange"] = "ValueChange";
+    FormFieldEventTypeEnum["DataProvider"] = "DataProvider";
+    FormFieldEventTypeEnum["DialogLifecycle"] = "DialogLifecycle";
+    FormFieldEventTypeEnum["Other"] = "Other";
+})(FormFieldEventTypeEnum || (FormFieldEventTypeEnum = {}));
+var FormEventTypeEnum;
+(function (FormEventTypeEnum) {
+    FormEventTypeEnum["ComponentLifecycle"] = "ComponentLifecycle";
+    FormEventTypeEnum["ValueChange"] = "ValueChange";
+    FormEventTypeEnum["Submit"] = "Submit";
+    FormEventTypeEnum["Other"] = "Other";
+})(FormEventTypeEnum || (FormEventTypeEnum = {}));
+class FormFieldEventComponentSubtype {
+    static { this.ON_INIT = 'Component.OnInit'; }
+    static { this.ON_VIEW_INIT = 'Component.OnViewInit'; }
+    static { this.ON_CONTENT_INIT = 'Component.OnContentInit'; }
+    static { this.ON_DESTROY = 'Component.OnDestroy'; }
+}
+class FormFieldEventDialogSubtype {
+    static { this.VISIBILITY = 'Dialog.Visibility'; }
+    static { this.TABLE_CAPTION_COMPONENT_INSTANCE = 'Dialog.MngTable.CaptionComponentInstance'; }
+    static { this.TABLE_COLUMN_ACTIONS_COMPONENT_INSTANCE = 'Dialog.MngTable.ColumnActionsComponentInstance'; }
+}
+
+class AFormlyCustomFieldComponent extends FieldType {
+    get model() {
+        return this._model;
+    }
+    get form() {
+        return this._form;
+    }
+    get options() {
+        return this._options;
+    }
+    get key() {
+        return this._key;
+    }
+    get formControl() {
+        return this._formControl;
+    }
+    get props() {
+        return this._props;
+    }
+    get showError() {
+        return this._showError;
+    }
+    get id() {
+        return this._id;
+    }
+    get formState() {
+        return this._formState;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: AFormlyCustomFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.2.1", type: AFormlyCustomFieldComponent, inputs: { field: "field", _model: ["model", "_model"], _form: ["form", "_form"], _options: ["options", "_options"], _key: ["key", "_key"], _formControl: ["formControl", "_formControl"], _props: ["props", "_props"], _showError: ["showError", "_showError"], _id: ["id", "_id"], _formState: ["formState", "_formState"] }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: AFormlyCustomFieldComponent, decorators: [{
+            type: Directive
+        }], propDecorators: { field: [{
+                type: Input,
+                args: ['field']
+            }], _model: [{
+                type: Input,
+                args: ['model']
+            }], _form: [{
+                type: Input,
+                args: ['form']
+            }], _options: [{
+                type: Input,
+                args: ['options']
+            }], _key: [{
+                type: Input,
+                args: ['key']
+            }], _formControl: [{
+                type: Input,
+                args: ['formControl']
+            }], _props: [{
+                type: Input,
+                args: ['props']
+            }], _showError: [{
+                type: Input,
+                args: ['showError']
+            }], _id: [{
+                type: Input,
+                args: ['id']
+            }], _formState: [{
+                type: Input,
+                args: ['formState']
+            }] } });
+
+class TableviewDataProviderInst extends DataProviderInst {
+    constructor(type, serviceType) {
+        super(type, serviceType);
+        this.editorDataProvider = EditorDataProvider.fromAnyParam(type, serviceType);
+        this.tableDataProvider = TableDataProvider.fromAnyParam(type, serviceType);
+    }
+    get isLazy() {
+        return this.tableDataProvider.isLazy;
+    }
+    get getAllReload$() {
+        return this.tableDataProvider.getAllReload$;
+    }
+    get getAll() {
+        return this.tableDataProvider.getAll;
+    }
+    get fetch() {
+        return this.editorDataProvider.fetch;
+    }
+    get create() {
+        return this.editorDataProvider.create;
+    }
+    get update() {
+        return this.editorDataProvider.update;
+    }
+    get delete() {
+        return this.editorDataProvider.delete;
+    }
+    getAllReload(queryParam) {
+        this.tableDataProvider.getAllReload(queryParam);
+    }
+    withGetAll(fn) {
+        this.tableDataProvider.withGetAll(fn);
+        return this;
+    }
+    withGetAllEagerly(fn) {
+        this.tableDataProvider.withGetAllEagerly(fn);
+        return this;
+    }
+    withFetch(fn) {
+        this.editorDataProvider.withFetch(fn);
+        return this;
+    }
+    withCreate(fn) {
+        this.editorDataProvider.withCreate(fn);
+        return this;
+    }
+    withUpdate(fn) {
+        this.editorDataProvider.withUpdate(fn);
+        return this;
+    }
+    withDelete(fn) {
+        this.editorDataProvider.withDelete(fn);
+        return this;
+    }
+}
+class TableviewDataProvider extends TableviewDataProviderInst {
+    constructor() {
+        super(undefined, undefined);
+    }
+    static create() {
+        return new TableviewDataProviderInst(undefined, undefined);
+    }
+    static fromClass(type) {
+        return new TableviewDataProviderInst(type, undefined);
+    }
+    static fromClassWithService(type, serviceType) {
+        return new TableviewDataProviderInst(type, serviceType);
+    }
+    static fromService(serviceType) {
+        return new TableviewDataProviderInst(undefined, serviceType);
+    }
+    static fromAnyParam(type, serviceType) {
+        if (typeof type !== 'undefined') {
+            return typeof serviceType !== 'undefined'
+                ? TableviewDataProvider.fromClassWithService(type, serviceType)
+                : TableviewDataProvider.fromClass(type);
+        }
+        else if (typeof serviceType !== 'undefined') {
+            return TableviewDataProvider.fromService(serviceType);
+        }
+        else {
+            return TableviewDataProvider.create();
+        }
+    }
+}
+class DynamicTableviewDataProviderInst extends TableviewDataProviderInst {
+    constructor(serviceType) {
+        super(undefined, serviceType);
+    }
+}
+class DynamicTableviewDataProvider extends DynamicTableviewDataProviderInst {
+    constructor() {
+        super(undefined);
+    }
+    static create() {
+        return new DynamicTableviewDataProviderInst(undefined);
+    }
+    static fromService(serviceType) {
+        return new DynamicTableviewDataProviderInst(serviceType);
+    }
+}
+
+function expandClassAttributeDefWithTableviewDef(attributes) {
+    if (!attributes) {
+        throw new CommonsInternalError('Class attribute definition is null, problem with TypeRegistry::findAttributesDefinitionByClassType?', { name: 'TableviewUtilsError' });
+    }
+    const typeRegistry = TypeRegistry.get();
+    const tableClassAttributeDef = [];
+    for (const attribute of attributes) {
+        const enumType = typeRegistry.findEnum(attribute.type);
+        const columnType = enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type);
+        tableClassAttributeDef.push({
+            name: attribute.name,
+            baseName: attribute.baseName,
+            type: attribute.type,
+            subtype: attribute.subtype,
+            columnType: enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type),
+            columnDisplayType: getColumnDisplayTypeFromColumnType(columnType, attribute.type),
+            fieldType: getFieldInputTypeFromClassAttributeDefType(attribute.type),
+            enumType: typeRegistry.findEnum(attribute.type),
+            classType: typeRegistry.findType(attribute.type)
+        });
+    }
+    return 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));
+}
+
+class TableviewDescriptorInst {
+    constructor(model) {
+        this._isLocalized = false;
+        this._model = model;
+        this._table = TableDescriptor.fromModel(model);
+        this._tableTitle = `${this._model.i18nBaseKey}.name`;
+        this._detailsEditor = EditorDescriptor.fromModel(model, TableviewEditorTypeEnum.Details);
+        this._detailsEditor.withDisabled();
+        this._addEditor = EditorDescriptor.fromModel(model, TableviewEditorTypeEnum.Add);
+        this._editEditor = EditorDescriptor.fromModel(model, TableviewEditorTypeEnum.Edit);
+    }
+    get table() {
+        return this._table;
+    }
+    get detailsEditor() {
+        return this._detailsEditor;
+    }
+    get addEditor() {
+        return this._addEditor;
+    }
+    get editEditor() {
+        return this._editEditor;
+    }
+    get tableTitle() {
+        return this._tableTitle;
+    }
+    get model() {
+        return this._model;
+    }
+    isLocalized() {
+        return this._isLocalized;
+    }
+    withTableDescriptor(descriptor) {
+        this._table = descriptor;
+        return this;
+    }
+    withEditorDescriptors(descriptor) {
+        this._detailsEditor = descriptor;
+        this._editEditor = descriptor;
+        this._addEditor = descriptor;
+        return this;
+    }
+    withDetailsDescriptor(descriptor) {
+        this._detailsEditor = descriptor;
+        return this;
+    }
+    withAddDescriptor(descriptor) {
+        this._addEditor = descriptor;
+        return this;
+    }
+    withEditDescriptor(descriptor) {
+        this._editEditor = descriptor;
+        return this;
+    }
+    /**
+     * creates new copy of editor descriptor and makes it disabled
+     * usable in combination with this::withEditorDescriptors, where detailsDescriptor is made non-disabled
+     * @param type which editor type to set to disabled
+     */
+    withDisabledEditorDescriptor(type = TableviewEditorTypeEnum.Details) {
+        if (type === TableviewEditorTypeEnum.Edit) {
+            this._editEditor = this._editEditor.copy().withDisabled();
+        }
+        else if (type === TableviewEditorTypeEnum.Details) {
+            this._detailsEditor = this._detailsEditor.copy().withDisabled();
+        }
+        else if (type === TableviewEditorTypeEnum.Add) {
+            this._addEditor = this._addEditor.copy().withDisabled();
+        }
+        return this;
+    }
+    withTableTitle(title) {
+        this._tableTitle = title;
+        return this;
+    }
+    withValidator(name, expression) {
+        this._detailsEditor.addValidation(name, expression);
+        this._addEditor.addValidation(name, expression);
+        this._editEditor.addValidation(name, expression);
+        return this;
+    }
+    getColumn(property) {
+        return this._table.getColumn(property);
+    }
+    getColumnUnsafe(property) {
+        return this._table.getColumnUnsafe(property);
+    }
+    removeColumn(property) {
+        this._table.removeColumn(property);
+    }
+    removeColumnUnsafe(property) {
+        this._table.removeColumnUnsafe(property);
+    }
+    withColumn(column) {
+        this._table.withColumn(column);
+        return this;
+    }
+    addColumn(property) {
+        return this._table.addColumn(property);
+    }
+    addColumnEnum(property, enumDesc) {
+        return this._table.addColumnEnum(property, enumDesc);
+    }
+    addColumnUnsafe(property) {
+        return this._table.addColumnUnsafe(property);
+    }
+    withColumns(...properties) {
+        this._table.withColumns(...properties);
+        return this;
+    }
+    getSort(property) {
+        return this._table.getSort(property);
+    }
+    getSortUnsafe(property) {
+        return this._table.getSortUnsafe(property);
+    }
+    removeSort(property) {
+        this._table.removeSort(property);
+    }
+    removeSortUnsafe(property) {
+        this._table.removeSortUnsafe(property);
+    }
+    addSort(property, isDefault = false, ascending) {
+        return this._table.addSort(property, isDefault, ascending);
+    }
+    addSortUnsafe(property, isDefault = false, ascending) {
+        return this._table.addSortUnsafe(property, isDefault, ascending);
+    }
+    withSort(property, isDefault = false, ascending) {
+        this._table.withSort(property, isDefault, ascending);
+        return this;
+    }
+    withSortUnsafe(property, isDefault = false, ascending) {
+        this._table.withSortUnsafe(property, isDefault, ascending);
+        return this;
+    }
+    withDefaultSort(property, ascending, order, enabled) {
+        this._table.withDefaultSort(property, ascending, order, enabled);
+        return this;
+    }
+    withDefaultSortUnsafe(property, ascending, order, enabled) {
+        this._table.withDefaultSortUnsafe(property, ascending, order, enabled);
+        return this;
+    }
+    withSorts(...properties) {
+        this._table.withSorts(...properties);
+        return this;
+    }
+    withSortsUnsafe(...properties) {
+        this._table.withSortsUnsafe(...properties);
+        return this;
+    }
+    getFilter(property) {
+        return this._table.getFilter(property);
+    }
+    getFilterUnsafe(property) {
+        return this._table.getFilterUnsafe(property);
+    }
+    removeFilter(property) {
+        this._table.removeFilter(property);
+    }
+    removeFilterUnsafe(property) {
+        this._table.removeFilterUnsafe(property);
+    }
+    addFilter(property) {
+        return this._table.addFilter(property);
+    }
+    addFilterUnsafe(property) {
+        return this._table.addFilterUnsafe(property);
+    }
+    addFilterLookup(property, provider, optionsValueProperty) {
+        return this._table.addFilterLookup(property, provider, optionsValueProperty);
+    }
+    addFilterLookupUnsafe(property, provider, optionsValueProperty) {
+        return this._table.addFilterLookupUnsafe(property, provider, optionsValueProperty);
+    }
+    addFilterLookupEnum(property, enumDesc, options) {
+        return this._table.addFilterLookupEnum(property, enumDesc, options);
+    }
+    addFilterLookupEnumUnsafe(property, enumDesc, options) {
+        return this._table.addFilterLookupEnumUnsafe(property, enumDesc, options);
+    }
+    addFilterFromColumn(property, forceSimple = false) {
+        return this._table.addFilterFromColumn(property, forceSimple);
+    }
+    withFiltersFromColumns(...properties) {
+        this._table.withFiltersFromColumns(...properties);
+        return this;
+    }
+    withFiltersFromColumnsUnsafe(...properties) {
+        this._table.withFiltersFromColumnsUnsafe(...properties);
+        return this;
+    }
+    addFilterFromColumnUnsafe(property, forceSimple = false) {
+        return this._table.addFilterFromColumnUnsafe(property, forceSimple);
+    }
+    withFilter(property, filter) {
+        this._table.withFilter(property, filter);
+        return this;
+    }
+    withFilterUnsafe(filter) {
+        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);
+    }
+    removeFieldUnsafe(property) {
+        this._editEditor.removeFieldUnsafe(property);
+        this._addEditor.removeFieldUnsafe(property);
+        this._detailsEditor.removeFieldUnsafe(property);
+    }
+    addFieldDescriptor(field) {
+        this._detailsEditor.addFieldDescriptor(field);
+        this._addEditor.addFieldDescriptor(field);
+        this._editEditor.addFieldDescriptor(field);
+        return this;
+    }
+    addField(property) {
+        const field = this._detailsEditor.addField(property);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    addFieldUnsafe(property) {
+        const field = this._detailsEditor.addFieldUnsafe(property);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    addFields(...properties) {
+        properties.forEach(p => this.addField(p));
+        return this;
+    }
+    addFieldToEditAndAdd(field) {
+        this._addEditor.addFieldDescriptor(field);
+        this._editEditor.addFieldDescriptor(field);
+    }
+    /**
+     * Adds lookup field.
+     *
+     * @param {Property} property - The property key of the editor.
+     * @param {TypeDescriptor<FieldModel>} type - The type descriptor for the lookup model.
+     * @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 FieldValue - The value type of field on editor.
+     *
+     * @returns {FieldLookupDescriptor<LookupModel, TableviewModel, undefined, FieldValue>} - The field lookup descriptor.
+     */
+    addFieldLookup(property, type) {
+        const field = this._detailsEditor.addFieldLookup(property, type);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    /**
+     * [UNSAFE] Adds lookup field.
+     * This method 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>} - 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 method 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 method 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.
+     * @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, 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 method 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>} - The field lookup descriptor.
+     */
+    addFieldLookupWithProviderAndOptionsValuePropertyUnsafe(property, provider, type, lookupOptionsValueProperty) {
+        const field = this._detailsEditor.addFieldLookupWithProviderAndOptionsValuePropertyUnsafe(property, provider, type, lookupOptionsValueProperty);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    addFieldLookupEnum(property, enumDesc, options) {
+        const field = this._detailsEditor.addFieldLookupEnum(property, enumDesc, options);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    addFieldLookupEnumUnsafe(property, enumDesc, options) {
+        const field = this._detailsEditor.addFieldLookupEnumUnsafe(property, enumDesc, options);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    addFieldManyEditor(property, tableviewDescriptor) {
+        const field = this._detailsEditor.addFieldManyEditor(property, tableviewDescriptor);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    addFieldManyEditorUnsafe(property, tableviewDescriptor) {
+        const field = this._detailsEditor.addFieldManyEditorUnsafe(property, tableviewDescriptor);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor) {
+        const field = this._detailsEditor.addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    addFieldManyToManyEditorUnsafe(property, mainTableDescriptor, lookupTableDescriptor) {
+        const field = this._detailsEditor.addFieldManyToManyEditorUnsafe(property, mainTableDescriptor, lookupTableDescriptor);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    addFieldManyToManyEditorWithProvider(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider) {
+        const field = this._detailsEditor.addFieldManyToManyEditorWithProvider(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    addFieldManyToManyEditorWithProviderUnsafe(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider) {
+        const field = this._detailsEditor.addFieldManyToManyEditorWithProviderUnsafe(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider);
+        this.addFieldToEditAndAdd(field);
+        return field;
+    }
+    createTabGroup(name, title) {
+        this._detailsEditor.createTabGroup(name, title);
+        this._addEditor.createTabGroup(name, title);
+        this._editEditor.createTabGroup(name, title);
+        return this;
+    }
+    createFieldGroup(name, title) {
+        this._detailsEditor.createFieldGroup(name, title);
+        this._addEditor.createFieldGroup(name, title);
+        this._editEditor.createFieldGroup(name, title);
+        return this;
+    }
+    copy() {
+        const tableview = new TableviewDescriptorInst(this._model.copy());
+        tableview._table = this._table.copy();
+        tableview._detailsEditor = this._detailsEditor.copy();
+        tableview._addEditor = this._addEditor.copy();
+        tableview._editEditor = this._editEditor.copy();
+        tableview._tableTitle = this._tableTitle;
+        tableview._isLocalized = this._isLocalized;
+        return tableview;
+    }
+    /**
+     * creates column and field with custom type, for example currency
+     * if field exists, it is replaced
+     * DO NOT USE WITH TYPES WHERE ARGS ARE REQUIRED - ERROR WILL BE THROWN
+     * for enum use withEnumType
+     * for custom class use withClassType
+     * @param property name of field
+     * @param columnType required column type
+     * @param fieldType optional, if not provided it is converted from column type
+     * @param columnDisplayType optional
+     */
+    withModifiedType(property, columnType, fieldType, columnDisplayType) {
+        return this.withModifiedTypeUnsafe(property, columnType, fieldType, columnDisplayType);
+    }
+    withModifiedTypeUnsafe(property, columnType, fieldType, columnDisplayType) {
+        if (!this.model.type) {
+            throw new CommonsInternalError(`withModifiedType cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        if (columnType === ColumnTypeEnum.Enum) {
+            throw new CommonsInternalError('Do not use with types where args are required', { name: 'TableviewDescriptorError' });
+        }
+        const attributeDef = getTableviewClassAttributeDef(this.model.type).find(attr => attr.name === property);
+        if (attributeDef != null) {
+            fieldType ??= getFieldInputTypeFromColumnType(columnType, columnDisplayType);
+            attributeDef.fieldType = fieldType;
+            this._table.withColumnModifiedTypeUnsafe(property, columnType, columnDisplayType);
+            this._editEditor.withFieldModifiedTypeUnsafe(property, fieldType);
+            this._addEditor.withFieldModifiedTypeUnsafe(property, fieldType);
+            this._detailsEditor.withFieldModifiedTypeUnsafe(property, fieldType);
+        }
+        return this;
+    }
+    /**
+     * creates column with enum type
+     * if fields exists, it is replaced
+     * @param property property name
+     * @param enumDesc type of enum
+     * @param fieldType type of field, optional, default is Text
+     */
+    withModifiedEnum(property, enumDesc, fieldType) {
+        return this.withModifiedEnumUnsafe(property, enumDesc, fieldType);
+    }
+    withModifiedEnumUnsafe(property, enumDesc, fieldType) {
+        if (!this.model.type) {
+            throw new CommonsInternalError(`withModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        const attributeDef = getTableviewClassAttributeDef(this.model.type).find(attr => attr.name === property);
+        if (attributeDef != null) {
+            attributeDef.fieldType = fieldType ?? FieldInputTypeEnum.Text;
+            this._table.withColumnModifiedEnumUnsafe(property, enumDesc);
+            this._editEditor.withFieldModifiedEnumUnsafe(property, enumDesc);
+            this._detailsEditor.withFieldModifiedEnumUnsafe(property, enumDesc);
+            this._addEditor.withFieldModifiedEnumUnsafe(property, enumDesc);
+        }
+        return this;
+    }
+    /**
+     * generates column with custom class type
+     * field is generated only if lookupProvider is provided
+     * @param property property name
+     * @param type class type of object
+     * @param titleProperty
+     * @param lookupProvider
+     * @param optionsLabelProperty
+     * @param filterProperty
+     */
+    withModifiedLookup(property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty) {
+        return this.withModifiedLookupUnsafe(property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty);
+    }
+    withModifiedLookupUnsafe(property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty) {
+        if (!this.model.type) {
+            throw new CommonsInternalError(`withModifiedLookup cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        const attributeDef = getTableviewClassAttributeDef(this.model.type).find(attr => attr.name === property);
+        if (attributeDef != null) {
+            type ??= attributeDef.classType ?? TypeRegistry.get().findType(attributeDef.type);
+            titleProperty ??= type ? ModelUtil.findTitleAttribute(type) ?? undefined : undefined;
+            optionsLabelProperty ??= titleProperty;
+            attributeDef.columnType = ColumnTypeEnum.String;
+            attributeDef.fieldType = FieldInputTypeEnum.Text;
+            if (lookupProvider != null) {
+                this._table.withColumnModifiedLookupUnsafe(property, lookupProvider, optionsLabelProperty, filterProperty);
+                this._addEditor.withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, optionsLabelProperty);
+                this._detailsEditor.withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, optionsLabelProperty);
+                this._editEditor.withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, optionsLabelProperty);
+            }
+            else {
+                const column = this._table.getColumnUnsafe(property) ?? this.addColumnUnsafe(property);
+                if (titleProperty) {
+                    column.withGetter(value => value?.[titleProperty]);
+                }
+            }
+        }
+        return this;
+    }
+    localized(property, model, localeProperty) {
+        return this.localizedUnsafe(property, model, localeProperty);
+    }
+    localizedUnsafe(property, model, localeProperty) {
+        this._isLocalized = true;
+        this._table.withLocalizationLocaleProperty(localeProperty);
+        this.detailsEditor.localizedUnsafe(property, model, localeProperty);
+        this.addEditor.localizedUnsafe(property, model, localeProperty);
+        this.editEditor.localizedUnsafe(property, model, localeProperty);
+        return this;
+    }
+}
+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 model = ModelDescriptor.fromClass(type, idProperty, titleProperty);
+        const descriptor = TableviewDescriptor.fromModel(model);
+        descriptor.withTableDescriptor(TableDescriptor.fromClassWithAutoAttrsDef(type, idProperty, titleProperty));
+        descriptor.withEditDescriptor(EditorDescriptor.fromClassWithAutoAttrsDef(type, idProperty, titleProperty, TableviewEditorTypeEnum.Edit));
+        descriptor.withDetailsDescriptor(EditorDescriptor.fromClassWithAutoAttrsDef(type, idProperty, titleProperty, TableviewEditorTypeEnum.Details).withDisabled());
+        descriptor.withAddDescriptor(EditorDescriptor.fromClassWithAutoAttrsDef(type, idProperty, titleProperty, TableviewEditorTypeEnum.Add));
+        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 descriptor = TableviewDescriptor.fromModel(ModelDescriptor.fromClass(type, idProperty, titleProperty));
+        descriptor.withTableDescriptor(TableDescriptor.fromClassWithCustomAttrsDef(type, columnAttributes, idProperty, titleProperty));
+        if (fieldAttributes !== null) {
+            descriptor.withEditDescriptor(EditorDescriptor.fromClassWithCustomAttrsDef(type, fieldAttributes ?? columnAttributes, idProperty, titleProperty, TableviewEditorTypeEnum.Edit));
+            descriptor.withDetailsDescriptor(EditorDescriptor.fromClassWithCustomAttrsDef(type, fieldAttributes ?? columnAttributes, idProperty, titleProperty, TableviewEditorTypeEnum.Details));
+            descriptor.withAddDescriptor(EditorDescriptor.fromClassWithCustomAttrsDef(type, fieldAttributes ?? columnAttributes, idProperty, titleProperty, TableviewEditorTypeEnum.Add));
+        }
+        return descriptor;
+    }
+}
+class TableviewDynamicDescriptorInt extends TableviewDescriptorInst {
+    constructor(model) {
+        super(model);
+        this._table = TableDynamicDescriptor.fromModel(this.model);
+        super._tableTitle = undefined;
+    }
+    get table() {
+        return this._table;
+    }
+    /**
+     * sets custom table descriptor
+     * @param descriptor
+     */
+    withTableDescriptor(descriptor) {
+        this._table = descriptor;
+        return this;
+    }
+    /**
+     * sets visibility hidden state to column with given property
+     * equals to be removing in auto and base tableview descriptor
+     * * @param property column's property
+     */
+    removeColumn(property) {
+        this._table.removeColumn(property);
+        return this;
+    }
+    withEntityForTranslations(i18nBaseKey) {
+        this._table.model.withI18nBase(i18nBaseKey);
+        this._detailsEditor.model.withI18nBase(i18nBaseKey);
+        return this;
+    }
+    /**
+     * creates deep copy of tableview object and its children
+     */
+    copy() {
+        const descriptor = new TableviewDynamicDescriptorInt(this.model.copy());
+        descriptor._table = this._table.copy();
+        descriptor._tableTitle = this._tableTitle;
+        return descriptor;
+    }
+}
+class TableviewDynamicDescriptor extends TableviewDynamicDescriptorInt {
+    constructor() {
+        super(ModelDescriptor.create());
+    }
+    static create(idProperty, titleProperty, i18nBaseKey) {
+        return new TableviewDynamicDescriptorInt(ModelDescriptor.create(idProperty, titleProperty, i18nBaseKey));
+    }
+    static fromModel(model) {
+        return new TableviewDynamicDescriptorInt(model);
+    }
+}
+
+function convertDataToStringWithDelimiter(data, delimiter, descriptor, translate) {
+    const replaceNullValue = (key, value) => (value === null ? '' : value);
+    const getterPipe = new GetterPipe();
+    return [
+        descriptor.table.columns.map(col => translate.instant(descriptor.model.typeName + '.properties.' + col.property)).join(delimiter),
+        ...data.map((row) => descriptor.table.columns
+            .map(column => {
+            if (typeof column.getter === 'function') {
+                return JSON.stringify(getterPipe.transform(row[column.property], column.getter, row), replaceNullValue);
+            }
+            else {
+                return JSON.stringify(row[column.property], replaceNullValue);
+            }
+        })
+            .join(delimiter))
+    ].join('\r\n');
+}
+function saveFileAs(blob, filename) {
+    const blobUrl = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.style.display = 'none';
+    link.target = '_blank';
+    link.href = blobUrl;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.dispatchEvent(new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+        view: window
+    }));
+    document.body.removeChild(link);
+}
+
+var TableviewDefaultActionsEnum;
+(function (TableviewDefaultActionsEnum) {
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Details"] = 0] = "Details";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Add"] = 1] = "Add";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Edit"] = 2] = "Edit";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["EditOnDetails"] = 3] = "EditOnDetails";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Delete"] = 4] = "Delete";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["DeleteOnDetails"] = 5] = "DeleteOnDetails";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Refresh"] = 6] = "Refresh";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Export"] = 7] = "Export";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["ExportJson"] = 8] = "ExportJson";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["ExportCsv"] = 9] = "ExportCsv";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["LocalizationLanguageSelect"] = 10] = "LocalizationLanguageSelect";
+})(TableviewDefaultActionsEnum || (TableviewDefaultActionsEnum = {}));
+const tableviewDefaultActions = [
+    TableviewDefaultActionsEnum.Details,
+    TableviewDefaultActionsEnum.Add,
+    TableviewDefaultActionsEnum.Edit,
+    TableviewDefaultActionsEnum.EditOnDetails,
+    TableviewDefaultActionsEnum.Delete,
+    TableviewDefaultActionsEnum.DeleteOnDetails,
+    TableviewDefaultActionsEnum.Refresh,
+    TableviewDefaultActionsEnum.Export,
+    TableviewDefaultActionsEnum.ExportJson,
+    TableviewDefaultActionsEnum.ExportCsv,
+    TableviewDefaultActionsEnum.LocalizationLanguageSelect
+];
+function getTableviewDefaultActions() {
+    return [...tableviewDefaultActions];
+}
+function createTableviewActions(tableview, defaultActions, defaultActionsOverrides, injector) {
+    return (defaultActions ?? getTableviewDefaultActions())
+        .map(t => createTableviewAction(t, tableview, defaultActions, defaultActionsOverrides, injector))
+        .filter(e => e != null);
+}
+function createTableviewAction(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);
+        case TableviewDefaultActionsEnum.Edit:
+            return tableviewEditAction(tableview.editEditor, injector);
+        case TableviewDefaultActionsEnum.Delete:
+            return tableviewDeleteAction(tableview.model, injector);
+        // table toolbar actions
+        case TableviewDefaultActionsEnum.Add:
+            return tableviewAddAction(tableview.addEditor, injector);
+        case TableviewDefaultActionsEnum.LocalizationLanguageSelect:
+            return tableviewLocalizationLanguageSelectAction(tableview);
+        case TableviewDefaultActionsEnum.Refresh:
+            return tableviewRefreshAction(tableview.model);
+        case TableviewDefaultActionsEnum.Export:
+            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportJson) || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv)
+                ? tableviewExportAction(tableview, injector, defaultActions)
+                : null;
+        //details actions
+        case TableviewDefaultActionsEnum.EditOnDetails:
+            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Edit)
+                ? tableviewEditOnDetailsAction(tableview.model, tableviewEditAction(tableview.editEditor, injector), injector)
+                : null;
+        case TableviewDefaultActionsEnum.DeleteOnDetails:
+            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Delete) ? tableviewDeleteOnDetailsAction(tableview.model, injector) : null;
+        // subactions
+        case TableviewDefaultActionsEnum.ExportJson:
+        case TableviewDefaultActionsEnum.ExportCsv:
+            return null;
+        default:
+            throw new CommonsInternalError(`Tableview default action of type ${type} not supported`);
+    }
+}
+function getInjector(injector) {
+    return injector === undefined ? inject(Injector) : 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 ? ActionEditorDetailsDescriptor.create(descriptor) : null;
+}
+function tableviewDetailsActionWithProvider(descriptor, serviceProvider, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasDetails ? ActionEditorDetailsDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+}
+function tableviewAddAction(descriptor, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasAdd ? ActionEditorAddDescriptor.create(descriptor) : null;
+}
+function tableviewAddActionWithProvider(descriptor, serviceProvider, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasAdd ? ActionEditorAddDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+}
+function tableviewEditAction(descriptor, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit ? ActionEditorEditDescriptor.create(descriptor) : null;
+}
+function tableviewEditActionWithProvider(descriptor, serviceProvider, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit ? ActionEditorEditDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+}
+function tableviewEditOnDetailsAction(descriptor, editDescriptor, injector) {
+    const routeData = getRouteData(injector);
+    if (routeData?.tableviewActions && !routeData.tableviewActions.hasEdit) {
+        return null;
+    }
+    const action = editDescriptor ? ActionLinkDescriptor.fromAction(editDescriptor) : ActionLinkDescriptor.fromModel(descriptor, ActionEditorEditDescriptorInst.ACTION_NAME);
+    action
+        .withTableviewCategory(TableviewActionDefaultCategories.EDIT)
+        .withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS])
+        .withPosition(ActionPositionEnum.FooterLeft)
+        .withRouterLink('./edit');
+    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 ? ActionDeleteDescriptor.create(descriptor) : null;
+}
+function tableviewDeleteActionWithProvider(descriptor, serviceProvider, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasDelete ? ActionDeleteDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+}
+function tableviewDeleteOnDetailsAction(model, injector) {
+    const action = tableviewDeleteAction(model, injector);
+    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
+    if (action) {
+        action
+            .withTableviewCategory(TableviewActionDefaultCategories.DELETE)
+            .withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS])
+            .withPosition(ActionPositionEnum.FooterLeft)
+            .withRunFunction(ctx => dataProviderExecutor
+            ? dataProviderExecutor.runDeleteOrFail(ctx).pipe(tap(() => {
+                ctx.viewContainer?.reloadTable({});
+                ctx.viewContainer?.closeEditor();
+            }))
+            : null);
+        action.button.withLabel(undefined);
+        action.button.styleClass.withSize(StyleSizeEnum.Normal);
+        return action;
+    }
+    return null;
+}
+function tableviewExportAction(descriptor, injector, defaultActions) {
+    const exportAction = ActionDescriptor.fromModel(descriptor.model, 'export')
+        .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));
+    exportAction.withSubactions(...subactions);
+    return exportAction;
+}
+function tableviewExportJsonAction(descriptor, injector) {
+    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
+    return ActionDescriptor.fromModel(descriptor.model, 'exportJson')
+        .withRunFunction(ctx => {
+        const params = ctx.parameters.dataListParams ? DataListParamsUtil.copy(ctx.parameters.dataListParams) : {};
+        params.offset = 0;
+        params.limit = 500;
+        ctx.parameters.dataListParams = params;
+        return dataProviderExecutor
+            ? dataProviderExecutor.runGetAllOrFail(ctx).pipe(map(res => {
+                const blob = new Blob([JSON.stringify(res.data, undefined, 4)], { type: 'application/json;charset=utf-8' });
+                const typeName = ctx.instance.action.model?.typeName ?? '';
+                saveFileAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.json`);
+                return undefined;
+            }))
+            : ctx.parameters.item;
+    })
+        .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-code'))
+        .withPosition(ActionPositionEnum.ToolbarRight);
+}
+function tableviewExportCsvAction(descriptor, injector) {
+    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
+    return ActionDescriptor.fromModel(descriptor.model, 'exportCsv')
+        .withRunFunction(ctx => {
+        const params = ctx.parameters.dataListParams ? DataListParamsUtil.copy(ctx.parameters.dataListParams) : {};
+        params.offset = 0;
+        params.limit = 500;
+        ctx.parameters.dataListParams = params;
+        return dataProviderExecutor
+            ? dataProviderExecutor.runGetAllOrFail(ctx).pipe(map(res => {
+                if (!res.data) {
+                    return undefined;
+                }
+                const blob = new Blob([convertDataToStringWithDelimiter(res.data, ',', descriptor, ctx.injector.get(TranslateService))], {
+                    type: 'text/csv;charset=utf-8'
+                });
+                const typeName = ctx.instance.action.model?.typeName ?? '';
+                saveFileAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.csv`);
+                return undefined;
+            }))
+            : ctx.parameters.item;
+    })
+        .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-file'))
+        .withPosition(ActionPositionEnum.ToolbarRight);
+}
+function tableviewRefreshAction(descriptor) {
+    const action = ActionDescriptor.fromModel(descriptor, 'refresh')
+        .withPosition(ActionPositionEnum.ToolbarRight)
+        .withTableviewCategory(TableviewActionDefaultCategories.READ)
+        .withRunNotificationSuccess(undefined, undefined, false)
+        .withRunFunction(ctx => {
+        ctx.viewContainer?.reloadTable({});
+        return of(null);
+    });
+    action.button.withIcon('pi pi-refresh').styleClass.withActionLevel(StyleLevelEnum.Secondary);
+    return action;
+}
+function tableviewLocalizationLanguageSelectAction(descriptor) {
+    return descriptor.isLocalized()
+        ? ActionDescriptor.fromModel(descriptor.model, 'translator').withPosition(ActionPositionEnum.ToolbarLeft).withComponentFromDi(DATA_LANGUAGE_DROPDOWN_COMPONENT_IT)
+        : null;
+}
+
+/**
+ * The `TableviewBuilder` class is used to build a tableview configuration.
+ * It allows you to set various options such as the descriptor, data provider,
+ * default actions, and custom actions for the tableview.
+ *
+ * @typeparam Model - The main model type.
+ * @typeparam Service - The API service type.
+ * @typeparam Descriptor - The descriptor type.
+ * @typeparam DataProvider - The data provider type.
+ * @typeparam Sorts - The sort type representing available sort keys.
+ * @typeparam Filters - The filter type representing available filter keys.
+ */
+class TableviewInputBuilder {
+    constructor(_descriptor, _dataProvider, injector) {
+        this._descriptor = _descriptor;
+        this._dataProvider = _dataProvider;
+        this.injector = injector;
+        this.defaultActions = getTableviewDefaultActions().map(a => ({ type: a, descriptor: undefined }));
+        this._customActions = [];
+    }
+    prepareSetterParams() {
+        return { descriptor: this._descriptor, dataProvider: this._dataProvider, injector: this.injector };
+    }
+    /**
+     * Sets a descriptor instead of the default one.
+     *
+     * @param {TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new descriptor. It should accept a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDescriptor(fn) {
+        this._descriptor = fn(this.prepareSetterParams());
+        return this;
+    }
+    /**
+     * Adjusts the descriptor using the provided adjust function.
+     *
+     * @param {(descriptor: Descriptor) => void} adjustFn - The function used to adjust the descriptor. It accepts a single parameter of type `Descriptor`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjustDescriptor(adjustFn) {
+        adjustFn(this._descriptor);
+        return this;
+    }
+    /**
+     * Sets the data provider for the TvBuilder instance
+     *
+     * @param {TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * * @returns {this} - Returns the current instance of the builder.
+     */
+    withDataProvider(fn) {
+        this._dataProvider = fn(this.prepareSetterParams());
+        return this;
+    }
+    /**
+     * Adjusts the data provider using the provided adjust function.
+     *
+     * @param {(dataProvider: DataProvider) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `DataProvider`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjustDataProvider(adjustFn) {
+        adjustFn(this._dataProvider);
+        return this;
+    }
+    /**
+     * Adjusts the data provider and/or descriptor using the provided adjust function.
+     *
+     * @param {(params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjust(adjustFn) {
+        adjustFn(this.prepareSetterParams());
+        return this;
+    }
+    /**
+     * Removes all the default tableview actions.
+     *
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withNoDefaultActions() {
+        this.defaultActions.forEach(a => (a.descriptor = null));
+        return this;
+    }
+    /**
+     * Adds the default actions specified in parameters.
+     *
+     * @param {TableviewDefaultActionsEnum[]} types - The default actions to add.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDefaultActions(...types) {
+        types.forEach(type => {
+            const action = this.defaultActions.find(a => a.type === type);
+            if (action?.descriptor === null) {
+                action.descriptor = undefined;
+            }
+        });
+        return this;
+    }
+    /**
+     * Removes the default actions specified in parameters.
+     *
+     * @param {TableviewDefaultActionsEnum[]} types - The default actions to remove.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withoutDefaultActions(...types) {
+        types.forEach(type => {
+            const action = this.defaultActions.find(a => a.type === type);
+            if (action) {
+                action.descriptor = null;
+            }
+        });
+        return this;
+    }
+    /**
+     * 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>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDefaultActionOverride(type, fn) {
+        const action = this.defaultActions.find(a => a.type === type);
+        if (action) {
+            action.descriptor = fn(this.prepareSetterParams()) ?? null;
+        }
+        return this;
+    }
+    /**
+     * 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>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAction(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * Builds and returns an instance of ITableview.
+     * DO NOT CALL this within tableview create callback function!
+     *
+     * @return {ITableview<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.
+     */
+    build() {
+        return {
+            actions: createTableviewActions(this._descriptor, this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type), this.defaultActions
+                .filter(a => a.descriptor != null)
+                .reduce((acc, a) => ({
+                ...acc,
+                [a.type]: a.descriptor
+            }), {}), this.injector).concat(this._customActions),
+            dataProvider: this._dataProvider,
+            descriptor: this._descriptor
+        };
+    }
+}
+
+/**
+ * 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 {(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(TableviewDescriptor.fromModel(model), TableviewDataProvider.fromService(service), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+function tableviewWithSortAndFilter(model, service, sorts, filters, buildFn) {
+    const builder = new TableviewInputBuilder(TableviewDescriptor.fromModel(model), TableviewDataProvider.fromService(service), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+
+// action descriptors
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AFieldDescriptor, AFieldGroupDescriptor, AFormlyCustomFieldComponent, AGenericFieldDescriptor, ActionActivationTriggerEnum, ActionConfirmationDescriptor, ActionDeleteDescriptor, ActionDeleteDescriptorInst, ActionDescriptor, ActionDescriptorInst, ActionEditorAddDescriptor, ActionEditorAddDescriptorInst, ActionEditorDescriptor, ActionEditorDescriptorInst, ActionEditorDetailsDescriptor, ActionEditorDetailsDescriptorInst, ActionEditorEditDescriptor, ActionEditorEditDescriptorInst, ActionEditorSubmitDescriptor, ActionEditorSubmitDescriptorInst, ActionEditorSubmitTypeEnum, ActionInstanceStateEnum, ActionLinkDescriptor, ActionLinkDescriptorInst, ActionPositionEnum, ActionTypeEnum, CommonsActionError, DATA_LANGUAGE_DROPDOWN_COMPONENT_IT, DataProviderExecutor, DynamicTableviewDataProvider, DynamicTableviewDataProviderInst, EDITOR_DEFAULT_GROUP_NAME, EditorDataProvider, EditorDataProviderInst, EditorDescriptor, EditorDescriptorInst, FieldActionDescriptor, FieldGroupDescriptor, FieldGroupTypeEnum, FieldInputDescriptor, FieldInputTypeEnum, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupTypeEnum, FieldManyEditorActionEnum, FieldManyEditorDescriptor, FieldManyEditorTypeEnum, FieldManyToManyEditorActionEnum, FieldManyToManyEditorDescriptor, FieldManyToManyEditorTypeEnum, FieldSizeEnum, FieldTabGroupDescriptor, FieldValidationDescriptor, FormEventTypeEnum, FormFieldEventComponentSubtype, FormFieldEventDialogSubtype, FormFieldEventTypeEnum, TableviewActionDefaultCategories, TableviewDataProvider, TableviewDataProviderInst, TableviewDefaultActionsEnum, TableviewDescriptor, TableviewDescriptorInst, TableviewDynamicDescriptor, TableviewDynamicDescriptorInt, TableviewEditorTypeEnum, TableviewInputBuilder, actionEditorGetProviderCfgObj, actionGetProviderCfgObj, convertDataToStringWithDelimiter, createTableviewAction, createTableviewActions, expandClassAttributeDefWithEditorDef, expandClassAttributeDefWithTableviewDef, fieldLookupGetProviderCfgObj, fieldManyToManyGetProviderCfgObj, getDataProviderService, getEditorClassAttributeDef, getFieldInputTypeFromClassAttributeDefType, getFieldInputTypeFromColumnType, getTableviewClassAttributeDef, getTableviewDefaultActions, maxDateValidator, minDateValidator, runCreateFromDataProvider, runDeleteFromDataProvider, runFetchFromDataProvider, runFnFromDataProviderOrFail, runFnFromDataProviderOrFallback, runGetAllFromDataProvider, runUpdateFromDataProvider, saveFileAs, tableview, tableviewAddAction, tableviewAddActionWithProvider, tableviewDeleteAction, tableviewDeleteActionWithProvider, tableviewDeleteOnDetailsAction, tableviewDetailsAction, tableviewDetailsActionWithProvider, tableviewEditAction, tableviewEditActionWithProvider, tableviewEditOnDetailsAction, tableviewExportAction, tableviewExportCsvAction, tableviewExportJsonAction, tableviewLocalizationLanguageSelectAction, tableviewRefreshAction, tableviewWithSortAndFilter };
+//# sourceMappingURL=mediusinc-mng-commons-tableview-api.mjs.map