@veloceapps/api 1.0.0

package/bundles/veloce-api.umd.js

@@ -0,0 +1,2117 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common/http'), require('@angular/core'), require('@veloce/core'), require('rxjs'), require('rxjs/operators'), require('lodash'), require('@angular/common'), require('moment')) :
+    typeof define === 'function' && define.amd ? define('@veloce/api', ['exports', '@angular/common/http', '@angular/core', '@veloce/core', 'rxjs', 'rxjs/operators', 'lodash', '@angular/common', 'moment'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.veloce = global.veloce || {}, global.veloce.api = {}), global.ng.common.http, global.ng.core, global["@veloce/core"], global.rxjs, global.rxjs.operators, global.lodash, global.ng.common, global.moment));
+})(this, (function (exports, i4, i0, i1, rxjs, operators, _, common, moment_) { 'use strict';
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n["default"] = e;
+        return Object.freeze(n);
+    }
+
+    var i4__namespace = /*#__PURE__*/_interopNamespace(i4);
+    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
+    var i1__namespace = /*#__PURE__*/_interopNamespace(i1);
+    var ___namespace = /*#__PURE__*/_interopNamespace(_);
+    var moment___namespace = /*#__PURE__*/_interopNamespace(moment_);
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b)
+                if (Object.prototype.hasOwnProperty.call(b, p))
+                    d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    var __assign = function () {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s)
+                    if (Object.prototype.hasOwnProperty.call(s, p))
+                        t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+                t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+            r = Reflect.decorate(decorators, target, key, desc);
+        else
+            for (var i = decorators.length - 1; i >= 0; i--)
+                if (d = decorators[i])
+                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); };
+    }
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+            return Reflect.metadata(metadataKey, metadataValue);
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try {
+                step(generator.next(value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function rejected(value) { try {
+                step(generator["throw"](value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function () { if (t[0] & 1)
+                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f)
+                throw new TypeError("Generator is already executing.");
+            while (_)
+                try {
+                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                        return t;
+                    if (y = 0, t)
+                        op = [op[0] & 2, t.value];
+                    switch (op[0]) {
+                        case 0:
+                        case 1:
+                            t = op;
+                            break;
+                        case 4:
+                            _.label++;
+                            return { value: op[1], done: false };
+                        case 5:
+                            _.label++;
+                            y = op[1];
+                            op = [0];
+                            continue;
+                        case 7:
+                            op = _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                        default:
+                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                                _ = 0;
+                                continue;
+                            }
+                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                                _.label = op[1];
+                                break;
+                            }
+                            if (op[0] === 6 && _.label < t[1]) {
+                                _.label = t[1];
+                                t = op;
+                                break;
+                            }
+                            if (t && _.label < t[2]) {
+                                _.label = t[2];
+                                _.ops.push(op);
+                                break;
+                            }
+                            if (t[2])
+                                _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                    }
+                    op = body.call(thisArg, _);
+                }
+                catch (e) {
+                    op = [6, e];
+                    y = 0;
+                }
+                finally {
+                    f = t = 0;
+                }
+            if (op[0] & 5)
+                throw op[1];
+            return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+    var __createBinding = Object.create ? (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
+    }) : (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        o[k2] = m[k];
+    });
+    function __exportStar(m, o) {
+        for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
+                __createBinding(o, m, p);
+    }
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m)
+            return m.call(o);
+        if (o && typeof o.length === "number")
+            return {
+                next: function () {
+                    if (o && i >= o.length)
+                        o = void 0;
+                    return { value: o && o[i++], done: !o };
+                }
+            };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+            return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+                ar.push(r.value);
+        }
+        catch (error) {
+            e = { error: error };
+        }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"]))
+                    m.call(i);
+            }
+            finally {
+                if (e)
+                    throw e.error;
+            }
+        }
+        return ar;
+    }
+    /** @deprecated */
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+    /** @deprecated */
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+            s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2)
+            for (var i = 0, l = from.length, ar; i < l; i++) {
+                if (ar || !(i in from)) {
+                    if (!ar)
+                        ar = Array.prototype.slice.call(from, 0, i);
+                    ar[i] = from[i];
+                }
+            }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n])
+            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try {
+            step(g[n](v));
+        }
+        catch (e) {
+            settle(q[0][3], e);
+        } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length)
+            resume(q[0][0], q[0][1]); }
+    }
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
+    }
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) {
+            Object.defineProperty(cooked, "raw", { value: raw });
+        }
+        else {
+            cooked.raw = raw;
+        }
+        return cooked;
+    }
+    ;
+    var __setModuleDefault = Object.create ? (function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function (o, v) {
+        o["default"] = v;
+    };
+    function __importStar(mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k in mod)
+                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+                    __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    }
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a getter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+        if (kind === "m")
+            throw new TypeError("Private method is not writable");
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a setter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+    }
+
+    var AttributeDTO = /** @class */ (function () {
+        function AttributeDTO(name, type, value, cfgStatus, id, scale) {
+            this.name = name;
+            this.type = type;
+            this.value = value;
+            this.cfgStatus = cfgStatus;
+            this.id = id;
+            this.scale = scale;
+        }
+        AttributeDTO.fromDTO = function (dto) {
+            return {
+                id: dto.id,
+                name: dto.name,
+                type: dto.type,
+                scale: dto.scale,
+                value: dto.value,
+                cfgStatus: dto.cfgStatus,
+            };
+        };
+        return AttributeDTO;
+    }());
+
+    var PriceAdjustmentDTO = /** @class */ (function () {
+        function PriceAdjustmentDTO(amount, explanation, type) {
+            this.amount = amount;
+            this.explanation = explanation;
+            this.type = type;
+        }
+        PriceAdjustmentDTO.fromDTO = function (dto) {
+            return {
+                amount: dto.amount,
+                explanation: dto.explanation,
+                type: dto.type,
+            };
+        };
+        return PriceAdjustmentDTO;
+    }());
+
+    var ChargeGroupItemDTO = /** @class */ (function () {
+        function ChargeGroupItemDTO(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;
+        }
+        ChargeGroupItemDTO.fromDTO = function (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,
+            };
+        };
+        return ChargeGroupItemDTO;
+    }());
+
+    var ChargeItemDTO = /** @class */ (function () {
+        function ChargeItemDTO(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;
+        }
+        ChargeItemDTO.fromDTO = function (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),
+            };
+        };
+        return ChargeItemDTO;
+    }());
+
+    var RecommendedPriceDTO = /** @class */ (function () {
+        function RecommendedPriceDTO(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;
+        }
+        RecommendedPriceDTO.fromDTO = function (dto) {
+            return {
+                netPrice: dto.netPrice,
+                listPrice: dto.listPrice,
+                chargeType: dto.chargeType,
+                chargeMethod: dto.chargeMethod,
+                frequencyUnit: dto.frequencyUnit,
+                frequencyDuration: dto.frequencyDuration,
+                explanation: dto.explanation,
+            };
+        };
+        return RecommendedPriceDTO;
+    }());
+
+    var DomainTypeDTO = /** @class */ (function () {
+        function DomainTypeDTO(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;
+        }
+        DomainTypeDTO.fromDTO = function (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,
+            };
+        };
+        return DomainTypeDTO;
+    }());
+
+    var PortDomainDTO = /** @class */ (function () {
+        function PortDomainDTO(name, type, minCard, maxCard, domainTypes, properties) {
+            this.name = name;
+            this.type = type;
+            this.minCard = minCard;
+            this.maxCard = maxCard;
+            this.domainTypes = domainTypes;
+            this.properties = properties;
+        }
+        PortDomainDTO.fromDTO = function (dto) {
+            return {
+                name: dto.name,
+                type: dto.type,
+                minCard: dto.minCard,
+                maxCard: dto.maxCard,
+                domainTypes: dto.domainTypes.map(DomainTypeDTO.fromDTO),
+                properties: dto.properties,
+            };
+        };
+        return PortDomainDTO;
+    }());
+
+    var PriceDTO = /** @class */ (function () {
+        function PriceDTO(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;
+        }
+        PriceDTO.fromDTO = function (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,
+            };
+        };
+        return PriceDTO;
+    }());
+
+    var LineItemDTO = /** @class */ (function () {
+        function LineItemDTO(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;
+        }
+        LineItemDTO.fromDTO = function (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, function (result, value, key) { return (result[key] = PortDomainDTO.fromDTO(value)); }),
+                properties: dto.properties,
+                qty: dto.qty,
+                totalPrices: _.transform(dto.totalPrices, function (result, value, key) { return (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,
+            };
+        };
+        return LineItemDTO;
+    }());
+
+    var ConfigurationApiService = /** @class */ (function () {
+        function ConfigurationApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/configuration';
+        }
+        ConfigurationApiService.prototype.configureLineItem = function (configurationRequest, runtimeModel) {
+            var _this = this;
+            return this.httpService
+                .api({
+                method: 'post',
+                url: "" + this.SERVICE_URL,
+                body: configurationRequest,
+                errorHandler: function (e) { return rxjs.throwError(e); },
+            })
+                .pipe(operators.map(function (response) {
+                var lineItem = LineItemDTO.fromDTO(response);
+                if (runtimeModel) {
+                    return _this.updatePortDomains(lineItem, runtimeModel);
+                }
+                else {
+                    return lineItem;
+                }
+            }));
+        };
+        ConfigurationApiService.prototype.configureAndPriceLineItem = function (configurationRequest, runtimeModel) {
+            var _this = this;
+            return this.httpService
+                .api({
+                method: 'post',
+                url: this.SERVICE_URL + "/price",
+                body: configurationRequest,
+                errorHandler: function (e) { return rxjs.throwError(e); },
+            })
+                .pipe(operators.map(function (response) {
+                var lineItem = LineItemDTO.fromDTO(response.lineItem);
+                return {
+                    lineItem: _this.updatePortDomains(lineItem, runtimeModel),
+                    context: response.context,
+                };
+            }));
+        };
+        ConfigurationApiService.prototype.getRuntimeDataByProductId = function (productId, offeringId) {
+            return this.httpService
+                .api({
+                method: 'get',
+                url: this.SERVICE_URL + "/" + productId + "/model" + ((offeringId && "/" + offeringId) || ''),
+            })
+                .pipe(operators.map(function (runtimeData) {
+                runtimeData.uiDefinitions = JSON.parse(runtimeData.uiDefinitionsSource);
+                runtimeData.uiDefinitions.forEach(function (uiDefinition) {
+                    i1.ModelTranslatorUtils.toLocalUIDefinition(uiDefinition);
+                });
+                return runtimeData;
+            }));
+        };
+        ConfigurationApiService.prototype.getRuntimeDataByModelId = function (modelId) {
+            return this.httpService
+                .api({
+                method: 'get',
+                url: this.SERVICE_URL + "/" + modelId + "/model-test",
+            })
+                .pipe(operators.map(function (runtimeData) {
+                runtimeData.uiDefinitions = [];
+                return runtimeData;
+            }));
+        };
+        ConfigurationApiService.prototype.updatePortDomains = function (lineItem, runtimeModel) {
+            var e_1, _d;
+            var _this = this;
+            var _a, _b, _c;
+            var type = runtimeModel.components.get(lineItem.type);
+            var portDomains = Object.assign({}, lineItem.portDomains);
+            try {
+                for (var _e = __values((_a = type === null || type === void 0 ? void 0 : type.ports) !== null && _a !== void 0 ? _a : []), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var port = _f.value;
+                    var 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;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_d = _e.return)) _d.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return Object.assign(Object.assign({}, lineItem), { lineItems: (_c = lineItem.lineItems) === null || _c === void 0 ? void 0 : _c.map(function (i) { return _this.updatePortDomains(i, runtimeModel); }), portDomains: portDomains });
+        };
+        return ConfigurationApiService;
+    }());
+    ConfigurationApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ConfigurationApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    ConfigurationApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ConfigurationApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ConfigurationApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var ConfigurationSettingsDTO = /** @class */ (function () {
+        function ConfigurationSettingsDTO(id, key, value) {
+            this.id = id;
+            this.key = key;
+            this.value = value;
+        }
+        ConfigurationSettingsDTO.fromDTO = function (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,
+            };
+        };
+        ConfigurationSettingsDTO.toDTO = function (data) {
+            return {
+                id: data.id,
+                key: data.key,
+                value: data.value,
+            };
+        };
+        return ConfigurationSettingsDTO;
+    }());
+
+    var ConfigurationSettingsApiService = /** @class */ (function () {
+        function ConfigurationSettingsApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/configuration-settings';
+        }
+        ConfigurationSettingsApiService.prototype.fetchSettings = function () {
+            return this.httpService
+                .api({
+                url: "" + this.SERVICE_URL,
+                method: 'get',
+            })
+                .pipe(operators.map(function (settings) { return settings.map(function (setting) { return ConfigurationSettingsDTO.fromDTO(setting); }); }));
+        };
+        ConfigurationSettingsApiService.prototype.fetchSetting = function (settingsKey) {
+            return this.httpService
+                .api({
+                url: this.SERVICE_URL + "/byKey/" + settingsKey,
+                method: 'get',
+            })
+                .pipe(operators.map(function (setting) { return ConfigurationSettingsDTO.fromDTO(setting, settingsKey); }));
+        };
+        ConfigurationSettingsApiService.prototype.createSetting = function (setting) {
+            var request = ConfigurationSettingsDTO.toDTO(setting);
+            return this.httpService.api({
+                url: "" + this.SERVICE_URL,
+                method: 'post',
+                body: Object.assign({}, request),
+            });
+        };
+        ConfigurationSettingsApiService.prototype.updateSetting = function (setting) {
+            var request = ConfigurationSettingsDTO.toDTO(setting);
+            return this.httpService.api({
+                url: this.SERVICE_URL + "/" + request.id,
+                method: 'put',
+                body: Object.assign({}, request),
+            });
+        };
+        ConfigurationSettingsApiService.prototype.removeSetting = function (setting) {
+            var request = ConfigurationSettingsDTO.toDTO(setting);
+            return this.httpService.api({
+                url: this.SERVICE_URL + "/" + request.id,
+                method: 'delete',
+            });
+        };
+        ConfigurationSettingsApiService.prototype.restoreSetting = function (settingId) {
+            return this.httpService.api({
+                url: this.SERVICE_URL + "/" + settingId + "/restore",
+                method: 'patch',
+            });
+        };
+        ConfigurationSettingsApiService.prototype.clear = function (name) {
+            return this.httpService
+                .api({
+                method: 'get',
+                url: '/cache/evict/' + name
+            });
+        };
+        return ConfigurationSettingsApiService;
+    }());
+    ConfigurationSettingsApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ConfigurationSettingsApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    ConfigurationSettingsApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ConfigurationSettingsApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ConfigurationSettingsApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var ContextApiService = /** @class */ (function () {
+        function ContextApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/context';
+        }
+        ContextApiService.prototype.getContext = function (headerId, mode) {
+            return this.httpService.api({
+                method: 'post',
+                body: {
+                    headerId: headerId,
+                    contextMode: i1.ConfigurationContextMode[mode],
+                },
+                url: "" + this.SERVICE_URL,
+            });
+        };
+        return ContextApiService;
+    }());
+    ContextApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ContextApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    ContextApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ContextApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ContextApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var DocumentAttachmentApiService = /** @class */ (function () {
+        function DocumentAttachmentApiService(httpService, fileDownloadService) {
+            this.httpService = httpService;
+            this.fileDownloadService = fileDownloadService;
+        }
+        DocumentAttachmentApiService.prototype.getAttachments = function (searchRequest) {
+            return this.httpService.api({
+                url: '/attachments/search',
+                method: 'post',
+                body: searchRequest,
+            });
+        };
+        DocumentAttachmentApiService.prototype.createAttachment = function (attachment, file, reportProgress) {
+            var 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: reportProgress,
+            });
+        };
+        DocumentAttachmentApiService.prototype.updateAttachment = function (id, attachment) {
+            return this.httpService.api({
+                url: "/attachments/" + id,
+                body: attachment,
+                method: 'put',
+            });
+        };
+        DocumentAttachmentApiService.prototype.getAttachmentFile = function (id, isPreventDownload) {
+            var _this = this;
+            return this.httpService
+                .api({
+                url: "/attachments/" + id + "/file",
+                responseType: isPreventDownload ? 'arraybuffer' : 'blob',
+                observe: isPreventDownload ? 'body' : 'response',
+            })
+                .pipe(operators.tap(function (response) {
+                if (!isPreventDownload) {
+                    _this.fileDownloadService.processDownload(response);
+                }
+            }), operators.map(function (response) { return (isPreventDownload ? new Blob([response.body || response]) : response.body || response); }));
+        };
+        DocumentAttachmentApiService.prototype.removeAttachment = function (id) {
+            return this.httpService.api({
+                url: "/attachments/" + id,
+                method: 'delete',
+            });
+        };
+        return DocumentAttachmentApiService;
+    }());
+    DocumentAttachmentApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: DocumentAttachmentApiService, deps: [{ token: i1__namespace.BaseHttpService }, { token: i1__namespace.FileDownloadService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    DocumentAttachmentApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: DocumentAttachmentApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: DocumentAttachmentApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }, { type: i1__namespace.FileDownloadService }]; } });
+
+    var SalesforceApiService = /** @class */ (function () {
+        function SalesforceApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/proxy';
+        }
+        SalesforceApiService.prototype.query = function (searchRequest, objectName) {
+            return this.httpService.api({
+                method: 'post',
+                body: Object.assign(Object.assign({}, searchRequest), { count: searchRequest.count || 100 }),
+                url: this.SERVICE_URL + "/query/" + objectName,
+            });
+        };
+        SalesforceApiService.prototype.queryObjects = function (search) {
+            var params = new i4.HttpParams();
+            if (search) {
+                params.append('search', search);
+            }
+            return this.httpService.api({
+                url: this.SERVICE_URL + "/query",
+                params: params,
+            });
+        };
+        SalesforceApiService.prototype.describe = function (objectName, fieldName) {
+            var methodUrl = this.SERVICE_URL + "/describe/" + objectName + "/fields" + (fieldName ? "/" + fieldName : '');
+            return this.httpService.api({ url: methodUrl });
+        };
+        SalesforceApiService.prototype.describe2 = function (objectName, fields) {
+            var methodUrl = this.SERVICE_URL + "/describe/" + objectName + "/fields";
+            return this.httpService.api({ method: 'post', url: methodUrl, body: fields });
+        };
+        SalesforceApiService.prototype.apexGetRequest = function (path, params) {
+            return this.httpService.api({ url: this.SERVICE_URL + "/apex" + path, params: params });
+        };
+        SalesforceApiService.prototype.apexPostRequest = function (path, body) {
+            return this.httpService.api({
+                method: 'post',
+                body: body,
+                url: this.SERVICE_URL + "/apex" + path,
+            });
+        };
+        return SalesforceApiService;
+    }());
+    SalesforceApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: SalesforceApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    SalesforceApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: SalesforceApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: SalesforceApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var moment = moment___namespace;
+    var mapSfQueryResult = function (limit) { return operators.map(function (records) {
+        if (!records.length) {
+            return { _result: 'No Records Found' };
+        }
+        if (limit === 1) {
+            return records[0];
+        }
+        return records;
+    }); };
+    var mapBooleanIfAplicable = function (value) {
+        if (value === 'true') {
+            return true;
+        }
+        if (value === 'false') {
+            return false;
+        }
+        return value;
+    };
+    var DocumentTemplatesApiService = /** @class */ (function () {
+        function DocumentTemplatesApiService(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;
+            }
+        }
+        DocumentTemplatesApiService.prototype.getTemplates = function (tag) {
+            return this.service.api({
+                url: '/templates',
+                method: 'get',
+                params: Object.assign({}, (tag && { tag: tag })),
+            });
+        };
+        DocumentTemplatesApiService.prototype.upsertTemplate = function (template, file, reportProgress) {
+            var 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: reportProgress,
+            });
+        };
+        DocumentTemplatesApiService.prototype.removeTemplate = function (id) {
+            return this.service.api({
+                url: '/templates' + id,
+                method: 'delete',
+            });
+        };
+        DocumentTemplatesApiService.prototype.cloneTemplate = function (id) {
+            return this.service.api({
+                url: '/templates/clone/' + id,
+                method: 'post',
+            });
+        };
+        DocumentTemplatesApiService.prototype.generateDocumentData = function (template, object, params) {
+            var _this = this;
+            var _a, _b, _c, _d;
+            var shouldPreventDownload = params === null || params === void 0 ? void 0 : params.shouldPreventDownload;
+            var useLocalDataGeneration = (_b = (_a = template.properties) === null || _a === void 0 ? void 0 : _a.find(function (_e) {
+                var name = _e.name;
+                return name === 'useLocalDataGeneration';
+            })) === null || _b === void 0 ? void 0 : _b.value;
+            if (!useLocalDataGeneration && object instanceof i1.QuoteDraft) {
+                return this.generate('/templates/generate-data', { template: template, quote: object }, shouldPreventDownload, shouldPreventDownload ? 'json' : 'blob');
+            }
+            var allQueries = __spreadArray([], __read(((_c = template === null || template === void 0 ? void 0 : template.queries) !== null && _c !== void 0 ? _c : [])));
+            var 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) || {};
+            var accountId = properties === null || properties === void 0 ? void 0 : properties.AccountId;
+            var 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: [],
+                });
+            }
+            var queries = allQueries.map(function (query) { return _this.queryObject(query, { properties: properties }); }) || [];
+            return rxjs.forkJoin(__spreadArray([], __read(queries)))
+                .pipe(operators.defaultIfEmpty([]))
+                .pipe(operators.map(function (results) {
+                var _a, _b, _c, _d;
+                var queriesResult = ___namespace.chain(results)
+                    .reduce(function (acc, r) {
+                    if (r) {
+                        return Object.assign(Object.assign({}, acc), r);
+                    }
+                    return acc;
+                }, {})
+                    .value();
+                var templateProperties = ((template === null || template === void 0 ? void 0 : template.properties) || []).reduce(function (trunk, _e) {
+                    var _f;
+                    var name = _e.name, value = _e.value;
+                    return Object.assign(Object.assign({}, trunk), (_f = {}, _f[name] = mapBooleanIfAplicable(value), _f));
+                }, {});
+                var data = Object.assign(Object.assign(Object.assign({}, (typeof object === 'object' ? object : { object: object })), queriesResult), templateProperties);
+                if (template.script && template.script.trim().length) {
+                    var currencyFormat_1 = ((_b = (_a = template.properties) === null || _a === void 0 ? void 0 : _a.find(function (_e) {
+                        var name = _e.name;
+                        return name === 'currencyFormat';
+                    })) === null || _b === void 0 ? void 0 : _b.value) || '1.2-2';
+                    var dateFormat_1 = ((_d = (_c = template.properties) === null || _c === void 0 ? void 0 : _c.find(function (_e) {
+                        var name = _e.name;
+                        return name === 'dateFormat';
+                    })) === null || _d === void 0 ? void 0 : _d.value) || 'D/MMM/YYYY';
+                    var formatDate = function (value) {
+                        return value ? moment(value).format(dateFormat_1) : value;
+                    };
+                    var transform = new Function("return " + template.script)();
+                    var transformedData = transform(Object.assign(Object.assign({}, data), { utils: {
+                            lodash: ___namespace,
+                            currency: function (value) { return new common.CurrencyPipe('en-US').transform(value, 'USD', 'symbol', currencyFormat_1); },
+                            date: formatDate,
+                        }, ToDay: formatDate(Date.now()) }));
+                    if (!shouldPreventDownload) {
+                        var blob = new Blob([JSON.stringify(transformedData)]);
+                        _this.fileDownloadService.processDownload(blob, 'data.json');
+                    }
+                    return transformedData;
+                }
+                return data;
+            }));
+        };
+        DocumentTemplatesApiService.prototype.generateDocument = function (template, object, params) {
+            if (params === void 0) { params = {}; }
+            var attachmentIds = (template.attachments || []).map(function (_e) {
+                var id = _e.id;
+                return id;
+            }).filter(Boolean);
+            var shouldUseLocalDocxTemplater = params.shouldUseLocalDocxTemplater;
+            return shouldUseLocalDocxTemplater && !(object instanceof i1.QuoteDraft)
+                ? this.generateDocumentNew(template, object, params)
+                : this.generateWithBackendDocxTemplater({ template: template, quote: object, attachmentIds: attachmentIds, params: params });
+        };
+        DocumentTemplatesApiService.prototype.generateDocumentNew = function (template, object, params) {
+            var _this = this;
+            if (params === void 0) { params = {}; }
+            var attachToQuote = params.attachToQuote, documentFormat = params.documentFormat, shouldPreventDownload = params.shouldPreventDownload;
+            var file$ = this.service.api({
+                method: 'get',
+                url: "/templates/" + template.id + "/file",
+                responseType: 'arraybuffer',
+            });
+            var attachmentIds = (template.attachments || []).map(function (_e) {
+                var id = _e.id;
+                return id;
+            });
+            var attachments$ = attachmentIds.length
+                ? attachmentIds.map(function (attachmentId) {
+                    return _this.documentAttachmentService.getAttachmentFile(attachmentId, true);
+                })
+                : [];
+            var data$ = this.generateDocumentData(template, object, Object.assign(Object.assign({}, params), { shouldPreventDownload: true }));
+            return rxjs.zip.apply(void 0, __spreadArray([file$, data$], __read(attachments$))).pipe(operators.switchMap(function (_e) {
+                var _f = __read(_e), file = _f[0], data = _f[1], attachments = _f.slice(2);
+                var _a;
+                var d = i1.DocxTemplater.generate(file, data);
+                var body = new FormData();
+                var 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) || {};
+                var 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 rxjs.of(d);
+                }
+                attachments.forEach(function (attachment) {
+                    body.append('attachments', new Blob([attachment]));
+                });
+                body.append('orderform', d);
+                return _this.http
+                    .post(_this.docGenHost + "/documents/merge", body, {
+                    responseType: 'arraybuffer',
+                })
+                    .pipe(operators.switchMap(function (pdf) {
+                    var blob = new Blob([pdf]);
+                    if (!shouldPreventDownload) {
+                        _this.fileDownloadService.processDownload(blob, documentName + ".pdf");
+                    }
+                    if (attachToQuote && object instanceof i1.QuoteDraft) {
+                        var 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 rxjs.of(blob);
+                }));
+            }));
+        };
+        DocumentTemplatesApiService.prototype.getAttachments = function (searchRequest) {
+            return this.documentAttachmentService.getAttachments(searchRequest);
+        };
+        DocumentTemplatesApiService.prototype.getAttachmentFile = function (id) {
+            return this.documentAttachmentService.getAttachmentFile(id);
+        };
+        DocumentTemplatesApiService.prototype.createAttachment = function (attachment, file, reportProgress) {
+            return this.documentAttachmentService.createAttachment(attachment, file, reportProgress);
+        };
+        DocumentTemplatesApiService.prototype.removeAttachment = function (id) {
+            return this.documentAttachmentService.removeAttachment(id);
+        };
+        DocumentTemplatesApiService.prototype.downloadTemplateFile = function (id) {
+            var _this = this;
+            return this.service
+                .api({
+                url: "/templates/" + id + "/file",
+                responseType: 'blob',
+                observe: 'response',
+            })
+                .pipe(operators.tap(function (response) {
+                _this.fileDownloadService.processDownload(response);
+            }), operators.map(function (response) { return response.body || response; }));
+        };
+        DocumentTemplatesApiService.prototype.generateWithBackendDocxTemplater = function (_e) {
+            var template = _e.template, quote = _e.quote, attachmentIds = _e.attachmentIds, params = _e.params;
+            var shouldPreventDownload = params.shouldPreventDownload;
+            var nonEmptyParams = Object.keys(params || {})
+                .filter(function (k) { return params[k] !== undefined; })
+                .reduce(function (obj, key) {
+                obj[key] = params[key];
+                return obj;
+            }, {});
+            return this.generate("/templates/" + template.id + "/generate", { quote: quote, attachments: attachmentIds }, Boolean(shouldPreventDownload), 'blob', nonEmptyParams, false);
+        };
+        DocumentTemplatesApiService.prototype.generate = function (url, body, shouldPreventDownload, responseType, params, isUpload, reportProgress) {
+            var _this = this;
+            var requestOptions = {
+                method: 'post',
+                url: url,
+                body: body,
+                reportProgress: reportProgress,
+                responseType: responseType,
+                observe: shouldPreventDownload ? 'body' : 'response',
+                params: params,
+            };
+            return (isUpload ? this.service.upload(requestOptions) : this.service.api(requestOptions)).pipe(operators.tap(function (response) {
+                if (!shouldPreventDownload) {
+                    _this.fileDownloadService.processDownload(response);
+                }
+            }));
+        };
+        DocumentTemplatesApiService.prototype.queryObject = function (_e, _f) {
+            var objectName = _e.objectName, resultObjectName = _e.resultObjectName, fields = _e.fields, statement = _e.statement;
+            var properties = _f.properties;
+            var _a;
+            var patternLimit = /(\s*limit\s\d*)/i;
+            var limit = 1;
+            if (patternLimit.test(statement)) {
+                var 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, '');
+            }
+            var resolvedStatement = i1.StringUtils.fillPlaceholders(statement, properties, /:\s*(\w[\w\d_.]+)/i);
+            var searchRequest = Object.assign({ skip: 0, count: limit, rawCondition: resolvedStatement }, ((fields === null || fields === void 0 ? void 0 : fields.length) && !!fields[0] && { fields: fields }));
+            return this.sfRepo.query(searchRequest, objectName).pipe(mapSfQueryResult(limit), operators.map(function (value) {
+                var _e;
+                return (_e = {}, _e[resultObjectName] = value, _e);
+            }));
+        };
+        return DocumentTemplatesApiService;
+    }());
+    DocumentTemplatesApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: DocumentTemplatesApiService, deps: [{ token: i1__namespace.BaseHttpService }, { token: SalesforceApiService }, { token: i1__namespace.FileDownloadService }, { token: DocumentAttachmentApiService }, { token: i4__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    DocumentTemplatesApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: DocumentTemplatesApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: DocumentTemplatesApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }, { type: SalesforceApiService }, { type: i1__namespace.FileDownloadService }, { type: DocumentAttachmentApiService }, { type: i4__namespace.HttpClient }]; } });
+
+    var PriceApiService = /** @class */ (function () {
+        function PriceApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/price';
+        }
+        PriceApiService.prototype.calculateRuntime = function (request) {
+            return this.httpService.api({
+                method: 'post',
+                url: this.SERVICE_URL + "/calculate-runtime",
+                body: request,
+            });
+        };
+        PriceApiService.prototype.calculate = function (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;
+            //   }),
+            // );
+        };
+        PriceApiService.prototype.getPriceLists = function () {
+            return this.httpService.api({
+                method: 'get',
+                url: '/price-lists',
+            });
+        };
+        PriceApiService.prototype.getPriceList = function (id) {
+            return this.httpService.api({
+                method: 'get',
+                url: "/price-lists/" + id,
+            });
+        };
+        PriceApiService.prototype.getSellingTermByEndDate = function (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,
+                },
+            });
+        };
+        PriceApiService.prototype.getSellingTermByTerm = function (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,
+                },
+            });
+        };
+        return PriceApiService;
+    }());
+    PriceApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: PriceApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    PriceApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: PriceApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: PriceApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var ProductModelApiService = /** @class */ (function () {
+        function ProductModelApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/models';
+        }
+        ProductModelApiService.prototype.addModel = function (model) {
+            return this.httpService
+                .api({
+                method: 'post',
+                url: this.SERVICE_URL,
+                body: model,
+                errorHandler: this.httpService.handleValidationError,
+            })
+                .pipe(operators.map(function (result) {
+                if (result.successful) {
+                    return result;
+                }
+                else {
+                    throw new Error(result.message);
+                }
+            }));
+        };
+        ProductModelApiService.prototype.releaseModel = function (model) {
+            return this.httpService
+                .api({
+                method: 'put',
+                url: this.SERVICE_URL + "/" + model.id + "/release",
+                body: model,
+                errorHandler: this.httpService.handleValidationError,
+            })
+                .pipe(operators.map(function (result) {
+                if (result.successful) {
+                    return '';
+                }
+                else {
+                    throw new Error(result.message);
+                }
+            }));
+        };
+        ProductModelApiService.prototype.removeModel = function (modelId, successFn, failureFn) {
+            var observable = this.httpService
+                .api({
+                method: 'delete',
+                url: this.SERVICE_URL + "/" + modelId,
+                errorHandler: this.httpService.handleValidationError,
+            })
+                .pipe(operators.map(function (result) {
+                if (result.successful) {
+                    return '';
+                }
+                else {
+                    throw new Error(result.message);
+                }
+            }));
+            observable.subscribe(function () {
+                successFn && successFn.apply();
+            }, function () {
+                failureFn && failureFn.apply();
+            });
+        };
+        ProductModelApiService.prototype.getModelVersions = function (modelId, count, skip) {
+            if (count === void 0) { count = 100; }
+            if (skip === void 0) { skip = 0; }
+            return this.httpService.api({
+                method: 'post',
+                url: this.SERVICE_URL + "/" + modelId + "/versions",
+                body: {
+                    skipCount: skip,
+                    count: count,
+                },
+            });
+        };
+        ProductModelApiService.prototype.getModel = function (id, version) {
+            var url = this.SERVICE_URL + "/" + id;
+            if (version) {
+                url += "/versions/" + version;
+            }
+            return this.httpService.api({ url: url });
+        };
+        ProductModelApiService.prototype.getModels = function (skipCount, searchText) {
+            return this.httpService.api({
+                method: 'post',
+                url: this.SERVICE_URL + "/search",
+                body: {
+                    nameRegex: searchText,
+                    skipCount: skipCount.toString(),
+                    count: ProductModelApiService.MAX_RESULTS,
+                },
+            });
+        };
+        ProductModelApiService.prototype.getLinkedModels = function (id, version) {
+            var url = this.SERVICE_URL + "/" + id;
+            if (version) {
+                url += "/versions/" + version;
+            }
+            url += '/linked';
+            return this.httpService.api({ url: url }).pipe(operators.map(function (linkedModels) {
+                if (linkedModels) {
+                    linkedModels.forEach(function (model) { return i1.ModelTranslatorUtils.toLocalModel(model); });
+                }
+                return linkedModels;
+            }));
+        };
+        ProductModelApiService.prototype.load = function (id, version) {
+            return rxjs.forkJoin([this.getModel(id, version), this.getLinkedModels(id, version)]).pipe(operators.map(function (_a) {
+                var _b = __read(_a, 2), model = _b[0], linkedModels = _b[1];
+                var container = new i1.ProductModelsContainer(model, linkedModels !== null && linkedModels !== void 0 ? linkedModels : []);
+                i1.ModelUtils.override(container.main, container.linked);
+                i1.ModelTranslatorUtils.toLocalModel(container.main, container.linked);
+                return container;
+            }));
+        };
+        ProductModelApiService.prototype.getPML = function (modelId, version) {
+            var url = this.SERVICE_URL + "/" + modelId + "/pml/" + version;
+            if (version) {
+                url += "/versions/" + version;
+            }
+            return this.httpService.api({
+                url: url,
+                responseType: 'text',
+            });
+        };
+        ProductModelApiService.prototype.savePML = function (modelId, pml, comment) {
+            return this.httpService
+                .api({
+                method: 'put',
+                url: this.SERVICE_URL + "/" + modelId + "/pml",
+                body: {
+                    id: modelId,
+                    pml: pml,
+                    comment: comment,
+                },
+            })
+                .pipe(operators.map(function (result) {
+                if (result.successful) {
+                    return '';
+                }
+                else {
+                    throw new Error(result.message);
+                }
+            }), operators.catchError(this.httpService.handleValidationError));
+        };
+        ProductModelApiService.prototype.generateProducts = function (modelId) {
+            return this.httpService.api({
+                url: this.SERVICE_URL + "/" + modelId + "/generate-products",
+            });
+        };
+        ProductModelApiService.prototype.saveModel = function (productModel, comment) {
+            var model = i1.EntityUtil.clone(productModel);
+            model.comment = comment;
+            i1.ModelTranslatorUtils.toServerModel(model);
+            return this.httpService
+                .api({
+                method: 'put',
+                url: this.SERVICE_URL + "/" + model.id,
+                body: model,
+            })
+                .pipe(operators.map(function (result) {
+                if (result.successful) {
+                    return '';
+                }
+                else {
+                    throw new Error(result.message);
+                }
+            }), operators.catchError(this.httpService.handleValidationError));
+        };
+        ProductModelApiService.prototype.validateModel = function (productModel) {
+            return this.httpService
+                .api({
+                method: 'post',
+                url: this.SERVICE_URL + "/validate",
+                body: productModel,
+                errorHandler: this.httpService.handleValidationError,
+            })
+                .pipe(operators.map(function (result) {
+                if (result.successful) {
+                    return '';
+                }
+                else {
+                    throw new Error(result.message);
+                }
+            }));
+        };
+        ProductModelApiService.prototype.renameModel = function (productModel, name) {
+            var model = i1.EntityUtil.clone(productModel);
+            model.name = name;
+            i1.ModelTranslatorUtils.toServerModel(model);
+            return this.httpService
+                .api({
+                method: 'patch',
+                url: this.SERVICE_URL + "/" + model.id,
+                body: model,
+            })
+                .pipe(operators.catchError(this.httpService.handleValidationError));
+        };
+        ProductModelApiService.prototype.uploadPmlFile = function (file, modelId) {
+            var formData = new FormData();
+            formData.append('file', file, file.name);
+            return this.httpService.upload({
+                url: this.SERVICE_URL + "/" + modelId + "/pml/upload",
+                body: formData,
+            });
+        };
+        ProductModelApiService.prototype.runPml = function (modelId, pml, rootType, configurationMode) {
+            return this.httpService.api({
+                method: 'post',
+                url: this.SERVICE_URL + "/" + modelId + "/pml/run",
+                body: {
+                    pml: pml,
+                    rootType: rootType,
+                    configurationMode: configurationMode,
+                },
+                responseType: 'text',
+            });
+        };
+        ProductModelApiService.prototype.evictAllCache = function () {
+            return this.httpService.api({
+                method: 'get',
+                url: '/cache/evict/environment-variables',
+            });
+        };
+        return ProductModelApiService;
+    }());
+    ProductModelApiService.MAX_RESULTS = 200;
+    ProductModelApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ProductModelApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    ProductModelApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ProductModelApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ProductModelApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var QuoteApiService = /** @class */ (function () {
+        function QuoteApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/quotes';
+        }
+        QuoteApiService.prototype.getQuote = function (quoteId, params) {
+            return this.httpService.api({
+                method: 'get',
+                url: this.SERVICE_URL + "/" + quoteId,
+                params: params,
+            });
+        };
+        QuoteApiService.prototype.upsertQuote = function (request) {
+            return this.httpService.api({
+                method: 'post',
+                url: "" + this.SERVICE_URL,
+                body: request,
+            });
+        };
+        QuoteApiService.prototype.submitQuote = function (request) {
+            return this.httpService.api({
+                method: 'post',
+                url: this.SERVICE_URL + "/submit",
+                body: request,
+            });
+        };
+        return QuoteApiService;
+    }());
+    QuoteApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: QuoteApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    QuoteApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: QuoteApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: QuoteApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var RampApiService = /** @class */ (function () {
+        function RampApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/ramp';
+        }
+        RampApiService.prototype.next = function (request) {
+            return this.httpService.api({
+                method: 'post',
+                url: this.SERVICE_URL + "/next",
+                body: request,
+            });
+        };
+        RampApiService.prototype.renew = function (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;
+            //   }),
+            // );
+        };
+        return RampApiService;
+    }());
+    RampApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: RampApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    RampApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: RampApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: RampApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var fromUIComponentStoryDTO = function (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,
+        };
+    };
+
+    var UITemplatesApiService = /** @class */ (function () {
+        function UITemplatesApiService(baseHttpService) {
+            var _this = this;
+            this.baseHttpService = baseHttpService;
+            this.serviceUrl = '/uitemplates';
+            this.fetchTemplates$ = function (name) {
+                var params = new i4.HttpParams();
+                if (name) {
+                    params = params.append('name', name);
+                }
+                return _this.baseHttpService.api({ url: "" + _this.serviceUrl, params: params });
+            };
+            this.createTemplate$ = function (template) {
+                return _this.baseHttpService.api({
+                    method: 'post',
+                    url: "" + _this.serviceUrl,
+                    body: template,
+                });
+            };
+            this.updateTemplate$ = function (template) {
+                return _this.baseHttpService.api({
+                    method: 'put',
+                    url: _this.serviceUrl + "/" + template.id,
+                    body: template,
+                });
+            };
+            this.duplicateTemplate$ = function (template) {
+                // TODO: integrate with BE
+                return rxjs.of(i1.UUID.UUID());
+            };
+            this.removeTemplate$ = function (id) {
+                return _this.baseHttpService.api({
+                    method: 'delete',
+                    url: _this.serviceUrl + "/" + id,
+                });
+            };
+            this.restoreTemplate$ = function (id) {
+                return _this.baseHttpService.api({
+                    method: 'patch',
+                    url: _this.serviceUrl + "/" + id,
+                });
+            };
+            this.searchTemplates$ = function (data) {
+                return _this.baseHttpService.api({
+                    method: 'post',
+                    url: _this.serviceUrl + "/search",
+                    params: data.params,
+                    body: data.expression,
+                });
+            };
+            this.fetchComponents$ = function (templateId, name) {
+                var params = new i4.HttpParams();
+                if (name) {
+                    params = params.append('name', name);
+                }
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + templateId + "/components",
+                    params: params,
+                });
+            };
+            this.fetchComponent$ = function (templateId, componentId) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + templateId + "/components/" + componentId,
+                });
+            };
+            this.createComponent$ = function (component) {
+                return _this.baseHttpService.api({
+                    method: 'post',
+                    url: _this.serviceUrl + "/" + component.uiTemplateId + "/components",
+                    body: component,
+                });
+            };
+            this.updateComponent$ = function (component) {
+                return _this.baseHttpService.api({
+                    method: 'put',
+                    url: _this.serviceUrl + "/" + component.uiTemplateId + "/components/" + component.id,
+                    body: component,
+                });
+            };
+            this.duplicateComponent$ = function (component) {
+                // TODO: integrate with BE
+                return rxjs.of(i1.UUID.UUID());
+            };
+            this.removeComponent$ = function (templateId, componentId) {
+                return _this.baseHttpService.api({
+                    method: 'delete',
+                    url: _this.serviceUrl + "/" + templateId + "/components/" + componentId,
+                });
+            };
+            this.restoreComponent$ = function (templateId, componentId) {
+                return _this.baseHttpService.api({
+                    method: 'patch',
+                    url: _this.serviceUrl + "/" + templateId + "/components/" + componentId,
+                });
+            };
+            this.searchComponents$ = function (templateId, data) {
+                return _this.baseHttpService.api({
+                    method: 'post',
+                    url: _this.serviceUrl + "/" + templateId + "/components/search",
+                    params: data.params,
+                    body: data.expression,
+                });
+            };
+            this.fetchStoryAttachment = function (templateId, componentId, storyId, type) {
+                return _this.baseHttpService
+                    .api({
+                    url: _this.serviceUrl + "/" + templateId + "/components/" + componentId + "/stories/" + storyId + "/attachments/" + type + "/file",
+                    responseType: 'text',
+                })
+                    .pipe(rxjs.catchError(function () { return rxjs.of(''); }));
+            };
+            this.convertToComponentStory$ = function (templateId, componentId, storyDto) {
+                return rxjs.forkJoin([
+                    storyDto.templateHtmlId ? _this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'html') : rxjs.of(undefined),
+                    storyDto.scriptJsId ? _this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'js') : rxjs.of(undefined),
+                    storyDto.styleCssId ? _this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'css') : rxjs.of(undefined),
+                    storyDto.sectionJsonId ? _this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'json') : rxjs.of(undefined),
+                ]).pipe(rxjs.map(function (_a) {
+                    var _b = __read(_a, 4), html = _b[0], js = _b[1], css = _b[2], json = _b[3];
+                    return ({ html: html, js: js, css: css, json: json });
+                }), rxjs.map(function (attachments) { return fromUIComponentStoryDTO(storyDto, attachments); }));
+            };
+            this.fetchStories$ = function (templateId, componentId, name) {
+                var params = new i4.HttpParams();
+                if (name) {
+                    params = params.append('name', name);
+                }
+                return _this.baseHttpService
+                    .api({
+                    url: _this.serviceUrl + "/" + templateId + "/components/" + componentId + "/stories",
+                    params: params,
+                })
+                    .pipe(rxjs.switchMap(function (dtos) {
+                    if (!dtos.length) {
+                        return rxjs.of([]);
+                    }
+                    return rxjs.forkJoin(dtos.map(function (dto) { return _this.convertToComponentStory$(templateId, componentId, dto); }));
+                }));
+            };
+            this.fetchStory$ = function (templateId, componentId, storyId) {
+                return _this.baseHttpService
+                    .api({
+                    url: _this.serviceUrl + "/" + templateId + "/components/" + componentId + "/stories/" + storyId,
+                })
+                    .pipe(rxjs.switchMap(function (dto) { return _this.convertToComponentStory$(templateId, componentId, dto); }));
+            };
+            this.createComponentStory$ = function (templateId, story) {
+                return _this.baseHttpService.api({
+                    method: 'post',
+                    url: _this.serviceUrl + "/" + templateId + "/components/" + story.uiComponentId + "/stories",
+                    body: story,
+                });
+            };
+            this.updateComponentStory$ = function (templateId, story) {
+                var script = story.script, template = story.template, styles = story.styles, section = story.section, 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(rxjs.map(function (dto) { return fromUIComponentStoryDTO(dto, { html: template, js: script, css: styles, json: section }); }));
+            };
+            this.deleteComponentStory$ = function (templateId, componentId, storyId) {
+                return _this.baseHttpService.api({
+                    method: 'delete',
+                    url: _this.serviceUrl + "/" + templateId + "/components/" + componentId + "/stories/" + storyId,
+                });
+            };
+            this.restoreComponentStory$ = function (templateId, componentId, storyId) {
+                return _this.baseHttpService.api({
+                    method: 'patch',
+                    url: _this.serviceUrl + "/" + templateId + "/components/" + componentId + "/stories/" + storyId,
+                });
+            };
+            this.uploadStoryAttachments$ = function (templateId, componentId, storyId, attachments) {
+                var 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$ = function (templateId, component) {
+                return rxjs.forkJoin([
+                    component.templateHtmlId ? _this.fetchComponentAttachmentFile$(templateId, component.id, 'html') : rxjs.of(undefined),
+                    component.scriptJsId ? _this.fetchComponentAttachmentFile$(templateId, component.id, 'js') : rxjs.of(undefined),
+                    component.styleCssId ? _this.fetchComponentAttachmentFile$(templateId, component.id, 'css') : rxjs.of(undefined),
+                    component.propertiesJsonId ? _this.fetchComponentAttachmentFile$(templateId, component.id, 'json') : rxjs.of(undefined),
+                ]).pipe(rxjs.map(function (_a) {
+                    var _b = __read(_a, 4), html = _b[0], js = _b[1], css = _b[2], json = _b[3];
+                    return ({ html: html, js: js, css: css, json: json });
+                }));
+            };
+            this.fetchComponentAttachmentFile$ = function (templateId, componentId, attachmentType) {
+                return _this.baseHttpService
+                    .api({
+                    method: 'get',
+                    url: _this.serviceUrl + "/" + templateId + "/components/" + componentId + "/attachments/" + attachmentType + "/file",
+                    responseType: 'text',
+                })
+                    .pipe(rxjs.catchError(function () { return rxjs.of(''); }));
+            };
+            this.uploadComponentAttachments$ = function (templateId, componentId, attachments) {
+                var 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,
+                });
+            };
+        }
+        UITemplatesApiService.prototype.getTemplateThumbnailUrl = function (templateId) {
+            return this.serviceUrl + "/" + templateId + "/thumbnail/file";
+        };
+        UITemplatesApiService.prototype.attachTemplateThumbnail$ = function (templateId, file) {
+            var data = new FormData();
+            data.append('thumb', file);
+            return this.baseHttpService.upload({
+                method: 'post',
+                url: this.serviceUrl + "/" + templateId + "/thumbnail",
+                body: data,
+            });
+        };
+        UITemplatesApiService.prototype.removeTemplateThumbnail$ = function (templateId) {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: this.serviceUrl + "/" + templateId + "/thumbnail",
+            });
+        };
+        return UITemplatesApiService;
+    }());
+    UITemplatesApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: UITemplatesApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    UITemplatesApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: UITemplatesApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: UITemplatesApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var ScriptsApiService = /** @class */ (function () {
+        function ScriptsApiService(baseHttpService) {
+            var _this = this;
+            this.baseHttpService = baseHttpService;
+            this.serviceUrl = '/admin/scripts';
+            this.fetchScripts$ = function () {
+                return _this.baseHttpService.api({ url: "" + _this.serviceUrl });
+            };
+            this.searchScripts$ = function (expression, skip, count) {
+                var params = new i4.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.fetchScript$ = function (id) {
+                return _this.baseHttpService.api({ url: _this.serviceUrl + "/" + id });
+            };
+            this.createScript$ = function (script) {
+                return _this.baseHttpService.api({
+                    url: "" + _this.serviceUrl,
+                    method: 'post',
+                    body: script,
+                });
+            };
+            this.updateScriptMeta$ = function (script) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + script.id,
+                    method: 'post',
+                    body: script,
+                });
+            };
+            this.updateScriptDetails$ = function (script) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + script.id,
+                    method: 'put',
+                    body: script,
+                });
+            };
+            this.cloneScript$ = function (cloneRequest) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + cloneRequest.id + "/clone",
+                    method: 'post',
+                    body: cloneRequest
+                });
+            };
+            this.removeScript$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + id,
+                    method: 'delete',
+                });
+            };
+            this.restoreScript$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + id + "/restore",
+                    method: 'patch',
+                });
+            };
+            this.execute$ = function (body) {
+                return _this.baseHttpService.api({
+                    url: "/scripts/execute",
+                    method: 'post',
+                    body: body,
+                });
+            };
+        }
+        return ScriptsApiService;
+    }());
+    ScriptsApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ScriptsApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    ScriptsApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ScriptsApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ScriptsApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var ApiModule = /** @class */ (function () {
+        function ApiModule() {
+        }
+        return ApiModule;
+    }());
+    ApiModule.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ApiModule, deps: [], target: i0__namespace.ɵɵFactoryTarget.NgModule });
+    ApiModule.ɵmod = i0__namespace.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ApiModule, imports: [i4.HttpClientModule] });
+    ApiModule.ɵinj = i0__namespace.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ApiModule, providers: [
+            i1.BaseHttpService,
+            i1.XrayService,
+            ConfigurationApiService,
+            ConfigurationSettingsApiService,
+            ContextApiService,
+            DocumentAttachmentApiService,
+            PriceApiService,
+            ProductModelApiService,
+            QuoteApiService,
+            DocumentTemplatesApiService,
+            RampApiService,
+            SalesforceApiService,
+            UITemplatesApiService,
+            ScriptsApiService,
+        ], imports: [[i4.HttpClientModule]] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ApiModule, decorators: [{
+                type: i0.NgModule,
+                args: [{
+                        imports: [i4.HttpClientModule],
+                        providers: [
+                            i1.BaseHttpService,
+                            i1.XrayService,
+                            ConfigurationApiService,
+                            ConfigurationSettingsApiService,
+                            ContextApiService,
+                            DocumentAttachmentApiService,
+                            PriceApiService,
+                            ProductModelApiService,
+                            QuoteApiService,
+                            DocumentTemplatesApiService,
+                            RampApiService,
+                            SalesforceApiService,
+                            UITemplatesApiService,
+                            ScriptsApiService,
+                        ],
+                    }]
+            }] });
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    exports.ApiModule = ApiModule;
+    exports.ConfigurationApiService = ConfigurationApiService;
+    exports.ConfigurationSettingsApiService = ConfigurationSettingsApiService;
+    exports.ContextApiService = ContextApiService;
+    exports.DocumentAttachmentApiService = DocumentAttachmentApiService;
+    exports.DocumentTemplatesApiService = DocumentTemplatesApiService;
+    exports.PriceApiService = PriceApiService;
+    exports.ProductModelApiService = ProductModelApiService;
+    exports.QuoteApiService = QuoteApiService;
+    exports.RampApiService = RampApiService;
+    exports.SalesforceApiService = SalesforceApiService;
+    exports.ScriptsApiService = ScriptsApiService;
+    exports.UITemplatesApiService = UITemplatesApiService;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=veloce-api.umd.js.map