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

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

@@ -4,14 +4,14 @@ import { MultiSelectChangeEvent } from 'primeng/multiselect';
 import { Table, TableLazyLoadEvent } from 'primeng/table';
 import { TableColumnReorderEvent } from 'primeng/table/table.interface';
 import { Observable } from 'rxjs';
-import { MediusQueryResult } from '../../api/models';
 import { ITableDataProvider } from '../../data-providers';
 import { ColumnDescriptor, TableDescriptorInst } from '../../descriptors/table';
 import { MngComponentDirective, MngTemplateDirective } from '../../directives';
+import { DataListResult } from '../../models';
 import { MngTableCellClickEvent, MngTableLoadEvent } from './models/table.event';
 import { ColumnWithPreferences } from './models/table.interface';
 import * as i0 from "@angular/core";
-export declare class MngTableComponent<T = any, S = any> implements OnInit, OnChanges, AfterContentInit, OnDestroy {
+export declare class MngTableComponent<Item = any, Service = undefined, Sorts = any, Filters extends keyof any = any> implements OnInit, OnChanges, AfterContentInit, OnDestroy {
     readonly cmpTypeName = "MngTableComponent";
     private readonly logger;
     private readonly injector;
@@ -23,11 +23,11 @@ export declare class MngTableComponent<T = any, S = any> implements OnInit, OnCh
     private readonly destroyRef;
     private readonly viewContainer;
     private readonly messageService;
-    descriptorInput: TableDescriptorInst<T>;
-    items?: Observable<Array<T>>;
-    queryResult?: Observable<MediusQueryResult<T> | undefined>;
+    descriptorInput: TableDescriptorInst<Item, Sorts, Filters>;
+    items?: Observable<Array<Item>>;
+    result?: Observable<DataListResult<Item> | undefined>;
     loadingInput?: Observable<boolean>;
-    dataProvider?: ITableDataProvider;
+    dataProvider?: ITableDataProvider<Item, Service, Sorts, Filters>;
     useQueryParams: boolean;
     selectionMode: 'single' | 'multiple';
     selectionEnabled: boolean;
@@ -36,8 +36,8 @@ export declare class MngTableComponent<T = any, S = any> implements OnInit, OnCh
     columnCustomLastComponent?: Type<any>;
     globalFilterFieldsInput?: string[];
     loadEventEmitter: EventEmitter<MngTableLoadEvent>;
-    cellClickEventEmitter: EventEmitter<MngTableCellClickEvent<T>>;
-    selectionChangeEventEmitter: EventEmitter<T[]>;
+    cellClickEventEmitter: EventEmitter<MngTableCellClickEvent<Item>>;
+    selectionChangeEventEmitter: EventEmitter<Item[]>;
     captionCmpInstEventEmitter: EventEmitter<any>;
     columnCustomLastCmpInstEventEmitter: EventEmitter<any>;
     templates: QueryList<MngTemplateDirective>;
@@ -50,7 +50,7 @@ export declare class MngTableComponent<T = any, S = any> implements OnInit, OnCh
     isLazy: WritableSignal<boolean>;
     isPagination: WritableSignal<boolean>;
     useQueryParamsInitialized: WritableSignal<boolean>;
-    data: WritableSignal<T[]>;
+    data: WritableSignal<Item[]>;
     count: WritableSignal<number>;
     loading: WritableSignal<boolean>;
     rowsPerPageOptions: WritableSignal<number[]>;
@@ -65,15 +65,16 @@ export declare class MngTableComponent<T = any, S = any> implements OnInit, OnCh
     rowHeight: WritableSignal<number | undefined>;
     private dataProviderService;
     private dataProviderLatestLazyLoadEvent?;
-    private dataProviderLatestLazyLoadEventVersion;
-    private dataProviderLatestQueryParam?;
-    private dataProviderLatestQueryParamVersion;
+    private latestLazyLoadEventVersion;
+    private latestParamsWithDefaults?;
+    private latestParamsWithDefaultsVersion;
     private dataProviderSubscription?;
-    descriptor: WritableSignal<TableDescriptorInst<any>>;
+    descriptor: WritableSignal<TableDescriptorInst<any, any, any>>;
     columns: WritableSignal<ColumnWithPreferences[]>;
     visibleColumns: import("@angular/core").Signal<ColumnWithPreferences[]>;
     hasColumnFilters: import("@angular/core").Signal<boolean>;
     private filterDescriptors;
+    private defaultParams;
     private isFilterChanged;
     private isSortChanged;
     anyColumnVisible: import("@angular/core").Signal<boolean>;
@@ -92,8 +93,8 @@ export declare class MngTableComponent<T = any, S = any> implements OnInit, OnCh
     onTableLazyLoad(event: TableLazyLoadEvent): void;
     onTableSort(event: any): void;
     onTableFilter(event: any): void;
-    onCellClick(event: Event, col: ColumnDescriptor<any, T>, item: T, idx: number): void;
-    onSelectionChange(event: Array<T>): void;
+    onCellClick(event: Event, col: ColumnDescriptor<any, Item>, item: Item, idx: number): void;
+    onSelectionChange(event: Array<Item>): void;
     /**
      * Method is called on column resize
      * @param element event's element
@@ -114,9 +115,9 @@ export declare class MngTableComponent<T = any, S = any> implements OnInit, OnCh
      * Reset column order and column visibility to default settings
      */
     resetDefaultLayout(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MngTableComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MngTableComponent<any, any>, "mng-table", never, { "descriptorInput": { "alias": "descriptor"; "required": true; }; "items": { "alias": "items"; "required": false; }; "queryResult": { "alias": "queryResult"; "required": false; }; "loadingInput": { "alias": "loading"; "required": false; }; "dataProvider": { "alias": "dataProvider"; "required": false; }; "useQueryParams": { "alias": "useQueryParams"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selectionEnabled": { "alias": "selectionEnabled"; "required": false; }; "columnLastMinWidth": { "alias": "columnLastMinWidth"; "required": false; }; "captionComponent": { "alias": "captionComponent"; "required": false; }; "columnCustomLastComponent": { "alias": "columnCustomLastComponent"; "required": false; }; "globalFilterFieldsInput": { "alias": "globalFilterFields"; "required": false; }; }, { "loadEventEmitter": "tableLoad"; "cellClickEventEmitter": "cellClick"; "selectionChangeEventEmitter": "selectionChange"; "captionCmpInstEventEmitter": "captionComponentInstance"; "columnCustomLastCmpInstEventEmitter": "columnCustomLastComponentInstance"; }, ["templates"], never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngTableComponent<any, any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngTableComponent<any, any, any, any>, "mng-table", never, { "descriptorInput": { "alias": "descriptor"; "required": true; }; "items": { "alias": "items"; "required": false; }; "result": { "alias": "result"; "required": false; }; "loadingInput": { "alias": "loading"; "required": false; }; "dataProvider": { "alias": "dataProvider"; "required": false; }; "useQueryParams": { "alias": "useQueryParams"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selectionEnabled": { "alias": "selectionEnabled"; "required": false; }; "columnLastMinWidth": { "alias": "columnLastMinWidth"; "required": false; }; "captionComponent": { "alias": "captionComponent"; "required": false; }; "columnCustomLastComponent": { "alias": "columnCustomLastComponent"; "required": false; }; "globalFilterFieldsInput": { "alias": "globalFilterFields"; "required": false; }; }, { "loadEventEmitter": "tableLoad"; "cellClickEventEmitter": "cellClick"; "selectionChangeEventEmitter": "selectionChange"; "captionCmpInstEventEmitter": "captionComponentInstance"; "columnCustomLastCmpInstEventEmitter": "columnCustomLastComponentInstance"; }, ["templates"], never, true, never>;
     static ngAcceptInputType_items: unknown;
-    static ngAcceptInputType_queryResult: unknown;
+    static ngAcceptInputType_result: unknown;
     static ngAcceptInputType_loadingInput: unknown;
 }

package/lib/components/tableview/actions/tableview-default-actions.d.ts

@@ -0,0 +1,36 @@
+import { Injector } from '@angular/core';
+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';
+export declare enum TableviewDefaultActionsEnum {
+    Details = 0,
+    Add = 1,
+    Edit = 2,
+    EditOnDetails = 3,
+    Delete = 4,
+    DeleteOnDetails = 5,
+    Refresh = 6,
+    Export = 7,
+    ExportJson = 8,
+    ExportCsv = 9,
+    LocalizationLanguageSelect = 10
+}
+export declare class TableviewDefaultActions {
+    private static readonly DEFAULT_ACTIONS;
+    static getDefaultActions(): TableviewDefaultActionsEnum[];
+    static createActions(tableview: TableviewDescriptorInst<any, any, any>, injector: Injector, defaultActions?: TableviewDefaultActionsEnum[], defaultActionsOverrides?: Record<number, ActionDescriptorInst<any>>): Array<ActionDescriptorInst<any>>;
+    static createAction(type: TableviewDefaultActionsEnum, tableview: TableviewDescriptorInst<any, any, any>, injector: Injector, defaultActions?: TableviewDefaultActionsEnum[], defaultActionsOverrides?: Record<number, ActionDescriptorInst<any>>): ActionDescriptorInst<any> | null;
+    private static getRouteData;
+    static details<Model>(descriptor: EditorDescriptorInst<Model>, injector: Injector): ActionEditorDetailsDescriptorInst<Model> | null;
+    static add<Model>(descriptor: EditorDescriptorInst<Model>, injector: Injector): ActionEditorAddDescriptorInst<Model> | null;
+    static edit<Model>(descriptor: EditorDescriptorInst<Model>, injector: Injector): ActionEditorEditDescriptorInst<Model> | null;
+    static editOnDetails<Model>(descriptor: ModelDescriptor<Model>, editDescriptor: ActionEditorEditDescriptorInst<Model> | null, injector: Injector): ActionLinkDescriptorInst<Model> | null;
+    static deleteOnDetails<Model>(model: ModelDescriptor<Model>, injector: Injector): ActionDescriptorInst<Model> | null;
+    static delete<Model>(descriptor: ModelDescriptor<Model>, injector: Injector): ActionDeleteDescriptorInst<Model> | null;
+    static export<Model>(descriptor: TableviewDescriptorInst<Model>, injector: Injector, defaultActions?: TableviewDefaultActionsEnum[]): ActionDescriptorInst<Model> | null;
+    static exportJson<Model>(descriptor: TableviewDescriptorInst<Model>, injector: Injector): ActionDescriptorInst<Model>;
+    static exportCsv<Model>(descriptor: TableviewDescriptorInst<Model>, injector: Injector): ActionDescriptorInst<Model>;
+    static refresh<Model>(descriptor: ModelDescriptor<Model>): ActionDescriptorInst<Model> | null;
+    static LocalizationLanguageSelect<Model>(descriptor: TableviewDescriptorInst<Model>): ActionDescriptorInst<Model> | null;
+}

package/lib/components/tableview/builders/tableview-builder.d.ts

@@ -0,0 +1,115 @@
+import { Injector } from '@angular/core';
+import { IDataProvider } from '../../../data-providers';
+import { ActionDescriptorInst } from '../../../descriptors/action';
+import { TableviewDescriptorInst } from '../../../descriptors/tableview';
+import { Nullable } from '../../../types';
+import { TableviewDefaultActionsEnum } from '../actions/tableview-default-actions';
+import { ITableview } from '../models/tableview.model';
+export type TvBuilderSetterParamsType<Descriptor, DataProvider> = {
+    descriptor: Descriptor;
+    dataProvider: DataProvider;
+    injector: Injector;
+};
+export type TvBuilderActionSetterFnType<ActionModel, ActionService, Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => Nullable<ActionDescriptorInst<ActionModel, ActionService>>;
+export type TvBuilderDescriptorSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => Descriptor;
+export type TvBuilderDataProviderSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => DataProvider;
+/**
+ * The `TableviewBuilder` class is used to build a tableview configuration.
+ * It allows you to set various options such as the descriptor, data provider,
+ * default actions, and custom actions for the tableview.
+ *
+ * @typeparam Model - The main model type.
+ * @typeparam Service - The API service type.
+ * @typeparam Descriptor - The descriptor type.
+ * @typeparam DataProvider - The data provider type.
+ * @typeparam Sorts - The sort type representing available sort keys.
+ * @typeparam Filters - The filter type representing available filter keys.
+ */
+export declare class TableviewBuilder<Model, Service, Descriptor extends TableviewDescriptorInst<Model, Sorts, Filters>, DataProvider extends IDataProvider<Model, Service>, Sorts = keyof Model, Filters extends keyof any = keyof Model> {
+    private _descriptor;
+    private _dataProvider;
+    private readonly injector;
+    private defaultActions;
+    private readonly _customActions;
+    constructor(_descriptor: Descriptor, _dataProvider: DataProvider, injector: Injector);
+    private prepareSetterParams;
+    /**
+     * Sets a descriptor instead of the default one.
+     *
+     * @param {TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new descriptor. It should accept a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDescriptor(fn: TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>): this;
+    /**
+     * Adjusts the descriptor using the provided adjust function.
+     *
+     * @param {(descriptor: Descriptor) => void} adjustFn - The function used to adjust the descriptor. It accepts a single parameter of type `Descriptor`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjustDescriptor(adjustFn: (descriptor: Descriptor) => void): this;
+    /**
+     * Sets the data provider for the TvBuilder instance
+     *
+     * @param {TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * * @returns {this} - Returns the current instance of the builder.
+     */
+    withDataProvider(fn: TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>): this;
+    /**
+     * Adjusts the data provider using the provided adjust function.
+     *
+     * @param {(dataProvider: DataProvider) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `DataProvider`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjustDataProvider(adjustFn: (dataProvider: DataProvider) => void): this;
+    /**
+     * Adjusts the data provider and/or descriptor using the provided adjust function.
+     *
+     * @param {(params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjust(adjustFn: (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void): this;
+    /**
+     * Removes all the default tableview actions.
+     *
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withNoDefaultActions(): this;
+    /**
+     * Adds the default actions specified in parameters.
+     *
+     * @param {TableviewDefaultActionsEnum[]} types - The default actions to add.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDefaultActions(...types: TableviewDefaultActionsEnum[]): this;
+    /**
+     * Removes the default actions specified in parameters.
+     *
+     * @param {TableviewDefaultActionsEnum[]} types - The default actions to remove.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withoutDefaultActions(...types: TableviewDefaultActionsEnum[]): this;
+    /**
+     * Overrides the default action.
+     *
+     * @param {TableviewDefaultActionsEnum} type - The default actions to override.
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDefaultActionOverride<ActionService = Service>(type: TableviewDefaultActionsEnum, fn: TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>): this;
+    /**
+     * Adds a custom action.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAction<ActionService = Service>(fn: TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>): this;
+    /**
+     * Builds and returns an instance of ITableview.
+     * DO NOT CALL this within tableview create callback function!
+     *
+     * @return {ITableview<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.
+     */
+    build(): ITableview<Model, Service, Sorts, Filters, Descriptor, DataProvider>;
+}

package/lib/components/tableview/helpers/tableview-create.d.ts

@@ -0,0 +1,16 @@
+import { TableviewDataProviderInst } from '../../../data-providers';
+import { ModelDescriptor, TypeDescriptor } from '../../../descriptors/model';
+import { TableviewDescriptorInst } from '../../../descriptors/tableview';
+import { ServiceClassType } from '../../../types';
+import { TableviewBuilder } from '../builders/tableview-builder';
+/**
+ * Creates a tableview with the given model, service.
+ *
+ * @param {ModelDescriptor<Model>} model - The model descriptor.
+ * @param {ServiceClassType<Service>} service - The class type of the service.
+ * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.
+ *
+ * @returns A tableview instance with descriptor, data provider and actions.
+ */
+export declare function tableview<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model>(model: ModelDescriptor<Model>, service: ServiceClassType<Service>, buildFn?: (builder: TableviewBuilder<Model, Service, TableviewDescriptorInst<Model, Sorts, Filters>, TableviewDataProviderInst<Model, Service, Sorts, Filters>, Sorts, Filters>) => void): import("@mediusinc/mng-commons").ITableview<Model, Service, Sorts, Filters, TableviewDescriptorInst<Model, Sorts, Filters>, TableviewDataProviderInst<Model, Service, Sorts, Filters, import("../../../types").ClassOptType<Model>, import("../../../types").ServiceClassOptType<Service>>>;
+export declare function tableviewWithSortAndFilter<Model, Service, Sorts, Filters extends keyof any>(model: ModelDescriptor<Model>, service: ServiceClassType<Service>, sorts: TypeDescriptor<Sorts>, filters: TypeDescriptor<Filters>, buildFn?: (builder: TableviewBuilder<Model, Service, TableviewDescriptorInst<Model, Sorts, Filters>, TableviewDataProviderInst<Model, Service, Sorts, Filters>, Sorts, Filters>) => void): import("@mediusinc/mng-commons").ITableview<Model, Service, Sorts, Filters, TableviewDescriptorInst<Model, Sorts, Filters>, TableviewDataProviderInst<Model, Service, Sorts, Filters, import("../../../types").ClassOptType<Model>, import("../../../types").ServiceClassOptType<Service>>>;

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

@@ -1,3 +1,6 @@
+export * from './actions/tableview-default-actions';
+export * from './builders/tableview-builder';
 export * from './tableview.component';
-export * from './route/tableview-route.abstract.component';
 export * from './route/tableview-route.component';
+export * from './models/tableview.model';
+export * from './helpers/tableview-create';

package/lib/components/tableview/models/tableview.model.d.ts

@@ -0,0 +1,8 @@
+import { ITableviewDataProvider } from '../../../data-providers';
+import { ActionDescriptorInst } from '../../../descriptors/action';
+import { TableviewDescriptorInst } from '../../../descriptors/tableview';
+export interface ITableview<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model, Descriptor = TableviewDescriptorInst<Model, Sorts, Filters>, DataProvider = ITableviewDataProvider<Model, Service, Sorts, Filters>> {
+    descriptor: Descriptor;
+    dataProvider: DataProvider;
+    actions: ActionDescriptorInst<Model>[];
+}

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

@@ -1,16 +1,7 @@
-import { OnInit } from '@angular/core';
-import { ITableviewDataProvider } from '../../../data-providers';
-import { ActionDescriptorInst } from '../../../descriptors/action';
-import { TableviewDescriptorInst } from '../../../descriptors/tableview';
-import { AMngTableviewRouteComponent } from './tableview-route.abstract.component';
+import { ITableview } from '../models/tableview.model';
 import * as i0 from "@angular/core";
-export declare class MngTableviewRouteComponent<T, S = undefined> extends AMngTableviewRouteComponent<T, S> implements OnInit {
-    descriptorInit?: TableviewDescriptorInst<T>;
-    dataProviderInit?: ITableviewDataProvider<T, S>;
-    actionsInit?: Array<ActionDescriptorInst<T>>;
-    protected createTableviewDescriptor(): TableviewDescriptorInst<T>;
-    protected createTableviewDataProvider(): ITableviewDataProvider<T, S>;
-    protected createActionDescriptors(): Array<ActionDescriptorInst<T>>;
-    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>;
+export declare class MngTableviewRouteComponent<Item, Service = undefined, Sorts = keyof Item, Filters extends keyof any = keyof Item> {
+    tableview: ITableview<Item, Service, Sorts, Filters>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngTableviewRouteComponent<any, any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngTableviewRouteComponent<any, any, any, any>, "mng-tableview-route", never, { "tableview": { "alias": "tableview"; "required": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,29 +1,29 @@
 import { AfterContentInit, OnInit, QueryList, TemplateRef } from '@angular/core';
-import { MediusQueryParam } from '../../api/models';
 import { ITableviewDataProvider } from '../../data-providers';
 import { ActionDescriptorInst } from '../../descriptors/action';
 import { TableviewDescriptorInst } from '../../descriptors/tableview';
 import { MngTemplateDirective } from '../../directives';
+import { DataListParams } from '../../models';
 import { ViewContainer } from '../../services/view';
 import { MngTableLoadEvent } from '../table/models/table.event';
 import * as i0 from "@angular/core";
-export declare class MngTableviewComponent<T, S> implements OnInit, AfterContentInit {
+export declare class MngTableviewComponent<Item = any, Service = undefined, Sorts = keyof Item, Filters extends keyof any = keyof Item> implements OnInit, AfterContentInit {
     readonly viewContainer: ViewContainer<any, any> | null;
-    descriptor: TableviewDescriptorInst<T>;
-    dataProvider?: ITableviewDataProvider<T, S>;
+    descriptor: TableviewDescriptorInst<Item, Sorts, Filters>;
+    dataProvider?: ITableviewDataProvider<Item, Service, Sorts, Filters>;
     actions: Array<ActionDescriptorInst<any>>;
-    tableActions: ActionDescriptorInst<T>[];
-    toolbarLeftActions: ActionDescriptorInst<T>[];
-    toolbarRightActions: ActionDescriptorInst<T>[];
-    tableQueryParam?: MediusQueryParam;
+    tableActions: ActionDescriptorInst<Item>[];
+    toolbarLeftActions: ActionDescriptorInst<Item>[];
+    toolbarRightActions: ActionDescriptorInst<Item>[];
+    tableParams?: DataListParams;
     hasItemSelectionAction: boolean;
-    selectedItems: T[];
+    selectedItems: Item[];
     templates: QueryList<MngTemplateDirective>;
     footerTemplate?: TemplateRef<any>;
     ngOnInit(): void;
     ngAfterContentInit(): void;
     onTableLoad(event: MngTableLoadEvent): void;
-    selectionChange(selectedItems: Array<T>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MngTableviewComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MngTableviewComponent<any, any>, "mng-tableview", never, { "descriptor": { "alias": "descriptor"; "required": true; }; "dataProvider": { "alias": "dataProvider"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; }, {}, ["templates"], never, true, never>;
+    selectionChange(selectedItems: Array<Item>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngTableviewComponent<any, any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngTableviewComponent<any, any, any, any>, "mng-tableview", never, { "descriptor": { "alias": "descriptor"; "required": true; }; "dataProvider": { "alias": "dataProvider"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; }, {}, ["templates"], never, true, never>;
 }

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

@@ -36,30 +36,30 @@ export declare class EditorDataProviderInst<Model, Service = any, ModelClass = C
      * 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.
+     * @returns {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.
+     * @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.
-     * @return {this} - Returns the instance of the class.
+     * @returns {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.
+     * @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.
-     * @return {this} - Returns the instance of the object calling this method.
+     * @returns {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.
+     * @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;
     /**
@@ -67,10 +67,10 @@ export declare class EditorDataProviderInst<Model, Service = any, ModelClass = C
      *
      * @param {EditorDataProviderDeleteFnType<Model, Service>} fn - The delete function to be set.
      *
-     * @return {this} - Returns the instance of the current class.
+     * @returns {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.
+     * @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;
 }

package/lib/data-providers/index.d.ts

@@ -3,4 +3,3 @@ export * from './editor.data-provider';
 export * from './lookup.data-provider';
 export * from './table.data-provider';
 export * from './tableview.data-provider';
-export * from './tableview-crud.data-provider';

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

@@ -1,7 +1,7 @@
-import { MediusQueryParam } from '../api/models';
+import { DataListParams } from '../models';
 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 type LookupDataProviderLookupFnType<ModelType = any, ServiceType = undefined, ReturnType = ItemOrObservable<Array<ModelType>>> = (params: DataListParams | undefined, service: ServiceType, search?: string) => ReturnType;
 export interface ILookupDataProviderLookup<ModelType, ServiceType> {
     lookup: LookupDataProviderLookupFnType<ModelType, ServiceType>;
     withLookup(fn?: LookupDataProviderLookupFnType<ModelType, ServiceType>): this;

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

@@ -1,40 +1,40 @@
 import { Observable, Subject } from 'rxjs';
-import { MediusQueryParam, MediusQueryResult } from '../api/models';
+import { DataListParams, DataListResult } from '../models';
 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 TableDataProviderGetAllFnType<Model = any, Service = undefined, Sorts = keyof Model, Filters extends keyof any = keyof Model, Return = ItemOrObservable<DataListResult<Model>>> = (params: DataListParams<Sorts, Filters>, 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 ITableDataProviderGetAll<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model> {
+    getAll: TableDataProviderGetAllFnType<Model, Service, Sorts, Filters>;
+    withGetAll(fn: TableDataProviderGetAllFnType<Model, Service, Sorts, Filters>): this;
 }
-export interface ITableDataProviderSupport {
+export interface ITableDataProviderSupport<Sorts = any, Filters extends keyof any = any> {
     get isLazy(): boolean;
-    get getAllReload$(): Observable<MediusQueryParam | undefined>;
-    getAllReload(queryParam?: MediusQueryParam): void;
+    get getAllReload$(): Observable<DataListParams<Sorts, Filters> | undefined>;
+    getAllReload(queryParam?: DataListParams<Sorts, Filters>): void;
 }
-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>;
+export type ITableDataProvider<Model = any, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> = IDataProvider<Model, Service, ModelClass, ServiceClass> & ITableDataProviderSupport<Sorts, Filters> & ITableDataProviderGetAll<Model, Service, Sorts, Filters>;
+export declare class TableDataProviderInst<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> extends DataProviderInst<Model, Service, ModelClass, ServiceClass> implements ITableDataProvider<Model, Service, Sorts, Filters, ModelClass, ServiceClass> {
+    protected readonly _getAllReloadSubject: Subject<DataListParams<Sorts, Filters> | undefined>;
     protected _isLazy: boolean;
     protected constructor(type: ModelClass, serviceType: ServiceClass);
-    protected _getAll: TableDataProviderGetAllFnType<Model, Service>;
+    protected _getAll: TableDataProviderGetAllFnType<Model, Service, Sorts, Filters>;
     get isLazy(): boolean;
-    get getAll(): TableDataProviderGetAllFnType<Model, Service, ItemOrObservable<MediusQueryResult<Model>>>;
-    get getAllReload$(): Observable<MediusQueryParam | undefined>;
-    withGetAll(fn: TableDataProviderGetAllFnType<Model, Service>): this;
+    get getAll(): TableDataProviderGetAllFnType<Model, Service, Sorts, Filters, ItemOrObservable<DataListResult<Model>>>;
+    get getAllReload$(): Observable<DataListParams<Sorts, Filters> | undefined>;
+    withGetAll(fn: TableDataProviderGetAllFnType<Model, Service, Sorts, Filters>): this;
     withGetAllEagerly(fn: TableDataProviderGetAllEagerFnType<Model, Service>): this;
-    getAllReload(queryParam?: MediusQueryParam): void;
+    getAllReload(queryParam?: DataListParams<Sorts, Filters>): 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>;
+    static create<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(): TableDataProviderInst<Model, undefined, Sorts, Filters, undefined, undefined>;
+    static fromClass<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>): TableDataProviderInst<Model, undefined, Sorts, Filters, ClassType<Model>, undefined>;
+    static fromClassWithService<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, Sorts, Filters, ClassType<Model>, ServiceClassType<Service>>;
+    static fromService<Service, Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, Sorts, Filters, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(): TableDataProviderInst<Model, undefined, Sorts, Filters, undefined, undefined>;
+    static fromAnyParam<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>): TableDataProviderInst<Model, undefined, Sorts, Filters, ClassType<Model>, undefined>;
+    static fromAnyParam<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: undefined, serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, Sorts, Filters, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, Sorts, Filters, ClassType<Model>, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): TableDataProviderInst<Model, Service, Sorts, Filters, ModelClass, ServiceClass>;
 }

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

@@ -1,22 +1,22 @@
-import { MediusQueryParam } from '../api/models';
+import { DataListParams } from '../models';
 import { ClassOptType, ClassType, ServiceClassOptType, ServiceClassType } from '../types';
 import { DataProviderInst } from './base.data-provider';
 import { EditorDataProviderCreateFnType, EditorDataProviderDeleteFnType, EditorDataProviderFetchFnType, EditorDataProviderInst, EditorDataProviderUpdateFnType, IEditorDataProvider } from './editor.data-provider';
 import { ITableDataProvider, TableDataProviderGetAllEagerFnType, TableDataProviderGetAllFnType, TableDataProviderInst } from './table.data-provider';
-export type ITableviewDataProvider<Model = any, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> = IEditorDataProvider<Model, Service, ModelClass, ServiceClass> & ITableDataProvider<Model, Service, ModelClass, ServiceClass>;
-export declare class TableviewDataProviderInst<Model, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> extends DataProviderInst<Model, Service, ModelClass, ServiceClass> implements ITableviewDataProvider<Model, Service, ModelClass, ServiceClass> {
+export type ITableviewDataProvider<Model = any, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> = IEditorDataProvider<Model, Service, ModelClass, ServiceClass> & ITableDataProvider<Model, Service, Sorts, Filters, ModelClass, ServiceClass>;
+export declare class TableviewDataProviderInst<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> extends DataProviderInst<Model, Service, ModelClass, ServiceClass> implements ITableviewDataProvider<Model, Service, Sorts, Filters, ModelClass, ServiceClass> {
     protected readonly editorDataProvider: EditorDataProviderInst<Model, Service, ModelClass, ServiceClass>;
-    protected readonly tableDataProvider: TableDataProviderInst<Model, Service, ModelClass, ServiceClass>;
+    protected readonly tableDataProvider: TableDataProviderInst<Model, Service, Sorts, Filters, ModelClass, ServiceClass>;
     protected constructor(type: ModelClass, serviceType: ServiceClass);
     get isLazy(): boolean;
-    get getAllReload$(): import("rxjs").Observable<MediusQueryParam | undefined>;
-    get getAll(): TableDataProviderGetAllFnType<Model, Service, import("../types").ItemOrObservable<import("../api/models").MediusQueryResult<Model>>>;
+    get getAllReload$(): import("rxjs").Observable<DataListParams<Sorts, Filters> | undefined>;
+    get getAll(): TableDataProviderGetAllFnType<Model, Service, Sorts, Filters, import("../types").ItemOrObservable<import("../models").DataListResult<Model>>>;
     get fetch(): EditorDataProviderFetchFnType<Model, Service, import("../types").IdType, import("../types").ItemOrObservable<Model>>;
     get create(): EditorDataProviderCreateFnType<Model, Service, Model | undefined, import("../types").ItemOrObservable<Model>> | undefined;
     get update(): EditorDataProviderUpdateFnType<Model, Service, import("../types").IdType, Model | undefined, import("../types").ItemOrObservable<Model>> | undefined;
     get delete(): EditorDataProviderDeleteFnType<Model, Service, import("../types").IdType, Model | undefined, import("../types").ItemOrObservable<Model | null>> | undefined;
-    getAllReload(queryParam?: MediusQueryParam | undefined): void;
-    withGetAll(fn: TableDataProviderGetAllFnType<Model, Service>): this;
+    getAllReload(queryParam?: DataListParams<Sorts, Filters>): void;
+    withGetAll(fn: TableDataProviderGetAllFnType<Model, Service, Sorts, Filters>): this;
     withGetAllEagerly(fn: TableDataProviderGetAllEagerFnType<Model, Service>): this;
     withFetch(fn: EditorDataProviderFetchFnType<Model, Service>): this;
     withCreate(fn?: EditorDataProviderCreateFnType<Model, Service>): this;
@@ -25,17 +25,17 @@ export declare class TableviewDataProviderInst<Model, Service = any, ModelClass
 }
 export declare class TableviewDataProvider extends TableviewDataProviderInst<any> {
     protected constructor();
-    static create<Model>(): TableviewDataProviderInst<Model, undefined, undefined, undefined>;
-    static fromClass<Model>(type: ClassType<Model>): TableviewDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
-    static fromClassWithService<Model, Service>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
-    static fromService<Service, Model>(serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
-    static fromAnyParam<Model>(): TableviewDataProviderInst<Model, undefined, undefined, undefined>;
-    static fromAnyParam<Model>(type: ClassType<Model>): TableviewDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
-    static fromAnyParam<Model, Service = any>(type: undefined, serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
-    static fromAnyParam<Model, Service = any>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
-    static fromAnyParam<Model, Service, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): TableviewDataProviderInst<Model, Service, ModelClass, ServiceClass>;
+    static create<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(): TableviewDataProviderInst<Model, undefined, Sorts, Filters, undefined, undefined>;
+    static fromClass<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>): TableviewDataProviderInst<Model, undefined, Sorts, Filters, ClassType<Model>, undefined>;
+    static fromClassWithService<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, Sorts, Filters, ClassType<Model>, ServiceClassType<Service>>;
+    static fromService<Service, Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, Sorts, Filters, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(): TableviewDataProviderInst<Model, undefined, Sorts, Filters, undefined, undefined>;
+    static fromAnyParam<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>): TableviewDataProviderInst<Model, undefined, Sorts, Filters, ClassType<Model>, undefined>;
+    static fromAnyParam<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: undefined, serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, Sorts, Filters, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, Sorts, Filters, ClassType<Model>, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): TableviewDataProviderInst<Model, Service, Sorts, Filters, ModelClass, ServiceClass>;
 }
-export declare class DynamicTableviewDataProviderInst<Service = any, ServiceClass = ServiceClassOptType<Service>> extends TableviewDataProviderInst<any, Service, undefined, ServiceClass> {
+export declare class DynamicTableviewDataProviderInst<Service = any, ServiceClass = ServiceClassOptType<Service>> extends TableviewDataProviderInst<any, Service, any, any, undefined, ServiceClass> {
     protected constructor(serviceType: ServiceClass);
 }
 export declare class DynamicTableviewDataProvider extends DynamicTableviewDataProviderInst {

package/lib/descriptors/action/action-confirmation.descriptor.d.ts

@@ -33,4 +33,4 @@ export declare class ActionConfirmationDescriptor<Model> {
     get acceptButton(): ActionButtonDescriptor;
     get rejectButton(): ActionButtonDescriptor | undefined;
 }
-export type ConfigurationConfigMapFn<T> = (ctx: ActionContext<T, any>, confirmConfig: Confirmation) => Confirmation;
+export type ConfigurationConfigMapFn<Item> = (ctx: ActionContext<Item, any>, confirmConfig: Confirmation) => Confirmation;