@veloceapps/api 1.0.0

package/fesm2015/veloce-api.js

@@ -0,0 +1,1686 @@
+import * as i4 from '@angular/common/http';
+import { HttpParams, HttpClientModule } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { Injectable, NgModule } from '@angular/core';
+import * as i1 from '@veloce/core';
+import { ModelTranslatorUtils, ConfigurationContextMode, QuoteDraft, DocxTemplater, StringUtils, ProductModelsContainer, ModelUtils, EntityUtil, UUID, BaseHttpService, XrayService } from '@veloce/core';
+import { throwError, forkJoin, zip, of, catchError as catchError$1, map as map$1, switchMap as switchMap$1 } from 'rxjs';
+import { map, tap, defaultIfEmpty, switchMap, catchError } 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 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, currency, sellingTerm, netPrice, listPrice, netUnitPrice, listUnitPrice, cost, priceAdjustment, priceWaterfalls, enablePriceAdjustment) {
+        this.chargeType = chargeType;
+        this.chargeMethod = chargeMethod;
+        this.properties = properties;
+        this.id = id;
+        this.chargeTypeDisplayValue = chargeTypeDisplayValue;
+        this.frequencyUnit = frequencyUnit;
+        this.frequencyDuration = frequencyDuration;
+        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.enablePriceAdjustment = enablePriceAdjustment;
+    }
+    static fromDTO(dto) {
+        var _a;
+        return {
+            id: dto.id,
+            chargeType: dto.chargeType,
+            chargeTypeDisplayValue: dto.chargeTypeDisplayValue,
+            chargeMethod: dto.chargeMethod,
+            frequencyUnit: dto.frequencyUnit,
+            frequencyDuration: dto.frequencyDuration,
+            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),
+            enablePriceAdjustment: dto.enablePriceAdjustment,
+            properties: dto.properties,
+        };
+    }
+}
+
+class ChargeItemDTO {
+    constructor(id, price, unitPrice, baseListPrice, baseListUnitPrice, listPrice, listUnitPrice, netPrice, netUnitPrice, chargeId, chargeType, chargeMethod, priceItemId, startDate, priceWaterfalls, quantity, properties, chargeTypeDisplayValue, arr, frequencyUnit, frequencyDuration, endDate, sellingTerm, currency, unitCost, cost, minUnitPrice, minPrice, enablePriceAdjustment, enableListPriceAdjustment, listPriceAdjustment, priceAdjustment) {
+        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.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;
+    }
+    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,
+            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),
+        };
+    }
+}
+
+class RecommendedPriceDTO {
+    constructor(netPrice, listPrice, chargeType, chargeMethod, explanation, frequencyDuration, frequencyUnit) {
+        this.netPrice = netPrice;
+        this.listPrice = listPrice;
+        this.chargeType = chargeType;
+        this.chargeMethod = chargeMethod;
+        this.explanation = explanation;
+        this.frequencyDuration = frequencyDuration;
+        this.frequencyUnit = frequencyUnit;
+    }
+    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,
+        };
+    }
+}
+
+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, productId, port, parentId, assetId, openOrderLineItemId, productName, rootId, actionCode, serviceStartDate, effectiveDate, startDate, endDate, planId, sellingFrequencyUnit, sellingFrequencyDuration, offeringId, offeringItemId, offeringInstanceId, rampInstanceId, enableRamp, configurable) {
+        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.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.startDate = startDate;
+        this.endDate = endDate;
+        this.planId = planId;
+        this.sellingFrequencyUnit = sellingFrequencyUnit;
+        this.sellingFrequencyDuration = sellingFrequencyDuration;
+        this.offeringId = offeringId;
+        this.offeringItemId = offeringItemId;
+        this.offeringInstanceId = offeringInstanceId;
+        this.rampInstanceId = rampInstanceId;
+        this.enableRamp = enableRamp;
+        this.configurable = configurable;
+    }
+    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,
+            parentId: dto.parentId,
+            assetId: dto.assetId,
+            openOrderLineItemId: dto.openOrderLineItemId,
+            productName: dto.productName,
+            rootId: dto.rootId,
+            actionCode: dto.actionCode,
+            serviceStartDate: dto.serviceStartDate,
+            effectiveDate: dto.effectiveDate,
+            startDate: dto.startDate,
+            endDate: dto.endDate,
+            planId: dto.planId,
+            sellingFrequencyUnit: dto.sellingFrequencyUnit,
+            sellingFrequencyDuration: dto.sellingFrequencyDuration,
+            offeringId: dto.offeringId,
+            offeringItemId: dto.offeringItemId,
+            offeringInstanceId: dto.offeringInstanceId,
+            rampInstanceId: dto.rampInstanceId,
+            enableRamp: dto.enableRamp,
+            configurable: dto.configurable,
+        };
+    }
+}
+
+class ConfigurationApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/configuration';
+    }
+    configureLineItem(configurationRequest, runtimeModel) {
+        return this.httpService
+            .api({
+            method: 'post',
+            url: `${this.SERVICE_URL}`,
+            body: configurationRequest,
+            errorHandler: e => throwError(e),
+        })
+            .pipe(map(response => {
+            const lineItem = LineItemDTO.fromDTO(response);
+            if (runtimeModel) {
+                return this.updatePortDomains(lineItem, runtimeModel);
+            }
+            else {
+                return lineItem;
+            }
+        }));
+    }
+    configureAndPriceLineItem(configurationRequest, runtimeModel) {
+        return this.httpService
+            .api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/price`,
+            body: configurationRequest,
+            errorHandler: e => throwError(e),
+        })
+            .pipe(map(response => {
+            const lineItem = LineItemDTO.fromDTO(response.lineItem);
+            return {
+                lineItem: this.updatePortDomains(lineItem, runtimeModel),
+                context: response.context,
+            };
+        }));
+    }
+    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.15", ngImport: i0, type: ConfigurationApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ConfigurationApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", 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() {
+        return this.httpService
+            .api({
+            url: `${this.SERVICE_URL}`,
+            method: 'get',
+        })
+            .pipe(map((settings) => settings.map(setting => ConfigurationSettingsDTO.fromDTO(setting))));
+    }
+    fetchSetting(settingsKey) {
+        return this.httpService
+            .api({
+            url: `${this.SERVICE_URL}/byKey/${settingsKey}`,
+            method: 'get',
+        })
+            .pipe(map((setting) => ConfigurationSettingsDTO.fromDTO(setting, settingsKey)));
+    }
+    createSetting(setting) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}`,
+            method: 'post',
+            body: Object.assign({}, request),
+        });
+    }
+    updateSetting(setting) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${request.id}`,
+            method: 'put',
+            body: Object.assign({}, request),
+        });
+    }
+    removeSetting(setting) {
+        const request = ConfigurationSettingsDTO.toDTO(setting);
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${request.id}`,
+            method: 'delete',
+        });
+    }
+    restoreSetting(settingId) {
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/${settingId}/restore`,
+            method: 'patch',
+        });
+    }
+    clear(name) {
+        return this.httpService
+            .api({
+            method: 'get',
+            url: '/cache/evict/' + name
+        });
+    }
+}
+ConfigurationSettingsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ConfigurationSettingsApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationSettingsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ConfigurationSettingsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", 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.15", ngImport: i0, type: ContextApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContextApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ContextApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ContextApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class DocumentAttachmentApiService {
+    constructor(httpService, fileDownloadService) {
+        this.httpService = httpService;
+        this.fileDownloadService = fileDownloadService;
+    }
+    getAttachments(searchRequest) {
+        return this.httpService.api({
+            url: '/attachments/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: `/attachments`,
+            body: formData,
+            method: 'post',
+            observe: reportProgress ? 'events' : undefined,
+            reportProgress,
+        });
+    }
+    updateAttachment(id, attachment) {
+        return this.httpService.api({
+            url: `/attachments/${id}`,
+            body: attachment,
+            method: 'put',
+        });
+    }
+    getAttachmentFile(id, isPreventDownload) {
+        return this.httpService
+            .api({
+            url: `/attachments/${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: `/attachments/${id}`,
+            method: 'delete',
+        });
+    }
+}
+DocumentAttachmentApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", 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.15", ngImport: i0, type: DocumentAttachmentApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", 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) {
+        return this.httpService.api({
+            method: 'post',
+            body: Object.assign(Object.assign({}, searchRequest), { count: searchRequest.count || 100 }),
+            url: `${this.SERVICE_URL}/query/${objectName}`,
+        });
+    }
+    queryObjects(search) {
+        const params = new HttpParams();
+        if (search) {
+            params.append('search', search);
+        }
+        return this.httpService.api({
+            url: `${this.SERVICE_URL}/query`,
+            params,
+        });
+    }
+    describe(objectName, fieldName) {
+        const methodUrl = `${this.SERVICE_URL}/describe/${objectName}/fields` + (fieldName ? `/${fieldName}` : '');
+        return this.httpService.api({ url: methodUrl });
+    }
+    describe2(objectName, fields) {
+        const methodUrl = `${this.SERVICE_URL}/describe/${objectName}/fields`;
+        return this.httpService.api({ method: 'post', url: methodUrl, body: fields });
+    }
+    apexGetRequest(path, params) {
+        return this.httpService.api({ url: `${this.SERVICE_URL}/apex${path}`, params });
+    }
+    apexPostRequest(path, body) {
+        return this.httpService.api({
+            method: 'post',
+            body,
+            url: `${this.SERVICE_URL}/apex${path}`,
+        });
+    }
+}
+SalesforceApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SalesforceApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+SalesforceApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SalesforceApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SalesforceApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+const moment = moment_;
+const mapSfQueryResult = (limit) => map((records) => {
+    if (!records.length) {
+        return { _result: 'No Records Found' };
+    }
+    if (limit === 1) {
+        return records[0];
+    }
+    return records;
+});
+const mapBooleanIfAplicable = (value) => {
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    return value;
+};
+class DocumentTemplatesApiService {
+    constructor(service, sfRepo, fileDownloadService, documentAttachmentService, http) {
+        this.service = service;
+        this.sfRepo = sfRepo;
+        this.fileDownloadService = fileDownloadService;
+        this.documentAttachmentService = documentAttachmentService;
+        this.http = http;
+        this.fallbackDocGenHost = 'https://dev-dp1.velocpq.com/docgen';
+        if (window.VELO_DOCGEN_API) {
+            this.docGenHost = window.VELO_DOCGEN_API;
+        }
+        else {
+            console.log(`window.VELO_DOCGEN_API not set, will use fallback "${this.fallbackDocGenHost}"`);
+            this.docGenHost = this.fallbackDocGenHost;
+        }
+    }
+    getTemplates(tag) {
+        return this.service.api({
+            url: '/templates',
+            method: 'get',
+            params: Object.assign({}, (tag && { tag })),
+        });
+    }
+    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',
+        }));
+        return this.service.upload({
+            url: `/templates` + ((template.id && `/${template.id}`) || ''),
+            body: formData,
+            method: template.id ? 'put' : 'post',
+            reportProgress,
+        });
+    }
+    removeTemplate(id) {
+        return this.service.api({
+            url: '/templates' + id,
+            method: 'delete',
+        });
+    }
+    cloneTemplate(id) {
+        return this.service.api({
+            url: '/templates/clone/' + id,
+            method: 'post',
+        });
+    }
+    generateDocumentData(template, object, params) {
+        var _a, _b, _c, _d;
+        const shouldPreventDownload = params === null || params === void 0 ? void 0 : params.shouldPreventDownload;
+        const useLocalDataGeneration = (_b = (_a = template.properties) === null || _a === void 0 ? void 0 : _a.find(({ name }) => name === 'useLocalDataGeneration')) === null || _b === void 0 ? void 0 : _b.value;
+        if (!useLocalDataGeneration && object instanceof QuoteDraft) {
+            return this.generate('/templates/generate-data', { template, quote: object }, shouldPreventDownload, shouldPreventDownload ? 'json' : 'blob');
+        }
+        const allQueries = [...((_c = template === null || template === void 0 ? void 0 : template.queries) !== null && _c !== void 0 ? _c : [])];
+        const properties = ((_d = object === null || object === void 0 ? void 0 : object.context) === null || _d === void 0 ? void 0 : _d.properties) || (object === null || object === void 0 ? void 0 : object.properties) || {};
+        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([]))
+            .pipe(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]: 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;
+        }));
+    }
+    generateDocument(template, object, params = {}) {
+        const attachmentIds = (template.attachments || []).map(({ id }) => id).filter(Boolean);
+        const { shouldUseLocalDocxTemplater } = params;
+        return shouldUseLocalDocxTemplater && !(object instanceof QuoteDraft)
+            ? this.generateDocumentNew(template, object, params)
+            : this.generateWithBackendDocxTemplater({ template, quote: object, attachmentIds, params });
+    }
+    generateDocumentNew(template, object, params = {}) {
+        const { attachToQuote, documentFormat, shouldPreventDownload } = params;
+        const file$ = this.service.api({
+            method: 'get',
+            url: `/templates/${template.id}/file`,
+            responseType: 'arraybuffer',
+        });
+        const attachmentIds = (template.attachments || []).map(({ id }) => id);
+        const attachments$ = attachmentIds.length
+            ? attachmentIds.map(attachmentId => {
+                return this.documentAttachmentService.getAttachmentFile(attachmentId, true);
+            })
+            : [];
+        const data$ = this.generateDocumentData(template, object, Object.assign(Object.assign({}, params), { shouldPreventDownload: true }));
+        return zip(file$, data$, ...attachments$).pipe(switchMap(([file, data, ...attachments]) => {
+            var _a;
+            const d = DocxTemplater.generate(file, data);
+            const body = new FormData();
+            const properties = ((_a = object === null || object === void 0 ? void 0 : object.context) === null || _a === void 0 ? void 0 : _a.properties) || (object === null || object === void 0 ? void 0 : object.properties) || {};
+            const documentName = (properties === null || properties === void 0 ? void 0 : properties.Name) || template.name;
+            // TODO: special CATO case. Refactor for a more generic approach
+            if (documentFormat === 'DOCX') {
+                this.fileDownloadService.processDownload(d, documentName);
+                return of(d);
+            }
+            attachments.forEach((attachment) => {
+                body.append('attachments', new Blob([attachment]));
+            });
+            body.append('orderform', d);
+            return this.http
+                .post(`${this.docGenHost}/documents/merge`, body, {
+                responseType: 'arraybuffer',
+            })
+                .pipe(switchMap((pdf) => {
+                const blob = new Blob([pdf]);
+                if (!shouldPreventDownload) {
+                    this.fileDownloadService.processDownload(blob, `${documentName}.pdf`);
+                }
+                if (attachToQuote && object instanceof QuoteDraft) {
+                    const formData = new FormData();
+                    formData.append('file', blob, `${documentName}.pdf`);
+                    return this.http.post(`${window['VELO_API']}/services/quotes/${object.quoteId}/attach-document`, formData, {
+                        responseType: 'arraybuffer',
+                        headers: {
+                            Authorization: window['VELO_KEY'],
+                        },
+                    });
+                }
+                return of(blob);
+            }));
+        }));
+    }
+    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);
+    }
+    downloadTemplateFile(id) {
+        return this.service
+            .api({
+            url: `/templates/${id}/file`,
+            responseType: 'blob',
+            observe: 'response',
+        })
+            .pipe(tap(response => {
+            this.fileDownloadService.processDownload(response);
+        }), map(response => response.body || response));
+    }
+    generateWithBackendDocxTemplater({ template, quote, attachmentIds, params, }) {
+        const { shouldPreventDownload } = params;
+        const nonEmptyParams = Object.keys(params || {})
+            .filter(k => params[k] !== undefined)
+            .reduce((obj, key) => {
+            obj[key] = params[key];
+            return obj;
+        }, {});
+        return this.generate(`/templates/${template.id}/generate`, { quote, attachments: attachmentIds }, Boolean(shouldPreventDownload), 'blob', nonEmptyParams, false);
+    }
+    generate(url, body, shouldPreventDownload, responseType, params, isUpload, reportProgress) {
+        const requestOptions = {
+            method: 'post',
+            url,
+            body,
+            reportProgress,
+            responseType,
+            observe: shouldPreventDownload ? 'body' : 'response',
+            params,
+        };
+        return (isUpload ? this.service.upload(requestOptions) : this.service.api(requestOptions)).pipe(tap(response => {
+            if (!shouldPreventDownload) {
+                this.fileDownloadService.processDownload(response);
+            }
+        }));
+    }
+    queryObject({ objectName, resultObjectName, fields, statement }, { properties }) {
+        var _a;
+        const patternLimit = /(\s*limit\s\d*)/i;
+        let limit = 1;
+        if (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 = StringUtils.fillPlaceholders(statement, properties, /:\s*(\w[\w\d_.]+)/i);
+        const searchRequest = Object.assign({ skip: 0, count: limit, rawCondition: resolvedStatement }, ((fields === null || fields === void 0 ? void 0 : fields.length) && !!fields[0] && { fields }));
+        return this.sfRepo.query(searchRequest, objectName).pipe(mapSfQueryResult(limit), map(value => ({ [resultObjectName]: value })));
+    }
+}
+DocumentTemplatesApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", 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.15", ngImport: i0, type: DocumentTemplatesApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: DocumentTemplatesApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }, { type: SalesforceApiService }, { type: i1.FileDownloadService }, { type: DocumentAttachmentApiService }, { type: i4.HttpClient }]; } });
+
+class PriceApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/price';
+    }
+    calculateRuntime(request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/calculate-runtime`,
+            body: request,
+        });
+    }
+    calculate(request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/calculate`,
+            body: request,
+        });
+        // TODO: move outside API service
+        // .pipe(
+        //   map(data => {
+        //     if (data.context) {
+        //       const context = this.contextService.resolveOrCreate();
+        //       const patchedContext = {
+        //         ...context,
+        //         properties: {
+        //           ...context.properties,
+        //           ...data.context.properties,
+        //         },
+        //       };
+        //       this.contextService.update(patchedContext);
+        //     }
+        //     return data;
+        //   }),
+        // );
+    }
+    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.15", ngImport: i0, type: PriceApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+PriceApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PriceApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PriceApiService, 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.15", ngImport: i0, type: ProductModelApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductModelApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ProductModelApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ProductModelApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class QuoteApiService {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.SERVICE_URL = '/quotes';
+    }
+    getQuote(quoteId, params) {
+        return this.httpService.api({
+            method: 'get',
+            url: `${this.SERVICE_URL}/${quoteId}`,
+            params,
+        });
+    }
+    upsertQuote(request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}`,
+            body: request,
+        });
+    }
+    submitQuote(request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/submit`,
+            body: request,
+        });
+    }
+}
+QuoteApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: QuoteApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+QuoteApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: QuoteApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", 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) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/next`,
+            body: request,
+        });
+    }
+    renew(request) {
+        return this.httpService.api({
+            method: 'post',
+            url: `${this.SERVICE_URL}/renew`,
+            body: request,
+        });
+        // TODO: move out of API service
+        // .pipe(
+        //   map(data => {
+        //     if (data.context) {
+        //       const context = this.contextService.resolveOrCreate();
+        //       Object.keys(data.context.properties).forEach(function (key) {
+        //         context.properties[key] = data.context.properties[key];
+        //       });
+        //       this.contextService.update(context);
+        //     }
+        //     return data;
+        //   }),
+        // );
+    }
+}
+RampApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: RampApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+RampApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: RampApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: RampApiService, 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,
+        templateHtmlId: dto.templateHtmlId,
+        scriptJsId: dto.scriptJsId,
+        styleCssId: dto.styleCssId,
+        sectionJsonId: dto.sectionJsonId,
+        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) => {
+            // TODO: integrate with BE
+            return of(UUID.UUID());
+        };
+        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) => {
+            // TODO: integrate with BE
+            return of(UUID.UUID());
+        };
+        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',
+            })
+                .pipe(catchError$1(() => of('')));
+        };
+        this.convertToComponentStory$ = (templateId, componentId, storyDto) => {
+            return forkJoin([
+                storyDto.templateHtmlId ? this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'html') : of(undefined),
+                storyDto.scriptJsId ? this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'js') : of(undefined),
+                storyDto.styleCssId ? this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'css') : of(undefined),
+                storyDto.sectionJsonId ? this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'json') : of(undefined),
+            ]).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.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([
+                component.templateHtmlId ? this.fetchComponentAttachmentFile$(templateId, component.id, 'html') : of(undefined),
+                component.scriptJsId ? this.fetchComponentAttachmentFile$(templateId, component.id, 'js') : of(undefined),
+                component.styleCssId ? this.fetchComponentAttachmentFile$(templateId, component.id, 'css') : of(undefined),
+                component.propertiesJsonId ? this.fetchComponentAttachmentFile$(templateId, component.id, 'json') : of(undefined),
+            ]).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',
+            })
+                .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.15", ngImport: i0, type: UITemplatesApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+UITemplatesApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UITemplatesApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UITemplatesApiService, 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: 'post',
+                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,
+            });
+        };
+    }
+}
+ScriptsApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ScriptsApiService, deps: [{ token: i1.BaseHttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+ScriptsApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ScriptsApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ScriptsApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseHttpService }]; } });
+
+class ApiModule {
+}
+ApiModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ApiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ApiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ApiModule, imports: [HttpClientModule] });
+ApiModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ApiModule, providers: [
+        BaseHttpService,
+        XrayService,
+        ConfigurationApiService,
+        ConfigurationSettingsApiService,
+        ContextApiService,
+        DocumentAttachmentApiService,
+        PriceApiService,
+        ProductModelApiService,
+        QuoteApiService,
+        DocumentTemplatesApiService,
+        RampApiService,
+        SalesforceApiService,
+        UITemplatesApiService,
+        ScriptsApiService,
+    ], imports: [[HttpClientModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ApiModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [HttpClientModule],
+                    providers: [
+                        BaseHttpService,
+                        XrayService,
+                        ConfigurationApiService,
+                        ConfigurationSettingsApiService,
+                        ContextApiService,
+                        DocumentAttachmentApiService,
+                        PriceApiService,
+                        ProductModelApiService,
+                        QuoteApiService,
+                        DocumentTemplatesApiService,
+                        RampApiService,
+                        SalesforceApiService,
+                        UITemplatesApiService,
+                        ScriptsApiService,
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ApiModule, ConfigurationApiService, ConfigurationSettingsApiService, ContextApiService, DocumentAttachmentApiService, DocumentTemplatesApiService, PriceApiService, ProductModelApiService, QuoteApiService, RampApiService, SalesforceApiService, ScriptsApiService, UITemplatesApiService };
+//# sourceMappingURL=veloce-api.js.map