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

package/tableview/api/editor/data-providers/editor.data-provider.d.ts

@@ -0,0 +1,87 @@
+import { ClassOptType, ClassType, DataProviderInst, IDataProvider, IdType, ItemOrObservable, ServiceClassOptType, ServiceClassType } from '@mediusinc/mng-commons/core';
+export type EditorDataProviderFetchFnType<Model = any, Service = undefined, Id = IdType, Return = ItemOrObservable<Model>> = (id: Id, service: Service, locale: string | undefined) => Return;
+export type EditorDataProviderCreateFnType<Model = any, Service = undefined, Item = Model | undefined, Return = ItemOrObservable<Model>> = (item: Item, service: Service) => Return;
+export type EditorDataProviderUpdateFnType<Model = any, Service = undefined, Id = IdType, Item = Model | undefined, Return = ItemOrObservable<Model>> = (id: Id, item: Item, service: Service) => Return;
+export type EditorDataProviderDeleteFnType<Model = any, Service = undefined, Id = IdType, Item = Model | undefined, Return = ItemOrObservable<Model | null>> = (id: Id, item: Item, service: Service) => Return;
+export interface IEditorDataProviderFetch<Model, Service> {
+    fetch: EditorDataProviderFetchFnType<Model, Service>;
+    withFetch(fn: EditorDataProviderFetchFnType<Model, Service>): this;
+}
+export interface IEditorDataProviderCreate<Model, Service> {
+    create?: EditorDataProviderCreateFnType<Model, Service>;
+    withCreate(fn?: EditorDataProviderCreateFnType<Model, Service>): this;
+}
+export interface IEditorDataProviderUpdate<Model, Service> {
+    update?: EditorDataProviderUpdateFnType<Model, Service>;
+    withUpdate(fn?: EditorDataProviderUpdateFnType<Model, Service>): this;
+}
+export interface IEditorDataProviderDelete<Model, Service> {
+    delete?: EditorDataProviderDeleteFnType<Model, Service>;
+    withDelete(fn?: EditorDataProviderDeleteFnType<Model, Service>): this;
+}
+export type IEditorDataProviderFnsType<Model, Service> = IEditorDataProviderFetch<Model, Service> & IEditorDataProviderCreate<Model, Service> & IEditorDataProviderUpdate<Model, Service> & IEditorDataProviderDelete<Model, Service>;
+export type IEditorDataProvider<Model = any, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> = IDataProvider<Model, Service, ModelClass, ServiceClass> & IEditorDataProviderFnsType<Model, Service>;
+export declare class EditorDataProviderInst<Model, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> extends DataProviderInst<Model, Service, ModelClass, ServiceClass> implements IEditorDataProvider<Model, Service, ModelClass, ServiceClass> {
+    protected _fetch: EditorDataProviderFetchFnType<Model, Service>;
+    protected _create?: EditorDataProviderCreateFnType<Model, Service>;
+    protected _update?: EditorDataProviderUpdateFnType<Model, Service>;
+    protected _delete?: EditorDataProviderDeleteFnType<Model, Service>;
+    protected constructor(type: ModelClass, serviceType: ServiceClass);
+    get fetch(): EditorDataProviderFetchFnType<Model, Service, IdType, ItemOrObservable<Model>>;
+    get create(): EditorDataProviderCreateFnType<Model, Service, Model | undefined, ItemOrObservable<Model>> | undefined;
+    get update(): EditorDataProviderUpdateFnType<Model, Service, IdType, Model | undefined, ItemOrObservable<Model>> | undefined;
+    get delete(): EditorDataProviderDeleteFnType<Model, Service, IdType, Model | undefined, ItemOrObservable<Model | null>> | undefined;
+    /**
+     * 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: EditorDataProviderFetchFnType<Model, Service>): 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?: EditorDataProviderCreateFnType<Model, Service>): 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?: EditorDataProviderUpdateFnType<Model, Service>): 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?: EditorDataProviderDeleteFnType<Model, Service>): this;
+}
+export declare class EditorDataProvider extends EditorDataProviderInst<any> {
+    protected constructor();
+    static create<Model>(): EditorDataProviderInst<Model, undefined, undefined, undefined>;
+    static fromClass<Model>(type: ClassType<Model>): EditorDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromClassWithService<Model, Service>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): EditorDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromService<Service, Model>(serviceType: ServiceClassType<Service>): EditorDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model>(): EditorDataProviderInst<Model, undefined, undefined, undefined>;
+    static fromAnyParam<Model>(type: ClassType<Model>): EditorDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromAnyParam<Model, Service = any>(type: undefined, serviceType: ServiceClassType<Service>): EditorDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service = any>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): EditorDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): EditorDataProviderInst<Model, Service, ModelClass, ServiceClass>;
+}

package/tableview/api/editor/descriptors/editor.descriptor.d.ts

@@ -0,0 +1,366 @@
+import { Type } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ArrayItemType, ClassType, EnumConstantType, IEditorDescriptorInternal, ILookupDataProvider, IdType, KeyofAndOfType, Nullable } from '@mediusinc/mng-commons/core';
+import { EnumDescriptor, ModelDescriptor, TypeDescriptor } from '@mediusinc/mng-commons/model';
+import { ITableDataProvider, TableDescriptorInst } from '@mediusinc/mng-commons/table/api';
+import { TableviewDescriptorInst } from '../../tableview/descriptors/tableview.descriptor';
+import { EditorClassAttributeDef } from '../models/class-tableview-attribute.model';
+import { IFieldsManageInterface } from '../models/editor-fields.model';
+import { TableviewEditorTypeEnum } from '../models/editor.model';
+import { FieldInputTypeEnum, FieldValidationMessage, FieldValidator } from '../models/field.model';
+import { FieldEventData, FormEvent, FormEventTypeEnum } from '../models/form-editor.event';
+import { FieldActionDescriptor } from './field-action.descriptor';
+import { AFieldDescriptor } from './field-base.descriptor';
+import { FieldGroupDescriptor, FieldTabGroupDescriptor } from './field-group.descriptor';
+import { FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupProviderType } from './field-lookup.descriptor';
+import { FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor } from './field-many.descriptor';
+import { FieldInputDescriptor, FieldInputDescriptorType } from './field.descriptor';
+export declare class EditorDescriptorInst<EditorModel> implements IEditorDescriptorInternal<EditorModel>, IFieldsManageInterface<EditorModel> {
+    static readonly defaultGroupName = "_default";
+    /** @ignore */ protected readonly _model: ModelDescriptor<EditorModel>;
+    /** @ignore */ protected readonly _tableviewEditorType: TableviewEditorTypeEnum;
+    /** @ignore */ protected readonly _tabs: Array<FieldTabGroupDescriptor<EditorModel>>;
+    /** @ignore */ protected readonly _groups: Array<FieldGroupDescriptor<EditorModel>>;
+    /** @ignore */ protected _fields: Array<AFieldDescriptor<any, EditorModel>>;
+    /** @ignore */ protected _currentTabGroup?: FieldTabGroupDescriptor<EditorModel>;
+    /** @ignore */ protected _currentGroup?: FieldGroupDescriptor<EditorModel>;
+    /** @ignore */ protected _disabled: boolean;
+    /** @ignore */ protected _isLocalized: boolean;
+    /** @ignore */ protected _localizationLocaleProperty?: string;
+    /** @ignore */ protected _localizationModel?: ModelDescriptor<any>;
+    /** @ignore */ protected _localizationLocalizationProperty?: string;
+    /** @ignore */ protected readonly _eventsSubject: Subject<FormEvent<EditorModel>>;
+    /**
+     * Creates new instance of editor descriptor.
+     * @param model Model descriptor.
+     * @param tableviewEditorType Type of editor in tableview (add, edit, view or none).
+     */
+    protected constructor(model: ModelDescriptor<EditorModel>, tableviewEditorType?: TableviewEditorTypeEnum);
+    /**
+     * Model descriptor for editor.
+     */
+    get model(): ModelDescriptor<EditorModel, import("@mediusinc/mng-commons/core").ClassOptType<EditorModel>>;
+    /**
+     * Editor's tabs.
+     */
+    get tabs(): FieldTabGroupDescriptor<EditorModel>[];
+    /**
+     * Editor's fields.
+     */
+    get fields(): AFieldDescriptor<any, EditorModel, any>[];
+    /**
+     * Type of editor for tableview.
+     */
+    get tableviewEditorType(): TableviewEditorTypeEnum;
+    /**
+     * If editor is disabled.
+     */
+    get disabled(): boolean;
+    get isLocalized(): boolean;
+    get localizationLocaleProperty(): string | undefined;
+    get localizationLocalizationProperty(): string | undefined;
+    get localizationModel(): ModelDescriptor<any, import("@mediusinc/mng-commons/core").ClassOptType<any>> | undefined;
+    /**
+     * 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: string, title?: string): FieldTabGroupDescriptor<EditorModel>;
+    /**
+     * 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: string, title?: string | null): FieldGroupDescriptor<EditorModel>;
+    /**
+     * Gets field by the model property name.
+     * @param property Model property name.
+     */
+    getField(property: keyof EditorModel): AFieldDescriptor<any, EditorModel, any> | null;
+    /**
+     * Gets field by the model property name (UNSAFE).
+     * @param property Model property name.
+     */
+    getFieldUnsafe(property: string): AFieldDescriptor<any, EditorModel> | null;
+    /**
+     * Removes field by the model property name.
+     * @param property Model property name.
+     */
+    removeField(property: keyof EditorModel): void;
+    /**
+     * Removes field by the model property name (UNSAFE).
+     * @param property Model property name.
+     */
+    removeFieldUnsafe(property: string): void;
+    /**
+     * Adds field by the descriptor.
+     * @param field Field descriptor.
+     */
+    addFieldDescriptor<FieldModel, FieldValue = FieldModel>(field: AFieldDescriptor<FieldModel, EditorModel, FieldValue>): this;
+    /**
+     * Adds field by the model property name.
+     * @param property Model property name.
+     */
+    addField<Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property): FieldInputDescriptor<EditorModel, FieldModel, FieldValue>;
+    /**
+     * 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<FieldModel = FieldInputDescriptorType, FieldValue = FieldModel>(property: string): FieldInputDescriptor<EditorModel, FieldModel, FieldValue>;
+    addFields(...properties: (keyof EditorModel)[]): this;
+    addFieldAction(actionName: string): FieldActionDescriptor<EditorModel>;
+    /**
+     * 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<K extends keyof EditorModel, LookupModel = NonNullable<EditorModel[K]>, FieldValue = EditorModel[K]>(property: K, type?: TypeDescriptor<LookupModel>): FieldLookupDescriptor<LookupModel, EditorModel, undefined, FieldValue>;
+    /**
+     * [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<LookupModel, FieldValue = LookupModel>(property: string, type?: TypeDescriptor<LookupModel>): FieldLookupDescriptor<LookupModel, EditorModel, undefined, FieldValue>;
+    /**
+     * 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 extends keyof EditorModel, LookupModel, LookupValueProperty extends KeyofAndOfType<LookupModel, EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, type: TypeDescriptor<LookupModel>, lookupOptionsValueProperty: LookupValueProperty): FieldLookupDescriptor<LookupModel, EditorModel, undefined, FieldValue>;
+    /**
+     * [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<LookupModel, FieldValue = Nullable<IdType>>(property: string, type: TypeDescriptor<LookupModel>, lookupOptionsValueProperty: string): FieldLookupDescriptor<LookupModel, EditorModel, undefined, FieldValue>;
+    /**
+     * 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 extends keyof EditorModel, Service, LookupModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, provider: FieldLookupProviderType<LookupModel, Service>, type?: TypeDescriptor<LookupModel>): FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>;
+    /**
+     * [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<LookupModel, Service, FieldValue = LookupModel>(property: string, provider: FieldLookupProviderType<LookupModel, Service>, type?: TypeDescriptor<LookupModel>): FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>;
+    /**
+     * 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 extends keyof EditorModel, Service, LookupModel, LookupValueProperty extends KeyofAndOfType<LookupModel, EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, provider: FieldLookupProviderType<LookupModel, Service>, type: TypeDescriptor<LookupModel>, lookupOptionsValueProperty: LookupValueProperty): FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>;
+    /**
+     * [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<Service, LookupModel, FieldValue = LookupModel>(property: string, provider: FieldLookupProviderType<LookupModel, Service>, type: TypeDescriptor<LookupModel>, lookupOptionsValueProperty: string): FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>;
+    addFieldLookupEnum<Property extends keyof EditorModel, Enum extends NonNullable<EditorModel[Property]>>(property: keyof EditorModel, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel>;
+    /**
+     * 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<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel>;
+    /**
+     * 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 extends keyof EditorModel, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, tableviewDescriptor: TableviewDescriptorInst<FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>;
+    /**
+     * 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<FieldModel, FieldValue = FieldModel[]>(property: string, tableviewDescriptor: TableviewDescriptorInst<FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>;
+    /**
+     * 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 extends keyof EditorModel, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
+    /**
+     * 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<FieldModel, FieldValue = FieldModel[]>(property: string, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, undefined, FieldValue>;
+    addFieldManyToManyEditorWithProvider<Property extends keyof EditorModel, ServiceType, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>, lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, ServiceType, FieldValue>;
+    addFieldManyToManyEditorWithProviderUnsafe<FieldModel, ServiceType, FieldValue = FieldModel[]>(property: string, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>, lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, ServiceType, FieldValue>;
+    /**
+     * Disables field on editor.
+     * @param disabled
+     */
+    withDisabled(disabled?: boolean): this;
+    /**
+     * Adds group validator to editor.
+     * @param name Name of the validation.
+     * @param validator Field validator function.
+     * @param message Field validation message.
+     */
+    addValidation(name: string, validator?: FieldValidator, message?: FieldValidationMessage): void;
+    /**
+     * Creates a copy of editor descriptor object.
+     */
+    copy(): EditorDescriptorInst<EditorModel>;
+    /**
+     * Created group from field group descriptor.
+     * @param fieldGroup Field group descriptor.
+     * @internal
+     */
+    createFieldGroupDescriptor(fieldGroup: FieldGroupDescriptor<EditorModel>): this;
+    /**
+     * Creates tab group from tab group descriptor.
+     * @param tabGroup Tab group descriptor.
+     * @internal
+     */
+    protected createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<EditorModel>): this;
+    /**
+     * Creates default field group.
+     * @internal
+     */
+    private createDefaultGroup;
+    /**
+     * Creates default tab group.
+     * @internal
+     */
+    private createDefaultTabGroup;
+    /**
+     * 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: keyof EditorModel, fieldType: FieldInputTypeEnum, ...args: any[]): this;
+    withFieldModifiedTypeUnsafe(property: string, fieldType: FieldInputTypeEnum, ...args: any[]): this;
+    /**
+     * Modifies selected field with enum type.
+     * @param property Model's property name.
+     * @param enumModel Enum descriptor.
+     * @param values
+     */
+    withFieldModifiedEnum<Property extends keyof EditorModel, Enum extends NonNullable<EditorModel[Property]>>(property: Property, enumModel?: EnumDescriptor<Enum>, values?: Array<Enum>): this;
+    withFieldModifiedEnumUnsafe<Enum = any>(property: string, enumDesc?: EnumDescriptor<Enum>, values?: Array<Enum>): this;
+    /**
+     * Modifies selected field with lookup field.
+     * @param property Model's property name.
+     * @param lookupProvider provider to be added to field
+     * @param titleProperty
+     */
+    withFieldModifiedLookupWithProvider<ServiceType, FieldModel>(property: keyof EditorModel, lookupProvider: ILookupDataProvider<FieldModel, ServiceType>, titleProperty?: keyof FieldModel): this;
+    withFieldModifiedLookupWithProviderUnsafe<Service, FieldModel>(property: string, lookupProvider: ILookupDataProvider<FieldModel, Service>, titleProperty?: string): 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 extends keyof EditorModel, LocalizationModel = ArrayItemType<EditorModel[Property]>>(property: Property, model: ModelDescriptor<LocalizationModel>, localeProperty: keyof LocalizationModel): this;
+    localizedUnsafe<LocalizationType>(property: string, model: ModelDescriptor<LocalizationType>, localeProperty: string): this;
+    nextEvent(type: FormEventTypeEnum, cmpType: Type<any>, cmpInstance: any, data?: FieldEventData<EditorModel>): void;
+    completeEvents(): void;
+    get events$(): import("rxjs").Observable<FormEvent<EditorModel>>;
+    /**
+     * 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
+     */
+    protected static upsertFieldFromAttributeDef<T>(descriptor: EditorDescriptorInst<T>, attribute: EditorClassAttributeDef, field?: AFieldDescriptor<any, T>, ...args: any[]): AFieldDescriptor<any, T>;
+}
+export declare class EditorDescriptor extends EditorDescriptorInst<any> {
+    protected constructor();
+    static create<EditorModel>(idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, i18nBaseKey?: string | ClassType<unknown>, tableviewEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel>;
+    static fromClass<EditorModel>(type: ClassType<EditorModel>, idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, i18nBaseKey?: ClassType<unknown> | string, tableviewEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel>;
+    static fromModel<EditorModel>(model: ModelDescriptor<EditorModel>, tableviewEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel>;
+    /**
+     * 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<EditorModel>(type: ClassType<EditorModel>, idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, tableEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel>;
+    /**
+     * 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<EditorModel>(type: ClassType<EditorModel>, attributes: EditorClassAttributeDef[], idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, tableEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel>;
+}

package/tableview/api/editor/descriptors/field-action.descriptor.d.ts

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { IEditorDescriptorInternal, StyleLevelEnum } from '@mediusinc/mng-commons/core';
+import { ActionButtonDescriptor } from '@mediusinc/mng-commons/form/api';
+import { FieldActionContext, FieldActionResult } from '../models/field-action-context.model';
+import { AFieldDescriptor } from './field-base.descriptor';
+export type FieldActionRunFnType<EditorModel> = (ctx: FieldActionContext<EditorModel>) => void | FieldActionResult | Observable<FieldActionResult>;
+export declare class FieldActionDescriptor<EditorModel> extends AFieldDescriptor<void, EditorModel> {
+    protected readonly _fieldActionName: string;
+    protected readonly _fieldActionNameLong: string;
+    protected _button: ActionButtonDescriptor;
+    protected _runFunction?: FieldActionRunFnType<EditorModel>;
+    private _wrappers;
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string);
+    get button(): ActionButtonDescriptor;
+    get runFunction(): FieldActionRunFnType<EditorModel> | undefined;
+    get wrappers(): string[];
+    withButtonDescriptor(button: ActionButtonDescriptor): this;
+    withButton(label?: string | null, icon?: string | null, styleLevel?: StyleLevelEnum, styleText?: boolean): this;
+    withRunFunction(fn: FieldActionRunFnType<EditorModel>): this;
+    withWrappers(wrappers: string[]): this;
+    copy(): FieldActionDescriptor<EditorModel>;
+}

package/tableview/api/editor/descriptors/field-base.descriptor.d.ts

@@ -0,0 +1,120 @@
+import { Type } from '@angular/core';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable, Subject } from 'rxjs';
+import { GetterFn, IEditorDescriptorInternal } from '@mediusinc/mng-commons/core';
+import { FieldAsyncValidator, FieldConfig, FieldSizeEnum, FieldValidationMessage, FieldValidator } from '../models/field.model';
+import { FormFieldEvent, FormFieldEventData, FormFieldEventTypeEnum } from '../models/form-editor.event';
+import { CommonsFormlyFieldConfig, CommonsFormlyHookFn } from '../models/formly-field.model';
+import { FieldValidationDescriptor } from './field-validation.descriptor';
+export declare abstract class AGenericFieldDescriptor<EditorModel> {
+    protected readonly _editor: IEditorDescriptorInternal<EditorModel>;
+    protected _config: FieldConfig;
+    protected constructor(editor: IEditorDescriptorInternal<EditorModel>);
+    get editor(): IEditorDescriptorInternal<EditorModel>;
+    get config(): FieldConfig;
+    withConfig(config: FieldConfig): this;
+    /**
+     * Override toJSON implementation to prevent overflow with circular dependency.
+     * @ignore
+     */
+    protected toJSON(): string;
+}
+export declare abstract class AFieldDescriptor<FieldModel, EditorModel, FieldValue = FieldModel> extends AGenericFieldDescriptor<EditorModel> {
+    /** @ignore */ protected readonly _property: string;
+    /** @ignore */ protected _label?: string | null;
+    /** @ignore */ protected _placeholder?: string;
+    /** @ignore */ protected _helpText?: string;
+    /** @ignore */ protected _required: boolean;
+    /** @ignore */ protected _requiredHideLabelMarker: boolean;
+    /** @ignore */ protected _disabled: boolean;
+    /** @ignore */ protected _defaultValue?: FieldValue;
+    /** @ignore */ protected _getter?: GetterFn<FieldValue, EditorModel>;
+    /** @ignore */ protected _setter?: (item: EditorModel, value: FieldValue) => void;
+    /** @ignore */ protected _validations: Array<FieldValidationDescriptor>;
+    /** @ignore */ protected _asyncValidations: Array<FieldValidationDescriptor>;
+    /** @ignore */ protected _requiredExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    /** @ignore */ protected _disabledExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    /** @ignore */ protected _hiddenExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    /** @ignore */ protected _updateOn: 'change' | 'blur' | 'submit';
+    /** @ignore */ protected _onInit?: CommonsFormlyHookFn;
+    /** @ignore */ protected _onChanges?: CommonsFormlyHookFn;
+    /** @ignore */ protected _afterContentInit?: CommonsFormlyHookFn;
+    /** @ignore */ protected _afterViewInit?: CommonsFormlyHookFn;
+    /** @ignore */ protected _onDestroy?: CommonsFormlyHookFn;
+    /** @ignore */ protected _onValueChange?: (field: CommonsFormlyFieldConfig, value: any) => void;
+    /** @ignore */ protected _className: string;
+    /** @ignore */ protected _fieldClassName?: string;
+    /** @ignore */ protected _labelClassName: string;
+    /** @ignore */ protected _inputClassName: string;
+    /** @ignore */ protected _size: FieldSizeEnum;
+    /** @ignore */ protected _isLocalized: boolean;
+    /** @ignore */ protected readonly _eventsSubject: Subject<FormFieldEvent<FieldModel, EditorModel>>;
+    protected constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string);
+    get property(): string;
+    get label(): string | null | undefined;
+    get placeholder(): string | undefined;
+    get helpText(): string | undefined;
+    get required(): boolean;
+    get requiredHideLabelMarker(): boolean;
+    get disabled(): boolean;
+    get defaultValue(): FieldValue | undefined;
+    get getter(): GetterFn<FieldValue, EditorModel> | undefined;
+    get setter(): ((item: EditorModel, value: FieldValue) => void) | undefined;
+    get validations(): FieldValidationDescriptor[];
+    get asyncValidations(): FieldValidationDescriptor[];
+    get requiredExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
+        [additionalProperties: string]: any;
+    }> | undefined) => boolean) | undefined;
+    get disabledExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
+        [additionalProperties: string]: any;
+    }> | undefined) => boolean) | undefined;
+    get hiddenExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig<import("@ngx-formly/core").FormlyFieldProps & {
+        [additionalProperties: string]: any;
+    }> | undefined) => boolean) | undefined;
+    get updateOn(): "submit" | "change" | "blur";
+    get onInit(): CommonsFormlyHookFn | undefined;
+    get onChanges(): CommonsFormlyHookFn | undefined;
+    get afterContentInit(): CommonsFormlyHookFn | undefined;
+    get afterViewInit(): CommonsFormlyHookFn | undefined;
+    get onDestroy(): CommonsFormlyHookFn | undefined;
+    get onValueChange(): ((field: CommonsFormlyFieldConfig<import("../models/formly-field.model").CommonsFormlyFieldProps>, value: any) => void) | undefined;
+    get className(): string;
+    get fieldClassName(): string | undefined;
+    get labelClassName(): string;
+    get inputClassName(): string;
+    get size(): FieldSizeEnum;
+    get isSizeSmall(): boolean;
+    get isSizeLarge(): boolean;
+    get isLocalized(): boolean;
+    abstract copy(): AFieldDescriptor<FieldModel, EditorModel, FieldValue>;
+    withLabel(label: string | null): this;
+    withPlaceholder(placeholder: string): this;
+    withHelpText(helpText: string): this;
+    withRequired(required?: boolean, requiredExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>, hideLabelMarker?: boolean): this;
+    withDisabled(disabled?: boolean, disabledExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>): this;
+    withHidden(hiddenExpression: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>): this;
+    withUpdateOn(updateOn: 'change' | 'blur' | 'submit'): this;
+    withOnInit(onInit?: CommonsFormlyHookFn): this;
+    withOnChanges(onChanges?: CommonsFormlyHookFn): this;
+    withAfterContentInit(afterContentInit?: CommonsFormlyHookFn): this;
+    withAfterViewInit(afterViewInit?: CommonsFormlyHookFn): this;
+    withOnDestroy(onDestroy?: CommonsFormlyHookFn): this;
+    withOnValueChange(onValueChange?: (field: CommonsFormlyFieldConfig, value: any) => void): this;
+    withDefaultValue(defaultValue: FieldValue): this;
+    withGetter(fn?: GetterFn<FieldValue, EditorModel>): this;
+    withSetter(fn?: (item: EditorModel, value: FieldValue) => void): this;
+    withValidation(name: string, validator?: FieldValidator, message?: FieldValidationMessage): this;
+    removeValidation(name: string): this;
+    withAsyncValidation(name: string, asyncValidator?: FieldAsyncValidator, message?: FieldValidationMessage): this;
+    removeAsyncValidation(name: string): this;
+    withClassName(className: string, labelClassName?: string, inputClassName?: string, fieldClassName?: string): this;
+    withSize(size?: FieldSizeEnum): 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(): this;
+    nextEvent(type: FormFieldEventTypeEnum, cmpType: Type<any>, cmpInstance: any, data?: FormFieldEventData<FieldModel, EditorModel>): void;
+    get events$(): Observable<FormFieldEvent<FieldModel, EditorModel>>;
+    protected copyFieldsTo(obj: AFieldDescriptor<FieldModel, EditorModel, FieldValue>): void;
+}

package/tableview/api/editor/descriptors/field-group.descriptor.d.ts

@@ -0,0 +1,41 @@
+import { IEditorDescriptorInternal } from '@mediusinc/mng-commons/core';
+import { FieldGroupTypeEnum, FieldValidationMessage, FieldValidator } from '../models/field.model';
+import { AFieldDescriptor, AGenericFieldDescriptor } from './field-base.descriptor';
+import { FieldValidationDescriptor } from './field-validation.descriptor';
+export declare abstract class AFieldGroupDescriptor<EditorModel> extends AGenericFieldDescriptor<EditorModel> {
+    protected readonly _name: string;
+    protected readonly _default: boolean;
+    protected _title?: string;
+    protected _fields: AGenericFieldDescriptor<EditorModel>[];
+    protected _validations: Array<FieldValidationDescriptor>;
+    protected constructor(editor: IEditorDescriptorInternal<EditorModel>, name: string);
+    removeField(property: string, filterFunction: (fields: AGenericFieldDescriptor<EditorModel>[]) => AGenericFieldDescriptor<EditorModel>[]): AGenericFieldDescriptor<EditorModel>[];
+    get title(): string | undefined;
+    abstract get fields(): AGenericFieldDescriptor<EditorModel>[];
+    get validations(): FieldValidationDescriptor[];
+    get baseName(): string;
+    get name(): string;
+    get default(): boolean;
+    abstract groupName(): string;
+    abstract addField(field: AGenericFieldDescriptor<EditorModel>): this;
+    abstract copy(): AFieldGroupDescriptor<EditorModel>;
+    withTitle(title: string): this;
+    withValidation(name: string, validator?: FieldValidator, message?: FieldValidationMessage): this;
+}
+export declare class FieldTabGroupDescriptor<EditorModel> extends AFieldGroupDescriptor<EditorModel> {
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, name: string);
+    get fields(): Array<FieldGroupDescriptor<EditorModel>>;
+    groupName(): string;
+    addField(field: FieldGroupDescriptor<EditorModel>): this;
+    copy(): FieldTabGroupDescriptor<EditorModel>;
+}
+export declare class FieldGroupDescriptor<EditorModel> extends AFieldGroupDescriptor<EditorModel> {
+    private _type;
+    constructor(editor: IEditorDescriptorInternal<EditorModel>, name: string);
+    get type(): FieldGroupTypeEnum;
+    get fields(): Array<AFieldDescriptor<any, EditorModel>>;
+    groupName(): string;
+    addField(field: AFieldDescriptor<any, EditorModel>): this;
+    asLogical(): this;
+    copy(): FieldGroupDescriptor<EditorModel>;
+}