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

package/data-api/class-dto/services/get-all-api.abstract.service.d.ts

@@ -0,0 +1,14 @@
+import { HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ClassType, DataListParams } from '@mediusinc/mng-commons';
+import { QueryResult } from '../models/query-result.model';
+import { AMngApiService } from './api.abstract.service';
+export interface IMngGetAllApiService<QRT extends QueryResult<any>> {
+    getAllGet(requestParams?: DataListParams<any, any>, params?: HttpParams, locale?: string): Observable<QRT>;
+}
+export declare abstract class AMngGetAllApiService<FetchType, QueryResultType extends QueryResult<any>> extends AMngApiService<FetchType> implements IMngGetAllApiService<QueryResultType> {
+    protected queryResultType: ClassType<QueryResultType>;
+    protected constructor(fetchType: ClassType<FetchType>, queryResultType: ClassType<QueryResultType>);
+    getAllGet(requestParams?: DataListParams, params?: HttpParams, locale?: string): Observable<QueryResultType>;
+    protected getGetAllGetPath(): string;
+}

package/data-api/class-dto/tableview/tableview-crud.data-provider.d.ts

@@ -0,0 +1,17 @@
+import { Type } from '@angular/core';
+import { ClassType, ServiceClassType, TableviewDataProviderInst } from '@mediusinc/mng-commons';
+import { QueryResult } from '../models/query-result.model';
+import { IMngCrudApiService } from '../services/crud-api.abstract.service';
+import { IMngGetAllApiService } from '../services/get-all-api.abstract.service';
+export type ToRequestMapFnType<Model, RequestModel> = (item?: Model) => RequestModel;
+export declare class TableviewCrudDataProviderInst<Model, RequestModel, Service extends IMngCrudApiService<Model, RequestModel> & IMngGetAllApiService<QueryResult<Model>>, Sorts = keyof Model, Filters extends keyof any = keyof Model> extends TableviewDataProviderInst<Model, Service, Sorts, Filters, ClassType<Model>, ServiceClassType<Service>> {
+    protected requestType: ClassType<RequestModel>;
+    private _toRequestMap;
+    protected constructor(type: ClassType<Model>, requestType: ClassType<RequestModel>, serviceType: Type<Service>, idPropertyName?: string, useGetAllForFetch?: boolean);
+    get toRequestMap(): ToRequestMapFnType<Model, RequestModel>;
+    withToRequestMap(fn: ToRequestMapFnType<Model, RequestModel>): this;
+}
+export declare class TableviewCrudDataProvider extends TableviewCrudDataProviderInst<any, any, any> {
+    static create<Model, RequestModel, Service extends IMngCrudApiService<Model, RequestModel> & IMngGetAllApiService<QueryResult<Model>>, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>, requestType: ClassType<RequestModel>, serviceType: Type<Service>, idProperty?: keyof Model, useGetAllForFetch?: boolean): TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>;
+    static createUnsafe<Model, RequestModel, Service extends IMngCrudApiService<Model, RequestModel> & IMngGetAllApiService<QueryResult<Model>>, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>, requestType: ClassType<RequestModel>, serviceType: Type<Service>, idProperty?: string, useGetAllForFetch?: boolean): TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>;
+}

package/data-api/helpers/get-all-params.d.ts

@@ -0,0 +1,69 @@
+import { Observable } from 'rxjs';
+import { DataListFilter, DataListParams, DataListResult } from '@mediusinc/mng-commons';
+import { GetAllParamsFilterMatchType, GetAllParamsType, GetAllParamsUrlQueryType } from '../models/request-params.model';
+/**
+ * Converts a filter match mode to its corresponding enum value.
+ *
+ * @param {string} matchMode - The filter match mode from data list filter to convert.
+ * @returns {GetAllParamsFilterMatchType} - The converted enum value.
+ * @throws {MngInternalError} - If the filter match mode is not supported.
+ */
+export declare function toGetAllParamsFilterMatchMode(matchMode: string): GetAllParamsFilterMatchType;
+/**
+ * Converts given parameters of a DataListParams object into a get all request param object with values as URL query string representation.
+ *
+ * @param {DataListParams} params - The parameters to convert.
+ * @typeparam Sorts - The type of the sorting options for the data list.
+ * @typeparam Filters - The type of the filters for the data list.
+ * @returns {GetAllParamsUrlQueryType<Filters>} - Get all request param object with values as URL query string representation.
+ */
+export declare function toGetAllParamsAsUrlQuery<Sorts, Filters extends keyof any>(params: DataListParams<Sorts, Filters>): GetAllParamsUrlQueryType<Filters>;
+/**
+ * Converts given parameters of a DataListParams object into a get all request param object with values as objects for POST requests.
+ *
+ * @param {DataListParams} params - The parameters to convert.
+ * @typeparam Sorts - The type of the sorting options for the data list.
+ * @typeparam Filters - The type of the filters for the data list.
+ * @returns {GetAllParamsType<Sorts, Filters>} - Get all request param object with values as objects for POST requests.
+ */
+export declare function toGetAllParams<Sorts, Filters extends keyof any>(params: DataListParams<Sorts, Filters>): GetAllParamsType<Sorts, Filters>;
+/**
+ * Converts DataListParams to sort query URL representation.
+ *
+ * @param {DataListParams} params - The params object with sort property to convert.
+ * @returns {string | undefined} - The formatted sort query URL param or undefined.
+ */
+export declare function toGetAllSortAsQueryUrl(params?: DataListParams<any, any>): string | undefined;
+/**
+ * Converts a DataListFilter object to a query URL string.
+ *
+ * @param {DataListFilter} filter - The filter object from params to convert.
+ * @returns {string|undefined} - The formatted filter query URL param or undefined.
+ */
+export declare function toGetAllFilterAsQueryUrl(filter?: DataListFilter): string | undefined;
+/**
+ * Executes the "getAll" on API service with request parameters.
+ * Get all is expected to be executed via GET method using params as URL queries.
+ *
+ * @param {Service} service - The API service instance.
+ * @param {Function} getAllFn - The "getAll" function on provided service instance.
+ * @param {Object} params - The data list params.
+ * @returns {Observable<<DataListResult<Item>>>} An observable with data list result.
+ */
+export declare function executeGetAll<Service, Item, Sorts, Filters extends keyof any>(service: Service, getAllFn: (requestParameters: GetAllParamsUrlQueryType<Filters>) => Observable<{
+    data?: Item[];
+    totalCount?: number;
+}>, params: DataListParams<Sorts, Filters>): Observable<DataListResult<Item>>;
+/**
+ * Executes the "getAll" on API service with request parameters.
+ * Get all is expected to be executed via POST method using params as object in body of request.
+ *
+ * @param {Service} service - The API service instance.
+ * @param {Function} getAllFn - The "getAll" function on provided service instance.
+ * @param {Object} params - The data list params.
+ * @returns {Observable<<DataListResult<Item>>>} An observable with data list result.
+ */
+export declare function executeGetAllAsPost<Service, Item, Sorts, Filters extends keyof any>(service: Service, getAllFn: (requestParameters: GetAllParamsType<Sorts, Filters>) => Observable<{
+    data?: Item[];
+    totalCount?: number;
+}>, params: DataListParams<Sorts, Filters>): Observable<DataListResult<Item>>;

package/data-api/helpers/tableview-get-all-params-create.d.ts

@@ -0,0 +1,14 @@
+import { ModelDescriptor, ServiceClassType, TableviewBuilder, TableviewDataProviderInst, TableviewDescriptorInst, TypeDescriptor } from '@mediusinc/mng-commons';
+import { GetAllParamsDefaultWoFiltersType } from '../models/request-params.model';
+import { ExtractGetAllParamsFilterType, ExtractGetAllParamsSortType } from '../types/extract-get-all-params.type';
+/**
+ * Creates a tableview with a given model, service and sorts and filters extracted from Data API Get All request params, service, and optional build function.
+ *
+ * @param {ModelDescriptor<Model>} model - The model descriptor.
+ * @param {ServiceClassType<Service>} service - The class type of the service.
+ * @param {TypeDescriptor<RequestParam>} params - The request param of get all request. Filters and sorts will be taken from here.
+ * @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 tableviewWithGetAllParams<Model, Service, RequestParam extends GetAllParamsDefaultWoFiltersType, Sorts = ExtractGetAllParamsSortType<RequestParam>, Filters extends keyof any = ExtractGetAllParamsFilterType<RequestParam>>(model: ModelDescriptor<Model>, service: ServiceClassType<Service>, params: TypeDescriptor<RequestParam>, 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("@mediusinc/mng-commons").ClassOptType<Model>, import("@mediusinc/mng-commons").ServiceClassOptType<Service>>>;

package/data-api/index.d.ts

@@ -0,0 +1,5 @@
+export * from './helpers/get-all-params';
+export * from './helpers/tableview-get-all-params-create';
+export * from './models/request-params.model';
+export * from './rxjs/map-to-data-list.operator';
+export * from './types/extract-get-all-params.type';

package/data-api/models/request-params.model.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Default (expected) type without filters, which are "dynamic" keys.
+ */
+export type GetAllParamsDefaultWoFiltersType<Sort = GetAllParamsSortType[] | string, GlobalFilter = GetAllParamsGlobalFilterType | string> = {
+    offset?: number;
+    limit?: number;
+    globalFilter?: GlobalFilter;
+    sort?: Sort;
+};
+/**
+ * Represents the sort direction type for a get all request params (ascending or descending).
+ */
+export type GetAllParamsSortDirectionType = 'ASCENDING' | 'DESCENDING';
+/**
+ * Represents the sort type for a get all request params.
+ *
+ * @typeparam Property The type of the property to sort by.
+ * @typeparam Direction The type of the sort direction.
+ */
+export type GetAllParamsSortType<Property = string, Direction = GetAllParamsSortDirectionType> = {
+    property: Property;
+    direction: Direction;
+};
+/**
+ * Represents the possible match types for filters in get all request params.
+ */
+export type GetAllParamsFilterMatchType = 'EQUALS' | 'NOT_EQUALS' | 'BETWEEN' | 'CONTAINS' | 'NOT_CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'IN' | 'NOT_IN' | 'LESS_THAN' | 'LESS_THAN_OR_EQUAL_TO' | 'GREATER_THAN' | 'GREATER_THAN_OR_EQUAL_TO' | 'EXISTS' | 'DOES_NOT_EXIST';
+/**
+ * Describes the possible case sensitivity for filter in get all request params.
+ */
+export type GetAllParamsFilterCaseSensitivityType = 'CASE_SENSITIVE' | 'CASE_INSENSITIVE';
+/**
+ * Describes the global filter (search) in get all request params.
+ */
+export type GetAllParamsGlobalFilterType<CaseSensitivity = GetAllParamsFilterCaseSensitivityType> = {
+    value: string;
+    caseSensitivity?: CaseSensitivity;
+};
+/**
+ * Describes the filters in get all request params.
+ */
+export type GetAllParamsFiltersType<FilterType, FilterProperties extends keyof any> = {
+    [P in FilterProperties]: FilterType;
+};
+/**
+ * Represents a filter type for get all request params.
+ */
+export type GetAllParamsFilterType<Value, CaseSensitivity = GetAllParamsFilterCaseSensitivityType, MatchType = GetAllParamsFilterMatchType> = {
+    value?: Value;
+    values?: Array<Value>;
+    caseSensitivity?: CaseSensitivity;
+    filterMatchType: MatchType;
+};
+/**
+ * Describes get all params with values as objects (for POST requests).
+ */
+export type GetAllParamsType<Sorts = string, Filters extends keyof any = string> = GetAllParamsDefaultWoFiltersType<GetAllParamsSortType<Sorts>[], GetAllParamsGlobalFilterType> & GetAllParamsFiltersType<GetAllParamsFilterType<any>, Filters>;
+/**
+ * Describes get all params with values as URL queries (for GET requests).
+ */
+export type GetAllParamsUrlQueryType<Filters extends keyof any> = GetAllParamsDefaultWoFiltersType<string, string> & GetAllParamsFiltersType<string, Filters>;

package/data-api/rxjs/map-to-data-list.operator.d.ts

@@ -0,0 +1,9 @@
+import { OperatorFunction } from 'rxjs';
+import { DataListResult } from '@mediusinc/mng-commons';
+/**
+ * Maps an Observable of data with optional totalCount and data to a data list result object with provided defaults of empty array and count 0.
+ */
+export declare function mapToDataList<Item>(): OperatorFunction<{
+    data?: Item[];
+    totalCount?: number;
+}, DataListResult<Item>>;

package/data-api/types/extract-get-all-params.type.d.ts

@@ -0,0 +1,14 @@
+import { GetAllParamsDefaultWoFiltersType, GetAllParamsSortType } from '../models/request-params.model';
+/**
+ * Represents the type definition for the `GetAllParamsDefaultWoFiltersType` class - excludes offset, limit, search and sort properties.
+ * All other properties are expected to be filters.
+ *
+ * @typeparam Request - The type parameter representing the extended GetAllParamsDefaultWoFiltersType object.
+ */
+export type ExtractGetAllParamsFilterType<Request extends GetAllParamsDefaultWoFiltersType> = keyof Omit<Request, 'offset' | 'limit' | 'globalFilter' | 'sort'>;
+/**
+ * Represents the type definition for the `GetAllParamsDefaultWoFiltersType` class - extracts allowed sort properties (usually an enum) on property key within array type.
+ *
+ * @typeparam Request - The type parameter representing the extended GetAllParamsDefaultWoFiltersType object.
+ */
+export type ExtractGetAllParamsSortType<Request extends GetAllParamsDefaultWoFiltersType<GetAllParamsSortType<any, any>[] | string, any>> = NonNullable<Request['sort']> extends Array<infer U> | string ? ('property' extends keyof U ? NonNullable<U['property']> : never) : never;

package/esm2022/data-api/class-dto/helpers/tableview-crud-create.mjs

@@ -0,0 +1,40 @@
+import { Injector, inject } from '@angular/core';
+import { TableviewBuilder, TableviewDescriptor } from '@mediusinc/mng-commons';
+import { TableviewCrudDataProvider } from '../tableview/tableview-crud.data-provider';
+function prepareBuilder(type, requestType, service, modelConfig, buildFn) {
+    const builder = new TableviewBuilder(TableviewDescriptor.fromClass(type, modelConfig?.idProperty, modelConfig?.titleProperty, modelConfig?.i18nBaseKey), TableviewCrudDataProvider.create(type, requestType, service, modelConfig?.idProperty), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+/**
+ * Creates a tableview with the given class, request class, service based on data API v2, sort, filters and optional class/model configuration.
+ * Sorts and filters are expected to be keys of class.
+ *
+ * @param {ClassType<Model>} type - The class representing the model.
+ * @param {ClassType<RequestModel>} requestType - The class representing the model for create and update operations.
+ * @param {ServiceClassType<Service>} service - The class type of the service implementing `IMngCrudApiService` and `IMngGetAllApiService`.
+ * @param {{ idProperty?: keyof Model; titleProperty?: keyof Model; i18nBaseKey?: ClassType<any> | string; }} [modelConfig] - Additional optional model configuration.
+ * @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 function tableviewCrud(type, requestType, service, modelConfig, buildFn) {
+    return prepareBuilder(type, requestType, service, modelConfig, buildFn);
+}
+/**
+ * Creates a tableview with the given class, request class, service based on data API v2, sort, filters and optional class/model configuration.
+ *
+ * @param {ClassType<Model>} type - The class representing the model.
+ * @param {ClassType<RequestModel>} requestType - The class representing the model for create and update operations.
+ * @param {ServiceClassType<Service>} service - The class type of the service implementing `IMngCrudApiService` and `IMngGetAllApiService`.
+ * @param {TypeDescriptor<Sorts>} sorts - The available sort keys of get all request.
+ * @param {TypeDescriptor<Filters>} filters - The available filter keys of get all request.
+ * @param {{ idProperty?: keyof Model; titleProperty?: keyof Model; i18nBaseKey?: ClassType<any> | string; }} [modelConfig] - Additional optional model configuration.
+ * @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 function tableviewCrudWithSortAndFilter(type, requestType, service, sorts, filters, modelConfig, buildFn) {
+    return prepareBuilder(type, requestType, service, modelConfig, buildFn);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tableview-crud-create.js","sourceRoot":"","sources":["../../../../../data-api/class-dto/src/helpers/tableview-crud-create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAE,MAAM,EAAC,MAAM,eAAe,CAAC;AAE/C,OAAO,EAA8B,gBAAgB,EAAE,mBAAmB,EAA0C,MAAM,wBAAwB,CAAC;AAKnJ,OAAO,EAAC,yBAAyB,EAAgC,MAAM,2CAA2C,CAAC;AAEnH,SAAS,cAAc,CACnB,IAAsB,EACtB,WAAoC,EACpC,OAAkC,EAClC,WAIC,EACD,OASS;IAET,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAQhC,mBAAmB,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,CAAC,EAClH,yBAAyB,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC,EACrF,MAAM,CAAC,QAAQ,CAAC,CACnB,CAAC;IACF,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC;IACnB,OAAO,OAAO,CAAC,KAAK,EAAE,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAOzB,IAAsB,EACtB,WAAoC,EACpC,OAAkC,EAClC,WAIC,EACD,OASS;IAET,OAAO,cAAc,CAA+C,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;AAC1H,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,8BAA8B,CAO1C,IAAsB,EACtB,WAAoC,EACpC,OAAkC,EAClC,KAA4B,EAC5B,OAAgC,EAChC,WAIC,EACD,OASS;IAET,OAAO,cAAc,CAA+C,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;AAC1H,CAAC","sourcesContent":["import {Injector, inject} from '@angular/core';\n\nimport {ClassType, ServiceClassType, TableviewBuilder, TableviewDescriptor, TableviewDescriptorInst, TypeDescriptor} from '@mediusinc/mng-commons';\n\nimport {QueryResult} from '../models/query-result.model';\nimport {IMngCrudApiService} from '../services/crud-api.abstract.service';\nimport {IMngGetAllApiService} from '../services/get-all-api.abstract.service';\nimport {TableviewCrudDataProvider, TableviewCrudDataProviderInst} from '../tableview/tableview-crud.data-provider';\n\nfunction prepareBuilder<Model, RequestModel, Service extends IMngCrudApiService<Model, RequestModel> & IMngGetAllApiService<QueryResult<Model>>, Sorts, Filters extends keyof any>(\n    type: ClassType<Model>,\n    requestType: ClassType<RequestModel>,\n    service: ServiceClassType<Service>,\n    modelConfig?: {\n        idProperty?: keyof Model;\n        titleProperty?: keyof Model;\n        i18nBaseKey?: string;\n    },\n    buildFn?: (\n        builder: TableviewBuilder<\n            Model,\n            Service,\n            TableviewDescriptorInst<Model, Sorts, Filters>,\n            TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>,\n            Sorts,\n            Filters\n        >\n    ) => void\n) {\n    const builder = new TableviewBuilder<\n        Model,\n        Service,\n        TableviewDescriptorInst<Model, Sorts, Filters>,\n        TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>,\n        Sorts,\n        Filters\n    >(\n        TableviewDescriptor.fromClass(type, modelConfig?.idProperty, modelConfig?.titleProperty, modelConfig?.i18nBaseKey),\n        TableviewCrudDataProvider.create(type, requestType, service, modelConfig?.idProperty),\n        inject(Injector)\n    );\n    buildFn?.(builder);\n    return builder.build();\n}\n\n/**\n * Creates a tableview with the given class, request class, service based on data API v2, sort, filters and optional class/model configuration.\n * Sorts and filters are expected to be keys of class.\n *\n * @param {ClassType<Model>} type - The class representing the model.\n * @param {ClassType<RequestModel>} requestType - The class representing the model for create and update operations.\n * @param {ServiceClassType<Service>} service - The class type of the service implementing `IMngCrudApiService` and `IMngGetAllApiService`.\n * @param {{ idProperty?: keyof Model; titleProperty?: keyof Model; i18nBaseKey?: ClassType<any> | string; }} [modelConfig] - Additional optional model configuration.\n * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.\n *\n * @returns A tableview instance with descriptor, data provider and actions.\n */\nexport function tableviewCrud<\n    Model,\n    RequestModel,\n    Service extends IMngCrudApiService<Model, RequestModel> & IMngGetAllApiService<QueryResult<Model>>,\n    Sorts = keyof Model,\n    Filters extends keyof any = keyof Model\n>(\n    type: ClassType<Model>,\n    requestType: ClassType<RequestModel>,\n    service: ServiceClassType<Service>,\n    modelConfig?: {\n        idProperty?: keyof Model;\n        titleProperty?: keyof Model;\n        i18nBaseKey?: string;\n    },\n    buildFn?: (\n        builder: TableviewBuilder<\n            Model,\n            Service,\n            TableviewDescriptorInst<Model, Sorts, Filters>,\n            TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>,\n            Sorts,\n            Filters\n        >\n    ) => void\n) {\n    return prepareBuilder<Model, RequestModel, Service, Sorts, Filters>(type, requestType, service, modelConfig, buildFn);\n}\n\n/**\n * Creates a tableview with the given class, request class, service based on data API v2, sort, filters and optional class/model configuration.\n *\n * @param {ClassType<Model>} type - The class representing the model.\n * @param {ClassType<RequestModel>} requestType - The class representing the model for create and update operations.\n * @param {ServiceClassType<Service>} service - The class type of the service implementing `IMngCrudApiService` and `IMngGetAllApiService`.\n * @param {TypeDescriptor<Sorts>} sorts - The available sort keys of get all request.\n * @param {TypeDescriptor<Filters>} filters - The available filter keys of get all request.\n * @param {{ idProperty?: keyof Model; titleProperty?: keyof Model; i18nBaseKey?: ClassType<any> | string; }} [modelConfig] - Additional optional model configuration.\n * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.\n *\n * @returns A tableview instance with descriptor, data provider and actions.\n */\nexport function tableviewCrudWithSortAndFilter<\n    Model,\n    RequestModel,\n    Service extends IMngCrudApiService<Model, RequestModel> & IMngGetAllApiService<QueryResult<Model>>,\n    Sorts,\n    Filters extends keyof any\n>(\n    type: ClassType<Model>,\n    requestType: ClassType<RequestModel>,\n    service: ServiceClassType<Service>,\n    sorts: TypeDescriptor<Sorts>,\n    filters: TypeDescriptor<Filters>,\n    modelConfig?: {\n        idProperty?: keyof Model;\n        titleProperty?: keyof Model;\n        i18nBaseKey?: string;\n    },\n    buildFn?: (\n        builder: TableviewBuilder<\n            Model,\n            Service,\n            TableviewDescriptorInst<Model, Sorts, Filters>,\n            TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>,\n            Sorts,\n            Filters\n        >\n    ) => void\n) {\n    return prepareBuilder<Model, RequestModel, Service, Sorts, Filters>(type, requestType, service, modelConfig, buildFn);\n}\n"]}

package/esm2022/data-api/class-dto/index.mjs

@@ -0,0 +1,13 @@
+// helpers
+export * from './helpers/tableview-crud-create';
+// models
+export * from './models/query-result.model';
+// serder
+export * from './serder/object-serializer';
+// services
+export * from './services/api.abstract.service';
+export * from './services/crud-api.abstract.service';
+export * from './services/get-all-api.abstract.service';
+// tableview
+export * from './tableview/tableview-crud.data-provider';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9kYXRhLWFwaS9jbGFzcy1kdG8vc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFVBQVU7QUFDVixjQUFjLGlDQUFpQyxDQUFDO0FBRWhELFNBQVM7QUFDVCxjQUFjLDZCQUE2QixDQUFDO0FBRTVDLFNBQVM7QUFDVCxjQUFjLDRCQUE0QixDQUFDO0FBRTNDLFdBQVc7QUFDWCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx5Q0FBeUMsQ0FBQztBQUV4RCxZQUFZO0FBQ1osY0FBYywwQ0FBMEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIGhlbHBlcnNcbmV4cG9ydCAqIGZyb20gJy4vaGVscGVycy90YWJsZXZpZXctY3J1ZC1jcmVhdGUnO1xuXG4vLyBtb2RlbHNcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3F1ZXJ5LXJlc3VsdC5tb2RlbCc7XG5cbi8vIHNlcmRlclxuZXhwb3J0ICogZnJvbSAnLi9zZXJkZXIvb2JqZWN0LXNlcmlhbGl6ZXInO1xuXG4vLyBzZXJ2aWNlc1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy9hcGkuYWJzdHJhY3Quc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2NydWQtYXBpLmFic3RyYWN0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy9nZXQtYWxsLWFwaS5hYnN0cmFjdC5zZXJ2aWNlJztcblxuLy8gdGFibGV2aWV3XG5leHBvcnQgKiBmcm9tICcuL3RhYmxldmlldy90YWJsZXZpZXctY3J1ZC5kYXRhLXByb3ZpZGVyJztcbiJdfQ==

package/esm2022/data-api/class-dto/mediusinc-mng-commons-data-api-class-dto.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaXVzaW5jLW1uZy1jb21tb25zLWRhdGEtYXBpLWNsYXNzLWR0by5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2RhdGEtYXBpL2NsYXNzLWR0by9zcmMvbWVkaXVzaW5jLW1uZy1jb21tb25zLWRhdGEtYXBpLWNsYXNzLWR0by50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/data-api/class-dto/models/query-result.model.mjs

@@ -0,0 +1,24 @@
+export class QueryResult {
+    static fromArray(pageData, allDataCount) {
+        const mqr = new QueryResult();
+        mqr.totalCount = allDataCount ?? pageData.length;
+        mqr.data = pageData;
+        return mqr;
+    }
+    static { this.attributeTypeMap = [
+        {
+            name: 'totalCount',
+            baseName: 'totalCount',
+            type: 'number'
+        },
+        {
+            name: 'data',
+            baseName: 'data',
+            type: 'Array<T>'
+        }
+    ]; }
+    static getAttributeTypeMap() {
+        return QueryResult.attributeTypeMap;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/data-api/class-dto/obsolete/helpers/query-param-convert.mjs

@@ -0,0 +1,103 @@
+import { map } from 'rxjs/operators';
+import { FilterMatchMode, MngInternalError } from '@mediusinc/mng-commons';
+import { MediusQueryParamBuilder } from '../models/builders/query-param.builder';
+import { MediusFilterMatchType } from '../models/filter-match-type.model';
+/**
+ * Converts the given DataListParams object to an ObsoleteV1QueryParam object.
+ *
+ * @param {DataListParams} params - The object to convert.
+ * @param {QueryParamMap} map - The configuration object used to map sort and filter properties.
+ *
+ * @returns The converted ObsoleteV1QueryParam object if params is not null or undefined, otherwise returns undefined.
+ *
+ * @deprecated
+ */
+export function toObsoleteV1QueryParam(params, map) {
+    if (!params)
+        return undefined;
+    const builder = MediusQueryParamBuilder.create();
+    if (params.offset !== undefined) {
+        builder.withItemsOffset(params.offset);
+    }
+    if (params.limit !== undefined) {
+        builder.withItemsPerPage(params.limit);
+    }
+    if (Array.isArray(params.sort)) {
+        params.sort.forEach(s => builder.withSort(map?.mapSort(s.property) ?? s.property, s.ascending));
+    }
+    if (typeof params.filters === 'object') {
+        Object.entries(params.filters).forEach(([key, value]) => {
+            const filter = value;
+            if (filter.value != null) {
+                const matchMode = filter.matchMode ? toObsoleteV1FilterMatchType(filter.matchMode) : MediusFilterMatchType.Equals;
+                let value = undefined;
+                let valueTo = undefined;
+                if (matchMode === MediusFilterMatchType.FromTo) {
+                    if (Array.isArray(filter.value)) {
+                        if (filter.value.length > 0)
+                            value = filter.value[0];
+                        if (filter.value.length > 1)
+                            valueTo = filter.value[1];
+                    }
+                }
+                else {
+                    value = filter.value;
+                }
+                builder.withFilter(map?.mapFilter(key) ?? key, value, valueTo, matchMode, filter.caseSensitive);
+            }
+        });
+    }
+    return builder.build();
+}
+export function toObsoleteV1FilterMatchType(match) {
+    switch (match) {
+        case FilterMatchMode.Equals:
+            return MediusFilterMatchType.Equals;
+        case FilterMatchMode.NotEquals:
+            return MediusFilterMatchType.NotEquals;
+        case FilterMatchMode.Contains:
+            return MediusFilterMatchType.Contains;
+        case FilterMatchMode.In:
+            return MediusFilterMatchType.In;
+        case FilterMatchMode.NotIn:
+            return MediusFilterMatchType.NotIn;
+        case FilterMatchMode.StartsWith:
+            return MediusFilterMatchType.StartsWith;
+        case FilterMatchMode.EndsWith:
+            return MediusFilterMatchType.EndsWith;
+        case FilterMatchMode.LessThan:
+            return MediusFilterMatchType.SmallerThan;
+        case FilterMatchMode.GreaterThan:
+            return MediusFilterMatchType.GreaterThan;
+        case FilterMatchMode.Between:
+            return MediusFilterMatchType.FromTo;
+        case FilterMatchMode.Exists:
+            return MediusFilterMatchType.Exists;
+        case FilterMatchMode.DoesNotExist:
+            return MediusFilterMatchType.DoesNotExist;
+        case FilterMatchMode.NotContains:
+        case FilterMatchMode.LessThanOrEqualTo:
+        case FilterMatchMode.GreaterThanOrEqualTo:
+        default:
+            throw new MngInternalError(`Filter match type '${match}' not supported.`);
+    }
+}
+/**
+ * Convert a query result from an obsolete API version 1 to a `DataListResult`
+ *
+ * @param {DataListParams} params - The data list parameters for the query
+ * @param {Service} service - The service object used to make the API call
+ * @param {function} apiOperation - The API operation function that returns an `Observable<MediusQueryResult<Item>>`
+ * @param {any} additionalParams - Additional parameters to pass to the API operation function (optional)
+ *
+ * @returns {Observable<DataListResult<Item>>} - An observable that emits a `DataListResult` object
+ *
+ * @deprecated
+ */
+export function toObsoleteV1QueryResult(params, service, apiOperation, additionalParams) {
+    const queryParam = toObsoleteV1QueryParam(params);
+    return apiOperation
+        .bind(service)(queryParam, ...(additionalParams ?? []))
+        .pipe(map(res => ({ data: res.pageData ?? [], totalCount: res.allDataCount })));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-param-convert.js","sourceRoot":"","sources":["../../../../../../data-api/class-dto/obsolete/src/helpers/query-param-convert.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,GAAG,EAAC,MAAM,gBAAgB,CAAC;AAEnC,OAAO,EAA0E,eAAe,EAAE,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AAElJ,OAAO,EAAC,uBAAuB,EAAC,MAAM,wCAAwC,CAAC;AAC/E,OAAO,EAAC,qBAAqB,EAAC,MAAM,mCAAmC,CAAC;AAcxE;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB,CAClC,MAAuC,EACvC,GAAmC;IAEnC,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAE9B,MAAM,OAAO,GAAG,uBAAuB,CAAC,MAAM,EAAE,CAAC;IAEjD,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE;QAC7B,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;KAC1C;IACD,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE;QAC5B,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;KAC1C;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;QAC5B,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,QAAkB,CAAC,IAAK,CAAC,CAAC,QAAmB,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;KACzH;IACD,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,EAAE;QACpC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YACpD,MAAM,MAAM,GAAG,KAAuB,CAAC;YACvC,IAAI,MAAM,CAAC,KAAK,IAAI,IAAI,EAAE;gBACtB,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,2BAA2B,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,MAAM,CAAC;gBAClH,IAAI,KAAK,GAA4B,SAAS,CAAC;gBAC/C,IAAI,OAAO,GAA4B,SAAS,CAAC;gBACjD,IAAI,SAAS,KAAK,qBAAqB,CAAC,MAAM,EAAE;oBAC5C,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;wBAC7B,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;4BAAE,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;wBACrD,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;4BAAE,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;qBAC1D;iBACJ;qBAAM;oBACH,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;iBACxB;gBAED,OAAO,CAAC,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,IAAI,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC;aACnG;QACL,CAAC,CAAC,CAAC;KACN;IAED,OAAO,OAAO,CAAC,KAAK,EAAE,CAAC;AAC3B,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,KAAa;IACrD,QAAQ,KAAK,EAAE;QACX,KAAK,eAAe,CAAC,MAAM;YACvB,OAAO,qBAAqB,CAAC,MAAM,CAAC;QACxC,KAAK,eAAe,CAAC,SAAS;YAC1B,OAAO,qBAAqB,CAAC,SAAS,CAAC;QAC3C,KAAK,eAAe,CAAC,QAAQ;YACzB,OAAO,qBAAqB,CAAC,QAAQ,CAAC;QAC1C,KAAK,eAAe,CAAC,EAAE;YACnB,OAAO,qBAAqB,CAAC,EAAE,CAAC;QACpC,KAAK,eAAe,CAAC,KAAK;YACtB,OAAO,qBAAqB,CAAC,KAAK,CAAC;QACvC,KAAK,eAAe,CAAC,UAAU;YAC3B,OAAO,qBAAqB,CAAC,UAAU,CAAC;QAC5C,KAAK,eAAe,CAAC,QAAQ;YACzB,OAAO,qBAAqB,CAAC,QAAQ,CAAC;QAC1C,KAAK,eAAe,CAAC,QAAQ;YACzB,OAAO,qBAAqB,CAAC,WAAW,CAAC;QAC7C,KAAK,eAAe,CAAC,WAAW;YAC5B,OAAO,qBAAqB,CAAC,WAAW,CAAC;QAC7C,KAAK,eAAe,CAAC,OAAO;YACxB,OAAO,qBAAqB,CAAC,MAAM,CAAC;QACxC,KAAK,eAAe,CAAC,MAAM;YACvB,OAAO,qBAAqB,CAAC,MAAM,CAAC;QACxC,KAAK,eAAe,CAAC,YAAY;YAC7B,OAAO,qBAAqB,CAAC,YAAY,CAAC;QAC9C,KAAK,eAAe,CAAC,WAAW,CAAC;QACjC,KAAK,eAAe,CAAC,iBAAiB,CAAC;QACvC,KAAK,eAAe,CAAC,oBAAoB,CAAC;QAC1C;YACI,MAAM,IAAI,gBAAgB,CAAC,sBAAsB,KAAK,kBAAkB,CAAC,CAAC;KACjF;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CACnC,MAAsB,EACtB,OAAgB,EAChB,YAAqG,EACrG,gBAAsB;IAEtB,MAAM,UAAU,GAAG,sBAAsB,CAAC,MAAM,CAAC,CAAC;IAClD,OAAO,YAAY;SACd,IAAI,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,GAAG,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC;SACtD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAC,IAAI,EAAE,GAAG,CAAC,QAAQ,IAAI,EAAE,EAAE,UAAU,EAAE,GAAG,CAAC,YAAY,EAAC,CAAC,CAAC,CAAC,CAAC;AACtF,CAAC","sourcesContent":["import {Observable} from 'rxjs';\nimport {map} from 'rxjs/operators';\n\nimport {DataListFilter, DataListFilterValueType, DataListParams, DataListResult, FilterMatchMode, MngInternalError} from '@mediusinc/mng-commons';\n\nimport {MediusQueryParamBuilder} from '../models/builders/query-param.builder';\nimport {MediusFilterMatchType} from '../models/filter-match-type.model';\nimport {MediusQueryParam} from '../models/query-param.model';\nimport {MediusQueryResult} from '../models/query-result.model';\nimport {QueryParamMap} from '../utils/query-param-map.util';\n\nexport function toObsoleteV1QueryParam(): undefined;\nexport function toObsoleteV1QueryParam<Sorts = string, Filters extends keyof any = string>(\n    params: DataListParams<Sorts, Filters>,\n    map?: QueryParamMap<Sorts, Filters>\n): MediusQueryParam;\nexport function toObsoleteV1QueryParam<Sorts = string, Filters extends keyof any = string>(\n    params: DataListParams<Sorts, Filters> | undefined,\n    map?: QueryParamMap<Sorts, Filters>\n): MediusQueryParam | undefined;\n/**\n * Converts the given DataListParams object to an ObsoleteV1QueryParam object.\n *\n * @param {DataListParams} params - The object to convert.\n * @param {QueryParamMap} map - The configuration object used to map sort and filter properties.\n *\n * @returns The converted ObsoleteV1QueryParam object if params is not null or undefined, otherwise returns undefined.\n *\n * @deprecated\n */\nexport function toObsoleteV1QueryParam<Sorts = string, Filters extends keyof any = string>(\n    params?: DataListParams<Sorts, Filters>,\n    map?: QueryParamMap<Sorts, Filters>\n): MediusQueryParam | undefined {\n    if (!params) return undefined;\n\n    const builder = MediusQueryParamBuilder.create();\n\n    if (params.offset !== undefined) {\n        builder.withItemsOffset(params.offset);\n    }\n    if (params.limit !== undefined) {\n        builder.withItemsPerPage(params.limit);\n    }\n    if (Array.isArray(params.sort)) {\n        params.sort.forEach(s => builder.withSort(map?.mapSort(s.property as string) ?? (s.property as string), s.ascending));\n    }\n    if (typeof params.filters === 'object') {\n        Object.entries(params.filters).forEach(([key, value]) => {\n            const filter = value as DataListFilter;\n            if (filter.value != null) {\n                const matchMode = filter.matchMode ? toObsoleteV1FilterMatchType(filter.matchMode) : MediusFilterMatchType.Equals;\n                let value: DataListFilterValueType = undefined;\n                let valueTo: DataListFilterValueType = undefined;\n                if (matchMode === MediusFilterMatchType.FromTo) {\n                    if (Array.isArray(filter.value)) {\n                        if (filter.value.length > 0) value = filter.value[0];\n                        if (filter.value.length > 1) valueTo = filter.value[1];\n                    }\n                } else {\n                    value = filter.value;\n                }\n\n                builder.withFilter(map?.mapFilter(key) ?? key, value, valueTo, matchMode, filter.caseSensitive);\n            }\n        });\n    }\n\n    return builder.build();\n}\n\nexport function toObsoleteV1FilterMatchType(match: string): MediusFilterMatchType {\n    switch (match) {\n        case FilterMatchMode.Equals:\n            return MediusFilterMatchType.Equals;\n        case FilterMatchMode.NotEquals:\n            return MediusFilterMatchType.NotEquals;\n        case FilterMatchMode.Contains:\n            return MediusFilterMatchType.Contains;\n        case FilterMatchMode.In:\n            return MediusFilterMatchType.In;\n        case FilterMatchMode.NotIn:\n            return MediusFilterMatchType.NotIn;\n        case FilterMatchMode.StartsWith:\n            return MediusFilterMatchType.StartsWith;\n        case FilterMatchMode.EndsWith:\n            return MediusFilterMatchType.EndsWith;\n        case FilterMatchMode.LessThan:\n            return MediusFilterMatchType.SmallerThan;\n        case FilterMatchMode.GreaterThan:\n            return MediusFilterMatchType.GreaterThan;\n        case FilterMatchMode.Between:\n            return MediusFilterMatchType.FromTo;\n        case FilterMatchMode.Exists:\n            return MediusFilterMatchType.Exists;\n        case FilterMatchMode.DoesNotExist:\n            return MediusFilterMatchType.DoesNotExist;\n        case FilterMatchMode.NotContains:\n        case FilterMatchMode.LessThanOrEqualTo:\n        case FilterMatchMode.GreaterThanOrEqualTo:\n        default:\n            throw new MngInternalError(`Filter match type '${match}' not supported.`);\n    }\n}\n\n/**\n * Convert a query result from an obsolete API version 1 to a `DataListResult`\n *\n * @param {DataListParams} params - The data list parameters for the query\n * @param {Service} service - The service object used to make the API call\n * @param {function} apiOperation - The API operation function that returns an `Observable<MediusQueryResult<Item>>`\n * @param {any} additionalParams - Additional parameters to pass to the API operation function (optional)\n *\n * @returns {Observable<DataListResult<Item>>} - An observable that emits a `DataListResult` object\n *\n * @deprecated\n */\nexport function toObsoleteV1QueryResult<Item, Service>(\n    params: DataListParams,\n    service: Service,\n    apiOperation: (qp: MediusQueryParam, ...additionalParams: any) => Observable<MediusQueryResult<Item>>,\n    additionalParams?: any\n): Observable<DataListResult<Item>> {\n    const queryParam = toObsoleteV1QueryParam(params);\n    return apiOperation\n        .bind(service)(queryParam, ...(additionalParams ?? []))\n        .pipe(map(res => ({data: res.pageData ?? [], totalCount: res.allDataCount})));\n}\n"]}

package/esm2022/data-api/class-dto/obsolete/helpers/tableview-crud-create.mjs

@@ -0,0 +1,21 @@
+import { Injector, inject } from '@angular/core';
+import { TableviewBuilder, TableviewDescriptor } from '@mediusinc/mng-commons';
+import { TableviewCrudObsoleteV1DataProvider } from '../tableview/tableview-crud.data-provider';
+/**
+ * Creates a tableview with the given class, service based on data API v1 (obsolete) and optional class/model configuration.
+ *
+ * @param {ClassType<Model>} type - The class representing the model.
+ * @param {ServiceClassType<Service>} service - The class type of the service implementing `IMngCrudObsoleteV1ApiService` and `IMngGetAllObsoleteV1ApiService`.
+ * @param {{ idProperty?: keyof Model; titleProperty?: keyof Model; i18nBaseKey?: ClassType<any> | string; }} [modelConfig] - Additional optional model configuration.
+ * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.
+ *
+ * @returns {Tableview} - The built table view.
+ *
+ * @deprecated
+ */
+export function tableviewCrudObsoleteV1(type, service, modelConfig, buildFn) {
+    const builder = new TableviewBuilder(TableviewDescriptor.fromClass(type, modelConfig?.idProperty, modelConfig?.titleProperty, modelConfig?.i18nBaseKey), TableviewCrudObsoleteV1DataProvider.create(type, service, modelConfig?.idProperty), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/data-api/class-dto/obsolete/index.mjs

@@ -0,0 +1,21 @@
+// helpers
+export * from './helpers/query-param-convert';
+export * from './helpers/tableview-crud-create';
+// models
+export * from './models/builders/query-param.builder';
+export * from './models/filter-match-type.model';
+export * from './models/filter-param.model';
+export * from './models/query-mode.model';
+export * from './models/query-param.model';
+export * from './models/query-result.model';
+// services
+export * from './services/api.abstract.service';
+export * from './services/crud-api.abstract.service';
+export * from './services/get-all-api.abstract.service';
+// tableview
+export * from './tableview/tableview-crud.data-provider';
+// utils
+export * from './utils/query-param-map.util';
+// provider
+export * from './provide';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9kYXRhLWFwaS9jbGFzcy1kdG8vb2Jzb2xldGUvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFVBQVU7QUFDVixjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsaUNBQWlDLENBQUM7QUFFaEQsU0FBUztBQUNULGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDZCQUE2QixDQUFDO0FBRTVDLFdBQVc7QUFDWCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx5Q0FBeUMsQ0FBQztBQUV4RCxZQUFZO0FBQ1osY0FBYywwQ0FBMEMsQ0FBQztBQUV6RCxRQUFRO0FBQ1IsY0FBYyw4QkFBOEIsQ0FBQztBQUU3QyxXQUFXO0FBQ1gsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBoZWxwZXJzXG5leHBvcnQgKiBmcm9tICcuL2hlbHBlcnMvcXVlcnktcGFyYW0tY29udmVydCc7XG5leHBvcnQgKiBmcm9tICcuL2hlbHBlcnMvdGFibGV2aWV3LWNydWQtY3JlYXRlJztcblxuLy8gbW9kZWxzXG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9idWlsZGVycy9xdWVyeS1wYXJhbS5idWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL2ZpbHRlci1tYXRjaC10eXBlLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL2ZpbHRlci1wYXJhbS5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9xdWVyeS1tb2RlLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3F1ZXJ5LXBhcmFtLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3F1ZXJ5LXJlc3VsdC5tb2RlbCc7XG5cbi8vIHNlcnZpY2VzXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2FwaS5hYnN0cmFjdC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvY3J1ZC1hcGkuYWJzdHJhY3Quc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2dldC1hbGwtYXBpLmFic3RyYWN0LnNlcnZpY2UnO1xuXG4vLyB0YWJsZXZpZXdcbmV4cG9ydCAqIGZyb20gJy4vdGFibGV2aWV3L3RhYmxldmlldy1jcnVkLmRhdGEtcHJvdmlkZXInO1xuXG4vLyB1dGlsc1xuZXhwb3J0ICogZnJvbSAnLi91dGlscy9xdWVyeS1wYXJhbS1tYXAudXRpbCc7XG5cbi8vIHByb3ZpZGVyXG5leHBvcnQgKiBmcm9tICcuL3Byb3ZpZGUnO1xuIl19

package/esm2022/data-api/class-dto/obsolete/mediusinc-mng-commons-data-api-class-dto-obsolete.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaXVzaW5jLW1uZy1jb21tb25zLWRhdGEtYXBpLWNsYXNzLWR0by1vYnNvbGV0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2RhdGEtYXBpL2NsYXNzLWR0by9vYnNvbGV0ZS9zcmMvbWVkaXVzaW5jLW1uZy1jb21tb25zLWRhdGEtYXBpLWNsYXNzLWR0by1vYnNvbGV0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/data-api/class-dto/obsolete/models/builders/query-param.builder.mjs

@@ -0,0 +1,83 @@
+import { MediusFilterMatchType } from '../filter-match-type.model';
+import { MediusFilterParam } from '../filter-param.model';
+import { MediusQueryMode } from '../query-mode.model';
+import { MediusQueryParam } from '../query-param.model';
+export class MediusQueryParamBuilder {
+    constructor(queryParam) {
+        this.queryParam = queryParam;
+    }
+    /**
+     * Creates a new instance of `MediusQueryParamBuilder` with the specified `itemsPerPage` and `itemsOffset` values.
+     *
+     * @param {number} [itemsPerPage=50] - The number of items per page.
+     * @param {number} [itemsOffset=0] - The offset value for the items.
+     *
+     * @returns {MediusQueryParamBuilder} A new instance of `MediusQueryParamBuilder`.
+     *
+     * @deprecated
+     */
+    static create(itemsPerPage = 50, itemsOffset = 0) {
+        const queryParam = new MediusQueryParam();
+        queryParam.itemsPerPage = itemsPerPage;
+        queryParam.itemsOffset = itemsOffset;
+        queryParam.queryMode = MediusQueryMode.All;
+        return new MediusQueryParamBuilder(queryParam);
+    }
+    /**
+     * Creates a new instance of MediusQueryParamBuilder based on an existing MediusQueryParam object.
+     *
+     * @param {MediusQueryParam} queryParam - The existing MediusQueryParam object to create from.
+     * @param {number} [itemsPerPage] - The number of items per page for the new instance. If not provided, default value is used.
+     * @param {number} [itemsOffset] - The offset for the new instance. If not provided, default value is used.
+     *
+     * @returns {MediusQueryParamBuilder} - A new instance of MediusQueryParamBuilder.
+     *
+     * @deprecated
+     */
+    static createFromExisting(queryParam, itemsPerPage, itemsOffset) {
+        queryParam.itemsPerPage = itemsPerPage ?? queryParam.itemsPerPage ?? 50;
+        queryParam.itemsOffset = itemsOffset ?? queryParam.itemsOffset ?? 0;
+        queryParam.queryMode = queryParam.queryMode ?? MediusQueryMode.All;
+        return new MediusQueryParamBuilder(queryParam);
+    }
+    withItemsPerPage(itemsPerPage) {
+        this.queryParam.itemsPerPage = itemsPerPage;
+        return this;
+    }
+    withItemsOffset(itemsOffset) {
+        this.queryParam.itemsOffset = itemsOffset;
+        return this;
+    }
+    withQueryMode(queryMode) {
+        this.queryParam.queryMode = queryMode;
+        return this;
+    }
+    withSort(property, asc = true) {
+        if (!this.queryParam.sortProperty || !this.queryParam.sortAsc) {
+            this.queryParam.sortProperty = [];
+            this.queryParam.sortAsc = [];
+        }
+        this.queryParam.sortProperty.push(property);
+        this.queryParam.sortAsc.push(asc);
+        return this;
+    }
+    withFilter(property, value, valueTo = undefined, matchType = MediusFilterMatchType.Contains, matchCaseSensitive = false) {
+        if (!this.queryParam.filterParams) {
+            this.queryParam.filterParams = [];
+        }
+        const filterParam = new MediusFilterParam();
+        filterParam.property = property;
+        filterParam.filterValue = value;
+        filterParam.filterValueTo = valueTo;
+        filterParam.filterMatchType = matchType;
+        filterParam.filterMatchCaseSensitive = matchCaseSensitive;
+        this.queryParam.filterParams.push(filterParam);
+        return this;
+    }
+    build() {
+        const queryParam = this.queryParam;
+        this.queryParam = new MediusQueryParam();
+        return queryParam;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-param.builder.js","sourceRoot":"","sources":["../../../../../../../data-api/class-dto/obsolete/src/models/builders/query-param.builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {MediusFilterMatchType} from '../filter-match-type.model';\nimport {MediusFilterParam} from '../filter-param.model';\nimport {MediusQueryMode} from '../query-mode.model';\nimport {MediusQueryParam} from '../query-param.model';\n\nexport class MediusQueryParamBuilder {\n    private constructor(private queryParam: MediusQueryParam) {}\n\n    /**\n     * Creates a new instance of `MediusQueryParamBuilder` with the specified `itemsPerPage` and `itemsOffset` values.\n     *\n     * @param {number} [itemsPerPage=50] - The number of items per page.\n     * @param {number} [itemsOffset=0] - The offset value for the items.\n     *\n     * @returns {MediusQueryParamBuilder} A new instance of `MediusQueryParamBuilder`.\n     *\n     * @deprecated\n     */\n    public static create(itemsPerPage = 50, itemsOffset = 0): MediusQueryParamBuilder {\n        const queryParam = new MediusQueryParam();\n        queryParam.itemsPerPage = itemsPerPage;\n        queryParam.itemsOffset = itemsOffset;\n        queryParam.queryMode = MediusQueryMode.All;\n        return new MediusQueryParamBuilder(queryParam);\n    }\n\n    /**\n     * Creates a new instance of MediusQueryParamBuilder based on an existing MediusQueryParam object.\n     *\n     * @param {MediusQueryParam} queryParam - The existing MediusQueryParam object to create from.\n     * @param {number} [itemsPerPage] - The number of items per page for the new instance. If not provided, default value is used.\n     * @param {number} [itemsOffset] - The offset for the new instance. If not provided, default value is used.\n     *\n     * @returns {MediusQueryParamBuilder} - A new instance of MediusQueryParamBuilder.\n     *\n     * @deprecated\n     */\n    public static createFromExisting(queryParam: MediusQueryParam, itemsPerPage?: number, itemsOffset?: number): MediusQueryParamBuilder {\n        queryParam.itemsPerPage = itemsPerPage ?? queryParam.itemsPerPage ?? 50;\n        queryParam.itemsOffset = itemsOffset ?? queryParam.itemsOffset ?? 0;\n        queryParam.queryMode = queryParam.queryMode ?? MediusQueryMode.All;\n        return new MediusQueryParamBuilder(queryParam);\n    }\n\n    public withItemsPerPage(itemsPerPage: number): MediusQueryParamBuilder {\n        this.queryParam.itemsPerPage = itemsPerPage;\n        return this;\n    }\n\n    public withItemsOffset(itemsOffset: number): MediusQueryParamBuilder {\n        this.queryParam.itemsOffset = itemsOffset;\n        return this;\n    }\n\n    public withQueryMode(queryMode: MediusQueryMode): MediusQueryParamBuilder {\n        this.queryParam.queryMode = queryMode;\n        return this;\n    }\n\n    public withSort(property: string, asc = true): MediusQueryParamBuilder {\n        if (!this.queryParam.sortProperty || !this.queryParam.sortAsc) {\n            this.queryParam.sortProperty = [];\n            this.queryParam.sortAsc = [];\n        }\n        this.queryParam.sortProperty.push(property);\n        this.queryParam.sortAsc.push(asc);\n        return this;\n    }\n\n    public withFilter(\n        property: string,\n        value: any,\n        valueTo: any = undefined,\n        matchType: MediusFilterMatchType = MediusFilterMatchType.Contains,\n        matchCaseSensitive = false\n    ): MediusQueryParamBuilder {\n        if (!this.queryParam.filterParams) {\n            this.queryParam.filterParams = [];\n        }\n        const filterParam = new MediusFilterParam();\n        filterParam.property = property;\n        filterParam.filterValue = value;\n        filterParam.filterValueTo = valueTo;\n        filterParam.filterMatchType = matchType;\n        filterParam.filterMatchCaseSensitive = matchCaseSensitive;\n        this.queryParam.filterParams.push(filterParam);\n        return this;\n    }\n\n    public build(): MediusQueryParam {\n        const queryParam = this.queryParam;\n        this.queryParam = new MediusQueryParam();\n        return queryParam;\n    }\n}\n"]}