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

package/tableview/api/action/models/tableview-action-default-categories.model.d.ts

@@ -2,9 +2,9 @@
  * Default categories for tableview actions
  */
 export declare class TableviewActionDefaultCategories {
-    static readonly READ = "read";
-    static readonly ADD = "add";
-    static readonly EDIT = "edit";
-    static readonly DELETE = "delete";
-    static readonly DETAILS = "details";
+    static readonly READ = "_defaultTwRead";
+    static readonly ADD = "_defaultTwAdd";
+    static readonly EDIT = "_defaultTwEdit";
+    static readonly DELETE = "_defaultTwDelete";
+    static readonly DETAILS = "_defaultTwDetails";
 }

package/tableview/api/action/services/data-provider-executor.service.d.ts

@@ -1,33 +1,34 @@
 import { Injector } from '@angular/core';
 import { Observable } from 'rxjs';
 import { DataListResult, IDataProvider, Nullable } from '@mediusinc/mng-commons/core';
+import { RunFetchFromDataProviderReasonType } from '../helpers/data-provider-executors';
 import { IActionContext } from '../models/execution/action-context.model';
 export declare abstract class DataProviderExecutor {
-    runGetAllOrFail<Item, Service>(ctx: IActionContext<Item, Service>): Observable<DataListResult<Item>>;
-    abstract runGetAll<Item, Service>(ctx: IActionContext<Item, Service>): Observable<DataListResult<Item>> | null;
-    abstract runGetAll<Item, Service>(ctx: IActionContext<Item, Service>, fallback: Observable<DataListResult<Item>>): Observable<DataListResult<Item>>;
-    abstract runGetAll<Item, Service>(ctx: IActionContext<Item, Service>, fallback: undefined): Observable<DataListResult<Item>> | null;
-    abstract runGetAll<Item, Service>(ctx: IActionContext<Item, Service>, fallback?: Observable<DataListResult<Item>>): Observable<DataListResult<Item>> | null;
-    runFetchOrFail<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item>;
-    abstract runFetch<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item> | null;
-    abstract runFetch<Item, Service>(ctx: IActionContext<Item, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
-    abstract runFetch<Item, Service>(ctx: IActionContext<Item, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
-    abstract runFetch<Item, Service>(ctx: IActionContext<Item, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
-    runCreateOrFail<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item>;
-    abstract runCreate<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item> | null;
-    abstract runCreate<Item, Service>(ctx: IActionContext<Item, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
-    abstract runCreate<Item, Service>(ctx: IActionContext<Item, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
-    abstract runCreate<Item, Service>(ctx: IActionContext<Item, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
-    runUpdateOrFail<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item>;
-    abstract runUpdate<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item> | null;
-    abstract runUpdate<Item, Service>(ctx: IActionContext<Item, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
-    abstract runUpdate<Item, Service>(ctx: IActionContext<Item, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
-    abstract runUpdate<Item, Service>(ctx: IActionContext<Item, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
-    runDeleteOrFail<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item | null>;
-    abstract runDelete<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Nullable<Item>> | null;
-    abstract runDelete<Item, Service>(ctx: IActionContext<Item, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
-    abstract runDelete<Item, Service>(ctx: IActionContext<Item, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
-    abstract runDelete<Item, Service>(ctx: IActionContext<Item, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    runGetAllOrFail<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<DataListResult<Item>>;
+    abstract runGetAll<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<DataListResult<Item>> | null;
+    abstract runGetAll<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: Observable<DataListResult<Item>>): Observable<DataListResult<Item>>;
+    abstract runGetAll<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: undefined): Observable<DataListResult<Item>> | null;
+    abstract runGetAll<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback?: Observable<DataListResult<Item>>): Observable<DataListResult<Item>> | null;
+    runFetchOrFail<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fetchReason?: RunFetchFromDataProviderReasonType): Observable<Item>;
+    abstract runFetch<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fetchReason?: RunFetchFromDataProviderReasonType): Observable<Item> | null;
+    abstract runFetch<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fetchReason: RunFetchFromDataProviderReasonType | undefined, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runFetch<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fetchReason: RunFetchFromDataProviderReasonType | undefined, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runFetch<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fetchReason: RunFetchFromDataProviderReasonType | undefined, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    runCreateOrFail<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Item>;
+    abstract runCreate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Item> | null;
+    abstract runCreate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runCreate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runCreate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    runUpdateOrFail<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Item>;
+    abstract runUpdate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Item> | null;
+    abstract runUpdate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runUpdate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runUpdate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    runDeleteOrFail<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Item | null>;
+    abstract runDelete<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Nullable<Item>> | null;
+    abstract runDelete<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runDelete<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runDelete<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
     /**
      * Gets service instance of data provider.
      *

package/tableview/api/class/README.md

@@ -0,0 +1,13 @@
+# @mediusinc/mng-commons/tableview/api
+
+Secondary entry point of `@mediusinc/mng-commons`. It can be used by importing from `@mediusinc/mng-commons/tableview/api/class`.
+
+## Dependencies within commons
+
+- `@mediusinc/mng-commons/core`
+- `@mediusinc/mng-commons/model`
+- `@mediusinc/mng-commons/model/class`
+- `@mediusinc/mng-commons/filter`
+- `@mediusinc/mng-commons/form/api`
+- `@mediusinc/mng-commons/table/api`
+- `@mediusinc/mng-commons/tableview/api`

package/tableview/api/{editor/helpers/class-attribute-converter.d.ts → class/editor/class-editor-attribute-converter.d.ts}

@@ -1,7 +1,7 @@
 import { ClassAttributeDef, ClassType } from '@mediusinc/mng-commons/core';
 import { ColumnDisplayTypeEnum, ColumnTypeEnum } from '@mediusinc/mng-commons/table/api';
-import { EditorClassAttributeDef } from '../models/class-tableview-attribute.model';
-import { FieldInputTypeEnum } from '../models/field.model';
+import { FieldInputTypeEnum } from '@mediusinc/mng-commons/tableview/api';
+import { EditorClassAttributeDef } from './class-editor-attribute.model';
 /**
  * converts string type to type enum, default is text
  * @param attributeType

package/tableview/api/{editor/models/class-tableview-attribute.model.d.ts → class/editor/class-editor-attribute.model.d.ts}

@@ -1,5 +1,5 @@
 import { ClassAttributeDef, ClassType, EnumType } from '@mediusinc/mng-commons/core';
-import { FieldInputTypeEnum } from '../../editor/models/field.model';
+import { FieldInputTypeEnum } from '@mediusinc/mng-commons/tableview/api';
 export interface EditorClassAttributeDef extends ClassAttributeDef {
     classType?: ClassType<any>;
     fieldType?: FieldInputTypeEnum;

package/tableview/api/class/editor/class-editor-data-provider.factory.d.ts

@@ -0,0 +1,4 @@
+import { ClassType, ServiceClassType } from '@mediusinc/mng-commons/core';
+import { EditorDataProviderInst } from '@mediusinc/mng-commons/tableview/api';
+export declare function editorDataProviderFromClass<Model>(type: ClassType<Model>): EditorDataProviderInst<Model, undefined, undefined>;
+export declare function editorDataProviderFromClass<Model, Service = any>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): EditorDataProviderInst<Model, Service, ServiceClassType<Service>>;

package/tableview/api/{editor/helpers/editor-descriptor-helpers.d.ts → class/editor/class-editor-descriptor-helpers.d.ts}

@@ -1,10 +1,7 @@
 import { ILookupDataProvider } from '@mediusinc/mng-commons/core';
 import { EnumDescriptor } from '@mediusinc/mng-commons/model';
-import { EditorDescriptorInst } from '../descriptors/editor.descriptor';
-import { AFieldDescriptor } from '../descriptors/field-base.descriptor';
-import { FieldLookupDescriptor } from '../descriptors/field-lookup.descriptor';
-import { EditorClassAttributeDef } from '../models/class-tableview-attribute.model';
-import { FieldInputTypeEnum } from '../models/field.model';
+import { AFieldDescriptor, EditorDescriptorInst, FieldInputTypeEnum, FieldLookupDescriptor } from '@mediusinc/mng-commons/tableview/api';
+import { EditorClassAttributeDef } from './class-editor-attribute.model';
 /**
  * Generates field based on attribute definition, used for auto model
  * @param descriptor Editor descriptor instance.

package/tableview/api/class/editor/class-editor-descriptor.factory.d.ts

@@ -0,0 +1,11 @@
+import { ClassType } from '@mediusinc/mng-commons/core';
+import { EditorDescriptorCreateOptsType, EditorDescriptorInst } from '@mediusinc/mng-commons/tableview/api';
+import { EditorClassAttributeDef } from './class-editor-attribute.model';
+export declare function editorDescriptorFromClass<EditorModel, ParentEditorModel = undefined>(type: ClassType<EditorModel>, opts?: EditorDescriptorCreateOptsType<EditorModel, ParentEditorModel>): EditorDescriptorInst<EditorModel, ParentEditorModel>;
+/**
+ * Generates descriptor based on type attribute definition
+ * @param type class type
+ * @param attributes
+ * @param opts
+ */
+export declare function editorDescriptorFromClassAttrsDef<EditorModel, ParentEditorModel = undefined>(type: ClassType<EditorModel>, attributes?: EditorClassAttributeDef[], opts?: EditorDescriptorCreateOptsType<EditorModel, ParentEditorModel>): EditorDescriptorInst<EditorModel, ParentEditorModel>;

package/tableview/api/class/index.d.ts

@@ -0,0 +1,10 @@
+export * from './editor/class-editor-attribute.model';
+export * from './editor/class-editor-attribute-converter';
+export * from './editor/class-editor-data-provider.factory';
+export * from './editor/class-editor-descriptor.factory';
+export * from './editor/class-editor-descriptor-helpers';
+export * from './tableview/class-tableview-attribute.model';
+export * from './tableview/class-tableview-attribute-converter';
+export * from './tableview/class-tableview-descriptor.factory';
+export * from './tableview/class-tableview-descriptor-helpers';
+export * from './tableview/class-tableview-data-provider.factory';

package/tableview/api/{tableview/helpers/class-attribute-converter.d.ts → class/tableview/class-tableview-attribute-converter.d.ts}

@@ -1,5 +1,5 @@
 import { ClassAttributeDef, ClassType } from '@mediusinc/mng-commons/core';
-import { TableviewClassAttributeDef } from '../models/class-tableview-attribute.model';
+import { TableviewClassAttributeDef } from './class-tableview-attribute.model';
 export declare function expandClassAttributeDefWithTableviewDef(attributes?: Array<ClassAttributeDef> | null): TableviewClassAttributeDef[];
 /**
  * returns attributes from class type and extends to typed def with column and field enum type

package/tableview/api/{tableview/models → class/tableview}/class-tableview-attribute.model.d.ts

@@ -1,3 +1,3 @@
-import { TableClassAttributeDef } from '@mediusinc/mng-commons/table/api';
-import { EditorClassAttributeDef } from '../../editor/models/class-tableview-attribute.model';
+import { TableClassAttributeDef } from '@mediusinc/mng-commons/table/api/class';
+import { EditorClassAttributeDef } from '../editor/class-editor-attribute.model';
 export type TableviewClassAttributeDef = EditorClassAttributeDef & TableClassAttributeDef;

package/tableview/api/class/tableview/class-tableview-data-provider.factory.d.ts

@@ -0,0 +1,4 @@
+import { ClassType, ServiceClassType } from '@mediusinc/mng-commons/core';
+import { TableviewDataProviderInst } from '@mediusinc/mng-commons/tableview/api';
+export declare function tableviewDataProviderFromClass<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>): TableviewDataProviderInst<Model, undefined, Sorts, Filters, undefined>;
+export declare function tableviewDataProviderFromClass<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, Sorts, Filters, ServiceClassType<Service>>;

package/tableview/api/{tableview/helpers/tableview-descriptor-helpers.d.ts → class/tableview/class-tableview-descriptor-helpers.d.ts}

@@ -1,8 +1,7 @@
 import { ClassType, ILookupDataProvider } from '@mediusinc/mng-commons/core';
 import { EnumDescriptor } from '@mediusinc/mng-commons/model';
 import { ColumnDisplayTypeEnum, ColumnTypeEnum } from '@mediusinc/mng-commons/table/api';
-import { FieldInputTypeEnum } from '../../editor/models/field.model';
-import { TableviewDescriptorInst } from '../descriptors/tableview.descriptor';
+import { FieldInputTypeEnum, TableviewDescriptorInst } from '@mediusinc/mng-commons/tableview/api';
 /**
  * creates column and field with custom type, for example currency
  * if field exists, it is replaced

package/tableview/api/class/tableview/class-tableview-descriptor.factory.d.ts

@@ -0,0 +1,12 @@
+import { ClassType } from '@mediusinc/mng-commons/core';
+import { TableviewDescriptorCreateMultiModelWithModelDescriptorOptsType, TableviewDescriptorInst } from '@mediusinc/mng-commons/tableview/api';
+import { TableviewClassAttributeDef } from './class-tableview-attribute.model';
+export declare function tableviewDescriptorFromClass<TableviewModel, Sorts = keyof TableviewModel, Filters = keyof TableviewModel, ParentEditorModel = undefined>(type: ClassType<TableviewModel>, opts?: TableviewDescriptorCreateMultiModelWithModelDescriptorOptsType<TableviewModel>): TableviewDescriptorInst<TableviewModel, Sorts, Filters, ParentEditorModel>;
+/**
+ * generates descriptor based on type attribute definition
+ * @param type class type
+ * @param columnAttributes
+ * @param fieldAttributes
+ * @param opts
+ */
+export declare function tableviewDescriptorFromClassAttrsDef<TableviewModel, Sorts = keyof TableviewModel, Filters = keyof TableviewModel>(type: ClassType<TableviewModel>, columnAttributes?: TableviewClassAttributeDef[], fieldAttributes?: TableviewClassAttributeDef[] | null, opts?: TableviewDescriptorCreateMultiModelWithModelDescriptorOptsType<TableviewModel>): TableviewDescriptorInst<TableviewModel, Sorts, Filters>;

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

@@ -1,18 +1,19 @@
-import { ClassType, ServiceClassType } from '@mediusinc/mng-commons/core';
+import { ServiceClassType } from '@mediusinc/mng-commons/core';
 import { ModelDescriptor, TypeDescriptor } from '@mediusinc/mng-commons/model';
 import { EditorDataProviderInst } from './editor.data-provider';
-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>>;
-}
-export declare function editorDataProvider<Model>(): EditorDataProviderInst<Model, undefined, undefined, undefined>;
-export declare function editorDataProvider<Model>(type: TypeDescriptor<Model>): EditorDataProviderInst<Model, undefined, undefined, undefined>;
-export declare function editorDataProvider<Model, Service = any>(type: TypeDescriptor<Model>, serviceType: ServiceClassType<Service>): EditorDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
-export declare function editorDataProviderWithService<Service, Model>(serviceType: ServiceClassType<Service>): EditorDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
-export declare function editorDataProviderFromClass<Model>(type: ClassType<Model>): EditorDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
-export declare function editorDataProviderFromClass<Model, Service = any>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): EditorDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
-export declare function editorDataProviderFromModel<Model, ModelClass = ClassType<Model>>(model: ModelDescriptor<Model, ModelClass>): EditorDataProviderInst<Model, undefined, ModelClass, undefined>;
-export declare function editorDataProviderFromModel<Model, Service = any, ModelClass = ClassType<Model>>(model: ModelDescriptor<Model, ModelClass>, ServiceClass: ServiceClassType<Service>): EditorDataProviderInst<Model, Service, ModelClass, ServiceClassType<Service>>;
+/**
+ * Creates and returns an instance of `EditorDataProviderInst` with the specified options for managing editor data.
+ *
+ * @param {Object} [opts] - The options object to configure the data provider.
+ * @param {TypeDescriptor<Model> | ModelDescriptor<Model>} [opts.type] - The descriptor defining the type of model.
+ * @param {ServiceClassType<Service>} [opts.service] - The service class type associated with the data provider.
+ * @param {TypeDescriptor<CreateModel> | ModelDescriptor<CreateModel>} [opts.createType] - The descriptor defining the create type.
+ * @param {TypeDescriptor<UpdateModel> | ModelDescriptor<UpdateModel>} [opts.updateType] - The descriptor defining the update type.
+ * @return {EditorDataProviderInst<Model, Service, ServiceClass, CreateModel, UpdateModel>} An instance of `EditorDataProviderInst` configured according to the provided options.
+ */
+export declare function editorDataProvider<Model, Service = undefined, CreateModel = Model, UpdateModel = Model, ServiceClass = Service extends undefined ? undefined : ServiceClassType<Service>>(opts?: {
+    type?: TypeDescriptor<Model> | ModelDescriptor<Model>;
+    service?: ServiceClassType<Service>;
+    createType?: TypeDescriptor<CreateModel> | ModelDescriptor<Model>;
+    updateType?: TypeDescriptor<UpdateModel> | ModelDescriptor<Model>;
+}): EditorDataProviderInst<Model, Service, ServiceClass, CreateModel, UpdateModel>;

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

@@ -1,43 +1,56 @@
 import { Observable, Subject } from 'rxjs';
-import { ClassOptType, DataProviderInst, IDataProvider, IdType, ItemOrObservable, ServiceClassOptType } from '@mediusinc/mng-commons/core';
+import { DataProviderInst, IDataProvider, IdType, ItemOrObservable, ServiceClassOptType, Undefined } from '@mediusinc/mng-commons/core';
 import { EditorResetEvent } from '../models/form-editor.event';
 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 type EditorDataProviderCreateFnType<CreateModel = any, Model = any, Service = undefined, Item = Undefined<CreateModel>, Return = ItemOrObservable<Undefined<Model>>> = (item: Item, service: Service) => Return;
+export type EditorDataProviderUpdateFnType<UpdateModel = any, Model = any, Service = undefined, Id = IdType, Item = Undefined<UpdateModel>, Return = ItemOrObservable<Undefined<Model>>> = (id: Id, item: Item, service: Service) => Return;
+export type EditorDataProviderDeleteFnType<Model = any, Service = undefined, Item = undefined, Id = IdType, Return = ItemOrObservable<Undefined<Model>>> = (id: Id, service: Service, item: Item) => Return;
+export type EditorDataProviderFetchMapToFnType<FromModel, ToModel> = (item: FromModel) => ToModel;
 export interface IEditorDataProviderFetch<Model, Service> {
-    fetch: EditorDataProviderFetchFnType<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 IEditorDataProviderCreate<CreateModel, Model, Service> {
+    create?: EditorDataProviderCreateFnType<CreateModel, Model, Service>;
+    withCreate(fn?: EditorDataProviderCreateFnType<CreateModel, Model, Service>): this;
 }
-export interface IEditorDataProviderUpdate<Model, Service> {
-    update?: EditorDataProviderUpdateFnType<Model, Service>;
-    withUpdate(fn?: EditorDataProviderUpdateFnType<Model, Service>): this;
+export interface IEditorDataProviderUpdate<UpdateModel, Model, Service> {
+    update?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>;
+    withUpdate(fn?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>): this;
 }
 export interface IEditorDataProviderDelete<Model, Service> {
-    delete?: EditorDataProviderDeleteFnType<Model, Service>;
-    withDelete(fn?: EditorDataProviderDeleteFnType<Model, Service>): this;
+    delete?: EditorDataProviderDeleteFnType<Model, Service, any>;
+    withDelete<Item = undefined>(fn?: EditorDataProviderDeleteFnType<Model, Service, Item>): this;
 }
-export type IEditorDataProviderFnsType<Model, Service> = IEditorDataProviderFetch<Model, Service> & IEditorDataProviderCreate<Model, Service> & IEditorDataProviderUpdate<Model, Service> & IEditorDataProviderDelete<Model, Service>;
+export interface IEditorDataProviderFetchMapToCreate<Model, CreateModel> {
+    mapFetchItemToCreateItem?: EditorDataProviderFetchMapToFnType<Model, CreateModel>;
+    withMapFetchItemToCreateItem(fn?: EditorDataProviderFetchMapToFnType<Model, CreateModel>): this;
+}
+export interface IEditorDataProviderFetchMapToUpdate<Model, UpdateModel> {
+    mapFetchItemToUpdateItem?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>;
+    withMapFetchItemToUpdateItem(fn?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>): this;
+}
+export type IEditorDataProviderFnsType<Model, Service, CreateModel = Model, UpdateModel = Model, DeleteModel = Model> = IEditorDataProviderFetch<Model, Service> & IEditorDataProviderCreate<CreateModel, Model, Service> & IEditorDataProviderUpdate<UpdateModel, Model, Service> & IEditorDataProviderDelete<DeleteModel, Service> & IEditorDataProviderFetchMapToCreate<Model, CreateModel> & IEditorDataProviderFetchMapToUpdate<Model, UpdateModel>;
 export interface IEditorDataProviderSupport<Model> {
     get editorReset$(): Observable<EditorResetEvent<Model>>;
     resetEditor(event?: EditorResetEvent<Model>): void;
 }
-export type IEditorDataProvider<Model = any, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> = IDataProvider<Model, Service, ModelClass, ServiceClass> & IEditorDataProviderFnsType<Model, Service> & IEditorDataProviderSupport<Model>;
-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> {
+export type IEditorDataProvider<Model = any, Service = any, ServiceClass = ServiceClassOptType<Service>, CreateModel = Model, UpdateModel = Model> = IDataProvider<Model, Service, ServiceClass> & IEditorDataProviderFnsType<Model, Service, CreateModel, UpdateModel> & IEditorDataProviderSupport<Model>;
+export declare class EditorDataProviderInst<Model, Service = any, ServiceClass = ServiceClassOptType<Service>, CreateModel = Model, UpdateModel = Model> extends DataProviderInst<Model, Service, ServiceClass> implements IEditorDataProvider<Model, Service, ServiceClass, CreateModel, UpdateModel> {
     protected readonly _editorResetSubject: Subject<EditorResetEvent<Model>>;
-    protected _fetch: EditorDataProviderFetchFnType<Model, Service>;
-    protected _create?: EditorDataProviderCreateFnType<Model, Service>;
-    protected _update?: EditorDataProviderUpdateFnType<Model, Service>;
-    protected _delete?: EditorDataProviderDeleteFnType<Model, Service>;
-    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;
+    protected _fetch?: EditorDataProviderFetchFnType<Model, Service>;
+    protected _create?: EditorDataProviderCreateFnType<CreateModel, Model, Service>;
+    protected _update?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>;
+    protected _delete?: EditorDataProviderDeleteFnType<Model, Service, any>;
+    protected _mapFetchItemToCreateItem?: EditorDataProviderFetchMapToFnType<Model, CreateModel>;
+    protected _mapFetchItemToUpdateItem?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>;
+    constructor(serviceType: ServiceClass);
+    get fetch(): EditorDataProviderFetchFnType<Model, Service, IdType, ItemOrObservable<Model>> | undefined;
+    get create(): EditorDataProviderCreateFnType<CreateModel, Model, Service, Undefined<CreateModel>, ItemOrObservable<Undefined<Model>>> | undefined;
+    get update(): EditorDataProviderUpdateFnType<UpdateModel, Model, Service, IdType, Undefined<UpdateModel>, ItemOrObservable<Undefined<Model>>> | undefined;
+    get delete(): EditorDataProviderDeleteFnType<Model, Service, any, IdType, ItemOrObservable<Undefined<Model>>> | undefined;
+    get mapFetchItemToCreateItem(): EditorDataProviderFetchMapToFnType<Model, CreateModel> | undefined;
+    get mapFetchItemToUpdateItem(): EditorDataProviderFetchMapToFnType<Model, UpdateModel> | undefined;
     get editorReset$(): Observable<EditorResetEvent<Model>>;
     /**
      * Sets the fetch function for the EditorDataProvider instance.
@@ -52,13 +65,13 @@ export declare class EditorDataProviderInst<Model, Service = any, ModelClass = C
     /**
      * Sets the create function for the EditorDataProvider.
      *
-     * @param {EditorDataProviderCreateFnType<Model, Service>} fn - The function used for creating new items.
+     * @param {EditorDataProviderCreateFnType<CreateModel, Model, Service>} fn - The function used for creating new items.
      * @returns {this} - Returns the instance of the class.
      *
      * @typeparam Model The type of data this DataProvider will handle.
      * @typeparam Service The type of service used by this DataProvider.
      */
-    withCreate(fn?: EditorDataProviderCreateFnType<Model, Service>): this;
+    withCreate(fn?: EditorDataProviderCreateFnType<CreateModel, Model, Service>): this;
     /**
      * Sets the update function for the EditorDataProvider.
      *
@@ -68,7 +81,7 @@ export declare class EditorDataProviderInst<Model, Service = any, ModelClass = C
      * @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;
+    withUpdate(fn?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>): this;
     /**
      * Sets the delete function for the editor data provider.
      *
@@ -79,6 +92,28 @@ export declare class EditorDataProviderInst<Model, Service = any, ModelClass = C
      * @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;
+    withDelete<Item = undefined>(fn?: EditorDataProviderDeleteFnType<Model, Service, Item>): this;
+    /**
+     * Sets the function to map data from fetch function to create model.
+     *
+     * @param {EditorDataProviderFetchMapToFnType<Model, CreateModel>} fn - The map function to be set.
+     *
+     * @returns {this} - Returns the instance of the current class.
+     *
+     * @typeparam Model The type of data from fetch function to map from.
+     * @typeparam CreateModel The type of data to map to.
+     */
+    withMapFetchItemToCreateItem(fn?: EditorDataProviderFetchMapToFnType<Model, CreateModel>): this;
+    /**
+     * Sets the function to map data from fetch function to update model.
+     *
+     * @param {EditorDataProviderFetchMapToFnType<Model, UpdateModel>} fn - The map function to be set.
+     *
+     * @returns {this} - Returns the instance of the current class.
+     *
+     * @typeparam Model The type of data from fetch function to map from.
+     * @typeparam UpdateModel The type of data to map to.
+     */
+    withMapFetchItemToUpdateItem(fn?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>): this;
     resetEditor(event?: EditorResetEvent<Model>): void;
 }

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

@@ -1,44 +1,11 @@
-import { ClassType } from '@mediusinc/mng-commons/core';
 import { ModelDescriptor, ModelDescriptorCreateOpts, TypeDescriptor } from '@mediusinc/mng-commons/model';
-import { EditorClassAttributeDef } from '../models/class-tableview-attribute.model';
 import { TableviewEditorTypeEnum } from '../models/editor.model';
 import { EditorDescriptorInst } from './editor.descriptor';
-export declare class EditorDescriptor extends EditorDescriptorInst<any> {
-    protected constructor();
-    static create<EditorModel, ParentEditorModel = undefined>(idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, i18nBaseKey?: string | ClassType<unknown>, tableviewEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel, ParentEditorModel>;
-    static fromClass<EditorModel, ParentEditorModel = undefined>(type: ClassType<EditorModel>, idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, i18nBaseKey?: ClassType<unknown> | string, tableviewEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel, ParentEditorModel>;
-    static fromModel<EditorModel, ParentEditorModel = undefined>(model: ModelDescriptor<EditorModel>, tableviewEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel, ParentEditorModel>;
-    /**
-     * 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, ParentEditorModel = undefined>(type: ClassType<EditorModel>, idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, tableEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel, ParentEditorModel>;
-    /**
-     * Creates editor descriptor automatically based on openapi model's attributes definition provided in parameters. Only fields for provided attributes will be included.
-     * @param type Model's class.
-     * @param attributes List of attribute definitions from which fields should be created.
-     * @param idProperty Id property representing model (optional).
-     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
-     * @param tableviewEditorType Type of editor in tableview (add, edit, view or none).
-     */
-    static fromClassWithCustomAttrsDef<EditorModel, ParentEditorModel = undefined>(type: ClassType<EditorModel>, attributes: EditorClassAttributeDef[], idProperty?: keyof EditorModel, titleProperty?: keyof EditorModel, tableviewEditorType?: TableviewEditorTypeEnum): EditorDescriptorInst<EditorModel, ParentEditorModel>;
-}
-export type EditorDescriptorCreateBaseOptsType = {
+export type EditorDescriptorCreateBaseOptsType<ParentEditorModel> = {
     tableviewEditorType?: TableviewEditorTypeEnum;
+    parentEditorType?: TypeDescriptor<ParentEditorModel> | ModelDescriptor<ParentEditorModel> | EditorDescriptorInst<ParentEditorModel, any>;
 };
-export type EditorDescriptorCreateOptsType<EditorModel> = ModelDescriptorCreateOpts<EditorModel> & EditorDescriptorCreateBaseOptsType;
+export type EditorDescriptorCreateOptsType<EditorModel, ParentEditorModel> = ModelDescriptorCreateOpts<EditorModel> & EditorDescriptorCreateBaseOptsType<ParentEditorModel>;
 export declare function editorDescriptor<EditorModel, ParentEditorModel = undefined>(): EditorDescriptorInst<EditorModel, ParentEditorModel>;
-export declare function editorDescriptor<EditorModel, ParentEditorModel = undefined>(opts: EditorDescriptorCreateOptsType<EditorModel>): EditorDescriptorInst<EditorModel, ParentEditorModel>;
-export declare function editorDescriptor<EditorModel, ParentEditorModel = undefined>(model: ModelDescriptor<EditorModel>, opts?: EditorDescriptorCreateBaseOptsType): EditorDescriptorInst<EditorModel, ParentEditorModel>;
-export declare function editorDescriptor<EditorModel, ParentEditorModel = undefined>(type: TypeDescriptor<EditorModel>, opts?: EditorDescriptorCreateOptsType<EditorModel>): EditorDescriptorInst<EditorModel, ParentEditorModel>;
-export declare function editorDescriptorFromClass<EditorModel, ParentEditorModel = undefined>(type: ClassType<EditorModel>, opts?: EditorDescriptorCreateOptsType<EditorModel>): EditorDescriptorInst<EditorModel, ParentEditorModel>;
-/**
- * Generates descriptor based on type attribute definition
- * @param type class type
- * @param attributes
- * @param opts
- */
-export declare function editorDescriptorFromClassAttrsDef<EditorModel, ParentEditorModel = undefined>(type: ClassType<EditorModel>, attributes?: EditorClassAttributeDef[], opts?: EditorDescriptorCreateOptsType<EditorModel>): EditorDescriptorInst<EditorModel, ParentEditorModel>;
+export declare function editorDescriptor<EditorModel, ParentEditorModel = undefined>(opts: EditorDescriptorCreateOptsType<EditorModel, ParentEditorModel>): EditorDescriptorInst<EditorModel, ParentEditorModel>;
+export declare function editorDescriptor<EditorModel, ParentEditorModel = undefined>(model: ModelDescriptor<EditorModel>, opts?: EditorDescriptorCreateBaseOptsType<ParentEditorModel>): EditorDescriptorInst<EditorModel, ParentEditorModel>;