@veloceapps/api 4.0.21-0

package/fesm2015/veloceapps-api.js

@@ -0,0 +1,2420 @@
+import * as i4 from '@angular/common/http';
+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 { ModelTranslatorUtils, ConfigurationContextMode, isLegacyDocumentTemplate, DocxTemplater, QuoteDraft, StringUtils, Expression, ProductModelsContainer, ModelUtils, EntityUtil, BaseHttpService, XrayService } from '@veloceapps/core';
+import { throwError, of, map as map$1, zip, forkJoin, noop, catchError as catchError$1, switchMap as switchMap$1 } from 'rxjs';
+import { map, catchError, tap, switchMap, defaultIfEmpty } from 'rxjs/operators';
+import * as _ from 'lodash';
+import { transform } from 'lodash';
+import { CurrencyPipe } from '@angular/common';
+import * as moment_ from 'moment';
+import { __rest } from 'tslib';
+
+class AccountApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/accounts';
+    }
+    getAccounts$(options) {
+        return this.httpService.api(Object.assign({ method: 'get', url: `${this.SERVICE_URL}` }, options));
+    }
+    searchAccounts$(searchParams, options) {
+        const params = new HttpParams({ fromObject: searchParams });
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}`, params: params }, options));
+    }
+    getAccount$(id, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${id}` }, options));
+    }
+    getAssets(accountId, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${accountId}/assets` }, options));
+    }
+    getOrders(accountId, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${accountId}/orders` }, options));
+    }
+    getQuotes(accountId, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${accountId}/quotes` }, options));
+    }
+    getAsset(accountId, assetId, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${accountId}/assets/${assetId}` }, options));
+    }
+    getOrder(accountId, orderId, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${accountId}/orders/${orderId}` }, options));
+    }
+    getQuote(accountId, quoteId, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${accountId}/quotes/${quoteId}` }, options));
+    }
+    quoteToOrder(accountId, quoteId, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${accountId}/quotes/${quoteId}/to-order`, method: 'post', body: { id: quoteId } }, options));
+    }
+    orderToAsset(accountId, orderId, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${accountId}/orders/${orderId}/to-asset`, method: 'post', body: { id: orderId } }, options));
+    }
+}
+AccountApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AccountApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+AccountApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AccountApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AccountApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class CatalogAdminApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/catalogs';
+        this.fetchCatalogs$ = (searchParams) => {
+            const params = new HttpParams({ fromObject: Object.assign({}, searchParams) });
+            return this.baseHttpService.api({ url: `${this.serviceUrl}`, params });
+        };
+        this.searchCatalogs$ = (searchParams, expression) => {
+            const params = new HttpParams({ fromObject: Object.assign({}, 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: Object.assign({}, 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.removeProduct$ = ({ catalogId, categoryId, data }) => {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: `${this.serviceUrl}/${catalogId}/categories/${categoryId}/products/${data.id}`,
+                body: data,
+            });
+        };
+    }
+}
+CatalogAdminApiService.MAX_RESULTS = 60;
+CatalogAdminApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CatalogAdminApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+CatalogAdminApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CatalogAdminApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CatalogAdminApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class CatalogApiService {
+    constructor(service) {
+        this.service = service;
+        this.serviceUrl = '/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, searchCriteria, 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: { searchCriteria },
+            },
+        });
+    }
+    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: "12.2.17", ngImport: i0, type: CatalogApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+CatalogApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CatalogApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CatalogApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class AttributeDTO {
+    constructor(name, type, value, cfgStatus, id, scale) {
+        this.name = name;
+        this.type = type;
+        this.value = value;
+        this.cfgStatus = cfgStatus;
+        this.id = id;
+        this.scale = scale;
+    }
+    static fromDTO(dto) {
+        return {
+            id: dto.id,
+            name: dto.name,
+            type: dto.type,
+            scale: dto.scale,
+            value: dto.value,
+            cfgStatus: dto.cfgStatus,
+        };
+    }
+}
+
+class PriceAdjustmentDTO {
+    constructor(amount, explanation, type) {
+        this.amount = amount;
+        this.explanation = explanation;
+        this.type = type;
+    }
+    static fromDTO(dto) {
+        return {
+            amount: dto.amount,
+            explanation: dto.explanation,
+            type: dto.type,
+        };
+    }
+}
+
+class ChargeGroupItemDTO {
+    constructor(chargeType, chargeMethod, properties, id, chargeTypeDisplayValue, frequencyUnit, frequencyDuration, basePrice, currency, sellingTerm, netPrice, listPrice, netUnitPrice, listUnitPrice, cost, priceAdjustment, priceWaterfalls, priceAdjustmentEnabled, listPriceAdjustmentEnabled) {
+        this.chargeType = chargeType;
+        this.chargeMethod = chargeMethod;
+        this.properties = properties;
+        this.id = id;
+        this.chargeTypeDisplayValue = chargeTypeDisplayValue;
+        this.frequencyUnit = frequencyUnit;
+        this.frequencyDuration = frequencyDuration;
+        this.basePrice = basePrice;
+        this.currency = currency;
+        this.sellingTerm = sellingTerm;
+        this.netPrice = netPrice;
+        this.listPrice = listPrice;
+        this.netUnitPrice = netUnitPrice;
+        this.listUnitPrice = listUnitPrice;
+        this.cost = cost;
+        this.priceAdjustment = priceAdjustment;
+        this.priceWaterfalls = priceWaterfalls;
+        this.priceAdjustmentEnabled = priceAdjustmentEnabled;
+        this.listPriceAdjustmentEnabled = listPriceAdjustmentEnabled;
+    }
+    static fromDTO(dto) {
+        var _a;
+        return {
+            id: dto.id,
+            chargeType: dto.chargeType,
+            chargeTypeDisplayValue: dto.chargeTypeDisplayValue,
+            chargeMethod: dto.chargeMethod,
+            frequencyUnit: dto.frequencyUnit,
+            frequencyDuration: dto.frequencyDuration,
+            basePrice: dto.basePrice,
+            currency: dto.currency,
+            sellingTerm: dto.sellingTerm,
+            netPrice: dto.netPrice,
+            listPrice: dto.listPrice,
+            netUnitPrice: dto.netUnitPrice,
+            listUnitPrice: dto.listUnitPrice,
+            cost: dto.cost,
+            priceAdjustment: dto.priceAdjustment && PriceAdjustmentDTO.fromDTO(dto.priceAdjustment),
+            priceWaterfalls: (_a = dto.priceWaterfalls) === null || _a === void 0 ? void 0 : _a.map(PriceAdjustmentDTO.fromDTO),
+            priceAdjustmentEnabled: dto.priceAdjustmentEnabled,
+            listPriceAdjustmentEnabled: dto.listPriceAdjustmentEnabled,
+            properties: dto.properties,
+        };
+    }
+}
+
+class ChargeItemDTO {
+    constructor(id, price, unitPrice, baseListPrice, baseListUnitPrice, listPrice, listUnitPrice, netPrice, previousNetPrice, netUnitPrice, chargeId, chargeType, chargeMethod, priceItemId, startDate, priceWaterfalls, quantity, properties, chargeTypeDisplayValue, arr, frequencyUnit, frequencyDuration, endDate, sellingTerm, currency, unitCost, cost, minUnitPrice, minPrice, enablePriceAdjustment, enableListPriceAdjustment, listPriceAdjustment, priceAdjustment, requiresApprovals) {
+        this.id = id;
+        this.price = price;
+        this.unitPrice = unitPrice;
+        this.baseListPrice = baseListPrice;
+        this.baseListUnitPrice = baseListUnitPrice;
+        this.listPrice = listPrice;
+        this.listUnitPrice = listUnitPrice;
+        this.netPrice = netPrice;
+        this.previousNetPrice = previousNetPrice;
+        this.netUnitPrice = netUnitPrice;
+        this.chargeId = chargeId;
+        this.chargeType = chargeType;
+        this.chargeMethod = chargeMethod;
+        this.priceItemId = priceItemId;
+        this.startDate = startDate;
+        this.priceWaterfalls = priceWaterfalls;
+        this.quantity = quantity;
+        this.properties = properties;
+        this.chargeTypeDisplayValue = chargeTypeDisplayValue;
+        this.arr = arr;
+        this.frequencyUnit = frequencyUnit;
+        this.frequencyDuration = frequencyDuration;
+        this.endDate = endDate;
+        this.sellingTerm = sellingTerm;
+        this.currency = currency;
+        this.unitCost = unitCost;
+        this.cost = cost;
+        this.minUnitPrice = minUnitPrice;
+        this.minPrice = minPrice;
+        this.enablePriceAdjustment = enablePriceAdjustment;
+        this.enableListPriceAdjustment = enableListPriceAdjustment;
+        this.listPriceAdjustment = listPriceAdjustment;
+        this.priceAdjustment = priceAdjustment;
+        this.requiresApprovals = requiresApprovals;
+    }
+    static fromDTO(dto) {
+        return {
+            id: dto.id,
+            price: dto.price,
+            unitPrice: dto.unitPrice,
+            baseListPrice: dto.baseListPrice,
+            baseListUnitPrice: dto.baseListUnitPrice,
+            listPrice: dto.listPrice,
+            listUnitPrice: dto.listUnitPrice,
+            netPrice: dto.netPrice,
+            previousNetPrice: dto.previousNetPrice,
+            netUnitPrice: dto.netUnitPrice,
+            chargeId: dto.chargeId,
+            chargeType: dto.chargeType,
+            chargeTypeDisplayValue: dto.chargeTypeDisplayValue,
+            chargeMethod: dto.chargeMethod,
+            priceItemId: dto.priceItemId,
+            startDate: dto.startDate,
+            endDate: dto.endDate,
+            priceWaterfalls: dto.priceWaterfalls.map(PriceAdjustmentDTO.fromDTO),
+            quantity: dto.quantity,
+            properties: dto.properties,
+            arr: dto.arr,
+            frequencyUnit: dto.frequencyUnit,
+            frequencyDuration: dto.frequencyDuration,
+            sellingTerm: dto.sellingTerm,
+            currency: dto.currency,
+            unitCost: dto.unitCost,
+            cost: dto.cost,
+            minUnitPrice: dto.minUnitPrice,
+            minPrice: dto.minPrice,
+            enablePriceAdjustment: dto.enablePriceAdjustment,
+            enableListPriceAdjustment: dto.enableListPriceAdjustment,
+            listPriceAdjustment: dto.listPriceAdjustment && PriceAdjustmentDTO.fromDTO(dto.listPriceAdjustment),
+            priceAdjustment: dto.priceAdjustment && PriceAdjustmentDTO.fromDTO(dto.priceAdjustment),
+            requiresApprovals: dto.requiresApprovals,
+        };
+    }
+}
+
+class RecommendedPriceDTO {
+    constructor(netPrice, listPrice, chargeType, chargeMethod, explanation, frequencyDuration, frequencyUnit, properties) {
+        this.netPrice = netPrice;
+        this.listPrice = listPrice;
+        this.chargeType = chargeType;
+        this.chargeMethod = chargeMethod;
+        this.explanation = explanation;
+        this.frequencyDuration = frequencyDuration;
+        this.frequencyUnit = frequencyUnit;
+        this.properties = properties;
+    }
+    static fromDTO(dto) {
+        return {
+            netPrice: dto.netPrice,
+            listPrice: dto.listPrice,
+            chargeType: dto.chargeType,
+            chargeMethod: dto.chargeMethod,
+            frequencyUnit: dto.frequencyUnit,
+            frequencyDuration: dto.frequencyDuration,
+            explanation: dto.explanation,
+            properties: dto.properties,
+        };
+    }
+}
+
+class DomainTypeDTO {
+    constructor(name, displayName, minCard, maxCard, recommendedPrices, properties, status, cardinality) {
+        this.name = name;
+        this.displayName = displayName;
+        this.minCard = minCard;
+        this.maxCard = maxCard;
+        this.recommendedPrices = recommendedPrices;
+        this.properties = properties;
+        this.status = status;
+        this.cardinality = cardinality;
+    }
+    static fromDTO(dto) {
+        var _a;
+        return {
+            name: dto.name,
+            displayName: dto.displayName,
+            minCard: dto.minCard,
+            maxCard: dto.maxCard,
+            recommendedPrices: (_a = dto.recommendedPrices) === null || _a === void 0 ? void 0 : _a.map(RecommendedPriceDTO.fromDTO),
+            properties: dto.properties,
+            status: dto.status,
+            cardinality: dto.cardinality,
+        };
+    }
+}
+
+class PortDomainDTO {
+    constructor(name, type, minCard, maxCard, domainTypes, properties) {
+        this.name = name;
+        this.type = type;
+        this.minCard = minCard;
+        this.maxCard = maxCard;
+        this.domainTypes = domainTypes;
+        this.properties = properties;
+    }
+    static fromDTO(dto) {
+        return {
+            name: dto.name,
+            type: dto.type,
+            minCard: dto.minCard,
+            maxCard: dto.maxCard,
+            domainTypes: dto.domainTypes.map(DomainTypeDTO.fromDTO),
+            properties: dto.properties,
+        };
+    }
+}
+
+class PriceDTO {
+    constructor(netPrice, listPrice, chargeType, chargeTypeDisplayValue, chargeMethod, frequencyUnit, frequencyDuration, sellingTerm) {
+        this.netPrice = netPrice;
+        this.listPrice = listPrice;
+        this.chargeType = chargeType;
+        this.chargeTypeDisplayValue = chargeTypeDisplayValue;
+        this.chargeMethod = chargeMethod;
+        this.frequencyUnit = frequencyUnit;
+        this.frequencyDuration = frequencyDuration;
+        this.sellingTerm = sellingTerm;
+    }
+    static fromDTO(dto) {
+        return {
+            netPrice: dto.netPrice,
+            listPrice: dto.listPrice,
+            chargeType: dto.chargeType,
+            chargeTypeDisplayValue: dto.chargeTypeDisplayValue,
+            chargeMethod: dto.chargeMethod,
+            frequencyUnit: dto.frequencyUnit,
+            frequencyDuration: dto.frequencyDuration,
+            sellingTerm: dto.sellingTerm,
+        };
+    }
+}
+
+class LineItemDTO {
+    constructor(id, activated, attributes, attributeDomains, cfgStatus, chargeGroupItems, chargeItems, domainComputations, lineItems, messages, name, optionalCharges, pending, portDomains, properties, qty, totalPrices, type, integrationId, productId, port, parentId, assetId, openOrderLineItemId, productName, rootId, actionCode, serviceStartDate, effectiveDate, effectiveStartDate, startDate, endDate, priceListId, planId, sellingFrequencyUnit, sellingFrequencyDuration, minimalTerm, offeringId, offeringItemId, offeringInstanceId, rampInstanceId, enableRamp, configurable, requiresApprovals) {
+        this.id = id;
+        this.activated = activated;
+        this.attributes = attributes;
+        this.attributeDomains = attributeDomains;
+        this.cfgStatus = cfgStatus;
+        this.chargeGroupItems = chargeGroupItems;
+        this.chargeItems = chargeItems;
+        this.domainComputations = domainComputations;
+        this.lineItems = lineItems;
+        this.messages = messages;
+        this.name = name;
+        this.optionalCharges = optionalCharges;
+        this.pending = pending;
+        this.portDomains = portDomains;
+        this.properties = properties;
+        this.qty = qty;
+        this.totalPrices = totalPrices;
+        this.type = type;
+        this.integrationId = integrationId;
+        this.productId = productId;
+        this.port = port;
+        this.parentId = parentId;
+        this.assetId = assetId;
+        this.openOrderLineItemId = openOrderLineItemId;
+        this.productName = productName;
+        this.rootId = rootId;
+        this.actionCode = actionCode;
+        this.serviceStartDate = serviceStartDate;
+        this.effectiveDate = effectiveDate;
+        this.effectiveStartDate = effectiveStartDate;
+        this.startDate = startDate;
+        this.endDate = endDate;
+        this.priceListId = priceListId;
+        this.planId = planId;
+        this.sellingFrequencyUnit = sellingFrequencyUnit;
+        this.sellingFrequencyDuration = sellingFrequencyDuration;
+        this.minimalTerm = minimalTerm;
+        this.offeringId = offeringId;
+        this.offeringItemId = offeringItemId;
+        this.offeringInstanceId = offeringInstanceId;
+        this.rampInstanceId = rampInstanceId;
+        this.enableRamp = enableRamp;
+        this.configurable = configurable;
+        this.requiresApprovals = requiresApprovals;
+    }
+    static fromDTO(dto) {
+        return {
+            id: dto.id,
+            activated: dto.activated,
+            attributes: dto.attributes.map(AttributeDTO.fromDTO),
+            attributeDomains: dto.attributeDomains,
+            cfgStatus: dto.cfgStatus,
+            chargeGroupItems: dto.chargeGroupItems.map(ChargeGroupItemDTO.fromDTO),
+            chargeItems: dto.chargeItems.map(ChargeItemDTO.fromDTO),
+            domainComputations: dto.domainComputations,
+            lineItems: dto.lineItems.map(LineItemDTO.fromDTO),
+            messages: dto.messages,
+            name: dto.name,
+            optionalCharges: dto.optionalCharges,
+            pending: dto.pending,
+            portDomains: transform(dto.portDomains, (result, value, key) => (result[key] = PortDomainDTO.fromDTO(value))),
+            properties: dto.properties,
+            qty: dto.qty,
+            totalPrices: transform(dto.totalPrices, (result, value, key) => (result[key] = PriceDTO.fromDTO(value))),
+            type: dto.type,
+            productId: dto.productId,
+            port: dto.port,
+            integrationId: dto.integrationId,
+            parentId: dto.parentId,
+            assetId: dto.assetId,
+            openOrderLineItemId: dto.openOrderLineItemId,
+            productName: dto.productName,
+            rootId: dto.rootId,
+            actionCode: dto.actionCode,
+            serviceStartDate: dto.serviceStartDate,
+            effectiveDate: dto.effectiveDate,
+            effectiveStartDate: dto.effectiveStartDate,
+            startDate: dto.startDate,
+            endDate: dto.endDate,
+            priceListId: dto.priceListId,
+            planId: dto.planId,
+            sellingFrequencyUnit: dto.sellingFrequencyUnit,
+            sellingFrequencyDuration: dto.sellingFrequencyDuration,
+            minimalTerm: dto.minimalTerm,
+            offeringId: dto.offeringId,
+            offeringItemId: dto.offeringItemId,
+            offeringInstanceId: dto.offeringInstanceId,
+            rampInstanceId: dto.rampInstanceId,
+            enableRamp: dto.enableRamp,
+            configurable: dto.configurable,
+            requiresApprovals: dto.requiresApprovals,
+        };
+    }
+}
+
+class ConfigurePriceDTO {
+    constructor(lineItem, context, charges, pricePlans) {
+        this.lineItem = lineItem;
+        this.context = context;
+        this.charges = charges;
+        this.pricePlans = pricePlans;
+    }
+    static fromDTO(dto) {
+        return {
+            lineItem: LineItemDTO.fromDTO(dto.lineItem),
+            charges: dto.charges,
+            pricePlans: dto.pricePlans,
+            context: dto.context,
+            deletedLineItems: dto.deletedLineItems.map(deletedLineItem => LineItemDTO.fromDTO(deletedLineItem)),
+        };
+    }
+}
+
+class ConfigurationApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/configuration';
+    }
+    configureLineItem({ configurationRequest, runtimeModel, pricingEnabled, }) {
+        return this.httpService
+            .api({
+            method: 'post',
+            url: `${this.SERVICE_URL}${pricingEnabled ? '/price' : ''}`,
+            body: configurationRequest,
+            errorHandler: e => throwError(e),
+        })
+            .pipe(map(response => ConfigurePriceDTO.fromDTO(response)), map(configurePrice => {
+            if (runtimeModel) {
+                return Object.assign(Object.assign({}, configurePrice), { lineItem: this.updatePortDomains(configurePrice.lineItem, runtimeModel) });
+            }
+            else {
+                return configurePrice;
+            }
+        }));
+    }
+    getRuntimeDataByProductId(productId, offeringId) {
+        return this.httpService
+            .api({
+            method: 'get',
+            url: `${this.SERVICE_URL}/${productId}/model` + ((offeringId && `/${offeringId}`) || ''),
+        })
+            .pipe(map(runtimeData => {
+            runtimeData.uiDefinitions = JSON.parse(runtimeData.uiDefinitionsSource);
+            runtimeData.uiDefinitions.forEach(uiDefinition => {
+                ModelTranslatorUtils.toLocalUIDefinition(uiDefinition);
+            });
+            return runtimeData;
+        }));
+    }
+    getRuntimeDataByModelId(modelId) {
+        return this.httpService
+            .api({
+            method: 'get',
+            url: `${this.SERVICE_URL}/${modelId}/model-test`,
+        })
+            .pipe(map((runtimeData) => {
+            runtimeData.uiDefinitions = [];
+            return runtimeData;
+        }));
+    }
+    updatePortDomains(lineItem, runtimeModel) {
+        var _a, _b, _c;
+        const type = runtimeModel.components.get(lineItem.type);
+        const portDomains = Object.assign({}, lineItem.portDomains);
+        for (const port of (_a = type === null || type === void 0 ? void 0 : type.ports) !== null && _a !== void 0 ? _a : []) {
+            const portDomain = portDomains[port.name];
+            if (((_b = portDomain === null || portDomain === void 0 ? void 0 : portDomain.properties) === null || _b === void 0 ? void 0 : _b.domainComputation) === 'false') {
+                portDomain.domainTypes = port.domainTypes;
+            }
+        }
+        return Object.assign(Object.assign({}, lineItem), { lineItems: (_c = lineItem.lineItems) === null || _c === void 0 ? void 0 : _c.map(i => this.updatePortDomains(i, runtimeModel)), portDomains });
+    }
+}
+ConfigurationApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ConfigurationSettingsDTO {
+    constructor(id, key, value) {
+        this.id = id;
+        this.key = key;
+        this.value = value;
+    }
+    static fromDTO(dto, key) {
+        return {
+            id: dto === null || dto === void 0 ? void 0 : dto.id,
+            key: (dto === null || dto === void 0 ? void 0 : dto.key) || key || '',
+            value: dto === null || dto === void 0 ? void 0 : dto.value,
+        };
+    }
+    static toDTO(data) {
+        return {
+            id: data.id,
+            key: data.key,
+            value: data.value,
+        };
+    }
+}
+
+class ConfigurationSettingsApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/configuration-settings';
+    }
+    fetchSettings(options) {
+        return this.httpService
+            .api(Object.assign({ url: `${this.SERVICE_URL}`, method: 'get' }, options))
+            .pipe(map((settings) => settings.map(setting => ConfigurationSettingsDTO.fromDTO(setting))));
+    }
+    fetchSetting(settingsKey, options) {
+        return this.httpService
+            .api(Object.assign({ url: `${this.SERVICE_URL}/byKey/${settingsKey}`, method: 'get' }, options))
+            .pipe(map((setting) => ConfigurationSettingsDTO.fromDTO(setting, settingsKey)), catchError(err => {
+            if (err instanceof HttpErrorResponse && err.status === 404) {
+                return of(null);
+            }
+            throw err;
+        }));
+    }
+    createSetting(setting, options) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}`, method: 'post', body: Object.assign({}, request) }, options));
+    }
+    updateSetting(setting, options) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${request.id}`, method: 'put', body: Object.assign({}, request) }, options));
+    }
+    removeSetting(setting, options) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${request.id}`, method: 'delete' }, options));
+    }
+    restoreSetting(settingId, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/${settingId}/restore`, method: 'patch' }, options));
+    }
+    clear(name, options) {
+        return this.httpService.api(Object.assign({ method: 'get', url: '/cache/evict/' + name }, options));
+    }
+}
+ConfigurationSettingsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationSettingsApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationSettingsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationSettingsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationSettingsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ContextApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/context';
+    }
+    getContext(headerId, mode) {
+        return this.httpService.api({
+            method: 'post',
+            body: {
+                headerId: headerId,
+                contextMode: ConfigurationContextMode[mode],
+            },
+            url: `${this.SERVICE_URL}`,
+        });
+    }
+}
+ContextApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ContextApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContextApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ContextApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ContextApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class DeltaApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/delta';
+    }
+    calculate$(request) {
+        return this.httpService
+            .api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/calculate`,
+            body: request,
+            skipErrorHandler: true,
+        })
+            .pipe(map$1(dtos => dtos.map(dto => LineItemDTO.fromDTO(dto))));
+    }
+}
+DeltaApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DeltaApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+DeltaApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DeltaApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DeltaApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class DocumentAttachmentApiService {
+    constructor(httpService, fileDownloadService) {
+        this.httpService = httpService;
+        this.fileDownloadService = fileDownloadService;
+        this.SERVICE_URL = '/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: "12.2.17", ngImport: i0, type: DocumentAttachmentApiService, deps: [{ token: i1.BaseHttpService }, { token: i1.FileDownloadService }], target: i0.ɵɵFactoryTarget.Injectable });
+DocumentAttachmentApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentAttachmentApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentAttachmentApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }, { type: i1.FileDownloadService }]; } });
+
+class SalesforceApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/proxy';
+    }
+    query(searchRequest, objectName, options) {
+        return this.httpService.api(Object.assign({ method: 'post', body: Object.assign(Object.assign({}, 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(Object.assign({ url: `${this.SERVICE_URL}/query`, params }, options));
+    }
+    describe(objectName, fieldName, options) {
+        const methodUrl = `${this.SERVICE_URL}/describe/${objectName}/fields` + (fieldName ? `/${fieldName}` : '');
+        return this.httpService.api(Object.assign({ url: methodUrl }, options));
+    }
+    describe2(objectName, fields, options) {
+        const methodUrl = `${this.SERVICE_URL}/describe/${objectName}/fields`;
+        return this.httpService.api(Object.assign({ method: 'post', url: methodUrl, body: fields }, options));
+    }
+    apexGetRequest(path, params, options) {
+        return this.httpService.api(Object.assign({ url: `${this.SERVICE_URL}/apex${path}`, params }, options));
+    }
+    apexPostRequest(path, body, options) {
+        return this.httpService.api(Object.assign({ method: 'post', body, url: `${this.SERVICE_URL}/apex${path}` }, options));
+    }
+}
+SalesforceApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SalesforceApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+SalesforceApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SalesforceApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SalesforceApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+const moment = moment_;
+class DocumentTemplatesApiService {
+    constructor(service, salesforceApiService, fileDownloadService, documentAttachmentService, http) {
+        this.service = service;
+        this.salesforceApiService = salesforceApiService;
+        this.fileDownloadService = fileDownloadService;
+        this.documentAttachmentService = documentAttachmentService;
+        this.http = http;
+        this.DOCGEN_TAG = 'docgen';
+        this.SERVICE_URL = '/templates';
+        this.DOC_GEN_URL_FALLBACK = 'https://dev-dp1.velocpq.com/docgen';
+        this.mapSfQueryResult = (limit) => map((records) => {
+            if (!records.length) {
+                return { _result: 'No Records Found' };
+            }
+            if (limit === 1) {
+                return records[0];
+            }
+            return records;
+        });
+        this.mapBooleanIfAplicable = (value) => {
+            if (value === 'true') {
+                return true;
+            }
+            if (value === 'false') {
+                return false;
+            }
+            return value;
+        };
+        if (window.VELO_DOCGEN_API) {
+            this.DOC_GEN_URL = window.VELO_DOCGEN_API;
+        }
+        else {
+            console.log(`window.VELO_DOCGEN_API not set, will use fallback "${this.DOC_GEN_URL_FALLBACK}"`);
+            this.DOC_GEN_URL = this.DOC_GEN_URL_FALLBACK;
+        }
+    }
+    getTemplates(tag) {
+        return this.service.api({
+            url: `${this.SERVICE_URL}`,
+            method: 'get',
+            params: Object.assign({}, (tag && { tag })),
+        });
+    }
+    getTemplate(id) {
+        return this.service.api({
+            url: `${this.SERVICE_URL}/${id}`,
+            method: 'get',
+        });
+    }
+    upsertTemplate(template, file, reportProgress) {
+        const formData = new FormData();
+        if (file) {
+            formData.append('file', file, file.name);
+        }
+        formData.append('template', new Blob([JSON.stringify(template)], {
+            type: 'application/json',
+        }));
+        let url = `${this.SERVICE_URL}`;
+        if (template.id) {
+            url += `/${template.id}`;
+        }
+        return this.service.upload({
+            url,
+            body: formData,
+            method: template.id ? 'put' : 'post',
+            reportProgress,
+        });
+    }
+    removeTemplate(id) {
+        return this.service.api({
+            url: `${this.SERVICE_URL}/${id}`,
+            method: 'delete',
+        });
+    }
+    restoreTemplate(id) {
+        return this.service.api({
+            url: `${this.SERVICE_URL}/${id}/restore`,
+            method: 'patch',
+        });
+    }
+    cloneTemplate(id, propertiesToOverride = {}) {
+        return this.service.api({
+            url: `${this.SERVICE_URL}/clone/${id}`,
+            method: 'post',
+            body: {
+                id,
+                propertiesToOverride,
+            },
+        });
+    }
+    getTemplateFile(id) {
+        return this.service.api({
+            method: 'get',
+            url: `${this.SERVICE_URL}/${id}/file`,
+            responseType: 'arraybuffer',
+        });
+    }
+    downloadTemplateFile(id) {
+        return this.service
+            .api({
+            url: `${this.SERVICE_URL}/${id}/file`,
+            responseType: 'blob',
+            observe: 'response',
+        })
+            .pipe(tap(response => {
+            this.fileDownloadService.processDownload(response);
+        }), map(response => response.body || response));
+    }
+    mergeDocuments(document, attachments) {
+        const body = new FormData();
+        attachments.forEach(attachment => {
+            body.append('attachments', new Blob([attachment]));
+        });
+        body.append('orderform', document);
+        return this.http.post(`${this.DOC_GEN_URL}/documents/merge`, body, {
+            responseType: 'arraybuffer',
+        });
+    }
+    getAttachments(searchRequest) {
+        return this.documentAttachmentService.getAttachments(searchRequest);
+    }
+    getAttachmentFile(id) {
+        return this.documentAttachmentService.getAttachmentFile(id);
+    }
+    createAttachment(attachment, file, reportProgress) {
+        return this.documentAttachmentService.createAttachment(attachment, file, reportProgress);
+    }
+    removeAttachment(id) {
+        return this.documentAttachmentService.removeAttachment(id);
+    }
+    generateDocumentData(template, object, params = {}) {
+        var _a;
+        if (isLegacyDocumentTemplate(template)) {
+            return this.generateDocumentDataLegacy(template, object, params);
+        }
+        const templateProperties = (_a = template.properties) === null || _a === void 0 ? void 0 : _a.reduce((acc, { name, value }) => (Object.assign(Object.assign({}, acc), { [name]: this.mapBooleanIfAplicable(value) })), {});
+        /*
+          Resolve quote and template properties for now
+          When procedures are ready, whey will replace template scripts.
+    
+          TODO: run procedure to resolve document data
+        */
+        return of(Object.assign(Object.assign({}, (typeof object === 'object' ? object : { object })), templateProperties));
+    }
+    generateDocument(template, object, params = {}) {
+        const documentData$ = this.generateDocumentData(template, object, Object.assign(Object.assign({}, params), { shouldPreventDownload: true }));
+        return zip(this.getTemplateFile(template.id), documentData$, this.resolveAttachments$(template)).pipe(switchMap(([templateFile, data, attachments]) => {
+            var _a, _b, _c, _d, _e, _f;
+            const document = DocxTemplater.generate(templateFile, data);
+            const properties = (_c = (_b = (_a = object === null || object === void 0 ? void 0 : object.context) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : object === null || object === void 0 ? void 0 : object.properties) !== null && _c !== void 0 ? _c : {};
+            const documentName = properties.Name || template.name;
+            const documentFormat = (_d = params.documentFormat) !== null && _d !== void 0 ? _d : (_f = (_e = template.properties) === null || _e === void 0 ? void 0 : _e.find(p => p.name === 'documentFormat')) === null || _f === void 0 ? void 0 : _f.value;
+            if (documentFormat === 'DOCX') {
+                this.fileDownloadService.processDownload(document, documentName);
+                return of(document);
+            }
+            return this.mergeDocuments(document, attachments).pipe(switchMap(pdf => {
+                if (params.attachToQuote && QuoteDraft.isQuote(object)) {
+                    const file = new File([pdf], `${documentName}.pdf`);
+                    return this.documentAttachmentService
+                        .createAttachment({
+                        linkedEntityId: object.quoteId,
+                        fileName: documentName,
+                        fileExtension: 'pdf',
+                        tags: this.DOCGEN_TAG,
+                    }, file)
+                        .pipe(map(() => pdf));
+                }
+                return of(pdf);
+            }), map(pdf => {
+                const blob = new Blob([pdf]);
+                if (!params.shouldPreventDownload) {
+                    this.fileDownloadService.processDownload(blob, `${documentName}.pdf`);
+                }
+                return blob;
+            }));
+        }));
+    }
+    generateDocumentDataLegacy(template, object, params = {}) {
+        var _a, _b, _c, _d;
+        const shouldPreventDownload = params.shouldPreventDownload;
+        const allQueries = [...((_a = template === null || template === void 0 ? void 0 : template.queries) !== null && _a !== void 0 ? _a : [])];
+        const properties = (_d = (_c = (_b = object === null || object === void 0 ? void 0 : object.context) === null || _b === void 0 ? void 0 : _b.properties) !== null && _c !== void 0 ? _c : object === null || object === void 0 ? void 0 : object.properties) !== null && _d !== void 0 ? _d : {};
+        const accountId = properties === null || properties === void 0 ? void 0 : properties.AccountId;
+        const userId = properties === null || properties === void 0 ? void 0 : properties.UserId;
+        if (accountId) {
+            allQueries.push({
+                queryName: 'QuoteAccountQuery',
+                objectName: 'Account',
+                resultObjectName: 'account',
+                statement: `Id ='${accountId}'`,
+                fields: [],
+            });
+        }
+        if (userId) {
+            allQueries.push({
+                queryName: 'QuoteUserQuery',
+                objectName: 'User',
+                resultObjectName: 'agent',
+                statement: `Id ='${userId}'`,
+                fields: [],
+            });
+        }
+        const queries = allQueries.map(query => this.queryObject(query, { properties })) || [];
+        return forkJoin([...queries]).pipe(defaultIfEmpty([]), map(results => {
+            var _a, _b, _c, _d;
+            const queriesResult = _.chain(results)
+                .reduce((acc, r) => {
+                if (r) {
+                    return Object.assign(Object.assign({}, acc), r);
+                }
+                return acc;
+            }, {})
+                .value();
+            const templateProperties = ((template === null || template === void 0 ? void 0 : template.properties) || []).reduce((trunk, { name, value }) => {
+                return Object.assign(Object.assign({}, trunk), { [name]: this.mapBooleanIfAplicable(value) });
+            }, {});
+            const data = Object.assign(Object.assign(Object.assign({}, (typeof object === 'object' ? object : { object })), queriesResult), templateProperties);
+            if (template.script && template.script.trim().length) {
+                const currencyFormat = ((_b = (_a = template.properties) === null || _a === void 0 ? void 0 : _a.find(({ name }) => name === 'currencyFormat')) === null || _b === void 0 ? void 0 : _b.value) || '1.2-2';
+                const dateFormat = ((_d = (_c = template.properties) === null || _c === void 0 ? void 0 : _c.find(({ name }) => name === 'dateFormat')) === null || _d === void 0 ? void 0 : _d.value) || 'D/MMM/YYYY';
+                const formatDate = (value) => {
+                    return value ? moment(value).format(dateFormat) : value;
+                };
+                const transform = new Function(`return ${template.script}`)();
+                const transformedData = transform(Object.assign(Object.assign({}, data), { utils: {
+                        lodash: _,
+                        currency: (value) => new CurrencyPipe('en-US').transform(value, 'USD', 'symbol', currencyFormat),
+                        date: formatDate,
+                    }, ToDay: formatDate(Date.now()) }));
+                if (!shouldPreventDownload) {
+                    const blob = new Blob([JSON.stringify(transformedData)]);
+                    this.fileDownloadService.processDownload(blob, 'data.json');
+                }
+                return transformedData;
+            }
+            return data;
+        }));
+    }
+    resolveAttachments$(template) {
+        var _a, _b;
+        const attachmentIds = (_b = (_a = template.attachments) === null || _a === void 0 ? void 0 : _a.map(({ id }) => id).filter(Boolean)) !== null && _b !== void 0 ? _b : [];
+        if (!attachmentIds.length) {
+            return of([]);
+        }
+        return forkJoin(attachmentIds.map(id => this.documentAttachmentService.getAttachmentFile(id, true)));
+    }
+    queryObject({ objectName, resultObjectName, fields, statement }, { properties }) {
+        var _a;
+        const patternLimit = /(\s*limit\s\d*)/i;
+        let limit = 1;
+        if (statement && patternLimit.test(statement)) {
+            const limitStr = (_a = statement === null || statement === void 0 ? void 0 : statement.match(patternLimit)) === null || _a === void 0 ? void 0 : _a[1].trim().substring(5).trim();
+            if (limitStr) {
+                limit = Number.parseInt(limitStr, 10);
+            }
+            statement = statement.replace(patternLimit, '');
+        }
+        const resolvedStatement = statement
+            ? StringUtils.fillPlaceholders(statement, properties, /:\s*(\w[\w\d_.]+)/i)
+            : undefined;
+        const searchRequest = Object.assign({ skip: 0, count: limit, rawCondition: resolvedStatement }, ((fields === null || fields === void 0 ? void 0 : fields.length) && !!fields[0] && { fields }));
+        return this.salesforceApiService.query(searchRequest, objectName).pipe(this.mapSfQueryResult(limit), map(value => ({ [resultObjectName]: value })));
+    }
+}
+DocumentTemplatesApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentTemplatesApiService, deps: [{ token: i1.BaseHttpService }, { token: SalesforceApiService }, { token: i1.FileDownloadService }, { token: DocumentAttachmentApiService }, { token: i4.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+DocumentTemplatesApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentTemplatesApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentTemplatesApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }, { type: SalesforceApiService }, { type: i1.FileDownloadService }, { type: DocumentAttachmentApiService }, { type: i4.HttpClient }]; } });
+
+class FlowsApiService {
+    constructor(configurationSettingsApiService) {
+        this.configurationSettingsApiService = configurationSettingsApiService;
+        this.flowsKey = 'flows';
+    }
+    getFlow(id) {
+        return this.fetchFlows().pipe(map(flows => flows.find(flow => flow.id == id)));
+    }
+    fetchFlows() {
+        return this.configurationSettingsApiService
+            .fetchSetting(this.flowsKey)
+            .pipe(map((flow) => ((flow === null || flow === void 0 ? void 0 : flow.value) ? JSON.parse(flow.value) : [])));
+    }
+}
+FlowsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowsApiService, deps: [{ token: ConfigurationSettingsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: ConfigurationSettingsApiService }]; } });
+
+class PicklistsApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin';
+        this.fetchAllPicklists$ = () => this.baseHttpService.api({ url: `${this.serviceUrl}/picklists` });
+        this.fetchPicklist$ = (code) => this.baseHttpService.api({ url: `${this.serviceUrl}/picklists/${code}` });
+        this.createPicklist$ = (picklist) => {
+            return this.baseHttpService.api({ method: 'post', url: `${this.serviceUrl}/picklists`, body: picklist });
+        };
+        this.updatePicklist$ = (picklist) => {
+            return this.baseHttpService.api({
+                method: 'put',
+                url: `${this.serviceUrl}/picklists/${picklist.id}`,
+                body: picklist,
+            });
+        };
+        this.removePicklist$ = (id) => this.baseHttpService.api({ method: 'delete', url: `${this.serviceUrl}/picklists/${id}` });
+        this.restorePicklist$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/picklists/${id}/restore`,
+                method: 'patch',
+            });
+        };
+        this.addPicklistValue$ = (picklist, value) => {
+            const data = Object.assign(Object.assign({}, picklist), { values: [...picklist.values, value] });
+            return this.baseHttpService.api({ method: 'put', url: `${this.serviceUrl}/picklists/${picklist.id}`, body: data });
+        };
+    }
+}
+PicklistsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PicklistsApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+PicklistsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PicklistsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PicklistsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class PriceApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/price';
+    }
+    calculate(request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/calculate`,
+            body: request,
+            skipErrorHandler: true,
+        });
+    }
+    getPriceLists() {
+        return this.httpService.api({
+            method: 'get',
+            url: '/price-lists',
+        });
+    }
+    getPriceList(id) {
+        return this.httpService.api({
+            method: 'get',
+            url: `/price-lists/${id}`,
+        });
+    }
+    getSellingTermByEndDate(planId, offeringId, startDate, endDate, frequencyUnit, frequencyDuration) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/selling-term-by-end-date`,
+            body: {
+                planId: planId,
+                offeringId: offeringId,
+                startDate: startDate,
+                endDate: endDate,
+                frequencyUnit: frequencyUnit,
+                frequencyDuration: frequencyDuration,
+            },
+        });
+    }
+    getSellingTermByTerm(planId, offeringId, startDate, term, frequencyUnit, frequencyDuration) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/selling-term-by-term`,
+            body: {
+                planId: planId,
+                offeringId: offeringId,
+                startDate: startDate,
+                term: term,
+                frequencyUnit: frequencyUnit,
+                frequencyDuration: frequencyDuration,
+            },
+        });
+    }
+}
+PriceApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PriceApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+PriceApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PriceApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PriceApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ProceduresApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.ADMIN_SERVICE_URL = '/admin/procedures';
+        this.SERVICE_URL = '/procedures';
+        this.fetchProcedures$ = () => {
+            return this.searchProcedures$(new Expression(), 0, 100);
+        };
+        this.searchProcedures$ = (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.ADMIN_SERVICE_URL}/search`,
+                params,
+                body: expression,
+            });
+        };
+        this.createProcedure$ = (newProcedure) => {
+            return this.baseHttpService.api({
+                url: `${this.ADMIN_SERVICE_URL}`,
+                method: 'post',
+                body: newProcedure,
+            });
+        };
+        this.updateProcedure$ = (procedure) => {
+            return this.baseHttpService.api({
+                url: `${this.ADMIN_SERVICE_URL}/${procedure.id}`,
+                method: 'put',
+                body: procedure,
+            });
+        };
+        this.duplicateProcedure$ = (body) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.ADMIN_SERVICE_URL}/${body.id}/clone`,
+                method: 'post',
+                body,
+            })
+                .pipe(map(response => response.clonedRecordId));
+        };
+        this.removeProcedure$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.ADMIN_SERVICE_URL}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreProcedure$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.ADMIN_SERVICE_URL}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+    }
+    fetchProcedure$(id) {
+        return this.baseHttpService.api({
+            url: `${this.ADMIN_SERVICE_URL}/${id}`,
+            method: 'get',
+        });
+    }
+    execute$(body) {
+        return this.baseHttpService.api({
+            url: `${this.SERVICE_URL}/execute`,
+            method: 'post',
+            body,
+        });
+    }
+    /**
+     * Run active procedure against QuoteDraft
+     * @param body
+     * @returns
+     */
+    apply$(body) {
+        return this.baseHttpService.api({
+            url: `${this.SERVICE_URL}/apply`,
+            method: 'post',
+            body,
+        });
+    }
+}
+ProceduresApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProceduresApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProceduresApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProceduresApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProceduresApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ProductApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/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.fetchAttributes$ = () => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}/attributes/definition` });
+        };
+        this.searchAttributes$ = (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}/attributes/definition/search`,
+                params: params,
+                body: expression,
+            });
+        };
+        this.fetchAttributesByModel = (modelId) => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}/attributes/definition/forModel/${modelId}` });
+        };
+        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',
+            });
+        };
+        this.createProductAttribute$ = (attributeData) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes`,
+                method: 'post',
+                body: attributeData,
+            });
+        };
+        this.updateProductAttribute$ = (attributeData) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/${attributeData.id}`,
+                method: 'put',
+                body: attributeData,
+            });
+        };
+        this.removeProductAttribute$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/${id}`,
+                method: 'delete',
+            });
+        };
+        this.createNewAttribute$ = (attributeData) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/definition`,
+                method: 'post',
+                body: attributeData,
+            });
+        };
+        this.updateAttribute$ = (body) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/definition/${body.id}`,
+                method: 'put',
+                body,
+            });
+        };
+        this.removeAttribute$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/definition/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreAttribute$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/attributes/definition/${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`;
+    }
+}
+ProductApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ProductModelApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/models';
+    }
+    addModel(model) {
+        return this.httpService
+            .api({
+            method: 'post',
+            url: this.SERVICE_URL,
+            body: model,
+            errorHandler: this.httpService.handleValidationError,
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return result;
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }));
+    }
+    releaseModel(model) {
+        return this.httpService
+            .api({
+            method: 'put',
+            url: `${this.SERVICE_URL}/${model.id}/release`,
+            body: model,
+            errorHandler: this.httpService.handleValidationError,
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return '';
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }));
+    }
+    removeModel(modelId, successFn, failureFn) {
+        const observable = this.httpService
+            .api({
+            method: 'delete',
+            url: `${this.SERVICE_URL}/${modelId}`,
+            errorHandler: this.httpService.handleValidationError,
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return '';
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }));
+        observable.subscribe(() => {
+            successFn && successFn.apply();
+        }, () => {
+            failureFn && failureFn.apply();
+        });
+    }
+    getModelVersions(modelId, count = 100, skip = 0) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/${modelId}/versions`,
+            body: {
+                skipCount: skip,
+                count: count,
+            },
+        });
+    }
+    getModel(id, version) {
+        let url = `${this.SERVICE_URL}/${id}`;
+        if (version) {
+            url += `/versions/${version}`;
+        }
+        return this.httpService.api({ url });
+    }
+    getModels(skipCount, searchText) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/search`,
+            body: {
+                nameRegex: searchText,
+                skipCount: skipCount.toString(),
+                count: ProductModelApiService.MAX_RESULTS,
+            },
+        });
+    }
+    getLinkedModels(id, version) {
+        let url = `${this.SERVICE_URL}/${id}`;
+        if (version) {
+            url += `/versions/${version}`;
+        }
+        url += '/linked';
+        return this.httpService.api({ url }).pipe(map((linkedModels) => {
+            if (linkedModels) {
+                linkedModels.forEach(model => ModelTranslatorUtils.toLocalModel(model));
+            }
+            return linkedModels;
+        }));
+    }
+    load(id, version) {
+        return forkJoin([this.getModel(id, version), this.getLinkedModels(id, version)]).pipe(map(([model, linkedModels]) => {
+            const container = new ProductModelsContainer(model, linkedModels !== null && linkedModels !== void 0 ? linkedModels : []);
+            ModelUtils.override(container.main, container.linked);
+            ModelTranslatorUtils.toLocalModel(container.main, container.linked);
+            return container;
+        }));
+    }
+    getPML(modelId, version) {
+        let url = `${this.SERVICE_URL}/${modelId}/pml/${version}`;
+        if (version) {
+            url += `/versions/${version}`;
+        }
+        return this.httpService.api({
+            url,
+            responseType: 'text',
+        });
+    }
+    savePML(modelId, pml, comment) {
+        return this.httpService
+            .api({
+            method: 'put',
+            url: `${this.SERVICE_URL}/${modelId}/pml`,
+            body: {
+                id: modelId,
+                pml: pml,
+                comment: comment,
+            },
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return '';
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }), catchError(this.httpService.handleValidationError));
+    }
+    generateProducts(modelId) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${modelId}/generate-products`,
+        });
+    }
+    saveModel(productModel, comment) {
+        const model = EntityUtil.clone(productModel);
+        model.comment = comment;
+        ModelTranslatorUtils.toServerModel(model);
+        return this.httpService
+            .api({
+            method: 'put',
+            url: `${this.SERVICE_URL}/${model.id}`,
+            body: model,
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return '';
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }), catchError(this.httpService.handleValidationError));
+    }
+    validateModel(productModel) {
+        return this.httpService
+            .api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/validate`,
+            body: productModel,
+            errorHandler: this.httpService.handleValidationError,
+        })
+            .pipe(map(result => {
+            if (result.successful) {
+                return '';
+            }
+            else {
+                throw new Error(result.message);
+            }
+        }));
+    }
+    renameModel(productModel, name) {
+        const model = EntityUtil.clone(productModel);
+        model.name = name;
+        ModelTranslatorUtils.toServerModel(model);
+        return this.httpService
+            .api({
+            method: 'patch',
+            url: `${this.SERVICE_URL}/${model.id}`,
+            body: model,
+        })
+            .pipe(catchError(this.httpService.handleValidationError));
+    }
+    uploadPmlFile(file, modelId) {
+        const formData = new FormData();
+        formData.append('file', file, file.name);
+        return this.httpService.upload({
+            url: `${this.SERVICE_URL}/${modelId}/pml/upload`,
+            body: formData,
+        });
+    }
+    runPml(modelId, pml, rootType, configurationMode) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/${modelId}/pml/run`,
+            body: {
+                pml,
+                rootType,
+                configurationMode,
+            },
+            responseType: 'text',
+        });
+    }
+    evictAllCache() {
+        return this.httpService.api({
+            method: 'get',
+            url: '/cache/evict/environment-variables',
+        });
+    }
+}
+ProductModelApiService.MAX_RESULTS = 200;
+ProductModelApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductModelApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductModelApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductModelApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductModelApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class QuoteApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/quotes';
+        /**
+         * @deprecated
+         * Will be removed in next major release
+         * Use `getQuoteDraft` instead
+         */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.getQuote = this.getQuoteDraft;
+    }
+    // request quoteId | accountId | opportunityId | orderId
+    getQuoteDraft(objectId, params, errorHandler) {
+        return this.httpService.api({
+            method: 'get',
+            url: `${this.SERVICE_URL}/${objectId}`,
+            params,
+            errorHandler,
+        });
+    }
+    upsertQuote(request, options) {
+        return this.httpService.api(Object.assign({ method: 'post', url: `${this.SERVICE_URL}`, body: request }, options));
+    }
+    submitQuote(request, options) {
+        return this.httpService.api(Object.assign({ method: 'post', url: `${this.SERVICE_URL}/submit`, body: request }, options));
+    }
+    attachDocument(id, documentName, data) {
+        const formData = new FormData();
+        const blob = new Blob([data]);
+        formData.append('file', blob, documentName);
+        return this.httpService.upload({
+            url: `${this.SERVICE_URL}/${id}/attach-document`,
+            responseType: 'arraybuffer',
+            method: 'post',
+            body: formData,
+        });
+    }
+}
+QuoteApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: QuoteApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+QuoteApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: QuoteApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: QuoteApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class RampApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/ramp';
+    }
+    next(request, options) {
+        return this.httpService.api(Object.assign({ method: 'post', url: `${this.SERVICE_URL}/next`, body: request }, options));
+    }
+    renew(request, options) {
+        return this.httpService.api(Object.assign({ method: 'post', url: `${this.SERVICE_URL}/renew`, body: request }, options));
+    }
+}
+RampApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RampApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+RampApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RampApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RampApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class RuleGroupsApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/rule-groups';
+        this.fetchRuleGroups$ = () => {
+            return this.searchRuleGroups$(new Expression(), 0, 100);
+        };
+        this.searchRuleGroups$ = (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.createRuleGroup$ = (ruleGroup) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}`,
+                method: 'post',
+                body: ruleGroup,
+            });
+        };
+        this.updateRuleGroup$ = (ruleGroup) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${ruleGroup.id}`,
+                method: 'post',
+                body: ruleGroup,
+            });
+        };
+        this.duplicateRuleGroup$ = (body) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.serviceUrl}/${body.id}/clone`,
+                method: 'post',
+                body,
+            })
+                .pipe(map$1(response => response.clonedRecordId));
+        };
+        this.removeRuleGroup$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreRuleGroup$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+    }
+}
+RuleGroupsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RuleGroupsApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+RuleGroupsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RuleGroupsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RuleGroupsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class RulesApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/rules';
+        this.fetchRules$ = () => {
+            return this.searchRules$(new Expression(), 0, 100);
+        };
+        this.searchRules$ = (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.createRule$ = (rule) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}`,
+                method: 'post',
+                body: rule,
+            });
+        };
+        this.updateRule$ = (rule) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${rule.id}`,
+                method: 'put',
+                body: rule,
+            });
+        };
+        this.duplicateRule$ = (body) => {
+            return this.baseHttpService
+                .api({
+                url: `${this.serviceUrl}/${body.id}/clone`,
+                method: 'post',
+                body,
+            })
+                .pipe(map(response => response.clonedRecordId));
+        };
+        this.removeRule$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreRule$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+    }
+    fetchRule$(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) {
+        return this.baseHttpService.api({
+            url: `/rules/execute`,
+            method: 'post',
+            body,
+        });
+    }
+}
+RulesApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RulesApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+RulesApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RulesApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RulesApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ScriptsApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/admin/scripts';
+        this.fetchScripts$ = () => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}` });
+        };
+        this.searchScripts$ = (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.fetchScript$ = (id) => {
+            return this.baseHttpService.api({ url: `${this.serviceUrl}/${id}` });
+        };
+        this.createScript$ = (script) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}`,
+                method: 'post',
+                body: script,
+            });
+        };
+        this.updateScriptMeta$ = (script) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${script.id}`,
+                method: 'put',
+                body: script,
+            });
+        };
+        this.updateScriptDetails$ = (script) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${script.id}`,
+                method: 'put',
+                body: script,
+            });
+        };
+        this.cloneScript$ = (cloneRequest) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${cloneRequest.id}/clone`,
+                method: 'post',
+                body: cloneRequest,
+            });
+        };
+        this.removeScript$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}`,
+                method: 'delete',
+            });
+        };
+        this.restoreScript$ = (id) => {
+            return this.baseHttpService.api({
+                url: `${this.serviceUrl}/${id}/restore`,
+                method: 'patch',
+            });
+        };
+        this.execute$ = (body) => {
+            return this.baseHttpService.api({
+                url: `/scripts/execute`,
+                method: 'post',
+                body,
+                errorHandler: () => null,
+            });
+        };
+    }
+}
+ScriptsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ScriptsApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ScriptsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ScriptsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ScriptsApiService, 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 UITemplatesApiService {
+    constructor(baseHttpService) {
+        this.baseHttpService = baseHttpService;
+        this.serviceUrl = '/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$1(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$1(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 } = story, rest = __rest(story, ["script", "template", "styles", "section"]);
+            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.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`,
+        });
+    }
+}
+UITemplatesApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UITemplatesApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+UITemplatesApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UITemplatesApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UITemplatesApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ApiModule {
+}
+ApiModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ApiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ApiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ApiModule, imports: [HttpClientModule] });
+ApiModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ApiModule, providers: [
+        BaseHttpService,
+        XrayService,
+        ConfigurationApiService,
+        ConfigurationSettingsApiService,
+        ContextApiService,
+        DocumentAttachmentApiService,
+        PriceApiService,
+        ProductModelApiService,
+        ProceduresApiService,
+        QuoteApiService,
+        DocumentTemplatesApiService,
+        RampApiService,
+        SalesforceApiService,
+        UITemplatesApiService,
+        ScriptsApiService,
+        RulesApiService,
+        RuleGroupsApiService,
+        FlowsApiService,
+        ProductApiService,
+        CatalogAdminApiService,
+        CatalogApiService,
+        DeltaApiService,
+        AccountApiService,
+        PicklistsApiService,
+    ], imports: [[HttpClientModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ApiModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [HttpClientModule],
+                    providers: [
+                        BaseHttpService,
+                        XrayService,
+                        ConfigurationApiService,
+                        ConfigurationSettingsApiService,
+                        ContextApiService,
+                        DocumentAttachmentApiService,
+                        PriceApiService,
+                        ProductModelApiService,
+                        ProceduresApiService,
+                        QuoteApiService,
+                        DocumentTemplatesApiService,
+                        RampApiService,
+                        SalesforceApiService,
+                        UITemplatesApiService,
+                        ScriptsApiService,
+                        RulesApiService,
+                        RuleGroupsApiService,
+                        FlowsApiService,
+                        ProductApiService,
+                        CatalogAdminApiService,
+                        CatalogApiService,
+                        DeltaApiService,
+                        AccountApiService,
+                        PicklistsApiService,
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AccountApiService, ApiModule, CatalogAdminApiService, CatalogApiService, ConfigurationApiService, ConfigurationSettingsApiService, ContextApiService, DeltaApiService, DocumentAttachmentApiService, DocumentTemplatesApiService, FlowsApiService, PicklistsApiService, PriceApiService, ProceduresApiService, ProductApiService, ProductModelApiService, QuoteApiService, RampApiService, RuleGroupsApiService, RulesApiService, SalesforceApiService, ScriptsApiService, UITemplatesApiService };
+//# sourceMappingURL=veloceapps-api.js.map