@mediusinc/mng-commons-data-api-class 5.0.0-rc.0

package/fesm2022/mediusinc-mng-commons-data-api-class-v1.mjs

@@ -0,0 +1,698 @@
+import { map } from 'rxjs/operators';
+import { CommonsInternalError, FilterMatchMode, TypeRegistry, CommonsFeatureTypeEnum } from '@mediusinc/mng-commons/core';
+import { inject, Injector, APP_INITIALIZER } from '@angular/core';
+import { TableviewDataProviderInst, TableviewInputBuilder, TableviewDescriptor } from '@mediusinc/mng-commons/tableview/api';
+import { ModelUtil } from '@mediusinc/mng-commons/model';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { ObjectSerializer } from '@mediusinc/mng-commons-data-api-class';
+import { of } from 'rxjs';
+
+/**
+ * Generated API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+var MediusFilterMatchType;
+(function (MediusFilterMatchType) {
+    MediusFilterMatchType["Equals"] = "EQUALS";
+    MediusFilterMatchType["NotEquals"] = "NOT_EQUALS";
+    MediusFilterMatchType["FromTo"] = "FROM_TO";
+    MediusFilterMatchType["Contains"] = "CONTAINS";
+    MediusFilterMatchType["StartsWith"] = "STARTS_WITH";
+    MediusFilterMatchType["EndsWith"] = "ENDS_WITH";
+    MediusFilterMatchType["In"] = "IN";
+    MediusFilterMatchType["NotIn"] = "NOT_IN";
+    MediusFilterMatchType["SmallerThan"] = "SMALLER_THAN";
+    MediusFilterMatchType["GreaterThan"] = "GREATER_THAN";
+    MediusFilterMatchType["Exists"] = "EXISTS";
+    MediusFilterMatchType["DoesNotExist"] = "DOES_NOT_EXIST";
+})(MediusFilterMatchType || (MediusFilterMatchType = {}));
+
+class MediusFilterParam {
+    static { this.attributeTypeMap = [
+        {
+            name: 'property',
+            baseName: 'property',
+            type: 'string'
+        },
+        {
+            name: 'filterValue',
+            baseName: 'filter_value',
+            type: 'object'
+        },
+        {
+            name: 'filterValueTo',
+            baseName: 'filter_value_to',
+            type: 'object'
+        },
+        {
+            name: 'filterMatchType',
+            baseName: 'filter_match_type',
+            type: 'FilterMatchType'
+        },
+        {
+            name: 'filterMatchCaseSensitive',
+            baseName: 'filter_match_case_sensitive',
+            type: 'boolean'
+        }
+    ]; }
+    static getAttributeTypeMap() {
+        return MediusFilterParam.attributeTypeMap;
+    }
+}
+
+/**
+ * Generated API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+var MediusQueryMode;
+(function (MediusQueryMode) {
+    MediusQueryMode["Count"] = "COUNT";
+    MediusQueryMode["Data"] = "DATA";
+    MediusQueryMode["All"] = "ALL";
+})(MediusQueryMode || (MediusQueryMode = {}));
+
+class MediusQueryParam {
+    static { this.attributeTypeMap = [
+        {
+            name: 'sortProperty',
+            baseName: 'sort_property',
+            type: 'Array<string>'
+        },
+        {
+            name: 'sortAsc',
+            baseName: 'sort_asc',
+            type: 'Array<boolean>'
+        },
+        {
+            name: 'itemsOffset',
+            baseName: 'items_offset',
+            type: 'number'
+        },
+        {
+            name: 'itemsPerPage',
+            baseName: 'items_per_page',
+            type: 'number'
+        },
+        {
+            name: 'filterParams',
+            baseName: 'filter_params',
+            type: 'Array<FilterParam>'
+        },
+        {
+            name: 'filterAllParam',
+            baseName: 'filter_all_param',
+            type: 'string'
+        },
+        {
+            name: 'filterAllProperties',
+            baseName: 'filter_all_properties',
+            type: 'Array<string>'
+        },
+        {
+            name: 'validateProperties',
+            baseName: 'validate_properties',
+            type: 'Array<string>'
+        },
+        {
+            name: 'selectInTwoSteps',
+            baseName: 'select_in_two_steps',
+            type: 'boolean'
+        },
+        {
+            name: 'sortEnumByOrdinal',
+            baseName: 'sort_enum_by_ordinal',
+            type: 'boolean'
+        },
+        {
+            name: 'groupByProperties',
+            baseName: 'group_by_properties',
+            type: 'Array<string>'
+        },
+        {
+            name: 'queryMode',
+            baseName: 'query_mode',
+            type: 'QueryMode'
+        }
+    ]; }
+    static getAttributeTypeMap() {
+        return MediusQueryParam.attributeTypeMap;
+    }
+}
+
+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;
+    }
+}
+
+/**
+ * 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
+ */
+function toV1QueryParam(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 ? toV1FilterMatchType(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();
+}
+function toV1FilterMatchType(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 CommonsInternalError(`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
+ */
+function executeV1GetAll(params, service, apiOperation, additionalParams) {
+    const queryParam = toV1QueryParam(params);
+    return apiOperation
+        .bind(service)(queryParam, ...(additionalParams ?? []))
+        .pipe(map(res => ({ data: res.pageData ?? [], totalCount: res.allDataCount })));
+}
+
+/**
+ * A data provider for a CRUD table view that uses an obsolete version 1 API service.
+ *
+ * @typeparam Model - The type of the data model.
+ * @typeparam Service - The type of the API service.
+ * @typeparam Sorts - The type for available sort keys on get all operation.
+ * @typeparam Filters - The type for available sort keys on get all operation.
+ *
+ * @deprecated
+ */
+class TableviewCrudV1DataProviderInst extends TableviewDataProviderInst {
+    constructor(type, serviceType, idPropertyName, useGetAllForFetch = false) {
+        super(type, serviceType);
+        this.withGetAll((params, service, locale) => service.getAllPost(toV1QueryParam(params), undefined, locale).pipe(map(res => ({ data: res.pageData ?? [], totalCount: res.allDataCount ?? res.pageData?.length ?? 0 }))));
+        if (useGetAllForFetch) {
+            const selectedIdPropertyName = idPropertyName ?? ModelUtil.findIdAttribute(type) ?? 'id';
+            this.withFetch((id, service) => {
+                const qp = MediusQueryParamBuilder.create(10, 0).withFilter(selectedIdPropertyName, id, id, MediusFilterMatchType.Equals, true).build();
+                return service.getAllPost(qp).pipe(map(res => res.pageData[0]));
+            });
+        }
+        else {
+            this.withFetch((id, service, locale) => service.getByIdGet(id, undefined, locale));
+        }
+        this.withCreate((item, service) => service.createPost(item));
+        this.withUpdate((id, item, service) => service.updatePut(id, item));
+        this.withDelete((id, item, service) => service.removeDelete(id, item));
+    }
+}
+class TableviewCrudV1DataProvider extends TableviewCrudV1DataProviderInst {
+    /**
+     * @deprecated
+     */
+    static create(type, serviceType, idProperty, useGetAllForFetch = false) {
+        return TableviewCrudV1DataProvider.createUnsafe(type, serviceType, idProperty, useGetAllForFetch);
+    }
+    /**
+     * @deprecated
+     */
+    static createUnsafe(type, serviceType, idProperty, useGetAllForFetch = false) {
+        return new TableviewCrudV1DataProviderInst(type, serviceType, idProperty, useGetAllForFetch);
+    }
+}
+
+/**
+ * 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
+ */
+function tableviewCrudV1(type, service, modelConfig, buildFn) {
+    const builder = new TableviewInputBuilder(TableviewDescriptor.fromClass(type, modelConfig?.idProperty, modelConfig?.titleProperty, modelConfig?.i18nBaseKey), TableviewCrudV1DataProvider.create(type, service, modelConfig?.idProperty), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+
+class MediusQueryResult {
+    static fromArray(pageData, allDataCount) {
+        const mqr = new MediusQueryResult();
+        mqr.allDataCount = allDataCount ?? pageData.length;
+        mqr.pageData = pageData;
+        return mqr;
+    }
+    static { this.attributeTypeMap = [
+        {
+            name: 'allDataCount',
+            baseName: 'all_data_count',
+            type: 'number'
+        },
+        {
+            name: 'pageData',
+            baseName: 'page_data',
+            type: 'Array<T>'
+        }
+    ]; }
+    static getAttributeTypeMap() {
+        return MediusQueryResult.attributeTypeMap;
+    }
+}
+
+/**
+ * This is an abstract class that provides base functionality for API services.
+ *
+ * @deprecated
+ */
+class ACommonsBaseV1ApiService {
+    constructor() {
+        this.objectSerializer = ObjectSerializer.get();
+        this.http = inject(HttpClient);
+    }
+    getUrl(...pathSegments) {
+        let baseUrl = this.getBasePath();
+        if (baseUrl.endsWith('/')) {
+            baseUrl = baseUrl.substring(0, baseUrl.length - 1);
+        }
+        const serviceBasePath = this.getServiceBasePath();
+        let path = [serviceBasePath, ...pathSegments].filter(s => s && s.length).join('/');
+        // omit first and last '/'
+        if (path.startsWith('/')) {
+            path = path.substring(1);
+        }
+        if (path.endsWith('/')) {
+            path = path.substring(0, path.length - 1);
+        }
+        // replace any double '//' from path that could come from joining paths
+        path = path.replace('//', '/');
+        return `${baseUrl}/${path}`;
+    }
+    serializeQueryParam(queryParam, type = 'QueryParam') {
+        return this.objectSerializer.serialize(queryParam, type);
+    }
+    deserializeQueryResult(item, qrType) {
+        return this.deserializeClass(item, qrType);
+    }
+    deserializeClass(item, type) {
+        return this.objectSerializer.deserializeClass(item, type);
+    }
+    deserializeClassArray(item, type) {
+        return this.objectSerializer.deserializeClassArray(item, type);
+    }
+    serializeClass(item, type) {
+        return this.objectSerializer.serializeClass(item, type);
+    }
+    serializeClassArray(item, type) {
+        return this.objectSerializer.serializeClassArray(item, type);
+    }
+}
+/**
+ * Represents an abstract base class for the ACommonsV1ApiService.
+ *
+ * @typeparam T The main type of data to be handled by the service.
+ *
+ * @deprecated
+ */
+class ACommonsV1ApiService extends ACommonsBaseV1ApiService {
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    deserialize(item) {
+        return this.deserializeClass(item, this.type);
+    }
+    serialize(item) {
+        return this.serializeClass(item, this.type);
+    }
+}
+
+/**
+ * An abstract class representing a service for retrieving all obsolete entities.
+ *
+ * @typeparam T The main type of data to be handled by the service.
+ * @typeparam QRT The type of the query result in get all operation.
+ *
+ * @deprecated
+ */
+class ACommonsGetAllV1ApiService extends ACommonsV1ApiService {
+    constructor(type, queryResultType) {
+        super(type);
+        this.queryResultType = queryResultType;
+    }
+    getAllPost(queryParamBody, params, locale) {
+        const url = this.getUrl(this.getGetAllPostPath());
+        if (params && locale) {
+            params = params.set('lang', locale);
+        }
+        else if (locale) {
+            params = new HttpParams().set('lang', locale);
+        }
+        return this.http
+            .post(url, queryParamBody ? this.serializeQueryParam(queryParamBody) : undefined, {
+            withCredentials: true,
+            observe: 'body',
+            reportProgress: false,
+            params: params
+        })
+            .pipe(map(res => this.deserializeQueryResult(res, this.queryResultType)));
+    }
+    getGetAllPostPath() {
+        return '/get-all';
+    }
+}
+
+/**
+ * Abstract class for creating CRUD API service implementation.
+ *
+ * @typeparam T The type of the entity.
+ * @typeparam QRT The type of the query result.
+ *
+ * @deprecated
+ */
+class ACommonsCrudV1ApiService extends ACommonsGetAllV1ApiService {
+    constructor(type, queryResultType) {
+        super(type, queryResultType);
+    }
+    createPost(item, params) {
+        const url = this.getUrl(this.getCreatePostPath(item));
+        return this.http
+            .post(url, this.serialize(item), {
+            withCredentials: true,
+            observe: 'body',
+            reportProgress: false,
+            params: params
+        })
+            .pipe(map(res => this.deserialize(res)));
+    }
+    getByIdGet(id, params, locale) {
+        const url = this.getUrl(this.getGetByIdGetPath(id));
+        if (params && locale) {
+            params = params.set('lang', locale);
+        }
+        else if (locale) {
+            params = new HttpParams().set('lang', locale);
+        }
+        return this.http
+            .get(url, {
+            withCredentials: true,
+            observe: 'body',
+            reportProgress: false,
+            params: params
+        })
+            .pipe(map(res => this.deserialize(res)));
+    }
+    updatePut(id, item, params) {
+        const url = this.getUrl(this.getUpdatePutPath(id, item));
+        return this.http
+            .put(url, this.serialize(item), {
+            withCredentials: true,
+            observe: 'body',
+            reportProgress: false,
+            params: params
+        })
+            .pipe(map(res => this.deserialize(res)));
+    }
+    removeDelete(id, item, params) {
+        const url = this.getUrl(this.getRemoveDeletePath(id, item));
+        return this.http
+            .request('delete', url, {
+            withCredentials: true,
+            observe: 'body',
+            reportProgress: false,
+            body: item ? this.serialize(item) : undefined,
+            params: params
+        })
+            .pipe(map(res => (res ? this.deserialize(res) : null)));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getCreatePostPath(item) {
+        return '';
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getUpdatePutPath(id, item) {
+        return `/${id}`;
+    }
+    getGetByIdGetPath(id) {
+        return `/${id}`;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getRemoveDeletePath(id, item) {
+        return `/${id}`;
+    }
+}
+
+/**
+ * A class representing a mapping of query parameters.
+ *
+ * @typeparam Sorts - The type for available sort keys on get all operation.
+ * @typeparam Filters - The type for available sort keys on get all operation.
+ *
+ * @deprecated
+ */
+class QueryParamMap {
+    constructor(_params) {
+        this._params = _params;
+        this._sorts = {};
+        this._filters = {};
+        // empty line
+    }
+    static create() {
+        return new QueryParamMap();
+    }
+    static forParams(params) {
+        return new QueryParamMap(params);
+    }
+    withSortMap(sort, mapTo) {
+        this._sorts[sort] = mapTo;
+        return this;
+    }
+    withFilterMap(filter, mapTo) {
+        this._filters[filter] = mapTo;
+        return this;
+    }
+    mapSort(sort) {
+        return this._sorts[sort] ?? sort;
+    }
+    mapFilter(filter) {
+        return this._filters[filter] ?? filter;
+    }
+    mapParams() {
+        if (!this._params) {
+            return undefined;
+        }
+        const params = {
+            offset: this._params.offset,
+            limit: this._params.limit,
+            search: this._params.search,
+            sort: this._params.sort?.map(s => ({ property: this.mapSort(s.property), ascending: s.ascending }))
+        };
+        if (this._params.filters) {
+            params.filters = {};
+            Object.entries(this._params.filters).forEach(([key, value]) => {
+                params.filters[this.mapFilter(key)] = {
+                    ...value
+                };
+            });
+        }
+        return params;
+    }
+}
+
+function initializeDataApiObsolete(config) {
+    return () => {
+        const typeRegistry = TypeRegistry.get();
+        typeRegistry.registerType(MediusFilterParam, 'FilterParam');
+        typeRegistry.registerType(MediusQueryParam, 'QueryParam');
+        typeRegistry.registerEnum(MediusFilterMatchType, 'FilterMatchType');
+        typeRegistry.registerEnum(MediusQueryMode, 'QueryMode');
+        ObjectSerializer.get().configure({ ...(config?.serialization ?? {}) });
+        return of(void 0);
+    };
+}
+/**
+ * Prepares providers for usage of the Obsolete Data API functionalities.
+ *
+ * @returns {CommonsFeature} The `CommonsFeature` object with the Data API Obsolete configuration.
+ *
+ * @deprecated.
+ */
+function withDataApiV1() {
+    return {
+        type: CommonsFeatureTypeEnum.DataApiAsClassV1,
+        providers: [
+            {
+                provide: APP_INITIALIZER,
+                useFactory: initializeDataApiObsolete,
+                deps: [],
+                multi: true
+            }
+        ]
+    };
+}
+
+// helpers
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ACommonsBaseV1ApiService, ACommonsCrudV1ApiService, ACommonsGetAllV1ApiService, ACommonsV1ApiService, MediusFilterMatchType, MediusFilterParam, MediusQueryMode, MediusQueryParam, MediusQueryParamBuilder, MediusQueryResult, QueryParamMap, TableviewCrudV1DataProvider, TableviewCrudV1DataProviderInst, executeV1GetAll, tableviewCrudV1, toV1FilterMatchType, toV1QueryParam, withDataApiV1 };
+//# sourceMappingURL=mediusinc-mng-commons-data-api-class-v1.mjs.map