@mediusinc/mng-commons 3.6.0-rc.3 → 3.7.0-rc.0

package/lib/components/form/formly/wrappers/formly-field-wrapper/formly-field-wrapper.component.d.ts

@@ -1,11 +1,12 @@
 import { OnInit } from '@angular/core';
 import { FieldWrapper } from '@ngx-formly/core';
-import { ActionDescriptor } from '../../../../../descriptors/action';
+import { ActionDescriptorInst } from '../../../../../descriptors/action';
 import * as i0 from "@angular/core";
 export declare class MngFormlyFieldWrapperComponent extends FieldWrapper implements OnInit {
-    localizationAction: ActionDescriptor<unknown>;
+    localizationAction: ActionDescriptorInst<any>;
     ngOnInit(): void;
     private addMissingTranslationHelperText;
+    private createLocalizationTableview;
     static ɵfac: i0.ɵɵFactoryDeclaration<MngFormlyFieldWrapperComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MngFormlyFieldWrapperComponent, "mng-formly-field-wrapper", never, {}, {}, never, never, true, never>;
 }

package/lib/components/layout/topbar-user.component.d.ts

@@ -5,14 +5,14 @@ import { MngCommonsService } from '../../services';
 import { MngMainLayoutComponentService } from './services';
 import * as i0 from "@angular/core";
 export declare class MngTopbarUserComponent implements OnInit, OnDestroy {
+    elementRef: ElementRef;
     mngCommons: MngCommonsService;
     mainLayoutService: MngMainLayoutComponentService;
-    elementRef: ElementRef;
     user?: IUser;
     userRoles$: Observable<string[]>;
     hrefJsVoid: import("@angular/platform-browser").SafeUrl;
     private subscriptions;
-    constructor(mngCommons: MngCommonsService, mainLayoutService: MngMainLayoutComponentService, elementRef: ElementRef);
+    constructor(elementRef: ElementRef, mngCommons: MngCommonsService, mainLayoutService: MngMainLayoutComponentService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     logout(user: IUser | undefined, event: Event): void;

package/lib/components/layout/version.component.d.ts

@@ -4,15 +4,15 @@ import { JsonPathPipe } from '../../pipes';
 import { MngVersionService } from '../../services';
 import * as i0 from "@angular/core";
 export declare class MngVersionComponent implements OnInit {
-    private versionService;
     private jsonPathPipe;
+    private versionService;
     initVersion?: VersionConfigType;
     displayName?: string;
     displayVersion?: string;
     versions?: Array<VersionConfig>;
     private loadingSubject;
     loading$: import("rxjs").Observable<boolean>;
-    constructor(versionService: MngVersionService, jsonPathPipe: JsonPathPipe);
+    constructor(jsonPathPipe: JsonPathPipe, versionService: MngVersionService);
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MngVersionComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MngVersionComponent, "mng-version", never, { "initVersion": { "alias": "version"; "required": false; }; }, {}, never, never, true, never>;

package/lib/components/layoutV2/model/layout-state.model.d.ts

@@ -1,11 +1,10 @@
-import { BehaviorSubject } from 'rxjs';
 export interface LayoutState {
-    staticMenuDesktopInactive$: BehaviorSubject<boolean>;
-    overlayMenuActive$: BehaviorSubject<boolean>;
-    rightMenuActive$: BehaviorSubject<boolean>;
-    configSidebarVisible$: BehaviorSubject<boolean>;
-    staticMenuMobileActive$: BehaviorSubject<boolean>;
-    menuHoverActive$: BehaviorSubject<boolean>;
-    sidebarActive$: BehaviorSubject<boolean>;
-    anchored$: BehaviorSubject<boolean>;
+    staticMenuDesktopInactive: boolean;
+    overlayMenuActive: boolean;
+    rightMenuActive: boolean;
+    configSidebarVisible: boolean;
+    staticMenuMobileActive: boolean;
+    menuHoverActive: boolean;
+    sidebarActive: boolean;
+    anchored: boolean;
 }

package/lib/components/layoutV2/services/main-layout.component.service.d.ts

@@ -2,7 +2,7 @@ import { LayoutState } from '../model';
 import * as i0 from "@angular/core";
 export declare class MngMainLayoutComponentV2Service {
     private config;
-    state: LayoutState;
+    state: import("@angular/core").WritableSignal<LayoutState>;
     private overlayOpen;
     overlayOpen$: import("rxjs").Observable<any>;
     onMenuToggle(): void;

package/lib/components/layoutV2/version.component.d.ts

@@ -4,15 +4,15 @@ import { JsonPathPipe } from '../../pipes';
 import { MngVersionService } from '../../services';
 import * as i0 from "@angular/core";
 export declare class MngVersionV2Component implements OnInit {
-    private versionService;
     private jsonPathPipe;
+    private versionService;
     initVersion?: VersionConfigType;
     displayName?: string;
     displayVersion?: string;
     versions?: Array<VersionConfig>;
     private loadingSubject;
     loading$: import("rxjs").Observable<boolean>;
-    constructor(versionService: MngVersionService, jsonPathPipe: JsonPathPipe);
+    constructor(jsonPathPipe: JsonPathPipe, versionService: MngVersionService);
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MngVersionV2Component, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MngVersionV2Component, "mng-version-v2", never, { "initVersion": { "alias": "version"; "required": false; }; }, {}, never, never, true, never>;

package/lib/components/tableview/index.d.ts

@@ -2,6 +2,5 @@ export * from './tableview.component';
 export * from './route/tableview-route.abstract.component';
 export * from './route/tableview-route.component';
 export * from './table/table.component';
-export * from './table/column-filter/column-filter.component';
 export * from './table/column-filter-full/column-filter-full.component';
 export * from './table/column-value/column-value.component';

package/lib/components/tableview/route/tableview-route.abstract.component.d.ts

@@ -2,35 +2,35 @@ import { OnInit } from '@angular/core';
 import { ActivatedRoute } from '@angular/router';
 import { TranslateService } from '@ngx-translate/core';
 import { ITableviewDataProvider } from '../../../data-providers';
-import { ModelDescriptor } from '../../../descriptors';
-import { ActionDeleteDescriptor, ActionDescriptor, ActionEditorAddDescriptor, ActionEditorDetailsDescriptor, ActionEditorEditDescriptor, ActionLinkDescriptor } from '../../../descriptors/action';
-import { EditorDescriptor } from '../../../descriptors/editor';
-import { TableviewDescriptor } from '../../../descriptors/tableview';
+import { ActionDeleteDescriptorInst, ActionDescriptorInst, ActionEditorAddDescriptorInst, ActionEditorDetailsDescriptorInst, ActionEditorEditDescriptorInst, ActionLinkDescriptorInst } from '../../../descriptors/action';
+import { EditorDescriptorInst } from '../../../descriptors/editor';
+import { ModelDescriptor } from '../../../descriptors/model';
+import { TableviewDescriptorInst } from '../../../descriptors/tableview';
 import { MngRouterData } from '../../../router/models';
 import * as i0 from "@angular/core";
-export declare abstract class AMngTableviewRouteComponent<T, S> implements OnInit {
-    descriptor: TableviewDescriptor<T>;
+export declare abstract class AMngTableviewRouteComponent<T = any, S = undefined> implements OnInit {
+    descriptor: TableviewDescriptorInst<T>;
     dataProvider: ITableviewDataProvider<T, S>;
-    actions: Array<ActionDescriptor<T>>;
+    actions: Array<ActionDescriptorInst<any>>;
     protected route: ActivatedRoute;
     protected translateService: TranslateService;
     constructor();
     protected get routeData(): MngRouterData;
     ngOnInit(): void;
-    protected abstract createTableviewDescriptor(): TableviewDescriptor<T>;
+    protected abstract createTableviewDescriptor(): TableviewDescriptorInst<T>;
     protected abstract createTableviewDataProvider(): ITableviewDataProvider<T, S>;
-    protected createActionDescriptors(): Array<ActionDescriptor<T>>;
-    protected createActionDescriptorForDetails(descriptor?: EditorDescriptor<T>): ActionEditorDetailsDescriptor<T> | null;
-    protected createActionDescriptorForAdd(descriptor?: EditorDescriptor<T>): ActionEditorAddDescriptor<T> | null;
-    protected createActionDescriptorForEdit(descriptor?: EditorDescriptor<T>): ActionEditorEditDescriptor<T> | null;
-    protected createActionDescriptorForDetailsEditLink(descriptor: ModelDescriptor<T> | undefined, editDescriptor: ActionEditorEditDescriptor<T> | null): ActionLinkDescriptor<T> | null;
-    protected createActionDescriptorForDetailsDelete(): ActionDescriptor<T> | null;
-    protected createActionDescriptorForDelete(descriptor?: ModelDescriptor<T>): ActionDeleteDescriptor<T> | null;
-    protected createActionDescriptorForExport(descriptor?: ModelDescriptor<T>): ActionDescriptor<T> | null;
-    protected createActionDescriptorForExportJson(descriptor?: ModelDescriptor<T>): ActionDescriptor<T>;
-    protected createActionDescriptorForExportCsv(descriptor?: ModelDescriptor<T>): ActionDescriptor<T>;
-    protected createActionDescriptorForRefresh(descriptor?: ModelDescriptor<T>): ActionDescriptor<T> | null;
-    protected createActionDescriptorForDataTranslate(descriptor?: ModelDescriptor<T>): ActionDescriptor<T> | null;
+    protected createActionDescriptors(): Array<ActionDescriptorInst<any>>;
+    protected createActionDescriptorForDetails(descriptor?: EditorDescriptorInst<T>): ActionEditorDetailsDescriptorInst<T> | null;
+    protected createActionDescriptorForAdd(descriptor?: EditorDescriptorInst<T>): ActionEditorAddDescriptorInst<T> | null;
+    protected createActionDescriptorForEdit(descriptor?: EditorDescriptorInst<T>): ActionEditorEditDescriptorInst<T> | null;
+    protected createActionDescriptorForDetailsEditLink(descriptor: ModelDescriptor<T, import("@mediusinc/mng-commons").ClassOptType<T>> | undefined, editDescriptor: ActionEditorEditDescriptorInst<T> | null): ActionLinkDescriptorInst<T> | null;
+    protected createActionDescriptorForDetailsDelete(): ActionDescriptorInst<T> | null;
+    protected createActionDescriptorForDelete(descriptor?: ModelDescriptor<T>): ActionDeleteDescriptorInst<T> | null;
+    protected createActionDescriptorForExport(descriptor?: ModelDescriptor<T>): ActionDescriptorInst<T> | null;
+    protected createActionDescriptorForExportJson(descriptor?: ModelDescriptor<T>): ActionDescriptorInst<T>;
+    protected createActionDescriptorForExportCsv(descriptor?: ModelDescriptor<T>): ActionDescriptorInst<T>;
+    protected createActionDescriptorForRefresh(descriptor?: ModelDescriptor<T>): ActionDescriptorInst<T> | null;
+    protected createActionDescriptorForDataTranslate(descriptor?: ModelDescriptor<T>): ActionDescriptorInst<T> | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<AMngTableviewRouteComponent<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AMngTableviewRouteComponent<any, any>, never, never, {}, {}, never, never, true, never>;
 }

package/lib/components/tableview/route/tableview-route.component.d.ts

@@ -1,18 +1,18 @@
 import { OnInit } from '@angular/core';
 import { ITableviewDataProvider } from '../../../data-providers';
-import { ActionDescriptor } from '../../../descriptors/action';
-import { TableviewDescriptor } from '../../../descriptors/tableview';
+import { ActionDescriptorInst } from '../../../descriptors/action';
+import { TableviewDescriptorInst } from '../../../descriptors/tableview';
 import { MngTableviewComponent } from '../tableview.component';
 import { AMngTableviewRouteComponent } from './tableview-route.abstract.component';
 import * as i0 from "@angular/core";
-export declare class MngTableviewRouteComponent<T, S> extends AMngTableviewRouteComponent<T, S> implements OnInit {
-    descriptorInit?: TableviewDescriptor<T>;
+export declare class MngTableviewRouteComponent<T, S = undefined> extends AMngTableviewRouteComponent<T, S> implements OnInit {
+    descriptorInit?: TableviewDescriptorInst<T>;
     dataProviderInit?: ITableviewDataProvider<T, S>;
-    actionsInit?: Array<ActionDescriptor<T>>;
+    actionsInit?: Array<ActionDescriptorInst<T>>;
     tableviewComponent?: MngTableviewComponent<T, S>;
-    protected createTableviewDescriptor(): TableviewDescriptor<T>;
+    protected createTableviewDescriptor(): TableviewDescriptorInst<T>;
     protected createTableviewDataProvider(): ITableviewDataProvider<T, S>;
-    protected createActionDescriptors(): Array<ActionDescriptor<T>>;
+    protected createActionDescriptors(): Array<ActionDescriptorInst<T>>;
     reloadTable(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MngTableviewRouteComponent<any, any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MngTableviewRouteComponent<any, any>, "mng-tableview-route", never, { "descriptorInit": { "alias": "descriptor"; "required": false; }; "dataProviderInit": { "alias": "dataProvider"; "required": false; }; "actionsInit": { "alias": "actions"; "required": false; }; }, {}, never, never, true, never>;

package/lib/components/tableview/table/table.component.d.ts

@@ -6,8 +6,8 @@ import { Table, TableLazyLoadEvent } from 'primeng/table';
 import { Observable } from 'rxjs';
 import { MediusQueryResult } from '../../../api/models';
 import { ITableDataProvider } from '../../../data-providers';
-import { ActionDescriptor } from '../../../descriptors/action';
-import { ColumnDescriptor, TableDescriptor } from '../../../descriptors/table';
+import { ActionDescriptorInst } from '../../../descriptors/action';
+import { ColumnDescriptor, TableDescriptorInst } from '../../../descriptors/table';
 import { MngComponentDirective, MngTemplateDirective } from '../../../directives';
 import { IViewContainer } from '../../../models';
 import { MngActionExecutorService, MngCommonsService, MngLocalStorageService, MngViewContainerComponentService } from '../../../services';
@@ -15,7 +15,7 @@ import { ActionInstance } from '../../action/models';
 import { MngTableCellClickEvent, MngTableLoadEvent } from '../models';
 import { ColumnWithPreferences } from './models';
 import * as i0 from "@angular/core";
-export declare class MngTableComponent<T, S> implements OnInit, OnChanges, AfterContentInit, OnDestroy {
+export declare class MngTableComponent<T = any, S = any> implements OnInit, OnChanges, AfterContentInit, OnDestroy {
     private injector;
     private router;
     private route;
@@ -26,16 +26,16 @@ export declare class MngTableComponent<T, S> implements OnInit, OnChanges, After
     private localStorageService;
     readonly cmpTypeName = "MngTableComponent";
     private readonly logger;
-    initialDescriptor: TableDescriptor<T>;
-    descriptor?: TableDescriptor<T>;
+    initialDescriptor: TableDescriptorInst<T>;
+    descriptor?: TableDescriptorInst<T>;
     items?: Observable<Array<T>> | Array<T>;
     queryResult?: Observable<MediusQueryResult<T>> | MediusQueryResult<T>;
     loading?: Observable<boolean> | boolean;
-    dataProvider?: ITableDataProvider<T, any>;
+    dataProvider?: ITableDataProvider;
     useQueryParams: boolean;
     selectionMode: 'single' | 'multiple';
     selectionEnabled: boolean;
-    actions: Array<ActionDescriptor<T>>;
+    actions: Array<ActionDescriptorInst<any>>;
     isColumnClickable?: boolean;
     viewContainerInit?: IViewContainer<T, S>;
     captionComponent?: Type<any>;
@@ -93,8 +93,8 @@ export declare class MngTableComponent<T, S> implements OnInit, OnChanges, After
     private isSortChanged;
     private filterDescriptors;
     showInlineActionsColumn: boolean;
-    rowClickActions: ActionDescriptor<T>[];
-    rowInlineActions: ActionDescriptor<T>[];
+    rowClickActions: ActionDescriptorInst<T>[];
+    rowInlineActions: ActionDescriptorInst<T>[];
     private routerIsNavigationOutsideInProgress;
     viewContainer?: IViewContainer<T, S>;
     private subscriptions;

package/lib/components/tableview/tableview.component.d.ts

@@ -2,8 +2,8 @@ import { AfterContentInit, OnDestroy, OnInit, QueryList, TemplateRef } from '@an
 import { Message, MessageService } from 'primeng/api';
 import { MediusQueryParam } from '../../api/models';
 import { IDataProvider, ITableviewDataProvider } from '../../data-providers';
-import { ActionDescriptor } from '../../descriptors/action';
-import { TableviewDescriptor } from '../../descriptors/tableview';
+import { ActionDescriptorInst } from '../../descriptors/action';
+import { TableviewDescriptorInst } from '../../descriptors/tableview';
 import { MngTemplateDirective } from '../../directives';
 import { IViewContainer } from '../../models';
 import { MngViewContainerComponentService } from '../../services';
@@ -13,13 +13,13 @@ import * as i0 from "@angular/core";
 export declare class MngTableviewComponent<T, S> implements OnInit, OnDestroy, AfterContentInit, IViewContainer<T, S> {
     private messageService;
     private viewContainerService;
-    descriptor: TableviewDescriptor<T>;
+    descriptor: TableviewDescriptorInst<T>;
     dataProvider?: ITableviewDataProvider<T, S>;
-    actions: Array<ActionDescriptor<T>>;
+    actions: Array<ActionDescriptorInst<any>>;
     tableComponent?: MngTableComponent<T, S>;
-    tableActions: ActionDescriptor<T>[];
-    toolbarLeftActions: ActionDescriptor<T>[];
-    toolbarRightActions: ActionDescriptor<T>[];
+    tableActions: ActionDescriptorInst<T>[];
+    toolbarLeftActions: ActionDescriptorInst<T>[];
+    toolbarRightActions: ActionDescriptorInst<T>[];
     tableQueryParam?: MediusQueryParam;
     private subscriptions;
     hasItemSelectionAction: boolean;
@@ -35,7 +35,7 @@ export declare class MngTableviewComponent<T, S> implements OnInit, OnDestroy, A
     ngOnDestroy(): void;
     getMessageService(): MessageService;
     getDataProvider(): IDataProvider<T, S> | undefined;
-    getActions(): ActionDescriptor<T>[];
+    getActions(): ActionDescriptorInst<any, any>[];
     reloadTable(): void;
     onTableLoad(event: MngTableLoadEvent): void;
     selectionChange(selectedItems: Array<T>): void;

package/lib/data-providers/base.data-provider.d.ts

@@ -1,14 +1,32 @@
-import { Type } from '@angular/core';
-import { ClassType } from '../types';
-export interface IDataProvider<T, S> {
-    modelType: ClassType<T> | null;
-    serviceType?: Type<S>;
+import { ClassOptType, ClassType, ServiceClassOptType, ServiceClassType } from '../types';
+export type IDataProvider<ModelType = any, ServiceType = any, CT = ClassOptType<ModelType>, ST = ServiceClassOptType<ServiceType>> = {
+    classType: CT;
+    serviceType: ST;
+    isDataProvider: boolean;
+};
+/**
+ * A base data provider class used for handling data operations.
+ *
+ * @tparam Model - The type of data this data provider will handle.
+ * @tparam Service - The type of service used by this data provider (optional).
+ * @tparam ModelClass - The model type for the data provider  (optional).
+ * @tparam ServiceClass - The service type for the data provider  (optional).
+ */
+export declare class DataProviderInst<Model, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> implements IDataProvider<Model, Service, ModelClass, ServiceClass> {
+    readonly classType: ModelClass;
+    readonly serviceType: ServiceClass;
+    protected constructor(classType: ModelClass, serviceType: ServiceClass);
+    get isDataProvider(): boolean;
 }
-export declare class DataProvider<T, S> {
-    protected _modelType: ClassType<T> | null;
-    protected _serviceType?: Type<S>;
-    constructor(modelType: ClassType<T> | null, serviceType?: Type<S>);
-    get serviceType(): Type<S> | undefined;
-    get modelType(): ClassType<T> | null;
-    withServiceType(type: Type<S>): this;
+export declare class DataProvider extends DataProviderInst<any> {
+    protected constructor();
+    static create<Model>(): DataProviderInst<Model, undefined, undefined, undefined>;
+    static fromClass<Model>(type: ClassType<Model>): DataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromClassWithService<Model, Service>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromService<Service, Model>(serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model>(): DataProviderInst<Model, undefined, undefined, undefined>;
+    static fromAnyParam<Model>(type: ClassType<Model>): DataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromAnyParam<Model, Service = any>(type: undefined, serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service = any>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): DataProviderInst<Model, Service, ModelClass, ServiceClass>;
 }

package/lib/data-providers/editor.data-provider.d.ts

@@ -1,25 +1,88 @@
-import { Type } from '@angular/core';
-import { Observable } from 'rxjs';
-import { ClassType, IdType } from '../types';
-import { DataProvider, IDataProvider } from './base.data-provider';
-export interface IEditorDataProvider<T, S> extends IDataProvider<T, S> {
-    fetch: (id: IdType, service?: S, locale?: string) => Observable<T>;
-    create?: (item?: T, service?: S) => Observable<T>;
-    update?: (id: IdType, item?: T, service?: S) => Observable<T>;
-    delete?: (id: IdType, item?: T, service?: S) => Observable<T | null>;
+import { ClassOptType, ClassType, IdType, ItemOrObservable, ServiceClassOptType, ServiceClassType } from '../types';
+import { DataProviderInst, IDataProvider } from './base.data-provider';
+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 declare class EditorDataProvider<T, S> extends DataProvider<T, S> implements IEditorDataProvider<T, S> {
-    protected _fetch: (id: IdType, service?: S, locale?: string) => Observable<T>;
-    protected _create?: (item?: T, service?: S) => Observable<T>;
-    protected _update?: (id: IdType, item?: T, service?: S) => Observable<T>;
-    protected _delete?: (id: IdType, item?: T, service?: S) => Observable<T | null>;
-    constructor(modelType: ClassType<T>, serviceType?: Type<S>);
-    get fetch(): (id: IdType, service?: S | undefined, locale?: string | undefined) => Observable<T>;
-    get create(): ((item?: T | undefined, service?: S | undefined) => Observable<T>) | undefined;
-    get update(): ((id: IdType, item?: T | undefined, service?: S | undefined) => Observable<T>) | undefined;
-    get delete(): ((id: IdType, item?: T | undefined, service?: S | undefined) => Observable<T | null>) | undefined;
-    withFetch(fetch: (id: IdType, service?: S, locale?: string) => Observable<T>): this;
-    withCreate(create: (item?: T, service?: S) => Observable<T>): this;
-    withUpdate(update: (id: IdType, item?: T, service?: S) => Observable<T>): this;
-    withDelete(deleteFn: (id: IdType, item?: T, service?: S) => Observable<T | null>): 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.
+     * @return {this} - The instance of the EditorDataProvider with the fetch function set.
+     *
+     * @template Model The type of data this DataProvider will handle.
+     * @template 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.
+     * @return {this} - Returns the instance of the class.
+     *
+     * @template Model The type of data this DataProvider will handle.
+     * @template 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.
+     * @return {this} - Returns the instance of the object calling this method.
+     *
+     * @template Model The type of data this DataProvider will handle.
+     * @template 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.
+     *
+     * @return {this} - Returns the instance of the current class.
+     *
+     * @template Model The type of data this DataProvider will handle.
+     * @template 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/lib/data-providers/lookup.data-provider.d.ts

@@ -1,14 +1,27 @@
-import { Type } from '@angular/core';
-import { Observable } from 'rxjs';
 import { MediusQueryParam } from '../api/models';
-import { ClassType } from '../types';
-import { DataProvider, IDataProvider } from './base.data-provider';
-export interface ILookupDataProvider<T, S> extends IDataProvider<T, S> {
-    lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>;
+import { ClassOptType, ClassType, ItemOrObservable, ServiceClassOptType, ServiceClassType } from '../types';
+import { DataProviderInst, IDataProvider } from './base.data-provider';
+export type LookupDataProviderLookupFnType<ModelType = any, ServiceType = undefined, ReturnType = ItemOrObservable<Array<ModelType>>> = (queryParam: MediusQueryParam | undefined, service: ServiceType, search?: string) => ReturnType;
+export interface ILookupDataProviderLookup<ModelType, ServiceType> {
+    lookup: LookupDataProviderLookupFnType<ModelType, ServiceType>;
+    withLookup(fn?: LookupDataProviderLookupFnType<ModelType, ServiceType>): this;
 }
-export declare class LookupDataProvider<T, S> extends DataProvider<T, S> implements ILookupDataProvider<T, S> {
-    protected _lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>;
-    constructor(modelType: ClassType<T> | null, serviceType?: Type<S>);
-    get lookup(): (queryParam?: MediusQueryParam | undefined, service?: S | undefined, search?: string | undefined) => Observable<T[]>;
-    withLookup(lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>): this;
+export type ILookupDataProvider<ModelType = any, ServiceType = any, CT = ClassOptType<ModelType>, ST = ServiceClassOptType<ServiceType>> = IDataProvider<ModelType, ServiceType, CT, ST> & ILookupDataProviderLookup<ModelType, ServiceType>;
+export declare class LookupDataProviderInst<ModelType, ServiceType = any, CT = ClassOptType<ModelType>, ST = ServiceClassOptType<ServiceType>> extends DataProviderInst<ModelType, ServiceType, CT, ST> implements ILookupDataProvider<ModelType, ServiceType, CT, ST> {
+    protected _lookup: LookupDataProviderLookupFnType<ModelType, ServiceType>;
+    protected constructor(type: CT, serviceType: ST);
+    get lookup(): LookupDataProviderLookupFnType<ModelType, ServiceType, ItemOrObservable<ModelType[]>>;
+    withLookup(fn: LookupDataProviderLookupFnType<ModelType, ServiceType>): this;
+}
+export declare class LookupDataProvider extends LookupDataProviderInst<any> {
+    protected constructor();
+    static create<Model>(): LookupDataProviderInst<Model, undefined, undefined, undefined>;
+    static fromClass<Model>(type: ClassType<Model>): LookupDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromClassWithService<Model, Service>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): LookupDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromService<ServiceType, ModelType>(serviceType: ServiceClassType<ServiceType>): LookupDataProviderInst<ModelType, ServiceType, undefined, ServiceClassType<ServiceType>>;
+    static fromAnyParam<Model>(): LookupDataProviderInst<Model, undefined, undefined, undefined>;
+    static fromAnyParam<Model>(type: ClassType<Model>): LookupDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromAnyParam<Model, Service = any>(type: undefined, serviceType: ServiceClassType<Service>): LookupDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service = any>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): LookupDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): LookupDataProviderInst<Model, Service, ModelClass, ServiceClass>;
 }

package/lib/data-providers/table.data-provider.d.ts

@@ -1,27 +1,40 @@
-import { Type } from '@angular/core';
 import { Observable, Subject } from 'rxjs';
 import { MediusQueryParam, MediusQueryResult } from '../api/models';
-import { ClassType } from '../types';
-import { DataProvider, IDataProvider } from './base.data-provider';
-export interface ITableDataProvider<T, S> extends IDataProvider<T, S> {
+import { ClassOptType, ClassType, ItemOrObservable, ServiceClassOptType, ServiceClassType } from '../types';
+import { DataProviderInst, IDataProvider } from './base.data-provider';
+export type TableDataProviderGetAllFnType<Model = any, Service = undefined, Return = ItemOrObservable<MediusQueryResult<Model>>> = (queryParam: MediusQueryParam, service: Service, locale?: string) => Return;
+export type TableDataProviderGetAllEagerFnType<Model = any, Service = undefined, Return = ItemOrObservable<Model[]>> = (service: Service, locale?: string) => Return;
+export interface ITableDataProviderGetAll<Model, Service> {
+    getAll: TableDataProviderGetAllFnType<Model, Service>;
+    withGetAll(fn: TableDataProviderGetAllFnType<Model, Service>): this;
+}
+export interface ITableDataProviderSupport {
     get isLazy(): boolean;
-    getAll: (queryParam: MediusQueryParam, service?: S, locale?: string) => Observable<MediusQueryResult<T>>;
+    get getAllReload$(): Observable<MediusQueryParam | undefined>;
     getAllReload(queryParam?: MediusQueryParam): void;
-    getAllReload$: Observable<MediusQueryParam | undefined>;
 }
-export declare class TableDataProvider<T, S> extends DataProvider<T, S> implements ITableDataProvider<T, S> {
+export type ITableDataProvider<Model = any, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> = IDataProvider<Model, Service, ModelClass, ServiceClass> & ITableDataProviderSupport & ITableDataProviderGetAll<Model, Service>;
+export declare class TableDataProviderInst<Model, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> extends DataProviderInst<Model, Service, ModelClass, ServiceClass> implements ITableDataProvider<Model, Service, ModelClass, ServiceClass> {
+    protected readonly _getAllReloadSubject: Subject<MediusQueryParam | undefined>;
     protected _isLazy: boolean;
-    protected _getAll: (queryParam: MediusQueryParam, service?: S, locale?: string) => Observable<MediusQueryResult<T>>;
-    protected _getAllReloadSubject: Subject<MediusQueryParam | undefined>;
-    constructor(modelType: ClassType<T>, serviceType?: Type<S>);
+    protected constructor(type: ModelClass, serviceType: ServiceClass);
+    protected _getAll: TableDataProviderGetAllFnType<Model, Service>;
     get isLazy(): boolean;
-    get getAll(): (queryParam: MediusQueryParam, service?: S | undefined, locale?: string | undefined) => Observable<MediusQueryResult<T>>;
+    get getAll(): TableDataProviderGetAllFnType<Model, Service, ItemOrObservable<MediusQueryResult<Model>>>;
     get getAllReload$(): Observable<MediusQueryParam | undefined>;
-    withGetAll(getAll: (queryParam: MediusQueryParam, service?: S, locale?: string) => Observable<MediusQueryResult<T>>): this;
-    /**
-     * Use this method to use inline load without lazy loading features on table and use inline pagination, filtering and sorting.
-     * @param getAll
-     */
-    withGetAllEagerly(getAll: (service?: S, locale?: string) => Observable<Array<T>>): this;
+    withGetAll(fn: TableDataProviderGetAllFnType<Model, Service>): this;
+    withGetAllEagerly(fn: TableDataProviderGetAllEagerFnType<Model, Service>): this;
     getAllReload(queryParam?: MediusQueryParam): void;
 }
+export declare class TableDataProvider extends TableDataProviderInst<any> {
+    protected constructor();
+    static create<Model>(): TableDataProviderInst<Model, undefined, undefined, undefined>;
+    static fromClass<Model>(type: ClassType<Model>): TableDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromClassWithService<Model, Service>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromService<Service, Model>(serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model>(): TableDataProviderInst<Model, undefined, undefined, undefined>;
+    static fromAnyParam<Model>(type: ClassType<Model>): TableDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromAnyParam<Model, Service = any>(type: undefined, serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service = any>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): TableDataProviderInst<Model, Service, ModelClass, ServiceClass>;
+}

package/lib/data-providers/tableview-crud.data-provider.d.ts

@@ -1,8 +1,12 @@
 import { Type } from '@angular/core';
 import { MediusQueryResult } from '../api/models';
 import { IMngCrudApiService, IMngGetAllApiService } from '../api/services';
-import { ClassType } from '../types';
-import { TableviewDataProvider } from './tableview.data-provider';
-export declare class TableviewCrudDataProvider<T, S extends IMngCrudApiService<T> & IMngGetAllApiService<MediusQueryResult<T>>> extends TableviewDataProvider<T, S> {
-    constructor(modelType: ClassType<T>, serviceType?: Type<S>, idPropertyName?: string, useGetAllForFetch?: boolean);
+import { ClassType, ServiceClassType } from '../types';
+import { TableviewDataProviderInst } from './tableview.data-provider';
+export declare class TableviewCrudDataProviderInst<Model, Service extends IMngCrudApiService<Model> & IMngGetAllApiService<MediusQueryResult<Model>>> extends TableviewDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>> {
+    protected constructor(type: ClassType<Model>, serviceType: Type<Service>, idPropertyName?: string, useGetAllForFetch?: boolean);
+}
+export declare class TableviewCrudDataProvider extends TableviewCrudDataProviderInst<any, any> {
+    static create<Model, Service extends IMngCrudApiService<Model> & IMngGetAllApiService<MediusQueryResult<Model>>>(type: ClassType<Model>, serviceType: Type<Service>, idProperty?: keyof Model, useGetAllForFetch?: boolean): TableviewCrudDataProviderInst<Model, Service>;
+    static createUnsafe<Model, Service extends IMngCrudApiService<Model> & IMngGetAllApiService<MediusQueryResult<Model>>>(type: ClassType<Model>, serviceType: Type<Service>, idProperty?: string, useGetAllForFetch?: boolean): TableviewCrudDataProviderInst<Model, Service>;
 }