@veloceapps/sdk 4.0.21-0

package/fesm2015/veloceapps-sdk-core.js

@@ -0,0 +1,1029 @@
+import * as i0 from '@angular/core';
+import { Injectable, NgModule } from '@angular/core';
+import { UUID, ConfigurationContext, ConfigurationContextMode, RuntimeModel, SalesforceIdUtils, ConfigurationMode, ChargeGroupUtils } from '@veloceapps/core';
+import { BehaviorSubject, map as map$1, distinctUntilChanged, catchError, of, tap as tap$1, zip, noop, combineLatest, throwError, shareReplay as shareReplay$1, switchMap as switchMap$1 } from 'rxjs';
+import { filter, tap, map, switchMap, skip, take, shareReplay, first, catchError as catchError$1, finalize } from 'rxjs/operators';
+import * as i1 from '@veloceapps/api';
+import { PriceApiService, ContextApiService, ProductModelApiService, ConfigurationApiService } from '@veloceapps/api';
+import { merge, flatten, sortBy, cloneDeep } from 'lodash';
+import { ToastType, ConfirmationComponent, ConfirmationDialogModule } from '@veloceapps/components';
+import * as i4 from 'primeng/api';
+import * as i5 from 'primeng/dynamicdialog';
+import moment from 'moment';
+
+const getDefaultLineItem = (context, uiDefinitionProperties, qty = 1) => {
+    var _a, _b, _c;
+    const id = UUID.UUID();
+    const lineItem = Object.assign({ id, type: (_a = uiDefinitionProperties.rootType) !== null && _a !== void 0 ? _a : '', cfgStatus: 'Default', actionCode: 'ADD', qty, productName: ((_b = context.properties) === null || _b === void 0 ? void 0 : _b.displayName) || context.productName, productId: (_c = context.productId) !== null && _c !== void 0 ? _c : '' }, (context.offeringId
+        ? { offeringId: context.offeringId, offeringInstanceId: context.offeringInstanceId || id }
+        : {}));
+    return lineItem;
+};
+
+var RuntimeMode;
+(function (RuntimeMode) {
+    RuntimeMode[RuntimeMode["TEST"] = 0] = "TEST";
+    RuntimeMode[RuntimeMode["PROD"] = 1] = "PROD";
+})(RuntimeMode || (RuntimeMode = {}));
+var RuntimeOperation;
+(function (RuntimeOperation) {
+    RuntimeOperation["INIT"] = "INIT";
+    RuntimeOperation["UPDATE"] = "UPDATE";
+})(RuntimeOperation || (RuntimeOperation = {}));
+var RuntimeStep;
+(function (RuntimeStep) {
+    RuntimeStep["START"] = "START";
+    RuntimeStep["UPDATE"] = "UPDATE";
+})(RuntimeStep || (RuntimeStep = {}));
+
+class ContextService {
+    constructor(contextApiService) {
+        this.contextApiService = contextApiService;
+        this.context = new BehaviorSubject(null);
+    }
+    get isInitialized() {
+        return Boolean(this.context.value);
+    }
+    resolve() {
+        if (!this.context.value) {
+            throw new Error('Context is not initialized yet!');
+        }
+        return Object.assign({}, this.context.value);
+    }
+    resolve$() {
+        return this.context.pipe(filter((ctx) => Boolean(ctx)));
+    }
+    create(headerId, mode) {
+        return this.contextApiService.getContext(headerId, mode).pipe(tap(context => this.context.next(merge(new ConfigurationContext(headerId, mode), context))), map(() => this.resolve()));
+    }
+    update(partialContext) {
+        const originalContext = this.resolve();
+        const updatedContext = Object.assign(Object.assign(Object.assign({}, originalContext), partialContext), { properties: Object.assign(Object.assign({}, originalContext.properties), partialContext.properties) });
+        this.context.next(updatedContext);
+        return updatedContext;
+    }
+    set(context) {
+        const originalContext = this.resolve();
+        const updatedContext = Object.assign(Object.assign({}, originalContext), context);
+        this.context.next(updatedContext);
+        return updatedContext;
+    }
+    delete() {
+        this.context.next(null);
+    }
+}
+ContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ContextService, deps: [{ token: i1.ContextApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ContextService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ContextService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.ContextApiService }]; } });
+
+class ProductImagesService {
+    constructor(productApiService) {
+        this.productApiService = productApiService;
+        this.imagesMap$ = new BehaviorSubject({});
+    }
+    getImageUrl$(productId) {
+        if (this.imagesMap$.value[productId] == null) {
+            this.imagesMap$.next(Object.assign(Object.assign({}, this.imagesMap$.value), { [productId]: '' }));
+            this.fetchProductImage(productId);
+        }
+        return this.imagesMap$.pipe(map$1(imagesMap => imagesMap[productId]), distinctUntilChanged());
+    }
+    fetchProductImage(productId) {
+        this.productApiService
+            .fetchImage$(productId)
+            .pipe(map$1(file => URL.createObjectURL(file)), catchError(() => of('')), tap$1(url => this.imagesMap$.next(Object.assign(Object.assign({}, this.imagesMap$.value), { [productId]: url }))))
+            .subscribe();
+    }
+}
+ProductImagesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductImagesService, deps: [{ token: i1.ProductApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductImagesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductImagesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductImagesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.ProductApiService }]; } });
+
+class QuoteDraftService {
+    constructor(context, quoteApiService, priceApiService) {
+        this.context = context;
+        this.quoteApiService = quoteApiService;
+        this.priceApiService = priceApiService;
+        this.quoteSubj$ = new BehaviorSubject(null);
+        this.resetSubj$ = new BehaviorSubject(true);
+        this.isInitializedSubj$ = new BehaviorSubject(false);
+        this.allPriceLists = [];
+        this.assetPriceLists = [];
+        this.hasUnsavedChanges = false;
+        this.reset$ = this.resetSubj$.asObservable();
+        this.activePriceList$ = this.context.resolve$().pipe(map(ctx => this.allPriceLists.find(priceList => priceList.id === ctx.properties.PriceListId)), map(priceList => priceList !== null && priceList !== void 0 ? priceList : null));
+        this.isInitializedSubj$
+            .pipe(filter(isInitialized => isInitialized), switchMap(() => this.quoteSubj$.asObservable()), skip(1), tap(quote => this.markAsUpdated(quote)))
+            .subscribe();
+    }
+    get isInitialized() {
+        return this.isInitializedSubj$.getValue();
+    }
+    set isInitialized(value) {
+        if (this.isInitialized !== value) {
+            this.isInitializedSubj$.next(value);
+        }
+    }
+    get hasAssets$() {
+        return this.quoteSubj$.pipe(map(() => this.hasAssets));
+    }
+    get hasAssets() {
+        const quoteDraft = this.quoteSubj$.value;
+        return Boolean(quoteDraft && quoteDraft.currentState.length > 0);
+    }
+    reset() {
+        this.resetSubj$.next(true);
+        this.quoteSubj$.next(null);
+    }
+    init(quoteId, params) {
+        return zip(this.quoteApiService.getQuoteDraft(quoteId, params), this.priceApiService.getPriceLists()).pipe(tap(([quote, allPriceLists]) => {
+            this.allPriceLists = allPriceLists;
+            this.quoteSubj$.next(quote);
+            this.context.update(quote.context);
+            this.populateActivePriceLists$();
+        }), map(() => noop()), take(1));
+    }
+    setCurrentLineItemState(lineItems) {
+        const quoteDraft = this.quoteSubj$.value;
+        if (!quoteDraft) {
+            return;
+        }
+        this.quoteSubj$.next(Object.assign(Object.assign({}, quoteDraft), { currentState: lineItems }));
+    }
+    updateQuoteDraft(update) {
+        const quoteDraft = this.quoteSubj$.value;
+        if (!quoteDraft) {
+            return;
+        }
+        if (update.context) {
+            this.context.set(update.context);
+        }
+        this.quoteSubj$.next(Object.assign(Object.assign({}, quoteDraft), update));
+    }
+    updateByPriceSummary(priceSummary) {
+        const quoteDraft = this.quoteSubj$.value;
+        if (!quoteDraft) {
+            return;
+        }
+        const updatedCurrentState = this.currentState.map(lineItem => {
+            const updated = priceSummary.lineItems.find(li => li.id === lineItem.id);
+            return updated !== null && updated !== void 0 ? updated : lineItem;
+        });
+        this.quoteSubj$.next(Object.assign(Object.assign({}, quoteDraft), { currentState: updatedCurrentState, totalPrices: priceSummary.totalPrices, approvalItems: priceSummary.approvalItems }));
+    }
+    get quoteDraft$() {
+        return combineLatest([this.quoteSubj$, this.context.resolve$()]).pipe(map(() => this.quoteDraft), filter((quote) => Boolean(quote)), shareReplay());
+    }
+    get quoteDraft() {
+        const quote = this.quoteSubj$.value;
+        if (!quote) {
+            return null;
+        }
+        return Object.assign(Object.assign({}, quote), { context: this.context.resolve() });
+    }
+    get quoteDraftForActivePriceList() {
+        const quoteDraft = this.quoteDraft;
+        if (!quoteDraft) {
+            return null;
+        }
+        return Object.assign(Object.assign({}, quoteDraft), { initialState: this.filterByActivePriceList(quoteDraft.initialState), currentState: this.filterByActivePriceList(quoteDraft.currentState) });
+    }
+    get currentState$() {
+        return this.quoteDraft$.pipe(map(quote => quote.currentState));
+    }
+    get currentState() {
+        var _a, _b;
+        return (_b = (_a = this.quoteDraft) === null || _a === void 0 ? void 0 : _a.currentState) !== null && _b !== void 0 ? _b : [];
+    }
+    /**
+     * Stream of activeCurrentState
+     */
+    get activeCurrentState$() {
+        return this.quoteDraft$.pipe(map(() => this.activeCurrentState));
+    }
+    /**
+     * activeCurrentState is currentState passed through additional filters
+     */
+    get activeCurrentState() {
+        var _a, _b;
+        let currentState = (_b = (_a = this.quoteDraft) === null || _a === void 0 ? void 0 : _a.currentState) !== null && _b !== void 0 ? _b : [];
+        currentState = this.filterByActivePriceList(currentState);
+        return currentState;
+    }
+    /**
+     * Stream of activeInitialState
+     */
+    get activeInitialState$() {
+        return this.quoteDraft$.pipe(map(() => this.activeInitialState));
+    }
+    /**
+     * activeInitialState is initialState passed through additional filters
+     */
+    get activeInitialState() {
+        var _a, _b;
+        const ctx = this.context.resolve();
+        let initialState = (_b = (_a = this.quoteDraft) === null || _a === void 0 ? void 0 : _a.initialState) !== null && _b !== void 0 ? _b : [];
+        if (ctx.mode === ConfigurationContextMode.ACCOUNT) {
+            initialState = this.filterByActivePriceList(initialState);
+        }
+        return initialState;
+    }
+    get isStandalone() {
+        return this.context.resolve().properties.standalone === 'true';
+    }
+    get isStandalone$() {
+        return this.context.resolve$().pipe(map(() => this.isStandalone));
+    }
+    isEditMode$() {
+        return this.context.resolve$().pipe(map(() => this.isEditMode()));
+    }
+    isEditMode() {
+        const context = this.context.resolve();
+        if (context.mode === ConfigurationContextMode.ACCOUNT) {
+            return true;
+        }
+        if (context.mode === ConfigurationContextMode.QUOTE) {
+            return context.properties.Status === 'Draft';
+        }
+        return false;
+    }
+    updateActivePriceList(priceListId) {
+        this.context.update({ properties: { PriceListId: priceListId } });
+    }
+    populateActivePriceLists$() {
+        const ctx = this.context.resolve();
+        const quoteDraft = this.quoteDraft;
+        if (!quoteDraft) {
+            return;
+        }
+        // In ACCOUNT mode populate price lists from related assets
+        if (ctx.mode === ConfigurationContextMode.ACCOUNT) {
+            // Populate list of price lists
+            this.assetPriceLists = quoteDraft.currentState
+                .map(({ priceListId }) => priceListId)
+                .reduce((trunk, priceListId) => {
+                var _a, _b;
+                if (!priceListId || trunk.some(item => item.id === priceListId)) {
+                    return trunk;
+                }
+                return [
+                    ...trunk,
+                    { id: priceListId, name: (_b = (_a = this.allPriceLists.find(item => item.id === priceListId)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '' },
+                ];
+            }, []);
+        }
+    }
+    filterByActivePriceList(lineItems) {
+        const ctx = this.context.resolve();
+        return lineItems.filter(li => !li.priceListId || li.priceListId === ctx.properties.PriceListId);
+    }
+    markAsUpdated(quote) {
+        if ((quote === null || quote === void 0 ? void 0 : quote.context.properties.mode) === ConfigurationContextMode.ACCOUNT) {
+            this.hasUnsavedChanges = !!quote && !quote.currentState.every(li => li.actionCode === 'EXIST');
+        }
+        else {
+            this.hasUnsavedChanges = true;
+        }
+    }
+}
+QuoteDraftService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: QuoteDraftService, deps: [{ token: ContextService }, { token: i1.QuoteApiService }, { token: i1.PriceApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+QuoteDraftService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: QuoteDraftService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: QuoteDraftService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: ContextService }, { type: i1.QuoteApiService }, { type: i1.PriceApiService }]; } });
+
+class RuntimeContextService {
+    constructor(configurationApiService) {
+        this.configurationApiService = configurationApiService;
+    }
+    getRuntimeContext(productId, offeringId) {
+        return this.configurationApiService.getRuntimeDataByProductId(productId, offeringId).pipe(map(runtimeData => {
+            var _a, _b, _c;
+            const uiDefinition = this.getUIDefinition(runtimeData);
+            const runtimeModel = RuntimeModel.create(runtimeData.types, runtimeData.products);
+            const { productName, properties } = (_a = Array.from(runtimeModel.components.values()).find(c => c.productId === productId)) !== null && _a !== void 0 ? _a : {};
+            return {
+                modelId: runtimeData.modelId,
+                uiDefinition: uiDefinition,
+                runtimeModel: runtimeModel,
+                runtimeMode: RuntimeMode.PROD,
+                productId: productId,
+                productType: (properties === null || properties === void 0 ? void 0 : properties.displayName) || productName,
+                offeringId: offeringId,
+                properties: {
+                    PricingEnabled: ((_b = uiDefinition === null || uiDefinition === void 0 ? void 0 : uiDefinition.properties) === null || _b === void 0 ? void 0 : _b.pricingEnabled) ? 'true' : 'false',
+                    PriceListId: (_c = uiDefinition === null || uiDefinition === void 0 ? void 0 : uiDefinition.properties) === null || _c === void 0 ? void 0 : _c.priceList,
+                },
+            };
+        }));
+    }
+    getUIDefinition(runtimeData) {
+        var _a;
+        let rawUiDefinitions;
+        try {
+            rawUiDefinitions = JSON.parse(runtimeData.uiDefinitionsSource);
+        }
+        catch (e) {
+            return;
+        }
+        const uiDefinitions = rawUiDefinitions.filter(uiDef => uiDef.version);
+        const uiDefinition = (_a = uiDefinitions.find(uiDef => uiDef.primary)) !== null && _a !== void 0 ? _a : uiDefinitions[0];
+        return uiDefinition;
+    }
+}
+RuntimeContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RuntimeContextService, deps: [{ token: i1.ConfigurationApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+RuntimeContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RuntimeContextService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RuntimeContextService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ConfigurationApiService }]; } });
+
+class ConfigurationRuntimeService {
+    constructor(apiService, contextService, runtimeContextService) {
+        this.apiService = apiService;
+        this.contextService = contextService;
+        this.runtimeContextService = runtimeContextService;
+        this._isInitialized = false;
+        this.uiDefinitionProperties = {};
+    }
+    reset() {
+        this._isInitialized = false;
+        this._runtimeContext = undefined;
+        this._assets = undefined;
+        this.initializationProps = undefined;
+        this.uiDefinitionProperties = {};
+    }
+    initTestMode(modelId, uiDefinition) {
+        var _a, _b;
+        this.uiDefinitionProperties = (_a = uiDefinition.properties) !== null && _a !== void 0 ? _a : {};
+        const uiDefinitionExternals = (_b = uiDefinition.externals) !== null && _b !== void 0 ? _b : {};
+        return combineLatest([
+            this.apiService.getRuntimeDataByModelId(modelId),
+            this.contextService.create('TestId', ConfigurationContextMode.TEST),
+        ]).pipe(first(), tap(([runtimeData, context]) => {
+            var _a;
+            this._runtimeContext = {
+                modelId: modelId,
+                runtimeModel: RuntimeModel.create(runtimeData.types, runtimeData.products),
+                runtimeMode: RuntimeMode.TEST,
+            };
+            this.contextService.update({
+                properties: Object.assign(Object.assign(Object.assign(Object.assign({}, (_a = this.runtimeContext) === null || _a === void 0 ? void 0 : _a.properties), context.properties), { ModelId: modelId, RuntimeMode: ConfigurationContextMode.TEST, PricingEnabled: this.uiDefinitionProperties.pricingEnabled ? 'true' : 'false', StartDate: new Date().toISOString().substring(0, 10), PriceListId: this.uiDefinitionProperties.priceList, standalone: 'true' }), uiDefinitionExternals),
+            });
+            this._isInitialized = true;
+        }));
+    }
+    init(props) {
+        this.initializationProps = props;
+        this._assets = props.assets;
+        const context = this.contextService.resolve();
+        return this.runtimeContextService.getRuntimeContext(props.productId, props.offeringId).pipe(tap(runtimeContext => {
+            var _a, _b, _c, _d;
+            this.uiDefinitionProperties = (_b = (_a = runtimeContext.uiDefinition) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {};
+            const { PriceListId } = (_c = context.properties) !== null && _c !== void 0 ? _c : {};
+            const mergeContext = Object.assign(Object.assign({}, runtimeContext), { properties: Object.assign(Object.assign(Object.assign({}, runtimeContext.properties), context.properties), { PricingEnabled: PriceListId ? 'true' : 'false' }) });
+            this.id15to18('AccountId', mergeContext.properties);
+            this._runtimeContext = mergeContext;
+            if (context.properties && ((_d = this._runtimeContext.properties) === null || _d === void 0 ? void 0 : _d.StartDate)) {
+                this.contextService.update({
+                    properties: Object.assign(Object.assign({}, this._runtimeContext.properties), context.properties),
+                });
+            }
+            this._isInitialized = true;
+        }));
+    }
+    id15to18(propertyName, source) {
+        if (!source) {
+            return;
+        }
+        const value = source[propertyName];
+        if (typeof value === 'string' && value.length === 15) {
+            source[propertyName] = SalesforceIdUtils.generateId18FromId15(value);
+        }
+    }
+    getAsset(lineItem) {
+        return this._assets && this._assets.find(a => a.id === lineItem.openOrderLineItemId || a.id === lineItem.assetId);
+    }
+    get isInitialized() {
+        return this._isInitialized;
+    }
+    get runtimeModel() {
+        var _a;
+        return (_a = this.runtimeContext) === null || _a === void 0 ? void 0 : _a.runtimeModel;
+    }
+    get runtimeContext() {
+        return this._runtimeContext;
+    }
+}
+ConfigurationRuntimeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationRuntimeService, deps: [{ token: i1.ConfigurationApiService }, { token: ContextService }, { token: RuntimeContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationRuntimeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationRuntimeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationRuntimeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ConfigurationApiService }, { type: ContextService }, { type: RuntimeContextService }]; } });
+
+const findLineItem = (id, lineItems) => {
+    return findLineItemWithComparator(lineItems, (li) => li.id === id);
+};
+const findLineItemWithComparator = (lineItems, comparator) => {
+    let currentLevel = lineItems;
+    while (currentLevel.length) {
+        const found = currentLevel.find(comparator);
+        if (found) {
+            return found;
+        }
+        currentLevel = flatten(currentLevel.map(parent => parent.lineItems));
+    }
+    return;
+};
+const insertLineItem = (lineItem, parentId, toInsert) => {
+    const insertData = lineItem.id === parentId ? [toInsert] : [];
+    return Object.assign(Object.assign({}, lineItem), { lineItems: [
+            ...insertData,
+            ...lineItem.lineItems.map(li => {
+                return insertLineItem(li, parentId, toInsert);
+            }),
+        ] });
+};
+const removeLineItem = (lineItem, idToRemove) => {
+    return Object.assign(Object.assign({}, lineItem), { lineItems: lineItem.lineItems
+            .map(li => {
+            if (li.id === idToRemove) {
+                return;
+            }
+            else if (li.lineItems.length) {
+                return removeLineItem(li, idToRemove);
+            }
+            return li;
+        })
+            .filter(r => !!r) });
+};
+const replaceLineItem = (lineItem, replaceTo) => {
+    if (lineItem.id === replaceTo.id) {
+        return Object.assign({}, replaceTo);
+    }
+    return Object.assign(Object.assign({}, lineItem), { lineItems: lineItem.lineItems.map(li => {
+            if (li.id === replaceTo.id) {
+                return replaceTo;
+            }
+            else if (li.lineItems.length) {
+                return replaceLineItem(li, replaceTo);
+            }
+            return li;
+        }) });
+};
+const mapAttributes = (attributes) => {
+    return attributes.reduce((acc, { name, value }) => (Object.assign(Object.assign({}, acc), { [name]: value })), {});
+};
+const getAttributes = (attributes, names = []) => {
+    const filtered = attributes.filter(({ name }) => names.includes(name));
+    return sortBy(filtered, [({ name }) => names.indexOf(name)]);
+};
+const upsertAttributes = (originalAttributes, attributesToUpsert) => {
+    return attributesToUpsert.reduce((acc, { name, value }) => {
+        const [origAttr] = getAttributes(acc, [name]);
+        return [
+            ...acc.filter(attr => attr.name !== name),
+            Object.assign(Object.assign({}, (origAttr !== null && origAttr !== void 0 ? origAttr : { name })), { cfgStatus: 'User', value }),
+        ];
+    }, originalAttributes);
+};
+const patchAttributes = (rootLineItem, id, attrs) => {
+    const lineItem = findLineItem(id, [rootLineItem]);
+    if (!lineItem) {
+        return rootLineItem;
+    }
+    const attributes = upsertAttributes(lineItem.attributes, attrs);
+    return replaceLineItem(rootLineItem, Object.assign(Object.assign({}, lineItem), { attributes }));
+};
+const getAttributeValue = (attributes, name) => { var _a; return (_a = attributes.find(attr => attr.name === name)) === null || _a === void 0 ? void 0 : _a.value; };
+const generateLineItem = (port, type, parentId, attributes = [], lineItems = []) => {
+    return {
+        id: UUID.UUID(),
+        port,
+        type,
+        actionCode: 'ADD',
+        cfgStatus: 'New',
+        attributes: attributes.map(({ name, value }) => ({ cfgStatus: 'User', name, value })),
+        lineItems,
+        parentId,
+        qty: 1,
+    };
+};
+const getRecommendedPrices = (portDomain, type) => {
+    var _a, _b;
+    const domainType = portDomain.domainTypes.find(({ name }) => name === type);
+    const [net, list] = (_b = (_a = domainType === null || domainType === void 0 ? void 0 : domainType.recommendedPrices) === null || _a === void 0 ? void 0 : _a.filter(({ chargeMethod }) => chargeMethod === 'ONE_TIME').reduce((acc, rp) => {
+        const [netPrice, listPrice] = acc;
+        return [netPrice + rp.netPrice, listPrice + rp.listPrice];
+    }, [0, 0])) !== null && _b !== void 0 ? _b : [0, 0];
+    return { net, list };
+};
+
+var lineItem_utils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findLineItem: findLineItem,
+    findLineItemWithComparator: findLineItemWithComparator,
+    insertLineItem: insertLineItem,
+    removeLineItem: removeLineItem,
+    replaceLineItem: replaceLineItem,
+    mapAttributes: mapAttributes,
+    getAttributes: getAttributes,
+    upsertAttributes: upsertAttributes,
+    patchAttributes: patchAttributes,
+    getAttributeValue: getAttributeValue,
+    generateLineItem: generateLineItem,
+    getRecommendedPrices: getRecommendedPrices
+});
+
+class LineItemWorker {
+    constructor(src) {
+        this.li = Object.assign({}, src);
+    }
+    insert(parentId, toInsert) {
+        return new LineItemWorker(insertLineItem(this.li, parentId, toInsert));
+    }
+    remove(id) {
+        return new LineItemWorker(removeLineItem(this.li, id));
+    }
+    replace(toReplace) {
+        return new LineItemWorker(replaceLineItem(this.li, toReplace));
+    }
+    patchAttribute(attrs, id) {
+        return new LineItemWorker(patchAttributes(this.li, id !== null && id !== void 0 ? id : this.li.id, attrs));
+    }
+}
+
+class ConfigurationService {
+    constructor(quoteDraftService, runtimeService, contextService, configurationApiService, messageService, dialogService) {
+        this.quoteDraftService = quoteDraftService;
+        this.runtimeService = runtimeService;
+        this.contextService = contextService;
+        this.configurationApiService = configurationApiService;
+        this.messageService = messageService;
+        this.dialogService = dialogService;
+        this.mode = ConfigurationMode.SEARCH;
+        this.states = {};
+        this.lineItem = new BehaviorSubject(undefined);
+        this.charges = new BehaviorSubject({});
+        this.pricePlans = new BehaviorSubject({});
+        this.hasUnsavedChanges = false;
+    }
+    reset() {
+        this.hasUnsavedChanges = false;
+        this.runtimeService.reset();
+        this.states = {};
+        this.lineItem.next(undefined);
+        this.charges.next({});
+        this.pricePlans.next({});
+    }
+    patch$(lineItem) {
+        if (!this.lineItem.value) {
+            return throwError(() => new Error(`Source LineItem not found`));
+        }
+        this.states.configurableRamp = new LineItemWorker(this.lineItem.value).replace(lineItem).li;
+        this.states.asset = this.states.configurableRamp
+            ? this.runtimeService.getAsset(this.states.configurableRamp)
+            : undefined;
+        return this.configure().pipe(catchError$1(error => {
+            console.error(error);
+            if (!this.runtimeService.uiDefinitionProperties.suppressToastMessages) {
+                this.messageService.add({ severity: 'error', summary: error });
+            }
+            // bounce back if configuration call has failed
+            this.lineItem.next(this.lineItem.value ? Object.assign({}, this.lineItem.value) : undefined);
+            return throwError(() => error);
+        }), tap(() => {
+            if (!this.hasUnsavedChanges) {
+                this.hasUnsavedChanges = true;
+            }
+        }));
+    }
+    patch(lineItem) {
+        this.patch$(lineItem).subscribe();
+    }
+    updateCurrentStates(update) {
+        this.states = Object.assign(Object.assign({}, this.states), update);
+    }
+    get() {
+        return this.lineItem.asObservable().pipe(shareReplay$1());
+    }
+    getSnapshot() {
+        return this.lineItem.value ? Object.assign({}, this.lineItem.value) : undefined;
+    }
+    getRuntimeModel() {
+        return this.runtimeService.runtimeModel;
+    }
+    getRuntimeContext() {
+        return this.runtimeService.runtimeContext;
+    }
+    get contextSnapshot() {
+        return this.contextService.resolve();
+    }
+    get context$() {
+        return this.contextService.resolve$();
+    }
+    get charges$() {
+        return this.charges.asObservable();
+    }
+    get chargesSnapshot() {
+        return this.charges.value;
+    }
+    get pricePlans$() {
+        return this.pricePlans.asObservable();
+    }
+    get pricePlansSnapshot() {
+        return this.pricePlans.value;
+    }
+    configure() {
+        var _a, _b, _c, _d, _e, _f;
+        const runtimeContext = this.getRuntimeContext();
+        const runtimeModel = this.getRuntimeModel();
+        if (!runtimeContext || !runtimeModel) {
+            return throwError(() => new Error('Runtime context/model not initialized'));
+        }
+        const uiDefinitionProperties = Object.assign(Object.assign({}, ((_b = (_a = runtimeContext.uiDefinition) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {})), ((_c = this.runtimeService.uiDefinitionProperties) !== null && _c !== void 0 ? _c : {}));
+        const qty = (_d = this.runtimeService.initializationProps) === null || _d === void 0 ? void 0 : _d.defaultQty;
+        const lineItem = (_e = this.states.configurableRamp) !== null && _e !== void 0 ? _e : getDefaultLineItem(runtimeContext, uiDefinitionProperties, qty);
+        const configurationRequest = this.createRequest(lineItem);
+        const mainPricingEnabled = (_f = runtimeContext.properties) === null || _f === void 0 ? void 0 : _f.PricingEnabled;
+        const pricingEnabled = mainPricingEnabled ? mainPricingEnabled === 'true' : uiDefinitionProperties.pricingEnabled;
+        return this.configurationApiService
+            .configureLineItem({ configurationRequest, runtimeModel, pricingEnabled })
+            .pipe(map(({ lineItem, context, charges, pricePlans, deletedLineItems }) => {
+            this.contextService.update(context !== null && context !== void 0 ? context : {});
+            this.charges.next(charges !== null && charges !== void 0 ? charges : {});
+            this.pricePlans.next(pricePlans !== null && pricePlans !== void 0 ? pricePlans : {});
+            if (deletedLineItems === null || deletedLineItems === void 0 ? void 0 : deletedLineItems.length) {
+                this.showInactiveProductsConfirmation();
+            }
+            return lineItem;
+        }))
+            .pipe(tap(lineItem => lineItem && this.lineItem.next(lineItem)), catchError$1(error => throwError(() => { var _a; return new Error(((_a = error.error) === null || _a === void 0 ? void 0 : _a.message) || error.message || JSON.stringify(error)); })));
+    }
+    configureExternal$(productId, qty) {
+        this.updateCurrentStates({
+            currentState: this.quoteDraftService.currentState,
+        });
+        return this.runtimeService.init({ productId, defaultQty: qty }).pipe(switchMap(() => this.configure()), first(), catchError$1(error => {
+            this.messageService.add({ severity: ToastType.error, summary: error });
+            throw error;
+        }), finalize(() => this.reset()));
+    }
+    createRequest(lineItem) {
+        return {
+            lineItem,
+            mode: this.mode,
+            step: !this.lineItem.value ? RuntimeStep.START : RuntimeStep.UPDATE,
+            attributeDomainMode: 'ALL',
+            context: this.contextService.resolve(),
+            lineItems: this.states.currentState || [],
+            asset: this.states.asset,
+        };
+    }
+    showInactiveProductsConfirmation() {
+        this.dialogService
+            .open(ConfirmationComponent, {
+            dismissableMask: false,
+            closeOnEscape: false,
+            closable: false,
+            showHeader: true,
+            header: `Inactive Products in Quote`,
+            width: '440px',
+            data: {
+                confirmationConfig: {
+                    title: ' ',
+                    description: 'This quote contains inactive products. Do you want to remove them?',
+                    submitBtn: 'Remove products',
+                    cancelBtn: 'Back to Quote',
+                },
+            },
+        })
+            .onClose.subscribe(result => {
+            if (!result) {
+                const context = this.contextService.resolve();
+                window['VELO_BACK_FN'].apply(null, [context.headerId]);
+            }
+        });
+    }
+}
+ConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationService, deps: [{ token: QuoteDraftService }, { token: ConfigurationRuntimeService }, { token: ContextService }, { token: i1.ConfigurationApiService }, { token: i4.MessageService }, { token: i5.DialogService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: QuoteDraftService }, { type: ConfigurationRuntimeService }, { type: ContextService }, { type: i1.ConfigurationApiService }, { type: i4.MessageService }, { type: i5.DialogService }]; } });
+
+class FlowUpdateService {
+    update(rootLineItems, updates) {
+        let remainingUpdates = [...updates];
+        let currentLevel = rootLineItems;
+        while (currentLevel.length && remainingUpdates.length) {
+            currentLevel.forEach(li => {
+                const unhandledUpdates = [];
+                remainingUpdates.forEach(update => {
+                    let updated = false;
+                    switch (update.dataType) {
+                        case 'LINEITEM':
+                            updated = this.applyLineItemUpdate(li, update);
+                            break;
+                        case 'CHARGE':
+                            updated = this.applyChargeUpdate(li, update);
+                            break;
+                        case 'GROUP_CHARGE':
+                            updated = this.applyChargeGroupUpdate(li, update);
+                            break;
+                        default:
+                            // Unknown dataType. Do not try to handle it anymore
+                            updated = true;
+                    }
+                    if (!updated) {
+                        unhandledUpdates.push(update);
+                    }
+                });
+                remainingUpdates = unhandledUpdates;
+            });
+            currentLevel = flatten(currentLevel.map(parent => parent.lineItems));
+        }
+    }
+    delete(lineItems, id) {
+        const idsToRemove = [id];
+        const topLevelLineItem = lineItems.find(li => li.id === id);
+        if (topLevelLineItem) {
+            // find term-related line items (which are only top level)
+            // expired term line items won't be deleted
+            let foundTermLineItem = topLevelLineItem;
+            while (foundTermLineItem) {
+                foundTermLineItem = lineItems.find(li => foundTermLineItem && li.rampInstanceId === foundTermLineItem.id);
+                if (foundTermLineItem) {
+                    idsToRemove.push(foundTermLineItem.id);
+                }
+            }
+        }
+        const filtered = lineItems.filter(lineItem => !idsToRemove.includes(lineItem.id));
+        return filtered.map(lineItem => new LineItemWorker(lineItem).remove(id).li);
+    }
+    applyLineItemUpdate(lineItem, update) {
+        if (lineItem.id !== update.id) {
+            return false;
+        }
+        switch (update.attributeType) {
+            case 'QTY':
+                lineItem.qty = update.newValue;
+                break;
+            case 'EFFECTIVE_START_DATE':
+                lineItem.properties.StartDate = moment(update.newValue).format('YYYY-MM-DD');
+                break;
+            case 'END_DATE':
+                lineItem.properties.EndDate = moment(update.newValue).format('YYYY-MM-DD');
+                break;
+            case 'PRICE_ADJUSTMENT':
+                {
+                    const [charge] = lineItem.chargeItems;
+                    if (charge) {
+                        charge.priceAdjustment = update.newValue;
+                    }
+                }
+                break;
+            case 'LIST_PRICE_ADJUSTMENT':
+                {
+                    const [charge] = lineItem.chargeItems;
+                    if (charge) {
+                        charge.listPriceAdjustment = update.newValue;
+                    }
+                }
+                break;
+            default:
+                throw new Error(`Not suppored AttributeType for LineItem update: ${update.attributeType}`);
+        }
+        return true;
+    }
+    applyChargeUpdate(lineItem, update) {
+        const foundCharge = lineItem.chargeItems.find(({ id }) => id === update.id);
+        if (!foundCharge) {
+            return false;
+        }
+        if (update.attributeType === 'PRICE_ADJUSTMENT') {
+            foundCharge.priceAdjustment = update.newValue;
+        }
+        else if (update.attributeType === 'LIST_PRICE_ADJUSTMENT') {
+            foundCharge.listPriceAdjustment = update.newValue;
+        }
+        else {
+            throw new Error(`Not suppored AttributeType for Charge Item update: ${update.attributeType}`);
+        }
+        return true;
+    }
+    applyChargeGroupUpdate(lineItem, update) {
+        const foundChargeGroup = ChargeGroupUtils.findChargeGroupById(update.id, lineItem);
+        if (!foundChargeGroup) {
+            return false;
+        }
+        if (update.attributeType === 'PRICE_ADJUSTMENT') {
+            foundChargeGroup.priceAdjustment = update.newValue;
+        }
+        else if (update.attributeType === 'LIST_PRICE_ADJUSTMENT') {
+            foundChargeGroup.listPriceAdjustment = update.newValue;
+        }
+        else {
+            throw new Error(`Not suppored AttributeType for Charge Group Item update: ${update.attributeType}`);
+        }
+        return true;
+    }
+}
+FlowUpdateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowUpdateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FlowUpdateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowUpdateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowUpdateService, decorators: [{
+            type: Injectable
+        }] });
+
+class FlowConfigurationService {
+    constructor(proceduresApiService, contextService, quoteDraftService, updateService, configurationService) {
+        this.proceduresApiService = proceduresApiService;
+        this.contextService = contextService;
+        this.quoteDraftService = quoteDraftService;
+        this.updateService = updateService;
+        this.configurationService = configurationService;
+    }
+    calculate$(quoteDraft) {
+        return this.proceduresApiService.apply$(quoteDraft).pipe(tap$1(result => {
+            // sort the result current state based on the quote draft initial state
+            const initialStateIds = quoteDraft.initialState.map(lineItem => lineItem.integrationId);
+            result.currentState = result.currentState
+                .slice()
+                .sort((a, b) => initialStateIds.indexOf(a.integrationId) - initialStateIds.indexOf(b.integrationId));
+            this.quoteDraftService.updateQuoteDraft(result);
+        }), map$1(noop));
+    }
+    calculate(quoteDraft) {
+        this.calculate$(quoteDraft).subscribe();
+    }
+    update$(updates) {
+        const quoteDraft = this.quoteDraftService.quoteDraft;
+        if (!quoteDraft) {
+            return of(null);
+        }
+        return of([]).pipe(map$1(() => {
+            const updatedState = cloneDeep(quoteDraft.currentState);
+            this.updateService.update(updatedState, updates);
+            return updatedState;
+        }), switchMap$1(updatedState => this.calculate$(Object.assign(Object.assign({}, quoteDraft), { currentState: updatedState }))), map$1(() => this.quoteDraftService.quoteDraft), this.handleErrorAndBounceBack());
+    }
+    update(updates) {
+        this.update$(updates).subscribe();
+    }
+    revert$(lineItemId) {
+        const quoteDraft = this.quoteDraftService.quoteDraft;
+        const initialState = this.quoteDraftService.activeInitialState;
+        const currentState = this.quoteDraftService.activeCurrentState;
+        const currentLineItemIndex = currentState.findIndex(({ id }) => id === lineItemId);
+        const currentLineItem = currentState[currentLineItemIndex];
+        const initialLineItem = initialState.find(({ integrationId }) => integrationId === (currentLineItem === null || currentLineItem === void 0 ? void 0 : currentLineItem.integrationId));
+        if (!quoteDraft || !currentLineItem || !initialLineItem) {
+            return of(null);
+        }
+        const updatedState = cloneDeep(currentState);
+        updatedState.splice(currentLineItemIndex, 1, initialLineItem);
+        return of([]).pipe(tap$1(() => {
+            this.quoteDraftService.setCurrentLineItemState(updatedState);
+        }), switchMap$1(() => this.calculate$(Object.assign(Object.assign({}, quoteDraft), { currentState: updatedState }))), map$1(() => this.quoteDraftService.quoteDraft), this.handleErrorAndBounceBack());
+    }
+    revert(lineItemId) {
+        this.revert$(lineItemId).subscribe();
+    }
+    delete$(ids) {
+        const quoteDraft = this.quoteDraftService.quoteDraft;
+        const currentState = this.quoteDraftService.currentState;
+        if (!quoteDraft) {
+            return of(null);
+        }
+        return of([]).pipe(map$1(() => ids.reduce((result, id) => this.updateService.delete(result, id), currentState)), switchMap$1(updatedState => this.calculate$(Object.assign(Object.assign({}, quoteDraft), { currentState: updatedState }))), map$1(() => this.quoteDraftService.quoteDraft), this.handleErrorAndBounceBack());
+    }
+    delete(ids) {
+        this.delete$(ids).subscribe();
+    }
+    addTerm$(term) {
+        const quoteDraft = this.quoteDraftService.quoteDraft;
+        if (!quoteDraft) {
+            return of(null);
+        }
+        const updatedState = [...quoteDraft.currentState, term];
+        return of([]).pipe(switchMap$1(() => this.calculate$(Object.assign(Object.assign({}, quoteDraft), { currentState: updatedState }))), map$1(() => this.quoteDraftService.quoteDraft), this.handleErrorAndBounceBack());
+    }
+    addToCart$(productId, qty) {
+        const quoteDraft = this.quoteDraftService.quoteDraft;
+        if (!quoteDraft) {
+            return of(null);
+        }
+        return this.configurationService.configureExternal$(productId, qty).pipe(map$1(lineItem => [...quoteDraft.currentState, lineItem]), switchMap$1(updatedState => this.calculate$(Object.assign(Object.assign({}, quoteDraft), { currentState: updatedState }))), map$1(() => this.quoteDraftService.quoteDraft), this.handleErrorAndBounceBack());
+    }
+    get() {
+        return this.quoteDraftService.quoteDraft$.pipe(map$1(() => this.quoteDraftService.activeCurrentState), shareReplay$1());
+    }
+    getSnapshot() {
+        var _a, _b;
+        return (_b = (_a = this.quoteDraftService) === null || _a === void 0 ? void 0 : _a.currentState.slice()) !== null && _b !== void 0 ? _b : [];
+    }
+    get charges$() {
+        return this.quoteDraftService.quoteDraft$.pipe(map$1(({ charges }) => charges));
+    }
+    get pricePlans$() {
+        return this.quoteDraftService.quoteDraft$.pipe(map$1(({ pricePlans }) => pricePlans));
+    }
+    get chargesSnapshot() {
+        var _a, _b;
+        return (_b = (_a = this.quoteDraftService.quoteDraft) === null || _a === void 0 ? void 0 : _a.charges) !== null && _b !== void 0 ? _b : {};
+    }
+    get pricePlansSnapshot() {
+        var _a, _b;
+        return (_b = (_a = this.quoteDraftService.quoteDraft) === null || _a === void 0 ? void 0 : _a.pricePlans) !== null && _b !== void 0 ? _b : {};
+    }
+    get contextSnapshot() {
+        return this.contextService.resolve();
+    }
+    get context$() {
+        return this.contextService.resolve$();
+    }
+    handleErrorAndBounceBack() {
+        return (source$) => {
+            return source$.pipe(catchError(error => {
+                console.error(error);
+                // bounce back if configuration call has failed
+                const quoteDraft = this.quoteDraftService.quoteDraft;
+                if (quoteDraft) {
+                    this.quoteDraftService.updateQuoteDraft(quoteDraft);
+                }
+                return throwError(() => error);
+            }));
+        };
+    }
+}
+FlowConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowConfigurationService, deps: [{ token: i1.ProceduresApiService }, { token: ContextService }, { token: QuoteDraftService }, { token: FlowUpdateService }, { token: ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowConfigurationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowConfigurationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ProceduresApiService }, { type: ContextService }, { type: QuoteDraftService }, { type: FlowUpdateService }, { type: ConfigurationService }]; } });
+
+class FlowConfigurationModule {
+}
+FlowConfigurationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowConfigurationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FlowConfigurationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowConfigurationModule });
+FlowConfigurationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowConfigurationModule, providers: [FlowConfigurationService, FlowUpdateService, PriceApiService], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FlowConfigurationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    providers: [FlowConfigurationService, FlowUpdateService, PriceApiService],
+                }]
+        }] });
+
+class ConfigurationModule {
+}
+ConfigurationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ConfigurationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationModule, imports: [ConfirmationDialogModule] });
+ConfigurationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationModule, providers: [
+        ContextApiService,
+        ProductModelApiService,
+        ConfigurationApiService,
+        ConfigurationRuntimeService,
+        RuntimeContextService,
+        ConfigurationService,
+    ], imports: [[ConfirmationDialogModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ConfigurationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ConfirmationDialogModule],
+                    providers: [
+                        ContextApiService,
+                        ProductModelApiService,
+                        ConfigurationApiService,
+                        ConfigurationRuntimeService,
+                        RuntimeContextService,
+                        ConfigurationService,
+                    ],
+                }]
+        }] });
+
+class SdkCoreModule {
+}
+SdkCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SdkCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SdkCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SdkCoreModule, imports: [ConfigurationModule, FlowConfigurationModule] });
+SdkCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SdkCoreModule, providers: [ContextService, QuoteDraftService, ProductImagesService], imports: [[ConfigurationModule, FlowConfigurationModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SdkCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ConfigurationModule, FlowConfigurationModule],
+                    providers: [ContextService, QuoteDraftService, ProductImagesService],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ConfigurationRuntimeService, ConfigurationService, ContextService, FlowConfigurationModule, FlowConfigurationService, FlowUpdateService, LineItemWorker, ProductImagesService, QuoteDraftService, RuntimeMode, RuntimeOperation, RuntimeStep, SdkCoreModule, findLineItem, findLineItemWithComparator, generateLineItem, getAttributeValue, getAttributes, getDefaultLineItem, getRecommendedPrices, insertLineItem, lineItem_utils as lineItemUtils, mapAttributes, patchAttributes, removeLineItem, replaceLineItem, upsertAttributes };
+//# sourceMappingURL=veloceapps-sdk-core.js.map