@veloceapps/api 5.0.13-0

package/bundles/veloceapps-api.umd.js

@@ -0,0 +1,2597 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common/http'), require('@angular/core'), require('@veloceapps/core'), require('rxjs'), require('rxjs/operators'), require('@angular/common'), require('lodash'), require('moment')) :
+    typeof define === 'function' && define.amd ? define('@veloceapps/api', ['exports', '@angular/common/http', '@angular/core', '@veloceapps/core', 'rxjs', 'rxjs/operators', '@angular/common', 'lodash', 'moment'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.veloceapps = global.veloceapps || {}, global.veloceapps.api = {}), global.ng.common.http, global.ng.core, global["@veloceapps/core"], global.rxjs, global.rxjs.operators, global.ng.common, global.lodash, 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_);
+
+    var AccountApiService = /** @class */ (function () {
+        function AccountApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/accounts';
+        }
+        AccountApiService.prototype.getAccounts$ = function (options) {
+            return this.httpService.api(Object.assign({ method: 'get', url: "" + this.SERVICE_URL }, options));
+        };
+        AccountApiService.prototype.searchAccounts$ = function (searchParams, options) {
+            var params = new i4.HttpParams({ fromObject: searchParams });
+            return this.httpService.api(Object.assign({ url: "" + this.SERVICE_URL, params: params }, options));
+        };
+        AccountApiService.prototype.getAccount$ = function (id, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + id }, options));
+        };
+        AccountApiService.prototype.getAssets = function (accountId, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + accountId + "/assets" }, options));
+        };
+        AccountApiService.prototype.getOrders = function (accountId, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + accountId + "/orders" }, options));
+        };
+        AccountApiService.prototype.getQuotes = function (accountId, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + accountId + "/quotes" }, options));
+        };
+        AccountApiService.prototype.getAsset = function (accountId, assetId, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + accountId + "/assets/" + assetId }, options));
+        };
+        AccountApiService.prototype.getOrder = function (accountId, orderId, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + accountId + "/orders/" + orderId }, options));
+        };
+        AccountApiService.prototype.getQuote = function (accountId, quoteId, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + accountId + "/quotes/" + quoteId }, options));
+        };
+        AccountApiService.prototype.quoteToOrder = function (accountId, quoteId, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + accountId + "/quotes/" + quoteId + "/to-order", method: 'post', body: { id: quoteId } }, options));
+        };
+        AccountApiService.prototype.orderToAsset = function (accountId, orderId, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + accountId + "/orders/" + orderId + "/to-asset", method: 'post', body: { id: orderId } }, options));
+        };
+        return AccountApiService;
+    }());
+    AccountApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: AccountApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    AccountApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: AccountApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: AccountApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var CatalogAdminApiService = /** @class */ (function () {
+        function CatalogAdminApiService(baseHttpService) {
+            var _this = this;
+            this.baseHttpService = baseHttpService;
+            this.serviceUrl = '/catalogs';
+            this.fetchCatalogs$ = function (searchParams) {
+                var params = new i4.HttpParams({ fromObject: Object.assign({}, searchParams) });
+                return _this.baseHttpService.api({ url: "" + _this.serviceUrl, params: params });
+            };
+            this.searchCatalogs$ = function (searchParams, expression) {
+                var params = new i4.HttpParams({ fromObject: Object.assign({}, searchParams) });
+                return _this.baseHttpService.api({
+                    method: 'post',
+                    url: _this.serviceUrl + "/search",
+                    params: params,
+                    body: expression || {},
+                });
+            };
+            this.fetchCategories$ = function (catalogId) {
+                return _this.baseHttpService.api({ url: _this.serviceUrl + "/" + catalogId + "/categories" });
+            };
+            this.searchProducts$ = function (catalogId, categoryId) {
+                return _this.baseHttpService.api({
+                    method: 'post',
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/products/search",
+                    body: {},
+                });
+            };
+            this.fetchAttributes$ = function (catalogId, categoryId) {
+                return _this.baseHttpService.api({ url: _this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/attributes" });
+            };
+            this.createNewCatalog$ = function (catalogData) {
+                return _this.baseHttpService.api({
+                    url: "" + _this.serviceUrl,
+                    method: 'post',
+                    body: catalogData,
+                });
+            };
+            this.duplicateCatalog$ = function (cloneRequest) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + cloneRequest.id + "/clone",
+                    method: 'post',
+                    body: cloneRequest,
+                });
+            };
+            this.updateCatalog$ = function (data) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + data.id,
+                    method: 'put',
+                    body: data,
+                });
+            };
+            this.removeCatalog$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + id,
+                    method: 'delete',
+                });
+            };
+            this.restoreCatalog$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + id + "/restore",
+                    method: 'patch',
+                });
+            };
+            this.createNewCategory$ = function (categoryData) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + categoryData.catalogId + "/categories",
+                    method: 'post',
+                    body: categoryData,
+                });
+            };
+            this.updateCategory$ = function (category) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + category.catalogId + "/categories/" + category.id,
+                    method: 'put',
+                    body: category,
+                });
+            };
+            this.duplicateCategory$ = function (catalogId, cloneRequest) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + cloneRequest.id + "/clone",
+                    method: 'post',
+                    body: cloneRequest,
+                });
+            };
+            this.removeCategory$ = function (id, catalogId) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + id,
+                    method: 'delete',
+                });
+            };
+            this.restoreCategory$ = function (id, catalogId) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + id + "/restore",
+                    method: 'patch',
+                });
+            };
+            this.removeAttribute$ = function (_a) {
+                var catalogId = _a.catalogId, categoryId = _a.categoryId, data = _a.data;
+                return _this.baseHttpService.api({
+                    method: 'delete',
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/attributes/" + data.id,
+                    body: data,
+                });
+            };
+            this.restoreAttribute$ = function (_a) {
+                var catalogId = _a.catalogId, categoryId = _a.categoryId, data = _a.data;
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/attributes/" + data.id + "/restore",
+                    method: 'patch',
+                });
+            };
+            this.createNewAttribute$ = function (_a) {
+                var catalogId = _a.catalogId, categoryId = _a.categoryId, data = _a.data;
+                return _this.baseHttpService.api({
+                    method: 'post',
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/attributes",
+                    body: data,
+                });
+            };
+            this.updateAttribute$ = function (_a) {
+                var catalogId = _a.catalogId, categoryId = _a.categoryId, data = _a.data;
+                return _this.baseHttpService.api({
+                    method: 'put',
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/attributes/" + data.id,
+                    body: data,
+                });
+            };
+            this.searchProductCandidates$ = function (catalogId, categoryId, expression, searchParams) {
+                var params = new i4.HttpParams({ fromObject: Object.assign({}, searchParams) });
+                return _this.baseHttpService.api({
+                    method: 'post',
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/candidates/search",
+                    params: params,
+                    body: expression,
+                });
+            };
+            this.addProduct$ = function (product, catalogId, categoryId) {
+                return _this.baseHttpService.api({
+                    method: 'post',
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/products",
+                    body: product,
+                });
+            };
+            this.removeProduct$ = function (_a) {
+                var catalogId = _a.catalogId, categoryId = _a.categoryId, data = _a.data;
+                return _this.baseHttpService.api({
+                    method: 'delete',
+                    url: _this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/products/" + data.id,
+                    body: data,
+                });
+            };
+        }
+        return CatalogAdminApiService;
+    }());
+    CatalogAdminApiService.MAX_RESULTS = 60;
+    CatalogAdminApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: CatalogAdminApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    CatalogAdminApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: CatalogAdminApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: CatalogAdminApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var CatalogApiService = /** @class */ (function () {
+        function CatalogApiService(service) {
+            this.service = service;
+            this.serviceUrl = '/product-catalogs';
+        }
+        CatalogApiService.prototype.fetchCatalogs$ = function () {
+            return this.service.api({
+                method: 'get',
+                url: "" + this.serviceUrl,
+            });
+        };
+        CatalogApiService.prototype.searchCatalogs$ = function (searchParams, expression) {
+            var params = new i4.HttpParams({ fromObject: searchParams });
+            return this.service.api({
+                method: 'post',
+                url: this.serviceUrl + "/search",
+                params: params,
+                body: expression,
+            });
+        };
+        CatalogApiService.prototype.getCatalog$ = function (id) {
+            return this.service.api({
+                method: 'get',
+                url: this.serviceUrl + "/" + id,
+            });
+        };
+        CatalogApiService.prototype.fetchCategories$ = function (catalogId) {
+            return this.service.api({
+                method: 'get',
+                url: this.serviceUrl + "/" + catalogId + "/categories",
+            });
+        };
+        CatalogApiService.prototype.fetchCatalogProducts$ = function (catalogId, searchParams, context) {
+            var params = new i4.HttpParams({ fromObject: searchParams });
+            return this.service.api({
+                method: 'post',
+                url: this.serviceUrl + "/" + catalogId + "/products",
+                params: params,
+                body: context,
+            });
+        };
+        CatalogApiService.prototype.fetchCategoryProducts$ = function (catalogId, categoryId, searchParams, context) {
+            var params = new i4.HttpParams({ fromObject: searchParams });
+            return this.service.api({
+                method: 'post',
+                url: this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/products",
+                params: params,
+                body: context,
+            });
+        };
+        CatalogApiService.prototype.searchCategoryProducts$ = function (catalogId, categoryId, searchParams, searchCriteria, context) {
+            var params = new i4.HttpParams({ fromObject: searchParams });
+            return this.service.api({
+                method: 'post',
+                url: this.serviceUrl + "/" + catalogId + "/categories/" + categoryId + "/products/search",
+                params: params,
+                body: {
+                    configurationContext: context,
+                    request: { searchCriteria: searchCriteria },
+                },
+            });
+        };
+        CatalogApiService.prototype.fetchEligibleProducts$ = function (searchParams, context) {
+            var params = new i4.HttpParams({ fromObject: searchParams });
+            return this.service.api({
+                method: 'post',
+                url: this.serviceUrl + "/products",
+                params: params,
+                body: context,
+            });
+        };
+        CatalogApiService.prototype.fetchProducts$ = function (searchParams) {
+            var params = new i4.HttpParams({ fromObject: searchParams });
+            return this.service.api({
+                method: 'get',
+                url: this.serviceUrl + "/products",
+                params: params,
+            });
+        };
+        return CatalogApiService;
+    }());
+    CatalogApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: CatalogApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    CatalogApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: CatalogApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: CatalogApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    /*! *****************************************************************************
+    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 ConfigurationApiService = /** @class */ (function () {
+        function ConfigurationApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/configuration';
+        }
+        ConfigurationApiService.prototype.configureLineItem = function (_d) {
+            var _this = this;
+            var configurationRequest = _d.configurationRequest, runtimeModel = _d.runtimeModel, pricingEnabled = _d.pricingEnabled;
+            return this.httpService
+                .api({
+                method: 'post',
+                url: "" + this.SERVICE_URL + (pricingEnabled ? '/price' : ''),
+                body: configurationRequest,
+                errorHandler: function (e) { return rxjs.throwError(e); },
+            })
+                .pipe(operators.map(function (configurePrice) {
+                if (runtimeModel) {
+                    return Object.assign(Object.assign({}, configurePrice), { lineItem: _this.updatePortDomains(configurePrice.lineItem, runtimeModel) });
+                }
+                else {
+                    return configurePrice;
+                }
+            }));
+        };
+        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 (options) {
+            return this.httpService
+                .api(Object.assign({ url: "" + this.SERVICE_URL, method: 'get' }, options))
+                .pipe(operators.map(function (settings) { return settings.map(function (setting) { return ConfigurationSettingsDTO.fromDTO(setting); }); }));
+        };
+        ConfigurationSettingsApiService.prototype.fetchSetting = function (settingsKey, options) {
+            return this.httpService
+                .api(Object.assign({ url: this.SERVICE_URL + "/byKey/" + settingsKey, method: 'get' }, options))
+                .pipe(operators.map(function (setting) { return ConfigurationSettingsDTO.fromDTO(setting, settingsKey); }), operators.catchError(function (err) {
+                if (err instanceof i4.HttpErrorResponse && err.status === 404) {
+                    return rxjs.of(null);
+                }
+                throw err;
+            }));
+        };
+        ConfigurationSettingsApiService.prototype.createSetting = function (setting, options) {
+            var request = ConfigurationSettingsDTO.toDTO(setting);
+            return this.httpService.api(Object.assign({ url: "" + this.SERVICE_URL, method: 'post', body: Object.assign({}, request) }, options));
+        };
+        ConfigurationSettingsApiService.prototype.updateSetting = function (setting, options) {
+            var request = ConfigurationSettingsDTO.toDTO(setting);
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + request.id, method: 'put', body: Object.assign({}, request) }, options));
+        };
+        ConfigurationSettingsApiService.prototype.removeSetting = function (setting, options) {
+            var request = ConfigurationSettingsDTO.toDTO(setting);
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + request.id, method: 'delete' }, options));
+        };
+        ConfigurationSettingsApiService.prototype.restoreSetting = function (settingId, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/" + settingId + "/restore", method: 'patch' }, options));
+        };
+        ConfigurationSettingsApiService.prototype.clear = function (name, options) {
+            return this.httpService.api(Object.assign({ method: 'get', url: '/cache/evict/' + name }, options));
+        };
+        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 DeltaApiService = /** @class */ (function () {
+        function DeltaApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/delta';
+        }
+        DeltaApiService.prototype.calculate$ = function (request) {
+            return this.httpService.api({
+                method: 'post',
+                url: this.SERVICE_URL + "/calculate",
+                body: request,
+                skipErrorHandler: true,
+            });
+        };
+        return DeltaApiService;
+    }());
+    DeltaApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: DeltaApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    DeltaApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: DeltaApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: DeltaApiService, 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;
+            this.SERVICE_URL = '/attachments';
+        }
+        DocumentAttachmentApiService.prototype.getAttachments = function (searchRequest) {
+            return this.httpService.api({
+                url: this.SERVICE_URL + "/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: "" + this.SERVICE_URL,
+                body: formData,
+                method: 'post',
+                observe: reportProgress ? 'events' : undefined,
+                reportProgress: reportProgress,
+            });
+        };
+        DocumentAttachmentApiService.prototype.updateAttachment = function (id, attachment) {
+            return this.httpService.api({
+                url: this.SERVICE_URL + "/" + id,
+                body: attachment,
+                method: 'put',
+            });
+        };
+        DocumentAttachmentApiService.prototype.getAttachmentFile = function (id, isPreventDownload) {
+            var _this = this;
+            return this.httpService
+                .api({
+                url: this.SERVICE_URL + "/" + 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: this.SERVICE_URL + "/" + 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, options) {
+            return this.httpService.api(Object.assign({ method: 'post', body: Object.assign(Object.assign({}, searchRequest), { count: searchRequest.count || 100 }), url: this.SERVICE_URL + "/query/" + objectName }, options));
+        };
+        SalesforceApiService.prototype.queryObjects = function (search, options) {
+            var params = new i4.HttpParams();
+            if (search) {
+                params = params.append('search', search);
+            }
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/query", params: params }, options));
+        };
+        SalesforceApiService.prototype.describe = function (objectName, fieldName, options) {
+            var methodUrl = this.SERVICE_URL + "/describe/" + objectName + "/fields" + (fieldName ? "/" + fieldName : '');
+            return this.httpService.api(Object.assign({ url: methodUrl }, options));
+        };
+        SalesforceApiService.prototype.describe2 = function (objectName, fields, options) {
+            var methodUrl = this.SERVICE_URL + "/describe/" + objectName + "/fields";
+            return this.httpService.api(Object.assign({ method: 'post', url: methodUrl, body: fields }, options));
+        };
+        SalesforceApiService.prototype.apexGetRequest = function (path, params, options) {
+            return this.httpService.api(Object.assign({ url: this.SERVICE_URL + "/apex" + path, params: params }, options));
+        };
+        SalesforceApiService.prototype.apexPostRequest = function (path, body, options) {
+            return this.httpService.api(Object.assign({ method: 'post', body: body, url: this.SERVICE_URL + "/apex" + path }, options));
+        };
+        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 DocumentTemplatesApiService = /** @class */ (function () {
+        function DocumentTemplatesApiService(service, salesforceApiService, fileDownloadService, documentAttachmentService, http) {
+            this.service = service;
+            this.salesforceApiService = salesforceApiService;
+            this.fileDownloadService = fileDownloadService;
+            this.documentAttachmentService = documentAttachmentService;
+            this.http = http;
+            this.DOCGEN_TAG = 'docgen';
+            this.SERVICE_URL = '/templates';
+            this.DOC_GEN_URL_FALLBACK = 'https://dev-dp1.velocpq.com/docgen';
+            this.mapSfQueryResult = function (limit) { return operators.map(function (records) {
+                if (!records.length) {
+                    return { _result: 'No Records Found' };
+                }
+                if (limit === 1) {
+                    return records[0];
+                }
+                return records;
+            }); };
+            this.mapBooleanIfAplicable = function (value) {
+                if (value === 'true') {
+                    return true;
+                }
+                if (value === 'false') {
+                    return false;
+                }
+                return value;
+            };
+            if (window.VELO_DOCGEN_API) {
+                this.DOC_GEN_URL = window.VELO_DOCGEN_API;
+            }
+            else {
+                console.log("window.VELO_DOCGEN_API not set, will use fallback \"" + this.DOC_GEN_URL_FALLBACK + "\"");
+                this.DOC_GEN_URL = this.DOC_GEN_URL_FALLBACK;
+            }
+        }
+        DocumentTemplatesApiService.prototype.getTemplates = function (tag) {
+            return this.service.api({
+                url: "" + this.SERVICE_URL,
+                method: 'get',
+                params: Object.assign({}, (tag && { tag: tag })),
+            });
+        };
+        DocumentTemplatesApiService.prototype.getTemplate = function (id) {
+            return this.service.api({
+                url: this.SERVICE_URL + "/" + id,
+                method: 'get',
+            });
+        };
+        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',
+            }));
+            var url = "" + this.SERVICE_URL;
+            if (template.id) {
+                url += "/" + template.id;
+            }
+            return this.service.upload({
+                url: url,
+                body: formData,
+                method: template.id ? 'put' : 'post',
+                reportProgress: reportProgress,
+            });
+        };
+        DocumentTemplatesApiService.prototype.removeTemplate = function (id) {
+            return this.service.api({
+                url: this.SERVICE_URL + "/" + id,
+                method: 'delete',
+            });
+        };
+        DocumentTemplatesApiService.prototype.restoreTemplate = function (id) {
+            return this.service.api({
+                url: this.SERVICE_URL + "/" + id + "/restore",
+                method: 'patch',
+            });
+        };
+        DocumentTemplatesApiService.prototype.cloneTemplate = function (id, propertiesToOverride) {
+            if (propertiesToOverride === void 0) { propertiesToOverride = {}; }
+            return this.service.api({
+                url: this.SERVICE_URL + "/clone/" + id,
+                method: 'post',
+                body: {
+                    id: id,
+                    propertiesToOverride: propertiesToOverride,
+                },
+            });
+        };
+        DocumentTemplatesApiService.prototype.getTemplateFile = function (id) {
+            return this.service.api({
+                method: 'get',
+                url: this.SERVICE_URL + "/" + id + "/file",
+                responseType: 'arraybuffer',
+            });
+        };
+        DocumentTemplatesApiService.prototype.downloadTemplateFile = function (id) {
+            var _this = this;
+            return this.service
+                .api({
+                url: this.SERVICE_URL + "/" + 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.mergeDocuments = function (document, attachments) {
+            var body = new FormData();
+            attachments.forEach(function (attachment) {
+                body.append('attachments', new Blob([attachment]));
+            });
+            body.append('orderform', document);
+            return this.http.post(this.DOC_GEN_URL + "/documents/merge", body, {
+                responseType: 'arraybuffer',
+            });
+        };
+        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.generateDocumentData = function (template, object, params) {
+            var _this = this;
+            if (params === void 0) { params = {}; }
+            var _a;
+            if (i1.isLegacyDocumentTemplate(template)) {
+                return this.generateDocumentDataLegacy(template, object, params);
+            }
+            var templateProperties = (_a = template.properties) === null || _a === void 0 ? void 0 : _a.reduce(function (acc, _g) {
+                var _h;
+                var name = _g.name, value = _g.value;
+                return (Object.assign(Object.assign({}, acc), (_h = {}, _h[name] = _this.mapBooleanIfAplicable(value), _h)));
+            }, {});
+            /*
+              Resolve quote and template properties for now
+              When procedures are ready, whey will replace template scripts.
+        
+              TODO: run procedure to resolve document data
+            */
+            return rxjs.of(Object.assign(Object.assign({}, (typeof object === 'object' ? object : { object: object })), templateProperties));
+        };
+        DocumentTemplatesApiService.prototype.generateDocument = function (template, object, params) {
+            var _this = this;
+            if (params === void 0) { params = {}; }
+            var documentData$ = this.generateDocumentData(template, object, Object.assign(Object.assign({}, params), { shouldPreventDownload: true }));
+            return rxjs.zip(this.getTemplateFile(template.id), documentData$, this.resolveAttachments$(template)).pipe(operators.switchMap(function (_g) {
+                var _h = __read(_g, 3), templateFile = _h[0], data = _h[1], attachments = _h[2];
+                var _a, _b, _c, _d, _e, _f;
+                var document = i1.DocxTemplater.generate(templateFile, data);
+                var properties = (_c = (_b = (_a = object === null || object === void 0 ? void 0 : object.context) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : object === null || object === void 0 ? void 0 : object.properties) !== null && _c !== void 0 ? _c : {};
+                var documentName = properties.Name || template.name;
+                var documentFormat = (_d = params.documentFormat) !== null && _d !== void 0 ? _d : (_f = (_e = template.properties) === null || _e === void 0 ? void 0 : _e.find(function (p) { return p.name === 'documentFormat'; })) === null || _f === void 0 ? void 0 : _f.value;
+                if (documentFormat === 'DOCX') {
+                    _this.fileDownloadService.processDownload(document, documentName);
+                    return rxjs.of(document);
+                }
+                return _this.mergeDocuments(document, attachments).pipe(operators.switchMap(function (pdf) {
+                    if (params.attachToQuote && i1.QuoteDraft.isQuote(object)) {
+                        var file = new File([pdf], documentName + ".pdf");
+                        return _this.documentAttachmentService
+                            .createAttachment({
+                            linkedEntityId: object.quoteId,
+                            fileName: documentName,
+                            fileExtension: 'pdf',
+                            tags: _this.DOCGEN_TAG,
+                        }, file)
+                            .pipe(operators.map(function () { return pdf; }));
+                    }
+                    return rxjs.of(pdf);
+                }), operators.map(function (pdf) {
+                    var blob = new Blob([pdf]);
+                    if (!params.shouldPreventDownload) {
+                        _this.fileDownloadService.processDownload(blob, documentName + ".pdf");
+                    }
+                    return blob;
+                }));
+            }));
+        };
+        DocumentTemplatesApiService.prototype.generateDocumentDataLegacy = function (template, object, params) {
+            var _this = this;
+            if (params === void 0) { params = {}; }
+            var _a, _b, _c, _d;
+            var shouldPreventDownload = params.shouldPreventDownload;
+            var allQueries = __spreadArray([], __read(((_a = template === null || template === void 0 ? void 0 : template.queries) !== null && _a !== void 0 ? _a : [])));
+            var properties = (_d = (_c = (_b = object === null || object === void 0 ? void 0 : object.context) === null || _b === void 0 ? void 0 : _b.properties) !== null && _c !== void 0 ? _c : object === null || object === void 0 ? void 0 : object.properties) !== null && _d !== void 0 ? _d : {};
+            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([]), 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, _g) {
+                    var _h;
+                    var name = _g.name, value = _g.value;
+                    return Object.assign(Object.assign({}, trunk), (_h = {}, _h[name] = _this.mapBooleanIfAplicable(value), _h));
+                }, {});
+                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 (_g) {
+                        var name = _g.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 (_g) {
+                        var name = _g.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.resolveAttachments$ = function (template) {
+            var _this = this;
+            var _a, _b;
+            var attachmentIds = (_b = (_a = template.attachments) === null || _a === void 0 ? void 0 : _a.map(function (_g) {
+                var id = _g.id;
+                return id;
+            }).filter(Boolean)) !== null && _b !== void 0 ? _b : [];
+            if (!attachmentIds.length) {
+                return rxjs.of([]);
+            }
+            return rxjs.forkJoin(attachmentIds.map(function (id) { return _this.documentAttachmentService.getAttachmentFile(id, true); }));
+        };
+        DocumentTemplatesApiService.prototype.queryObject = function (_g, _h) {
+            var objectName = _g.objectName, resultObjectName = _g.resultObjectName, fields = _g.fields, statement = _g.statement;
+            var properties = _h.properties;
+            var _a;
+            var patternLimit = /(\s*limit\s\d*)/i;
+            var limit = 1;
+            if (statement && 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 = statement
+                ? i1.StringUtils.fillPlaceholders(statement, properties, /:\s*(\w[\w\d_.]+)/i)
+                : undefined;
+            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.salesforceApiService.query(searchRequest, objectName).pipe(this.mapSfQueryResult(limit), operators.map(function (value) {
+                var _g;
+                return (_g = {}, _g[resultObjectName] = value, _g);
+            }));
+        };
+        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 EndpointsApiService = /** @class */ (function () {
+        function EndpointsApiService(baseHttpService) {
+            this.baseHttpService = baseHttpService;
+            this.adminServiceUrl = '/admin/api-endpoints';
+            this.serviceUrl = '/api-endpoints';
+        }
+        EndpointsApiService.prototype.fetchEndpoints$ = function () {
+            return this.searchEndpoints$(new i1.Expression(), 0, -1);
+        };
+        EndpointsApiService.prototype.searchEndpoints$ = 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.adminServiceUrl + "/search",
+                params: params,
+                body: expression,
+            });
+        };
+        EndpointsApiService.prototype.removeEndpoint$ = function (id) {
+            return this.baseHttpService.api({
+                url: this.adminServiceUrl + "/" + id,
+                method: 'delete',
+            });
+        };
+        EndpointsApiService.prototype.restoreEndpoint$ = function (id) {
+            return this.baseHttpService.api({
+                url: this.adminServiceUrl + "/" + id + "/restore",
+                method: 'patch',
+            });
+        };
+        EndpointsApiService.prototype.fetchEndpoint$ = function (id) {
+            return this.baseHttpService.api({
+                url: this.adminServiceUrl + "/" + id,
+                method: 'get',
+            });
+        };
+        EndpointsApiService.prototype.createEndpoint$ = function (body) {
+            return this.baseHttpService.api({
+                url: "" + this.adminServiceUrl,
+                method: 'post',
+                body: body,
+            });
+        };
+        EndpointsApiService.prototype.updateEndpoint$ = function (body) {
+            return this.baseHttpService.api({
+                url: this.adminServiceUrl + "/" + body.id,
+                method: 'put',
+                body: body,
+            });
+        };
+        EndpointsApiService.prototype.duplicateEndpoint$ = function (cloneRequest) {
+            return this.baseHttpService.api({
+                url: this.adminServiceUrl + "/" + cloneRequest.id + "/clone",
+                method: 'post',
+                body: cloneRequest,
+            });
+        };
+        EndpointsApiService.prototype.executeEndpoint$ = function (body) {
+            return this.baseHttpService.api({
+                url: this.serviceUrl + "/execute",
+                method: 'post',
+                body: body,
+                responseType: 'text',
+            });
+        };
+        return EndpointsApiService;
+    }());
+    EndpointsApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: EndpointsApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    EndpointsApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: EndpointsApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: EndpointsApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var FlowsApiService = /** @class */ (function () {
+        function FlowsApiService(configurationSettingsApiService) {
+            this.configurationSettingsApiService = configurationSettingsApiService;
+            this.flowsKey = 'flows';
+        }
+        FlowsApiService.prototype.getFlow = function (id) {
+            return this.fetchFlows().pipe(operators.map(function (flows) { return flows.find(function (flow) { return flow.id == id; }); }));
+        };
+        FlowsApiService.prototype.fetchFlows = function () {
+            return this.configurationSettingsApiService
+                .fetchSetting(this.flowsKey)
+                .pipe(operators.map(function (flow) { return ((flow === null || flow === void 0 ? void 0 : flow.value) ? JSON.parse(flow.value) : []); }));
+        };
+        return FlowsApiService;
+    }());
+    FlowsApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: FlowsApiService, deps: [{ token: ConfigurationSettingsApiService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    FlowsApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: FlowsApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: FlowsApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: ConfigurationSettingsApiService }]; } });
+
+    var OrgInfoApiService = /** @class */ (function () {
+        function OrgInfoApiService(http) {
+            var _a;
+            this.http = http;
+            this.CANVAS_URL_FALLBACK = 'https://canvas.velocpq.com';
+            this.hostUrl = (_a = window.VELO_CANVAS_API) !== null && _a !== void 0 ? _a : this.CANVAS_URL_FALLBACK;
+        }
+        OrgInfoApiService.prototype.getOrgInfo$ = function (organizationId) {
+            return this.http.get(this.hostUrl + "/org-info/" + organizationId);
+        };
+        return OrgInfoApiService;
+    }());
+    OrgInfoApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: OrgInfoApiService, deps: [{ token: i4__namespace.HttpClient }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    OrgInfoApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: OrgInfoApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: OrgInfoApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i4__namespace.HttpClient }]; } });
+
+    var PicklistsApiService = /** @class */ (function () {
+        function PicklistsApiService(baseHttpService) {
+            var _this = this;
+            this.baseHttpService = baseHttpService;
+            this.serviceUrl = '/admin';
+            this.fetchAllPicklists$ = function () { return _this.baseHttpService.api({ url: _this.serviceUrl + "/picklists" }); };
+            this.fetchPicklist$ = function (code) { return _this.baseHttpService.api({ url: _this.serviceUrl + "/picklists/" + code }); };
+            this.createPicklist$ = function (picklist) {
+                return _this.baseHttpService.api({ method: 'post', url: _this.serviceUrl + "/picklists", body: picklist });
+            };
+            this.updatePicklist$ = function (picklist) {
+                return _this.baseHttpService.api({
+                    method: 'put',
+                    url: _this.serviceUrl + "/picklists/" + picklist.id,
+                    body: picklist,
+                });
+            };
+            this.removePicklist$ = function (id) { return _this.baseHttpService.api({ method: 'delete', url: _this.serviceUrl + "/picklists/" + id }); };
+            this.restorePicklist$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/picklists/" + id + "/restore",
+                    method: 'patch',
+                });
+            };
+            this.addPicklistValue$ = function (picklist, value) {
+                var data = Object.assign(Object.assign({}, picklist), { values: __spreadArray(__spreadArray([], __read(picklist.values)), [value]) });
+                return _this.baseHttpService.api({ method: 'put', url: _this.serviceUrl + "/picklists/" + picklist.id, body: data });
+            };
+        }
+        return PicklistsApiService;
+    }());
+    PicklistsApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: PicklistsApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    PicklistsApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: PicklistsApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: PicklistsApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var PriceApiService = /** @class */ (function () {
+        function PriceApiService(httpService) {
+            this.httpService = httpService;
+            this.SERVICE_URL = '/price';
+        }
+        PriceApiService.prototype.calculate = function (request) {
+            return this.httpService.api({
+                method: 'post',
+                url: this.SERVICE_URL + "/calculate",
+                body: request,
+                skipErrorHandler: true,
+            });
+        };
+        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 ProceduresApiService = /** @class */ (function () {
+        function ProceduresApiService(baseHttpService) {
+            var _this = this;
+            this.baseHttpService = baseHttpService;
+            this.ADMIN_SERVICE_URL = '/admin/procedures';
+            this.SERVICE_URL = '/procedures';
+            this.fetchProcedures$ = function () {
+                return _this.searchProcedures$(new i1.Expression(), 0, 100);
+            };
+            this.searchProcedures$ = 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.ADMIN_SERVICE_URL + "/search",
+                    params: params,
+                    body: expression,
+                });
+            };
+            this.createProcedure$ = function (newProcedure) {
+                return _this.baseHttpService.api({
+                    url: "" + _this.ADMIN_SERVICE_URL,
+                    method: 'post',
+                    body: newProcedure,
+                });
+            };
+            this.updateProcedure$ = function (procedure) {
+                return _this.baseHttpService.api({
+                    url: _this.ADMIN_SERVICE_URL + "/" + procedure.id,
+                    method: 'put',
+                    body: procedure,
+                });
+            };
+            this.duplicateProcedure$ = function (body) {
+                return _this.baseHttpService
+                    .api({
+                    url: _this.ADMIN_SERVICE_URL + "/" + body.id + "/clone",
+                    method: 'post',
+                    body: body,
+                })
+                    .pipe(operators.map(function (response) { return response.clonedRecordId; }));
+            };
+            this.removeProcedure$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.ADMIN_SERVICE_URL + "/" + id,
+                    method: 'delete',
+                });
+            };
+            this.restoreProcedure$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.ADMIN_SERVICE_URL + "/" + id + "/restore",
+                    method: 'patch',
+                });
+            };
+        }
+        ProceduresApiService.prototype.fetchProcedure$ = function (id) {
+            return this.baseHttpService.api({
+                url: this.ADMIN_SERVICE_URL + "/" + id,
+                method: 'get',
+            });
+        };
+        ProceduresApiService.prototype.execute$ = function (body) {
+            return this.baseHttpService.api({
+                url: this.SERVICE_URL + "/execute",
+                method: 'post',
+                body: body,
+            });
+        };
+        /**
+         * Run active procedure against QuoteDraft
+         * @param body
+         * @returns
+         */
+        ProceduresApiService.prototype.apply$ = function (body) {
+            return this.baseHttpService.api({
+                url: this.SERVICE_URL + "/apply",
+                method: 'post',
+                body: body,
+            });
+        };
+        return ProceduresApiService;
+    }());
+    ProceduresApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ProceduresApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    ProceduresApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ProceduresApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ProceduresApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var ProductApiService = /** @class */ (function () {
+        function ProductApiService(baseHttpService) {
+            var _this = this;
+            this.baseHttpService = baseHttpService;
+            this.serviceUrl = '/products';
+            this.fetchProducts$ = function (payload) {
+                var params = new i4.HttpParams();
+                params = params.append('count', payload.count);
+                params = params.append('skip', payload.skip);
+                if (payload.name) {
+                    params = params.append('name', payload.name);
+                }
+                return _this.baseHttpService.api({ url: "" + _this.serviceUrl, params: params });
+            };
+            this.searchProducts$ = 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.fetchProduct$ = function (id) { return _this.baseHttpService.api({ url: _this.serviceUrl + "/" + id }); };
+            this.fetchAttributes$ = function () {
+                return _this.baseHttpService.api({ url: _this.serviceUrl + "/attributes/definition" });
+            };
+            this.searchAttributes$ = 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 + "/attributes/definition/search",
+                    params: params,
+                    body: expression,
+                });
+            };
+            this.fetchAttributesByModel = function (modelId) {
+                return _this.baseHttpService.api({ url: _this.serviceUrl + "/attributes/definition/forModel/" + modelId });
+            };
+            this.createNewProduct$ = function (productData) {
+                return _this.baseHttpService.api({
+                    url: "" + _this.serviceUrl,
+                    method: 'post',
+                    body: productData,
+                });
+            };
+            this.updateProduct$ = function (body) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + body.id,
+                    method: 'put',
+                    body: body,
+                });
+            };
+            this.removeProduct$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + id,
+                    method: 'delete',
+                });
+            };
+            this.restoreProduct$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + id + "/restore",
+                    method: 'patch',
+                });
+            };
+            this.createProductAttribute$ = function (attributeData) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/attributes",
+                    method: 'post',
+                    body: attributeData,
+                });
+            };
+            this.updateProductAttribute$ = function (attributeData) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/attributes/" + attributeData.id,
+                    method: 'put',
+                    body: attributeData,
+                });
+            };
+            this.removeProductAttribute$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/attributes/" + id,
+                    method: 'delete',
+                });
+            };
+            this.createNewAttribute$ = function (attributeData) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/attributes/definition",
+                    method: 'post',
+                    body: attributeData,
+                });
+            };
+            this.updateAttribute$ = function (body) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/attributes/definition/" + body.id,
+                    method: 'put',
+                    body: body,
+                });
+            };
+            this.removeAttribute$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/attributes/definition/" + id,
+                    method: 'delete',
+                });
+            };
+            this.restoreAttribute$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/attributes/definition/" + id + "/restore",
+                    method: 'patch',
+                });
+            };
+        }
+        ProductApiService.prototype.attachImage$ = function (productId, file) {
+            var data = new FormData();
+            data.append('image', file);
+            return this.baseHttpService.upload({
+                method: 'post',
+                url: this.serviceUrl + "/" + productId + "/image",
+                body: data,
+            });
+        };
+        ProductApiService.prototype.removeImage$ = function (productId) {
+            return this.baseHttpService.api({
+                method: 'delete',
+                url: this.serviceUrl + "/" + productId + "/image",
+            });
+        };
+        ProductApiService.prototype.fetchImage$ = function (productId) {
+            return this.baseHttpService.api({
+                url: this.getImageUrl(productId),
+                method: 'get',
+                responseType: 'blob',
+                errorHandler: rxjs.noop,
+            });
+        };
+        ProductApiService.prototype.getImageUrl = function (productId) {
+            return this.serviceUrl + "/" + productId + "/image";
+        };
+        return ProductApiService;
+    }());
+    ProductApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ProductApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    ProductApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ProductApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: ProductApiService, 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';
+            /**
+             * @deprecated
+             * Will be removed in next major release
+             * Use `getQuoteDraft` instead
+             */
+            // eslint-disable-next-line @typescript-eslint/member-ordering
+            this.getQuote = this.getQuoteDraft;
+        }
+        // request quoteId | accountId | opportunityId | orderId
+        QuoteApiService.prototype.getQuoteDraft = function (objectId, params, errorHandler) {
+            return this.httpService.api({
+                method: 'get',
+                url: this.SERVICE_URL + "/" + objectId,
+                params: params,
+                errorHandler: errorHandler,
+            });
+        };
+        QuoteApiService.prototype.upsertQuote = function (request, options) {
+            return this.httpService.api(Object.assign({ method: 'post', url: "" + this.SERVICE_URL, body: request }, options));
+        };
+        QuoteApiService.prototype.submitQuote = function (request, options) {
+            return this.httpService.api(Object.assign({ method: 'post', url: this.SERVICE_URL + "/submit", body: request }, options));
+        };
+        QuoteApiService.prototype.attachDocument = function (id, documentName, data) {
+            var formData = new FormData();
+            var blob = new Blob([data]);
+            formData.append('file', blob, documentName);
+            return this.httpService.upload({
+                url: this.SERVICE_URL + "/" + id + "/attach-document",
+                responseType: 'arraybuffer',
+                method: 'post',
+                body: formData,
+            });
+        };
+        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, options) {
+            return this.httpService.api(Object.assign({ method: 'post', url: this.SERVICE_URL + "/next", body: request }, options));
+        };
+        RampApiService.prototype.renew = function (request, options) {
+            return this.httpService.api(Object.assign({ method: 'post', url: this.SERVICE_URL + "/renew", body: request }, options));
+        };
+        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 RuleGroupsApiService = /** @class */ (function () {
+        function RuleGroupsApiService(baseHttpService) {
+            var _this = this;
+            this.baseHttpService = baseHttpService;
+            this.serviceUrl = '/admin/rule-groups';
+            this.fetchRuleGroups$ = function () {
+                return _this.searchRuleGroups$(new i1.Expression(), 0, 100);
+            };
+            this.searchRuleGroups$ = 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.createRuleGroup$ = function (ruleGroup) {
+                return _this.baseHttpService.api({
+                    url: "" + _this.serviceUrl,
+                    method: 'post',
+                    body: ruleGroup,
+                });
+            };
+            this.updateRuleGroup$ = function (ruleGroup) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + ruleGroup.id,
+                    method: 'post',
+                    body: ruleGroup,
+                });
+            };
+            this.duplicateRuleGroup$ = function (body) {
+                return _this.baseHttpService
+                    .api({
+                    url: _this.serviceUrl + "/" + body.id + "/clone",
+                    method: 'post',
+                    body: body,
+                })
+                    .pipe(rxjs.map(function (response) { return response.clonedRecordId; }));
+            };
+            this.removeRuleGroup$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + id,
+                    method: 'delete',
+                });
+            };
+            this.restoreRuleGroup$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + id + "/restore",
+                    method: 'patch',
+                });
+            };
+        }
+        return RuleGroupsApiService;
+    }());
+    RuleGroupsApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: RuleGroupsApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    RuleGroupsApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: RuleGroupsApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: RuleGroupsApiService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.BaseHttpService }]; } });
+
+    var RulesApiService = /** @class */ (function () {
+        function RulesApiService(baseHttpService) {
+            var _this = this;
+            this.baseHttpService = baseHttpService;
+            this.serviceUrl = '/admin/rules';
+            this.fetchRules$ = function () {
+                return _this.searchRules$(new i1.Expression(), 0, 100);
+            };
+            this.searchRules$ = 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.createRule$ = function (rule) {
+                return _this.baseHttpService.api({
+                    url: "" + _this.serviceUrl,
+                    method: 'post',
+                    body: rule,
+                });
+            };
+            this.updateRule$ = function (rule) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + rule.id,
+                    method: 'put',
+                    body: rule,
+                });
+            };
+            this.duplicateRule$ = function (body) {
+                return _this.baseHttpService
+                    .api({
+                    url: _this.serviceUrl + "/" + body.id + "/clone",
+                    method: 'post',
+                    body: body,
+                })
+                    .pipe(operators.map(function (response) { return response.clonedRecordId; }));
+            };
+            this.removeRule$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + id,
+                    method: 'delete',
+                });
+            };
+            this.restoreRule$ = function (id) {
+                return _this.baseHttpService.api({
+                    url: _this.serviceUrl + "/" + id + "/restore",
+                    method: 'patch',
+                });
+            };
+        }
+        RulesApiService.prototype.fetchRule$ = function (id) {
+            return this.baseHttpService.api({
+                url: this.serviceUrl + "/" + id,
+                method: 'get',
+            });
+        };
+        RulesApiService.prototype.fetchHeaderFields$ = function () {
+            return this.baseHttpService.api({
+                url: this.serviceUrl + "/describe/Header",
+                method: 'get',
+            });
+        };
+        RulesApiService.prototype.execute$ = function (body) {
+            return this.baseHttpService.api({
+                url: "/rules/execute",
+                method: 'post',
+                body: body,
+            });
+        };
+        return RulesApiService;
+    }());
+    RulesApiService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: RulesApiService, deps: [{ token: i1__namespace.BaseHttpService }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    RulesApiService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: RulesApiService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: RulesApiService, 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: 'put',
+                    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,
+                    errorHandler: function () { return null; },
+                });
+            };
+        }
+        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 fromUIComponentStoryDTO = function (dto, attachments) {
+        return {
+            id: dto.id,
+            name: dto.name,
+            uiComponentId: dto.uiComponentId,
+            description: dto.description,
+            section: attachments.json,
+            template: attachments.html,
+            script: attachments.js,
+            styles: attachments.css,
+        };
+    };
+
+    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, cloneRequest) {
+                return _this.baseHttpService
+                    .api({
+                    url: _this.serviceUrl + "/" + template.id + "/clone",
+                    method: 'post',
+                    body: cloneRequest,
+                })
+                    .pipe(rxjs.map(function (response) { return response.clonedRecordId; }));
+            };
+            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, cloneRequest) {
+                return _this.baseHttpService
+                    .api({
+                    url: _this.serviceUrl + "/" + component.uiTemplateId + "/components/" + component.id + "/clone",
+                    method: 'post',
+                    body: cloneRequest,
+                })
+                    .pipe(rxjs.map(function (response) { return response.clonedRecordId; }));
+            };
+            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',
+                    errorHandler: rxjs.noop,
+                })
+                    .pipe(rxjs.catchError(function () { return rxjs.of(''); }));
+            };
+            this.convertToComponentStory$ = function (templateId, componentId, storyDto) {
+                return rxjs.forkJoin([
+                    _this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'html'),
+                    _this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'js'),
+                    _this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'css'),
+                    _this.fetchStoryAttachment(templateId, componentId, storyDto.id, 'json'),
+                ]).pipe(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.duplicateComponentStory$ = function (story, cloneRequest) {
+                return _this.baseHttpService
+                    .api({
+                    url: _this.serviceUrl + "/" + story.template + "/components/" + story.uiComponentId + "/stories/" + story.id + "/clone",
+                    method: 'post',
+                    body: cloneRequest,
+                })
+                    .pipe(rxjs.map(function (response) { return response.clonedRecordId; }));
+            };
+            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([
+                    _this.fetchComponentAttachmentFile$(templateId, component.id, 'html'),
+                    _this.fetchComponentAttachmentFile$(templateId, component.id, 'js'),
+                    _this.fetchComponentAttachmentFile$(templateId, component.id, 'css'),
+                    _this.fetchComponentAttachmentFile$(templateId, component.id, 'json'),
+                ]).pipe(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',
+                    errorHandler: rxjs.noop,
+                })
+                    .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 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,
+            ProceduresApiService,
+            QuoteApiService,
+            DocumentTemplatesApiService,
+            RampApiService,
+            SalesforceApiService,
+            UITemplatesApiService,
+            ScriptsApiService,
+            RulesApiService,
+            RuleGroupsApiService,
+            FlowsApiService,
+            ProductApiService,
+            CatalogAdminApiService,
+            CatalogApiService,
+            DeltaApiService,
+            AccountApiService,
+            PicklistsApiService,
+            EndpointsApiService,
+            OrgInfoApiService,
+        ], 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,
+                            ProceduresApiService,
+                            QuoteApiService,
+                            DocumentTemplatesApiService,
+                            RampApiService,
+                            SalesforceApiService,
+                            UITemplatesApiService,
+                            ScriptsApiService,
+                            RulesApiService,
+                            RuleGroupsApiService,
+                            FlowsApiService,
+                            ProductApiService,
+                            CatalogAdminApiService,
+                            CatalogApiService,
+                            DeltaApiService,
+                            AccountApiService,
+                            PicklistsApiService,
+                            EndpointsApiService,
+                            OrgInfoApiService,
+                        ],
+                    }]
+            }] });
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    exports.AccountApiService = AccountApiService;
+    exports.ApiModule = ApiModule;
+    exports.CatalogAdminApiService = CatalogAdminApiService;
+    exports.CatalogApiService = CatalogApiService;
+    exports.ConfigurationApiService = ConfigurationApiService;
+    exports.ConfigurationSettingsApiService = ConfigurationSettingsApiService;
+    exports.ContextApiService = ContextApiService;
+    exports.DeltaApiService = DeltaApiService;
+    exports.DocumentAttachmentApiService = DocumentAttachmentApiService;
+    exports.DocumentTemplatesApiService = DocumentTemplatesApiService;
+    exports.EndpointsApiService = EndpointsApiService;
+    exports.FlowsApiService = FlowsApiService;
+    exports.OrgInfoApiService = OrgInfoApiService;
+    exports.PicklistsApiService = PicklistsApiService;
+    exports.PriceApiService = PriceApiService;
+    exports.ProceduresApiService = ProceduresApiService;
+    exports.ProductApiService = ProductApiService;
+    exports.ProductModelApiService = ProductModelApiService;
+    exports.QuoteApiService = QuoteApiService;
+    exports.RampApiService = RampApiService;
+    exports.RuleGroupsApiService = RuleGroupsApiService;
+    exports.RulesApiService = RulesApiService;
+    exports.SalesforceApiService = SalesforceApiService;
+    exports.ScriptsApiService = ScriptsApiService;
+    exports.UITemplatesApiService = UITemplatesApiService;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=veloceapps-api.umd.js.map