@veloceapps/api 11.0.0-5 → 11.0.0-50

package/fesm2020/veloceapps-api-v2.mjs

@@ -0,0 +1,1848 @@
+import { HttpParams, HttpErrorResponse, HttpClientModule } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { Injectable, NgModule } from '@angular/core';
+import * as i1 from '@veloceapps/core';
+import { Expression, RuleGroupTypes, Operator, parseJsonSafely, parseJsonStringAsObject, BaseHttpService, XrayService } from '@veloceapps/core';
+import { noop, of, map as map$1, tap as tap$1, catchError as catchError$1, forkJoin, switchMap } from 'rxjs';
+import { map, catchError, tap } from 'rxjs/operators';
+import * as i2 from 'primeng/api';
+
+class CacheApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/v2/cache/evict';
+    }
+    clear$(name, options) {
+        return this.httpService.api({
+            method: 'get',
+            url: `${this.SERVICE_URL}/` + name,
+            ...options,
+        });
+    }
+}
+CacheApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CacheApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+CacheApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CacheApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CacheApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class CatalogAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/v2/catalogs';
+        this.fetchCatalogs$ = (searchParams) => {
+            const params = new HttpParams({ fromObject: { ...searchParams } });
+            return this.baseHttpService.api({ url: `${this.serviceUrl}`, params });
+        };
+        this.searchCatalogs$ = (searchParams, expression) => {
+            const params = new HttpParams({ fromObject: { ...searchParams } });
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/search`,
+                params,
+                body: expression || {},
+            });
+        };
+        this.fetchCategories$ = (catalogId) => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}/${catalogId}/categories` });
+        };
+        this.searchProducts$ = (catalogId, categoryId) => {
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products/search`,
+                body: {},
+            });
+        };
+        this.fetchAttributes$ = (catalogId, categoryId) => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/attributes` });
+        };
+        this.createNewCatalog$ = (catalogData) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}`,
+                method: 'post',
+                body: catalogData,
+            });
+        };
+        this.duplicateCatalog$ = (cloneRequest) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${cloneRequest.id}/clone`,
+                method: 'post',
+                body: cloneRequest,
+            });
+        };
+        this.updateCatalog$ = (data) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${data.id}`,
+                method: 'put',
+                body: data,
+            });
+        };
+        this.removeCatalog$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreCatalog$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+        this.createNewCategory$ = (categoryData) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${categoryData.catalogId}/categories`,
+                method: 'post',
+                body: categoryData,
+            });
+        };
+        this.updateCategory$ = (category) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${category.catalogId}/categories/${category.id}`,
+                method: 'put',
+                body: category,
+            });
+        };
+        this.duplicateCategory$ = (catalogId, cloneRequest) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${catalogId}/categories/${cloneRequest.id}/clone`,
+                method: 'post',
+                body: cloneRequest,
+            });
+        };
+        this.removeCategory$ = (id, catalogId) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${catalogId}/categories/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreCategory$ = (id, catalogId) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${catalogId}/categories/${id}/restore`,
+                method: 'patch',
+            });
+        };
+        this.removeAttribute$ = ({ catalogId, categoryId, data, }) => {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/attributes/${data.id}`,
+                body: data,
+            });
+        };
+        this.restoreAttribute$ = ({ catalogId, categoryId, data, }) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/attributes/${data.id}/restore`,
+                method: 'patch',
+            });
+        };
+        this.createNewAttribute$ = ({ catalogId, categoryId, data, }) => {
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/attributes`,
+                body: data,
+            });
+        };
+        this.updateAttribute$ = ({ catalogId, categoryId, data, }) => {
+            return this.baseHttpService.api({
+                method: 'put',
+                url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/attributes/${data.id}`,
+                body: data,
+            });
+        };
+        this.searchProductCandidates$ = (catalogId, categoryId, expression, searchParams) => {
+            const params = new HttpParams({ fromObject: { ...searchParams } });
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/candidates/search`,
+                params,
+                body: expression,
+            });
+        };
+        this.addProduct$ = (product, catalogId, categoryId) => {
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products`,
+                body: product,
+            });
+        };
+        this.updateProduct$ = (product, catalogId, categoryId) => {
+            return this.baseHttpService.api({
+                method: 'put',
+                url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products/${product.id}`,
+                body: product,
+            });
+        };
+        this.removeProduct$ = ({ catalogId, categoryId, data, }) => {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products/${data.id}`,
+            });
+        };
+    }
+    attachImage$(catalogId, categoryId, file) {
+        const data = new FormData();
+        data.append('image', file);
+        return this.baseHttpService.upload({
+            method: 'post',
+            url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/image`,
+            body: data,
+        });
+    }
+    removeImage$(catalogId, categoryId) {
+        return this.baseHttpService.api({
+            method: 'delete',
+            url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/image`,
+        });
+    }
+    fetchImage$(catalogId, categoryId) {
+        return this.baseHttpService.api({
+            url: this.getImageUrl(catalogId, categoryId),
+            method: 'get',
+            responseType: 'blob',
+            errorHandler: noop,
+        });
+    }
+    getImageUrl(catalogId, categoryId) {
+        return `${this.serviceUrl}/${catalogId}/categories/${categoryId}/image`;
+    }
+}
+CatalogAdminApiService.MAX_RESULTS = 60;
+CatalogAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+CatalogAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class CatalogApiService {
+    constructor(service) {
+        this.service = service;
+        this.serviceUrl = '/v2/product-catalogs';
+    }
+    fetchCatalogs$() {
+        return this.service.api({
+            method: 'get',
+            url: `${this.serviceUrl}`,
+        });
+    }
+    searchCatalogs$(searchParams, expression) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'post',
+            url: `${this.serviceUrl}/search`,
+            params,
+            body: expression,
+        });
+    }
+    getCatalog$(id) {
+        return this.service.api({
+            method: 'get',
+            url: `${this.serviceUrl}/${id}`,
+        });
+    }
+    fetchCategories$(catalogId) {
+        return this.service.api({
+            method: 'get',
+            url: `${this.serviceUrl}/${catalogId}/categories`,
+        });
+    }
+    fetchCatalogProducts$(catalogId, searchParams, context) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'post',
+            url: `${this.serviceUrl}/${catalogId}/products`,
+            params,
+            body: context,
+        });
+    }
+    fetchCategoryProducts$(catalogId, categoryId, searchParams, context) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'post',
+            url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products`,
+            params,
+            body: context,
+        });
+    }
+    searchCategoryProducts$(catalogId, categoryId, searchParams, searchRequest, context) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'post',
+            url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products/search`,
+            params,
+            body: {
+                configurationContext: context,
+                request: searchRequest,
+            },
+        });
+    }
+    fetchEligibleProducts$(searchParams, context) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'post',
+            url: `${this.serviceUrl}/products`,
+            params: params,
+            body: context,
+        });
+    }
+    fetchProducts$(searchParams) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.service.api({
+            method: 'get',
+            url: `${this.serviceUrl}/products`,
+            params: params,
+        });
+    }
+}
+CatalogApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+CatalogApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CatalogApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ConfigurationProcessorsApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/v2/configuration/processors/owners';
+        this.fetchConfigurationProcessors$ = (ownerId) => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}/${ownerId}` });
+        };
+        this.createConfigurationProcessors$ = (configurationProcessor) => {
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/${configurationProcessor.ownerId}`,
+                body: configurationProcessor,
+            });
+        };
+        this.updateConfigurationProcessors$ = (configurationProcessor) => {
+            return this.baseHttpService.api({
+                method: 'put',
+                url: `${this.serviceUrl}/${configurationProcessor.ownerId}/${configurationProcessor.id}`,
+                body: configurationProcessor,
+            });
+        };
+        this.deleteConfigurationProcessors$ = (configurationProcessor) => {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: `${this.serviceUrl}/${configurationProcessor.ownerId}/${configurationProcessor.id}`,
+            });
+        };
+    }
+}
+ConfigurationProcessorsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationProcessorsApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationProcessorsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationProcessorsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationProcessorsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ConfigurationSettingsDTO {
+    static fromDTO(dto, key) {
+        return {
+            id: dto?.id,
+            key: dto?.key || key || '',
+            value: dto?.value,
+        };
+    }
+    static toDTO(data) {
+        return {
+            id: data.id,
+            key: data.key,
+            value: data.value,
+        };
+    }
+    constructor(id, key, value) {
+        this.id = id;
+        this.key = key;
+        this.value = value;
+    }
+}
+
+class ConfigurationSettingsApiService {
+    constructor(httpService, messageService) {
+        this.httpService = httpService;
+        this.messageService = messageService;
+        this.SERVICE_URL = '/v2/settings';
+    }
+    fetchSettings(options) {
+        return this.httpService
+            .api({
+            url: `${this.SERVICE_URL}`,
+            method: 'get',
+            ...options,
+        })
+            .pipe(map((settings) => settings.map(setting => ConfigurationSettingsDTO.fromDTO(setting))));
+    }
+    fetchSetting(settingsKey, options) {
+        return this.httpService
+            .api({
+            url: `${this.SERVICE_URL}/byKey/${settingsKey}`,
+            method: 'get',
+            ...options,
+            skipErrorHandler: true,
+        })
+            .pipe(map((setting) => ConfigurationSettingsDTO.fromDTO(setting, settingsKey)), catchError(err => {
+            if (err instanceof HttpErrorResponse && err.status === 404) {
+                if (!options?.skipErrorHandler) {
+                    this.messageService.add({
+                        severity: 'error',
+                        summary: `Configuration Setting "${settingsKey}" is not found`,
+                        sticky: true,
+                    });
+                }
+                return of(null);
+            }
+            throw err;
+        }));
+    }
+    createSetting(setting, options) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}`,
+            method: 'post',
+            body: {
+                ...request,
+            },
+            ...options,
+        });
+    }
+    updateSetting(setting, options) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${request.id}`,
+            method: 'put',
+            body: {
+                ...request,
+            },
+            ...options,
+        });
+    }
+    removeSetting(setting, options) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${request.id}`,
+            method: 'delete',
+            ...options,
+        });
+    }
+    restoreSetting(settingId, options) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${settingId}/restore`,
+            method: 'patch',
+            ...options,
+        });
+    }
+}
+ConfigurationSettingsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationSettingsApiService, deps: [{ token: i1.BaseHttpService }, { token: i2.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationSettingsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationSettingsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationSettingsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }, { type: i2.MessageService }]; } });
+
+class ContextDefinitionAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/v2/context-definition';
+    }
+    fetchContextDefinitions$() {
+        return this.baseHttpService.api({ url: `${this.serviceUrl}`, skipErrorHandler: true }).pipe(catchError(() => {
+            return of([]);
+        }));
+    }
+    fetchContextMappings$(id) {
+        return this.baseHttpService.api({ url: `${this.serviceUrl}/${id}/mappings` });
+    }
+    fetchContextDefinitionStructure$(id) {
+        return this.baseHttpService
+            .api({
+            url: `${this.serviceUrl}/${id}/structure/details`,
+            skipErrorHandler: true,
+        })
+            .pipe(catchError(() => {
+            return of([]);
+        }), map(objects => {
+            return objects.map(object => {
+                const tag = object.tags?.[0]?.title;
+                const objectAttributes = object.attributes || [];
+                return {
+                    id: object.id,
+                    title: tag || object.title,
+                    parentNodeId: object.parentNodeId,
+                    nodeTags: (object.tags ?? []).map(nodeTag => nodeTag.title),
+                    attributes: objectAttributes.reduce((result, attribute) => {
+                        const tag = attribute.tags?.[0]?.title;
+                        if (tag) {
+                            result.push({
+                                title: tag,
+                                fieldType: attribute.fieldType,
+                                dataType: attribute.dataType,
+                            });
+                        }
+                        return result;
+                    }, []),
+                };
+            });
+        }));
+    }
+    fetchRlmProcedures(contextDefinitionId) {
+        const params = {};
+        if (contextDefinitionId) {
+            params['contextDefinitionId'] = contextDefinitionId;
+        }
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}/procedures`,
+            params,
+        });
+    }
+}
+ContextDefinitionAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContextDefinitionAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContextDefinitionAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContextDefinitionAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContextDefinitionAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class DocumentAttachmentApiService {
+    constructor(httpService, fileDownloadService) {
+        this.httpService = httpService;
+        this.fileDownloadService = fileDownloadService;
+        this.SERVICE_URL = '/v2/attachments';
+    }
+    getAttachments(searchRequest) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/search`,
+            method: 'post',
+            body: searchRequest,
+        });
+    }
+    createAttachment(attachment, file, reportProgress) {
+        const formData = new FormData();
+        if (file) {
+            formData.append('file', file, file.name);
+        }
+        formData.append('attachment', new Blob([JSON.stringify(attachment)], {
+            type: 'application/json',
+        }));
+        return this.httpService.upload({
+            url: `${this.SERVICE_URL}`,
+            body: formData,
+            method: 'post',
+            observe: reportProgress ? 'events' : undefined,
+            reportProgress,
+        });
+    }
+    updateAttachment(id, attachment) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${id}`,
+            body: attachment,
+            method: 'put',
+        });
+    }
+    getAttachmentFile(id, isPreventDownload) {
+        return this.httpService
+            .api({
+            url: `${this.SERVICE_URL}/${id}/file`,
+            responseType: isPreventDownload ? 'arraybuffer' : 'blob',
+            observe: isPreventDownload ? 'body' : 'response',
+        })
+            .pipe(tap(response => {
+            if (!isPreventDownload) {
+                this.fileDownloadService.processDownload(response);
+            }
+        }), map(response => (isPreventDownload ? new Blob([response.body || response]) : response.body || response)));
+    }
+    removeAttachment(id) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${id}`,
+            method: 'delete',
+        });
+    }
+}
+DocumentAttachmentApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DocumentAttachmentApiService, deps: [{ token: i1.BaseHttpService }, { token: i1.FileDownloadService }], target: i0.ɵɵFactoryTarget.Injectable });
+DocumentAttachmentApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DocumentAttachmentApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DocumentAttachmentApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }, { type: i1.FileDownloadService }]; } });
+
+class EndpointsAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/v2/api-endpoints';
+    }
+    fetchEndpoints$() {
+        return this.searchEndpoints$(new Expression(), 0, -1);
+    }
+    searchEndpoints$(expression, skip, count) {
+        let params = new HttpParams();
+        params = params.set('skip', '' + skip);
+        params = params.set('count', '' + count);
+        return this.baseHttpService.api({
+            method: 'post',
+            url: `${this.serviceUrl}/search`,
+            params,
+            body: expression,
+        });
+    }
+    removeEndpoint$(id) {
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}/${id}`,
+            method: 'delete',
+        });
+    }
+    restoreEndpoint$(id) {
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}/${id}/restore`,
+            method: 'patch',
+        });
+    }
+    fetchEndpoint$(id) {
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}/${id}`,
+            method: 'get',
+        });
+    }
+    createEndpoint$(body) {
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}`,
+            method: 'post',
+            body,
+        });
+    }
+    updateEndpoint$(body) {
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}/${body.id}`,
+            method: 'put',
+            body,
+        });
+    }
+    duplicateEndpoint$(cloneRequest) {
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}/${cloneRequest.id}/clone`,
+            method: 'post',
+            body: cloneRequest,
+        });
+    }
+    executeEndpoint$(body) {
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}/execute`,
+            method: 'post',
+            body,
+            responseType: 'text',
+            skipErrorHandler: true,
+        });
+    }
+}
+EndpointsAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: EndpointsAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+EndpointsAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: EndpointsAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: EndpointsAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class FlowsApiService {
+    constructor(configurationSettingsApiService) {
+        this.configurationSettingsApiService = configurationSettingsApiService;
+        this.flowsKey = 'flows';
+    }
+    getFlow(id) {
+        return this.fetchFlows().pipe(map(flows => flows.find(flow => flow.id == id)), map(flow => {
+            if (!flow) {
+                throw new Error(`Flow with flowId=${id} is not defined`);
+            }
+            return flow;
+        }));
+    }
+    fetchFlows() {
+        return this.configurationSettingsApiService
+            .fetchSetting(this.flowsKey)
+            .pipe(map((setting) => (setting?.value ? JSON.parse(setting.value) : [])));
+    }
+}
+FlowsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowsApiService, deps: [{ token: ConfigurationSettingsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: ConfigurationSettingsApiService }]; } });
+
+class FunctionGroupsAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/v2/functions/groups';
+        this.fetchAll$ = () => {
+            return this.search$(new Expression(), 0, 100);
+        };
+        this.search$ = (expression, skip, count) => {
+            let params = new HttpParams();
+            params = params.set('skip', '' + skip);
+            params = params.set('count', '' + count);
+            return this.baseHttpService.api({ method: 'post', url: `${this.serviceUrl}/search`, params, body: expression });
+        };
+        this.create$ = (ruleGroup) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}`,
+                method: 'post',
+                body: ruleGroup,
+            });
+        };
+        this.update$ = (ruleGroup) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${ruleGroup.id}`,
+                method: 'post',
+                body: ruleGroup,
+            });
+        };
+        this.duplicate$ = (body) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.serviceUrl}/${body.id}/clone`,
+                method: 'post',
+                body,
+            })
+                .pipe(map$1(response => response.clonedRecordId));
+        };
+        this.remove$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restore$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+    }
+}
+FunctionGroupsAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FunctionGroupsAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+FunctionGroupsAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FunctionGroupsAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FunctionGroupsAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class FunctionsAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/v2/functions/rules';
+        this.fetchAll$ = () => {
+            return this.search$(new Expression(), 0, 100);
+        };
+        this.search$ = (expression, skip, count) => {
+            let params = new HttpParams();
+            if (typeof skip === 'number') {
+                params = params.set('skip', '' + skip);
+            }
+            if (typeof count === 'number') {
+                params = params.set('count', '' + count);
+            }
+            return this.baseHttpService.api({ method: 'post', url: `${this.serviceUrl}/search`, params, body: expression });
+        };
+        this.create$ = (rule) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}`,
+                method: 'post',
+                body: rule,
+            });
+        };
+        this.update$ = (rule) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${rule.id}`,
+                method: 'put',
+                body: rule,
+            });
+        };
+        this.duplicate$ = (body) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.serviceUrl}/${body.id}/clone`,
+                method: 'post',
+                body,
+            })
+                .pipe(map$1(response => response.clonedRecordId));
+        };
+        this.remove$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restore$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+    }
+    fetch$(id) {
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}/${id}`,
+            method: 'get',
+        });
+    }
+    fetchHeaderFields$() {
+        return this.baseHttpService.api({
+            url: `${this.serviceUrl}/describe/Header`,
+            method: 'get',
+        });
+    }
+    execute$(body) {
+        const url = this.getExecuteRuleUrl(body.rule.ruleGroupType);
+        return this.baseHttpService.api({
+            url,
+            method: 'post',
+            body,
+        });
+    }
+    executeExtractFunction$(body) {
+        return this.baseHttpService.api({
+            url: '/admin/v2/functions/extract',
+            method: 'post',
+            body,
+        });
+    }
+    fetchFunctionDatasets$() {
+        return this.baseHttpService.api({
+            url: '/admin/v2/functions/datasets',
+            method: 'get',
+        });
+    }
+    getExecuteRuleUrl(ruleGroupType) {
+        switch (ruleGroupType) {
+            case RuleGroupTypes.eligibility:
+                return `${this.serviceUrl}/eligibility/execute`;
+            case RuleGroupTypes.rlmContextBased:
+            case RuleGroupTypes.generalContextBased:
+                return `${this.serviceUrl}/execute`;
+            default:
+                return `${this.serviceUrl}/legacy/execute`;
+        }
+    }
+}
+FunctionsAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FunctionsAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+FunctionsAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FunctionsAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FunctionsAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class GuidedSellingsAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/v2/guided-selling';
+        this.fetchGuidedSellings$ = (searchParams) => {
+            return this.searchGuidedSellings$(searchParams);
+        };
+        this.searchGuidedSellings$ = (searchParams, expression) => {
+            const params = new HttpParams({ fromObject: { ...searchParams } });
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/search`,
+                params,
+                body: expression || {},
+            });
+        };
+        this.fetchGuidedSelling$ = (id) => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}/${id}` });
+        };
+        this.createNewGuidedSelling$ = (guidedSelling) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}`,
+                method: 'post',
+                body: guidedSelling,
+            });
+        };
+        this.duplicateGuidedSelling$ = (cloneRequest) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${cloneRequest.id}/clone`,
+                method: 'post',
+                body: cloneRequest,
+            });
+        };
+        this.updateGuidedSelling$ = (data) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${data.id}`,
+                method: 'put',
+                body: data,
+            });
+        };
+        this.removeGuidedSelling$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreGuidedSelling$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+    }
+}
+GuidedSellingsAdminApiService.MAX_RESULTS = 60;
+GuidedSellingsAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: GuidedSellingsAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+GuidedSellingsAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: GuidedSellingsAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: GuidedSellingsAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class GuidedSellingApiService {
+    constructor(http) {
+        this.http = http;
+        this.serviceUrl = '/v2/guided-selling';
+    }
+    searchByName$(name, searchParams) {
+        const params = new HttpParams({ fromObject: { ...searchParams } });
+        const expression = new Expression(undefined, [{ key: 'name', operator: Operator.EQ, value: name }]);
+        return this.http.api({
+            method: 'post',
+            url: `${this.serviceUrl}/search`,
+            params,
+            body: expression || {},
+        });
+    }
+    searchById$(id, searchParams) {
+        const params = new HttpParams({ fromObject: { ...searchParams } });
+        const expression = new Expression(undefined, [{ key: 'id', operator: Operator.EQ, value: id }]);
+        return this.http.api({
+            method: 'post',
+            url: `${this.serviceUrl}/search`,
+            params,
+            body: expression || {},
+        });
+    }
+}
+GuidedSellingApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: GuidedSellingApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+GuidedSellingApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: GuidedSellingApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: GuidedSellingApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class OrchestrationsAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.SERVICE_URL = '/admin/v2/orchestrations';
+        this.fetchAll$ = () => {
+            return this.search$(new Expression(), 0, 100);
+        };
+        this.search$ = (expression, skip, count) => {
+            let params = new HttpParams();
+            params = params.set('skip', '' + skip);
+            params = params.set('count', '' + count);
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.SERVICE_URL}/search`,
+                params,
+                body: expression,
+            });
+        };
+        this.create$ = (newProcedure) => {
+            return this.baseHttpService.api({
+                url: `${this.SERVICE_URL}`,
+                method: 'post',
+                body: newProcedure,
+            });
+        };
+        this.update$ = (procedure) => {
+            return this.baseHttpService.api({
+                url: `${this.SERVICE_URL}/${procedure.id}`,
+                method: 'put',
+                body: procedure,
+            });
+        };
+        this.duplicate$ = (body) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.SERVICE_URL}/${body.id}/clone`,
+                method: 'post',
+                body,
+            })
+                .pipe(map$1(response => response.clonedRecordId));
+        };
+        this.remove$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.SERVICE_URL}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restore$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.SERVICE_URL}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+    }
+    fetch$(id) {
+        return this.baseHttpService.api({
+            url: `${this.SERVICE_URL}/${id}`,
+            method: 'get',
+        });
+    }
+    execute$(body) {
+        return this.baseHttpService.api({
+            url: `${this.SERVICE_URL}/execute`,
+            method: 'post',
+            body,
+        });
+    }
+    catalogExecute$(body) {
+        return this.baseHttpService.api({
+            url: `${this.SERVICE_URL}/catalog/execute`,
+            method: 'post',
+            body,
+        });
+    }
+}
+OrchestrationsAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OrchestrationsAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+OrchestrationsAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OrchestrationsAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OrchestrationsAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class OrchestrationsApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.SERVICE_URL = '/v2/orchestrations';
+    }
+    apply$(request, options) {
+        return this.baseHttpService.api({
+            url: `${this.SERVICE_URL}/apply`,
+            method: 'post',
+            body: request,
+            ...options,
+        });
+    }
+}
+OrchestrationsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OrchestrationsApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+OrchestrationsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OrchestrationsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OrchestrationsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class SalesforceApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/v2/proxy';
+    }
+    query(searchRequest, objectName, options) {
+        return this.httpService.api({
+            method: 'post',
+            body: { ...searchRequest, count: searchRequest.count || 100 },
+            url: `${this.SERVICE_URL}/query/${objectName}`,
+            ...options,
+        });
+    }
+    queryObjects(search, options) {
+        let params = new HttpParams();
+        if (search) {
+            params = params.append('search', search);
+        }
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/query`,
+            params,
+            ...options,
+        });
+    }
+    search(req, options) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/rest/search`,
+            params: { q: req.searchString },
+            ...options,
+        });
+    }
+    describeObject(objectName, options) {
+        const methodUrl = `${this.SERVICE_URL}/describe/${objectName}/fields`;
+        return this.httpService.api({ url: methodUrl, ...options });
+    }
+    describeField(objectName, fieldName, options) {
+        const methodUrl = `${this.SERVICE_URL}/describe/${objectName}/fields/${fieldName}`;
+        return this.httpService.api({ url: methodUrl, ...options });
+    }
+    describe2(objectName, fields, options) {
+        const methodUrl = `${this.SERVICE_URL}/describe/${objectName}/fields`;
+        return this.httpService.api({ method: 'post', url: methodUrl, body: fields, ...options });
+    }
+    apexGetRequest(path, params, options) {
+        // this line is needed because HttpParams instance from Integration behaves wrong in studio instance of Angular
+        const httpParams = new HttpParams({ fromString: params.toString() });
+        return this.httpService.api({ url: `${this.SERVICE_URL}/apex${path}`, params: httpParams, ...options });
+    }
+    apexPostRequest(path, body, options) {
+        return this.httpService.api({
+            method: 'post',
+            body,
+            url: `${this.SERVICE_URL}/apex${path}`,
+            ...options,
+        });
+    }
+    restGetRequest(path, params, options) {
+        const httpParams = new HttpParams({ fromString: params.toString() });
+        return this.httpService.api({ url: `${this.SERVICE_URL}/rest${path}`, params: httpParams, ...options });
+    }
+    getGlobalPicklists() {
+        return this.httpService.api({
+            method: 'get',
+            url: `${this.SERVICE_URL}/globalvalueset`,
+        });
+    }
+    getGlobalPicklistValues(id) {
+        return this.httpService.api({
+            method: 'get',
+            url: `${this.SERVICE_URL}/globalvalueset/${id}/values`,
+        });
+    }
+}
+SalesforceApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SalesforceApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+SalesforceApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SalesforceApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SalesforceApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class PCMApiService {
+    constructor(sfApiService) {
+        this.sfApiService = sfApiService;
+    }
+    fetchPCMByProductId(productId) {
+        return this.sfApiService.restGetRequest(`/connect/pcm/products/${productId}`, new HttpParams()).pipe(tap$1(response => {
+            if (response.status.code !== '200') {
+                throw new Error(response.status.message);
+            }
+        }), map$1(response => {
+            const pcm = response.products[0];
+            if (!pcm) {
+                throw new Error('PCM product is not found');
+            }
+            return pcm;
+        }));
+    }
+}
+PCMApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PCMApiService, deps: [{ token: SalesforceApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+PCMApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PCMApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PCMApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: SalesforceApiService }]; } });
+
+class PicklistsAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/v2/picklists';
+        this.fetchAllPicklists$ = () => this.baseHttpService.api({ url: `${this.serviceUrl}` });
+        this.fetchPicklist$ = (code) => this.baseHttpService.api({ url: `${this.serviceUrl}/${code}` });
+        this.createPicklist$ = (picklist) => {
+            return this.baseHttpService.api({ method: 'post', url: `${this.serviceUrl}`, body: picklist });
+        };
+        this.updatePicklist$ = (picklist) => {
+            return this.baseHttpService.api({
+                method: 'put',
+                url: `${this.serviceUrl}/${picklist.id}`,
+                body: picklist,
+            });
+        };
+        this.removePicklist$ = (id) => this.baseHttpService.api({ method: 'delete', url: `${this.serviceUrl}/${id}` });
+        this.restorePicklist$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+        this.addPicklistValue$ = (picklist, value) => {
+            const data = {
+                ...picklist,
+                values: [...picklist.values, value],
+            };
+            return this.baseHttpService.api({ method: 'put', url: `${this.serviceUrl}/${picklist.id}`, body: data });
+        };
+    }
+}
+PicklistsAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PicklistsAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+PicklistsAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PicklistsAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PicklistsAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ProductsAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/v2/products';
+        this.fetchProducts$ = (payload) => {
+            let params = new HttpParams();
+            params = params.append('count', payload.count);
+            params = params.append('skip', payload.skip);
+            if (payload.name) {
+                params = params.append('name', payload.name);
+            }
+            return this.baseHttpService.api({ url: `${this.serviceUrl}`, params });
+        };
+        this.searchProducts$ = (expression, skip, count) => {
+            let params = new HttpParams();
+            params = params.set('skip', '' + skip);
+            params = params.set('count', '' + count);
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/search`,
+                params: params,
+                body: expression,
+            });
+        };
+        this.fetchProduct$ = (id) => this.baseHttpService.api({ url: `${this.serviceUrl}/${id}` });
+        this.createNewProduct$ = (productData) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}`,
+                method: 'post',
+                body: productData,
+            });
+        };
+        this.updateProduct$ = (body) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${body.id}`,
+                method: 'put',
+                body,
+            });
+        };
+        this.removeProduct$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreProduct$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+    }
+    attachImage$(productId, file) {
+        const data = new FormData();
+        data.append('image', file);
+        return this.baseHttpService.upload({
+            method: 'post',
+            url: `${this.serviceUrl}/${productId}/image`,
+            body: data,
+        });
+    }
+    removeImage$(productId) {
+        return this.baseHttpService.api({
+            method: 'delete',
+            url: `${this.serviceUrl}/${productId}/image`,
+        });
+    }
+    fetchImage$(productId) {
+        return this.baseHttpService.api({
+            url: this.getImageUrl(productId),
+            method: 'get',
+            responseType: 'blob',
+            errorHandler: noop,
+        });
+    }
+    getImageUrl(productId) {
+        return `${this.serviceUrl}/${productId}/image`;
+    }
+}
+ProductsAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProductsAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductsAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProductsAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProductsAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class SalesTransactionApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/v2/transactions';
+    }
+    /**
+     * This endpoint doesn't include orders and assets
+     * @param objectId SF record ID (quoteId | accountId | opportunityId | orderId etc)
+     * @param params Query params
+     * @param options Request options
+     */
+    getState(objectId, params, options) {
+        return this.httpService.api({
+            method: 'get',
+            url: `${this.SERVICE_URL}/${objectId}`,
+            params: params,
+            ...options,
+        });
+    }
+    upsert(request, options) {
+        return of({
+            id: 'ID',
+        });
+        // return this.httpService.api({
+        //   method: 'post',
+        //   url: `${this.SERVICE_URL}`,
+        //   body: request,
+        //   ...options,
+        // });
+    }
+    submit(request, options) {
+        return of({
+            id: 'ID',
+        });
+        // return this.httpService.api({
+        //   method: 'post',
+        //   url: `${this.SERVICE_URL}`,
+        //   body: request,
+        //   ...options,
+        // });
+    }
+}
+SalesTransactionApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SalesTransactionApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+SalesTransactionApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SalesTransactionApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SalesTransactionApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ShoppingCartSettingsApiService {
+    constructor(configurationSettingsApiService) {
+        this.configurationSettingsApiService = configurationSettingsApiService;
+        this.shoppingCartSettingsKey = 'shopping-cart';
+    }
+    getSetting(id) {
+        return this.fetchSettings().pipe(map((settings) => parseJsonSafely(settings?.value, [])), map(settings => settings.find(setting => setting.id == id)));
+    }
+    fetchSettings() {
+        return this.configurationSettingsApiService.fetchSetting(this.shoppingCartSettingsKey, { skipErrorHandler: true });
+    }
+    getSettingsMap() {
+        return this.fetchSettings().pipe(map((settings) => parseJsonSafely(settings?.value, [])), map((settings) => settings.reduce((acc, setting) => {
+            return { ...acc, [setting.id]: setting.properties };
+        }, {})));
+    }
+}
+ShoppingCartSettingsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ShoppingCartSettingsApiService, deps: [{ token: ConfigurationSettingsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ShoppingCartSettingsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ShoppingCartSettingsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ShoppingCartSettingsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: ConfigurationSettingsApiService }]; } });
+
+function uiDefinitionFromDTO(container) {
+    const { sourceBlob, ...rest } = container;
+    return {
+        ...rest,
+        source: parseJsonStringAsObject(sourceBlob),
+    };
+}
+function uiDefinitionToDTO(container) {
+    const { source, ...rest } = container;
+    return {
+        ...rest,
+        sourceBlob: JSON.stringify(source),
+    };
+}
+function newUiDefinitionToDTO(container) {
+    const { source, ...rest } = container;
+    return {
+        ...rest,
+        sourceBlob: JSON.stringify(source),
+    };
+}
+
+class UIDefinitionsAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/v2/uidefinitions';
+    }
+    fetchAll$(params) {
+        let httpParams = new HttpParams();
+        if (params?.productId != null) {
+            httpParams = httpParams.set('productId', params.productId);
+        }
+        if (params?.defaultUIDefinitionId != null) {
+            httpParams = httpParams.set('defaultUIDefinitionId', params.defaultUIDefinitionId);
+        }
+        return this.baseHttpService
+            .api({
+            method: 'get',
+            url: this.serviceUrl,
+            params: httpParams,
+        })
+            .pipe(map$1(containers => containers.map(uiDefinitionFromDTO)));
+    }
+    fetch$(id) {
+        return this.baseHttpService
+            .api({
+            method: 'get',
+            url: `${this.serviceUrl}/${id}`,
+        })
+            .pipe(map$1(container => uiDefinitionFromDTO({ ...container, id })));
+    }
+    create$(uiDefinitionContainer) {
+        const dto = newUiDefinitionToDTO(uiDefinitionContainer);
+        return this.baseHttpService
+            .api({
+            method: 'post',
+            url: this.serviceUrl,
+            body: dto,
+        })
+            .pipe(map$1(container => uiDefinitionFromDTO(container)));
+    }
+    update$(uiDefinitionContainer) {
+        const dto = uiDefinitionToDTO(uiDefinitionContainer);
+        return this.baseHttpService
+            .api({
+            method: 'put',
+            url: `${this.serviceUrl}/${uiDefinitionContainer.id}`,
+            body: dto,
+        })
+            .pipe(map$1(container => uiDefinitionFromDTO(container)));
+    }
+    delete$(id) {
+        return this.baseHttpService.api({
+            method: 'delete',
+            url: `${this.serviceUrl}/${id}`,
+        });
+    }
+}
+UIDefinitionsAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UIDefinitionsAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+UIDefinitionsAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UIDefinitionsAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UIDefinitionsAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+const fromUIComponentStoryDTO = (dto, attachments) => {
+    return {
+        id: dto.id,
+        name: dto.name,
+        uiComponentId: dto.uiComponentId,
+        description: dto.description,
+        section: attachments.json,
+        template: attachments.html,
+        script: attachments.js,
+        styles: attachments.css,
+    };
+};
+
+class UITemplatesAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/v2/uitemplates';
+        this.fetchTemplates$ = (name) => {
+            let params = new HttpParams();
+            if (name) {
+                params = params.append('name', name);
+            }
+            return this.baseHttpService.api({ url: `${this.serviceUrl}`, params });
+        };
+        this.createTemplate$ = (template) => {
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}`,
+                body: template,
+            });
+        };
+        this.updateTemplate$ = (template) => {
+            return this.baseHttpService.api({
+                method: 'put',
+                url: `${this.serviceUrl}/${template.id}`,
+                body: template,
+            });
+        };
+        this.duplicateTemplate$ = (template, cloneRequest) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.serviceUrl}/${template.id}/clone`,
+                method: 'post',
+                body: cloneRequest,
+            })
+                .pipe(map$1(response => response.clonedRecordId));
+        };
+        this.removeTemplate$ = (id) => {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: `${this.serviceUrl}/${id}`,
+            });
+        };
+        this.restoreTemplate$ = (id) => {
+            return this.baseHttpService.api({
+                method: 'patch',
+                url: `${this.serviceUrl}/${id}`,
+            });
+        };
+        this.searchTemplates$ = (data) => {
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/search`,
+                params: data.params,
+                body: data.expression,
+            });
+        };
+        this.fetchComponents$ = (templateId, name) => {
+            let params = new HttpParams();
+            if (name) {
+                params = params.append('name', name);
+            }
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${templateId}/components`,
+                params,
+            });
+        };
+        this.fetchComponent$ = (templateId, componentId) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}`,
+            });
+        };
+        this.createComponent$ = (component) => {
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/${component.uiTemplateId}/components`,
+                body: component,
+            });
+        };
+        this.updateComponent$ = (component) => {
+            return this.baseHttpService.api({
+                method: 'put',
+                url: `${this.serviceUrl}/${component.uiTemplateId}/components/${component.id}`,
+                body: component,
+            });
+        };
+        this.duplicateComponent$ = (component, cloneRequest) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.serviceUrl}/${component.uiTemplateId}/components/${component.id}/clone`,
+                method: 'post',
+                body: cloneRequest,
+            })
+                .pipe(map$1(response => response.clonedRecordId));
+        };
+        this.removeComponent$ = (templateId, componentId) => {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}`,
+            });
+        };
+        this.restoreComponent$ = (templateId, componentId) => {
+            return this.baseHttpService.api({
+                method: 'patch',
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}`,
+            });
+        };
+        this.searchComponents$ = (templateId, data) => {
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/${templateId}/components/search`,
+                params: data.params,
+                body: data.expression,
+            });
+        };
+        this.fetchStoryAttachment = (templateId, componentId, storyId, type) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}/stories/${storyId}/attachments/${type}/file`,
+                responseType: 'text',
+                errorHandler: noop,
+            })
+                .pipe(catchError$1(() => of('')));
+        };
+        this.convertToComponentStory$ = (templateId, componentId, storyDto) => {
+            return forkJoin([
+                this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'html'),
+                this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'js'),
+                this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'css'),
+                this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'json'),
+            ]).pipe(map$1(([html, js, css, json]) => ({ html, js, css, json })), map$1(attachments => fromUIComponentStoryDTO(storyDto, attachments)));
+        };
+        this.fetchStories$ = (templateId, componentId, name) => {
+            let params = new HttpParams();
+            if (name) {
+                params = params.append('name', name);
+            }
+            return this.baseHttpService
+                .api({
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}/stories`,
+                params,
+            })
+                .pipe(switchMap(dtos => {
+                if (!dtos.length) {
+                    return of([]);
+                }
+                return forkJoin(dtos.map(dto => this.convertToComponentStory$(templateId, componentId, dto)));
+            }));
+        };
+        this.fetchStory$ = (templateId, componentId, storyId) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}/stories/${storyId}`,
+            })
+                .pipe(switchMap(dto => this.convertToComponentStory$(templateId, componentId, dto)));
+        };
+        this.createComponentStory$ = (templateId, story) => {
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/${templateId}/components/${story.uiComponentId}/stories`,
+                body: story,
+            });
+        };
+        this.updateComponentStory$ = (templateId, story) => {
+            const { script, template, styles, section, ...rest } = story;
+            return this.baseHttpService
+                .api({
+                method: 'put',
+                url: `${this.serviceUrl}/${templateId}/components/${story.uiComponentId}/stories/${story.id}`,
+                body: rest,
+            })
+                .pipe(map$1(dto => fromUIComponentStoryDTO(dto, { html: template, js: script, css: styles, json: section })));
+        };
+        this.duplicateComponentStory$ = (story, cloneRequest) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.serviceUrl}/${story.template}/components/${story.uiComponentId}/stories/${story.id}/clone`,
+                method: 'post',
+                body: cloneRequest,
+            })
+                .pipe(map$1(response => response.clonedRecordId));
+        };
+        this.deleteComponentStory$ = (templateId, componentId, storyId) => {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}/stories/${storyId}`,
+            });
+        };
+        this.restoreComponentStory$ = (templateId, componentId, storyId) => {
+            return this.baseHttpService.api({
+                method: 'patch',
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}/stories/${storyId}`,
+            });
+        };
+        this.uploadStoryAttachments$ = (templateId, componentId, storyId, attachments) => {
+            const formData = new FormData();
+            if (attachments.html != null) {
+                formData.append('html', new Blob([attachments.html]), 'story-template.html');
+            }
+            if (attachments.css != null) {
+                formData.append('css', new Blob([attachments.css]), 'story-styles.css');
+            }
+            if (attachments.js != null) {
+                formData.append('js', new Blob([attachments.js]), 'story-script.js');
+            }
+            if (attachments.json != null) {
+                formData.append('json', new Blob([attachments.json]), 'story-section.json');
+            }
+            return this.baseHttpService.upload({
+                method: 'post',
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}/stories/${storyId}/attachments`,
+                body: formData,
+            });
+        };
+        this.fetchComponentAttachments$ = (templateId, component) => {
+            return forkJoin([
+                this.fetchComponentAttachmentFile$(templateId, component.id, 'html'),
+                this.fetchComponentAttachmentFile$(templateId, component.id, 'js'),
+                this.fetchComponentAttachmentFile$(templateId, component.id, 'css'),
+                this.fetchComponentAttachmentFile$(templateId, component.id, 'json'),
+            ]).pipe(map$1(([html, js, css, json]) => ({ html, js, css, json })));
+        };
+        this.fetchComponentsAttachments$ = (templateId) => {
+            return this.fetchComponents$(templateId).pipe(switchMap(components => {
+                return forkJoin(components.map(component => this.fetchComponentAttachments$(templateId, component)));
+            }));
+        };
+        this.fetchComponentAttachmentFile$ = (templateId, componentId, attachmentType) => {
+            return this.baseHttpService
+                .api({
+                method: 'get',
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}/attachments/${attachmentType}/file`,
+                responseType: 'text',
+                errorHandler: noop,
+            })
+                .pipe(catchError$1(() => of('')));
+        };
+        this.uploadComponentAttachments$ = (templateId, componentId, attachments) => {
+            const formData = new FormData();
+            if (attachments.html != null) {
+                formData.append('html', new Blob([attachments.html]), 'template.html');
+            }
+            if (attachments.css != null) {
+                formData.append('css', new Blob([attachments.css]), 'styles.css');
+            }
+            if (attachments.js != null) {
+                formData.append('js', new Blob([attachments.js]), 'script.js');
+            }
+            if (attachments.json != null) {
+                formData.append('json', new Blob([attachments.json]), 'section.json');
+            }
+            return this.baseHttpService.upload({
+                method: 'post',
+                url: `${this.serviceUrl}/${templateId}/components/${componentId}/attachments`,
+                body: formData,
+            });
+        };
+    }
+    getTemplateThumbnailUrl(templateId) {
+        return `${this.serviceUrl}/${templateId}/thumbnail/file`;
+    }
+    attachTemplateThumbnail$(templateId, file) {
+        const data = new FormData();
+        data.append('thumb', file);
+        return this.baseHttpService.upload({
+            method: 'post',
+            url: `${this.serviceUrl}/${templateId}/thumbnail`,
+            body: data,
+        });
+    }
+    removeTemplateThumbnail$(templateId) {
+        return this.baseHttpService.api({
+            method: 'delete',
+            url: `${this.serviceUrl}/${templateId}/thumbnail`,
+        });
+    }
+}
+UITemplatesAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UITemplatesAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+UITemplatesAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UITemplatesAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UITemplatesAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class VeloceObjectsAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/v2/veloceobjects';
+        this.updateCategory$ = (category) => {
+            return this.baseHttpService.api({
+                method: 'put',
+                url: `${this.serviceUrl}/categories/${category.id}`,
+                body: category,
+            });
+        };
+        this.deleteCategory$ = (id) => {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: `${this.serviceUrl}/categories/${id}`,
+            });
+        };
+        this.searchObjects$ = (searchParams, expression) => {
+            const params = new HttpParams({ fromObject: { ...searchParams } });
+            return this.baseHttpService.api({
+                method: 'post',
+                url: `${this.serviceUrl}/search`,
+                params,
+                body: expression || {},
+            });
+        };
+        this.deleteObject$ = (id) => {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: `${this.serviceUrl}/${id}`,
+            });
+        };
+        this.duplicateObject$ = (body) => {
+            return this.baseHttpService
+                .api({
+                method: 'post',
+                url: `${this.serviceUrl}/${body.id}/clone`,
+                body,
+            })
+                .pipe(map(response => response.clonedRecordId));
+        };
+        this.restoreObject$ = (id) => {
+            return this.baseHttpService.api({
+                method: 'patch',
+                url: `${this.serviceUrl}/${id}/restore`,
+            });
+        };
+    }
+    fetchCategories$() {
+        return this.baseHttpService.api({ url: `${this.serviceUrl}/categories` });
+    }
+    createCategory$(category) {
+        return this.baseHttpService.api({
+            method: 'post',
+            url: `${this.serviceUrl}/categories`,
+            body: category,
+        });
+    }
+    fetchObjects$() {
+        return this.baseHttpService.api({ url: `${this.serviceUrl}` });
+    }
+    fetchObject$(id) {
+        return this.baseHttpService.api({ url: `${this.serviceUrl}/${id}` });
+    }
+    createObject$(object) {
+        return this.baseHttpService.api({
+            method: 'post',
+            url: `${this.serviceUrl}`,
+            body: object,
+        });
+    }
+    updateObject$(object) {
+        return this.baseHttpService.api({
+            method: 'put',
+            url: `${this.serviceUrl}/${object.id}`,
+            body: object,
+        });
+    }
+}
+VeloceObjectsAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: VeloceObjectsAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+VeloceObjectsAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: VeloceObjectsAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: VeloceObjectsAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ApiV2Module {
+}
+ApiV2Module.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ApiV2Module, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ApiV2Module.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: ApiV2Module, imports: [HttpClientModule] });
+ApiV2Module.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ApiV2Module, providers: [
+        BaseHttpService,
+        CacheApiService,
+        CatalogAdminApiService,
+        CatalogApiService,
+        ConfigurationProcessorsApiService,
+        ConfigurationSettingsApiService,
+        ContextDefinitionAdminApiService,
+        DocumentAttachmentApiService,
+        EndpointsAdminApiService,
+        FlowsApiService,
+        FunctionGroupsAdminApiService,
+        OrchestrationsAdminApiService,
+        OrchestrationsApiService,
+        PCMApiService,
+        PicklistsAdminApiService,
+        ProductsAdminApiService,
+        FunctionsAdminApiService,
+        GuidedSellingsAdminApiService,
+        GuidedSellingApiService,
+        SalesforceApiService,
+        SalesTransactionApiService,
+        ShoppingCartSettingsApiService,
+        UIDefinitionsAdminApiService,
+        UITemplatesAdminApiService,
+        VeloceObjectsAdminApiService,
+        XrayService,
+    ], imports: [HttpClientModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ApiV2Module, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [HttpClientModule],
+                    providers: [
+                        BaseHttpService,
+                        CacheApiService,
+                        CatalogAdminApiService,
+                        CatalogApiService,
+                        ConfigurationProcessorsApiService,
+                        ConfigurationSettingsApiService,
+                        ContextDefinitionAdminApiService,
+                        DocumentAttachmentApiService,
+                        EndpointsAdminApiService,
+                        FlowsApiService,
+                        FunctionGroupsAdminApiService,
+                        OrchestrationsAdminApiService,
+                        OrchestrationsApiService,
+                        PCMApiService,
+                        PicklistsAdminApiService,
+                        ProductsAdminApiService,
+                        FunctionsAdminApiService,
+                        GuidedSellingsAdminApiService,
+                        GuidedSellingApiService,
+                        SalesforceApiService,
+                        SalesTransactionApiService,
+                        ShoppingCartSettingsApiService,
+                        UIDefinitionsAdminApiService,
+                        UITemplatesAdminApiService,
+                        VeloceObjectsAdminApiService,
+                        XrayService,
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ApiV2Module, CacheApiService, CatalogAdminApiService, CatalogApiService, ConfigurationProcessorsApiService, ConfigurationSettingsApiService, ContextDefinitionAdminApiService, DocumentAttachmentApiService, EndpointsAdminApiService, FlowsApiService, FunctionGroupsAdminApiService, FunctionsAdminApiService, GuidedSellingApiService, GuidedSellingsAdminApiService, OrchestrationsAdminApiService, OrchestrationsApiService, PCMApiService, PicklistsAdminApiService, ProductsAdminApiService, SalesTransactionApiService, SalesforceApiService, ShoppingCartSettingsApiService, UIDefinitionsAdminApiService, UITemplatesAdminApiService, VeloceObjectsAdminApiService };
+//# sourceMappingURL=veloceapps-api-v2.mjs.map