@veloceapps/sdk 8.0.0-16 → 8.0.0-160

package/fesm2020/veloceapps-sdk-core.mjs

@@ -1,16 +1,16 @@
 import * as i0 from '@angular/core';
-import { Injectable, InjectionToken, NgModule, inject, Directive, Input, LOCALE_ID, Pipe } from '@angular/core';
-import { UUID, ConfigurationContextMode, ConfigurationContext, RuntimeModel, getUIDefinitionProperties, isLegacyUIDefinition, SalesforceIdUtils, ConfigurationMode, ConfigurationTranslatorUtils, EntityUtil, ChargeGroupUtils, DEFAULT_CURRENCY_ISO_CODE, DEFAULT_CURRENCY_SYMBOL, validateDateFormat, DEFAULT_DATE_FORMAT, DEFAULT_DECIMALS_COUNT, getSupportedDateFormats, DEFAULT_DECIMAL_SEPARATOR, DEFAULT_THOUSANDS_SEPARATOR, parseJsonSafely, formatNumber } from '@veloceapps/core';
+import { Injectable, InjectionToken, Optional, Inject, NgModule, inject, Directive, Input, LOCALE_ID, Pipe } from '@angular/core';
+import { UUID, ConfigurationContextMode, ConfigurationContext, UITemplateType, isDefined, ConfigurationProcessorTypes, EntityUtil, DEFAULT_CURRENCY_ISO_CODE, DEFAULT_CURRENCY_SYMBOL, validateDateFormat, DEFAULT_DATE_FORMAT, DEFAULT_DECIMALS_COUNT, getSupportedDateFormats, DEFAULT_DECIMAL_SEPARATOR, DEFAULT_THOUSANDS_SEPARATOR, DEFAULT_ACTION_CODE_LABELS, parseJsonSafely, ConfigurationMode, ConfigurationTranslatorUtils, ChargeGroupUtils, RuntimeModel, isNotLegacyUIDefinition, SalesforceIdUtils, DEFAULT_TIME_FORMAT, formatNumber } from '@veloceapps/core';
 import * as i1 from '@veloceapps/api';
-import { PriceApiService, ContextApiService, ProductModelApiService, ConfigurationApiService } from '@veloceapps/api';
-import { BehaviorSubject, combineLatest, zip, noop, throwError, shareReplay as shareReplay$1, switchMap as switchMap$1, of, tap as tap$1, map as map$2, catchError as catchError$1, Subject, take as take$1, distinctUntilChanged } from 'rxjs';
-import { filter, tap, map, first, switchMap, skip, take, shareReplay, catchError, finalize } from 'rxjs/operators';
-import { merge, isEqual, flatten, sortBy, map as map$1, transform, omit, cloneDeep, uniq } from 'lodash';
-import { HttpErrorResponse } from '@angular/common/http';
-import * as i4 from '@veloceapps/components';
+import { ApiModule } from '@veloceapps/api';
+import { BehaviorSubject, switchMap, map as map$1, tap as tap$1, noop, catchError, throwError, of, forkJoin, Subject, filter as filter$1, zip, combineLatest, shareReplay as shareReplay$1, finalize, takeUntil, buffer, debounceTime, share, take as take$1, distinctUntilChanged } from 'rxjs';
+import { map, filter, tap, switchMap as switchMap$1, skip, take, shareReplay, catchError as catchError$1, finalize as finalize$1, first } from 'rxjs/operators';
+import { merge, isEmpty, flatten, entries, sortBy, map as map$2, omit, isEqual, cloneDeep, assign, uniqBy, transform } from 'lodash';
+import * as i6 from '@veloceapps/components';
 import { ToastType, ConfirmationComponent, ConfirmationDialogModule } from '@veloceapps/components';
+import { HttpErrorResponse } from '@angular/common/http';
 import * as i5 from 'primeng/api';
-import * as i6 from 'primeng/dynamicdialog';
+import * as i6$1 from 'primeng/dynamicdialog';
 import moment from 'moment';
 import { NgControl } from '@angular/forms';
 import 'primeng/calendar';
@@ -33,15 +33,20 @@ const getDefaultLineItem = (context, uiDefinitionProperties, qty = 1) => {
         ...(uiDefinitionProperties.offeringId ? { offeringId: uiDefinitionProperties.offeringId } : {}),
     };
 };
-const getGuidedSellingConfigurationRequest = (data) => {
+const getGuidedSellingConfigurationRequest = (data, context) => {
+    const _context = { ...context };
+    delete _context.configurationToken;
+    const properties = { ...context.properties };
+    delete properties['ConfigurationToken'];
     return {
         mode: 'SEARCH',
         step: 'START',
         attributeDomainMode: 'ALL',
         context: {
-            headerId: 'TestId',
+            ..._context,
             mode: ConfigurationContextMode.TEST,
             properties: {
+                ...properties,
                 ModelId: data.modelId,
                 Name: 'Veloce Guided Selling',
                 PricingEnabled: 'false',
@@ -62,6 +67,26 @@ const getGuidedSellingConfigurationRequest = (data) => {
         },
     };
 };
+const generateConfigurationLineItem = (props, qty = 1) => {
+    const id = UUID.UUID();
+    const attributes = Object.entries(props.attributesMap ?? {}).map(([name, value]) => ({
+        name,
+        value,
+        cfgStatus: 'User',
+    }));
+    const lineItems = [];
+    return {
+        id,
+        type: props.product.typeName ?? '',
+        cfgStatus: 'Default',
+        actionCode: 'ADD',
+        qty,
+        attributes,
+        lineItems,
+        productName: props.product.name,
+        productId: props.product.id ?? '',
+    };
+};
 
 class ContextService {
     constructor(contextApiService) {
@@ -71,9 +96,25 @@ class ContextService {
     get isInitialized() {
         return Boolean(this.context.value);
     }
+    get isInitialized$() {
+        return this.context.pipe(map(Boolean));
+    }
     get mode() {
         return this.resolve().properties.mode;
     }
+    get isEditMode$() {
+        return this.resolve$().pipe(map(() => this.isEditMode));
+    }
+    get isEditMode() {
+        const context = this.resolve();
+        if (context.mode === ConfigurationContextMode.ACCOUNT) {
+            return true;
+        }
+        if (context.mode === ConfigurationContextMode.QUOTE) {
+            return context.properties.Status === 'Draft';
+        }
+        return false;
+    }
     resolve() {
         if (!this.context.value) {
             throw new Error('Context is not initialized yet!');
@@ -86,6 +127,18 @@ class ContextService {
     create(headerId, mode) {
         return this.contextApiService.getContext(headerId, mode).pipe(tap(context => this.context.next(merge(new ConfigurationContext(headerId, mode), context))), map(() => this.resolve()));
     }
+    initTestMode() {
+        return this.create('TestId', ConfigurationContextMode.TEST).pipe(map(context => {
+            return this.update({
+                properties: {
+                    ...context.properties,
+                    RuntimeMode: ConfigurationContextMode.TEST,
+                    StartDate: new Date().toISOString().substring(0, 10),
+                    standalone: 'true',
+                },
+            });
+        }));
+    }
     update(partialContext) {
         const originalContext = this.resolve();
         const updatedContext = {
@@ -112,13 +165,14 @@ class ContextService {
         this.context.next(null);
     }
 }
-ContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ContextService, deps: [{ token: i1.ContextApiService }], target: i0.ɵɵFactoryTarget.Injectable });
-ContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ContextService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ContextService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
+ContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContextService, deps: [{ token: i1.ContextApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContextService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContextService, decorators: [{
+            type: Injectable
         }], ctorParameters: function () { return [{ type: i1.ContextApiService }]; } });
 
+const FLOW_CUSTOMIZATION = new InjectionToken('FLOW_CUSTOMIZATION');
+
 const FORMATTING_SETTINGS_TOKEN = new InjectionToken('Summary of formatting settings for variant types of data, e.g. numbers, text, dates, etc');
 
 var RuntimeMode;
@@ -139,146 +193,382 @@ var RuntimeStep;
 
 const UI_DEFINITION_VERSION = 3;
 
-class RuntimeContextService {
-    constructor(configurationApiService) {
-        this.configurationApiService = configurationApiService;
+class FlowInfoService {
+    get flow() {
+        return this.flowSubj$.value;
+    }
+    set flow(value) {
+        this.flowSubj$.next(value);
+    }
+    get isLegacy() {
+        return !!this.flow && this.flow?.properties.stateful == null;
+    }
+    get isStateful() {
+        return !!this.flow?.properties.stateful;
+    }
+    constructor(flowsApiService, templatesApiService, customizationService) {
+        this.flowsApiService = flowsApiService;
+        this.templatesApiService = templatesApiService;
+        this.customizationService = customizationService;
+        this.templates = {};
+        this.defaultTemplates = {
+            flowEngine: 'Flow Engine',
+        };
+        this.flowSubj$ = new BehaviorSubject(null);
+        this.flow$ = this.flowSubj$.asObservable();
+    }
+    init$(flowId, params) {
+        this.params = params;
+        return this.flowsApiService.getFlow(flowId).pipe(switchMap(flow => this.initFlowTemplates$(flow).pipe(map$1(() => flow))), tap$1(flow => this.flowSubj$.next(flow)), map$1(noop), catchError(e => {
+            this.flowSubj$.next(null);
+            return throwError(() => e);
+        }));
     }
-    getRuntimeContext(productId, offeringId) {
-        return this.configurationApiService.getRuntimeDataByProductId(productId, offeringId).pipe(map(runtimeData => {
-            const uiDefinitionContainer = this.getUIDefinitionContainer(runtimeData);
-            const runtimeModel = RuntimeModel.create(runtimeData.types, runtimeData.products);
-            const { productName, properties } = Array.from(runtimeModel.components.values()).find(c => c.productId === productId) ?? {};
-            const uiDefinitionProperties = getUIDefinitionProperties(uiDefinitionContainer);
-            return {
-                modelId: runtimeData.modelId,
-                uiDefinitionContainer: uiDefinitionContainer,
-                runtimeModel: runtimeModel,
-                runtimeMode: RuntimeMode.PROD,
-                productId: productId,
-                productType: properties?.['displayName'] || productName,
-                offeringId: offeringId,
-                properties: {
-                    PricingEnabled: uiDefinitionProperties.pricingEnabled ? 'true' : 'false',
-                    PriceListId: uiDefinitionProperties.priceList,
-                },
-            };
+    cleanup() {
+        this.flowSubj$.next(null);
+        this.params = undefined;
+        this.templates = {};
+    }
+    initFlowTemplates$(flow) {
+        if (isEmpty(flow.properties.templates)) {
+            return of(undefined);
+        }
+        return forkJoin([
+            this.templatesApiService.fetchTemplates$(),
+            this.customizationService?.getTemplates?.() ?? of([]),
+        ]).pipe(map$1(([templates, localTemplates]) => {
+            Object.entries({ ...this.defaultTemplates, ...flow.properties.templates }).forEach(([key, name]) => {
+                const type = this.remapTemplateName(key);
+                if (type) {
+                    this.templates[type] =
+                        localTemplates.find(template => template.name === name && template.type === type) ??
+                            templates.find(template => template.name === name && template.type === type);
+                }
+            });
         }));
     }
-    getUIDefinitionContainer(runtimeData) {
-        const containers = runtimeData.uiDefinitions.filter(container => !isLegacyUIDefinition(container.source));
-        return containers.find(container => container.source.primary) ?? containers[0];
+    remapTemplateName(templateType) {
+        switch (templateType) {
+            case 'flowEngine':
+                return UITemplateType.FLOW_ENGINE;
+            default:
+                break;
+        }
+        switch (templateType) {
+            case 'assets':
+            case 'shoppingCart':
+                // No separate Assets template at the moment
+                return UITemplateType.SHOPPING_CART;
+            case 'catalog':
+                return UITemplateType.CATALOG;
+            case 'docGen':
+                return UITemplateType.DOCGEN;
+            case 'guidedSelling':
+                return UITemplateType.GUIDED_SELLING;
+            case 'flowHeader':
+                return UITemplateType.FLOW_HEADER;
+            default:
+                break;
+        }
+        return undefined;
+    }
+}
+FlowInfoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowInfoService, deps: [{ token: i1.FlowsApiService }, { token: i1.UITemplatesApiService }, { token: FLOW_CUSTOMIZATION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowInfoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowInfoService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowInfoService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FlowsApiService }, { type: i1.UITemplatesApiService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FLOW_CUSTOMIZATION]
+                }] }]; } });
+
+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 {
+        ...lineItem,
+        lineItems: [
+            ...insertData,
+            ...lineItem.lineItems.map(li => {
+                return insertLineItem(li, parentId, toInsert);
+            }),
+        ],
+    };
+};
+const removeLineItem = (lineItem, idToRemove) => {
+    return {
+        ...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, skipCardinalityCalculation = false) => {
+    if (lineItem.id === replaceTo.id) {
+        if (!skipCardinalityCalculation) {
+            return { ...recalculateCardinalityVariables(lineItem, replaceTo) };
+        }
+        else {
+            return { ...replaceTo };
+        }
+    }
+    return {
+        ...lineItem,
+        lineItems: lineItem.lineItems.map(li => replaceLineItem(li, replaceTo, skipCardinalityCalculation)),
+    };
+};
+const collectCardinalityComputations = (portDomains) => {
+    const cardinalityComputations = new Map();
+    entries(portDomains).forEach(([key, portDomain]) => {
+        cardinalityComputations.set(key, portDomain.properties['cardinalityComputation'] === 'true');
+    });
+    return cardinalityComputations;
+};
+const calculateCardinalityVariables = (lineItems, cardinalityComputations) => {
+    const cardVars = new Map();
+    lineItems
+        .filter(({ port, type }) => !!port && !!type)
+        .forEach(li => {
+        if (cardinalityComputations.get(`${li.port}`)) {
+            const cardinalityVariableName = `#CV-${li.type}@${li.port}`;
+            cardVars.set(cardinalityVariableName, (cardVars.get(cardinalityVariableName) ?? 0) + li.qty);
+        }
+    });
+    return cardVars;
+};
+const cardinalityRegexp = new RegExp('#CV-[a-zA-Z0-9_]+@(?<portName>[a-zA-Z0-9_]+)');
+const recalculateCardinalityVariables = (original, updated) => {
+    const cardinalityComputations = collectCardinalityComputations(updated.portDomains ?? original.portDomains ?? {});
+    const cardinalityVariables = calculateCardinalityVariables(updated.lineItems, cardinalityComputations);
+    const originalCardinalityVariables = calculateCardinalityVariables(original.lineItems, cardinalityComputations);
+    originalCardinalityVariables.forEach((value, key) => {
+        const execArray = cardinalityRegexp.exec(key);
+        const portName = execArray?.groups?.['portName'];
+        if (!portName || cardinalityComputations.get(portName)) {
+            if (cardinalityVariables.get(key) === value) {
+                // no need to update cardinality if no changes
+                cardinalityVariables.delete(key);
+            }
+            else if (!cardinalityVariables.has(key)) {
+                // remove last item from port
+                cardinalityVariables.set(key, 0);
+            }
+        }
+    });
+    return {
+        ...updated,
+        attributes: upsertAttributes(updated.attributes, [...cardinalityVariables].map(([name, value]) => ({ name, value, cfgStatus: 'Changed' }))),
+    };
+};
+const mapAttributes = (attributes) => {
+    return attributes.reduce((acc, { name, value }) => ({ ...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),
+            { ...(origAttr ?? { name }), cfgStatus: origAttr ? 'Changed' : 'User', value },
+        ];
+    }, originalAttributes);
+};
+const patchAttributes = (rootLineItem, id, attrs, skipCardinalityCalculation = false) => {
+    const lineItem = findLineItem(id, [rootLineItem]);
+    if (!lineItem) {
+        return rootLineItem;
+    }
+    const attributes = upsertAttributes(lineItem.attributes, attrs);
+    return replaceLineItem(rootLineItem, { ...lineItem, attributes }, skipCardinalityCalculation);
+};
+const getAttributeValue = (attributes, name) => attributes.find(attr => attr.name === name)?.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) => {
+    const domainType = portDomain.domainTypes.find(({ name }) => name === type);
+    const [net, list] = domainType?.recommendedPrices
+        ?.filter(({ chargeMethod }) => chargeMethod === 'ONE_TIME')
+        .reduce((acc, rp) => {
+        const [netPrice, listPrice] = acc;
+        return [netPrice + rp.netPrice, listPrice + rp.listPrice];
+    }, [0, 0]) ?? [0, 0];
+    return { net, list };
+};
+const generateModifiedAssetsMap = (lineItems) => {
+    return lineItems.reduce((acc, li) => {
+        const isModified = isLineItemModified(li);
+        if (!isModified) {
+            return acc;
+        }
+        const target = getOriginParent(lineItems, li);
+        const id = target?.assetId ?? target?.openOrderLineItemId;
+        if (id) {
+            acc[id] = true;
+        }
+        return acc;
+    }, {});
+};
+const getOriginParent = (lineItems, currentLineItem) => {
+    let target = currentLineItem;
+    while (target && target.rampInstanceId) {
+        target = lineItems.find(sub => sub.id === currentLineItem.rampInstanceId);
+    }
+    return target;
+};
+const isLineItemModified = (lineItem) => {
+    if (lineItem.actionCode === 'EXIST' && lineItem.status === 'PENDING') {
+        return false;
+    }
+    return lineItem.actionCode !== 'EXIST';
+};
+const multiplyLineItems = (lineItem, qty, split) => {
+    if (split) {
+        const unifyIds = (lineItem) => ({
+            ...lineItem,
+            id: UUID.UUID(),
+            lineItems: lineItem.lineItems.map(unifyIds),
+        });
+        return map$2(new Array(qty), () => unifyIds(lineItem));
+    }
+    else {
+        return [
+            {
+                ...lineItem,
+                qty: qty,
+            },
+        ];
+    }
+};
+const isTechnicalAttribute = (name) => {
+    return name.startsWith('#') || name.startsWith('$');
+};
+const filterOutTechnicalAttributes = (attributes) => {
+    return attributes.filter(({ name }) => !isTechnicalAttribute(name));
+};
+
+var lineItem_utils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    filterOutTechnicalAttributes: filterOutTechnicalAttributes,
+    findLineItem: findLineItem,
+    findLineItemWithComparator: findLineItemWithComparator,
+    generateLineItem: generateLineItem,
+    generateModifiedAssetsMap: generateModifiedAssetsMap,
+    getAttributeValue: getAttributeValue,
+    getAttributes: getAttributes,
+    getOriginParent: getOriginParent,
+    getRecommendedPrices: getRecommendedPrices,
+    insertLineItem: insertLineItem,
+    isLineItemModified: isLineItemModified,
+    isTechnicalAttribute: isTechnicalAttribute,
+    mapAttributes: mapAttributes,
+    multiplyLineItems: multiplyLineItems,
+    patchAttributes: patchAttributes,
+    recalculateCardinalityVariables: recalculateCardinalityVariables,
+    removeLineItem: removeLineItem,
+    replaceLineItem: replaceLineItem,
+    upsertAttributes: upsertAttributes
+});
+
+class LineItemWorker {
+    constructor(src) {
+        this.li = { ...src };
+    }
+    insert(parentId, toInsert) {
+        return new LineItemWorker(insertLineItem(this.li, parentId, toInsert));
+    }
+    remove(id) {
+        return new LineItemWorker(removeLineItem(this.li, id));
+    }
+    replace(toReplace, skipCardinalityCalculation = false) {
+        return new LineItemWorker(replaceLineItem(this.li, toReplace, skipCardinalityCalculation));
+    }
+    patchAttribute(attrs, id, skipCardinalityCalculation = false) {
+        return new LineItemWorker(patchAttributes(this.li, id ?? this.li.id, attrs, skipCardinalityCalculation));
     }
 }
-RuntimeContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: RuntimeContextService, deps: [{ token: i1.ConfigurationApiService }], target: i0.ɵɵFactoryTarget.Injectable });
-RuntimeContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: RuntimeContextService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", 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.initializationProps = undefined;
-        this.uiDefinitionProperties = {};
+function extractMetadata(uiDefinition) {
+    return omit(uiDefinition, [
+        'children',
+        'pages',
+        'components',
+    ]);
+}
+
+class IntegrationState {
+    constructor() {
+        this.stateSubj$ = new BehaviorSubject({});
+        this.action$ = new Subject();
     }
-    initTestMode(uiDefinitionContainer) {
-        this.uiDefinitionProperties = getUIDefinitionProperties(uiDefinitionContainer);
-        const uiDefinitionExternals = uiDefinitionContainer.source.externals ?? {};
-        return combineLatest([
-            this.apiService.getRuntimeDataByModelId(uiDefinitionContainer.modelId),
-            this.contextService.create('TestId', ConfigurationContextMode.TEST),
-        ]).pipe(first(), map(([runtimeData, context]) => {
-            this.contextService.update({
-                properties: {
-                    ...this.runtimeContext?.properties,
-                    ...context.properties,
-                    ModelId: uiDefinitionContainer.modelId,
-                    RuntimeMode: ConfigurationContextMode.TEST,
-                    PricingEnabled: this.uiDefinitionProperties.pricingEnabled ? 'true' : 'false',
-                    StartDate: new Date().toISOString().substring(0, 10),
-                    PriceListId: this.uiDefinitionProperties.priceList,
-                    offeringId: this.uiDefinitionProperties.offeringId,
-                    standalone: 'true',
-                    ...uiDefinitionExternals,
-                },
-            });
-            this._runtimeContext = {
-                modelId: uiDefinitionContainer.modelId,
-                runtimeModel: RuntimeModel.create(runtimeData.types, runtimeData.products),
-                runtimeMode: RuntimeMode.TEST,
-                uiDefinitionContainer,
-            };
-            return this._runtimeContext;
-        }), tap(() => (this._isInitialized = true)));
+    get state$() {
+        return this.stateSubj$.asObservable();
     }
-    init(props) {
-        this.initializationProps = props;
-        const context = this.contextService.resolve();
-        return this.runtimeContextService.getRuntimeContext(props.productId, props.offeringId).pipe(tap(runtimeContext => {
-            this.uiDefinitionProperties = getUIDefinitionProperties(runtimeContext.uiDefinitionContainer);
-            const { PriceListId } = context.properties ?? {};
-            const mergeContext = {
-                ...runtimeContext,
-                properties: {
-                    ...runtimeContext.properties,
-                    ...context.properties,
-                    PricingEnabled: PriceListId ? 'true' : 'false',
-                },
-            };
-            this.id15to18('AccountId', mergeContext.properties);
-            this._runtimeContext = mergeContext;
-            if (context.properties && this._runtimeContext.properties?.StartDate) {
-                this.contextService.update({
-                    properties: {
-                        ...this._runtimeContext.properties,
-                        ...context.properties,
-                    },
-                });
-            }
-            return this._runtimeContext;
-        }), tap(() => (this._isInitialized = true)));
+    get state() {
+        return this.stateSubj$.getValue();
     }
-    overrideUIDefinition(uiDefinitionContainer) {
-        if (!this._runtimeContext) {
-            return;
-        }
-        this._runtimeContext.uiDefinitionContainer = uiDefinitionContainer;
-        this.uiDefinitionProperties = getUIDefinitionProperties(uiDefinitionContainer);
+    patchState(update) {
+        this.stateSubj$.next({ ...this.stateSubj$.getValue(), ...update });
     }
-    id15to18(propertyName, source) {
-        if (!source) {
-            return;
-        }
-        const value = source[propertyName];
-        if (typeof value === 'string' && value.length === 15) {
-            source[propertyName] = SalesforceIdUtils.generateId18FromId15(value);
-        }
+    dispatch(action) {
+        this.action$.next(action);
     }
-    get isInitialized() {
-        return this._isInitialized;
+    listen$(actionType) {
+        return this.action$.pipe(filter$1(action => action.type === actionType), map$1(action => action.payload));
     }
-    get runtimeModel() {
-        return this.runtimeContext?.runtimeModel;
+    listenAll$() {
+        return this.action$.asObservable();
     }
-    get runtimeContext() {
-        return this._runtimeContext;
+    clear() {
+        this.stateSubj$.next({});
     }
 }
-ConfigurationRuntimeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", 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: "15.2.8", ngImport: i0, type: ConfigurationRuntimeService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationRuntimeService, decorators: [{
+IntegrationState.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IntegrationState, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+IntegrationState.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IntegrationState });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IntegrationState, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.ConfigurationApiService }, { type: ContextService }, { type: RuntimeContextService }]; } });
+        }] });
 
 class QuoteDraftService {
+    get isInitialized$() {
+        return this.isInitializedSubj$.asObservable();
+    }
     get isInitialized() {
         return this.isInitializedSubj$.getValue();
     }
@@ -301,12 +591,20 @@ class QuoteDraftService {
     }
     get hasProducts() {
         const quoteDraft = this.quoteSubj$.value;
-        return Boolean(quoteDraft && quoteDraft.currentState.length > 0);
+        return this.filterByActivePriceList(quoteDraft?.currentState || []).some(li => !li.assetId && !li.openOrderLineItemId);
+    }
+    get hasAssets$() {
+        return this.quoteSubj$.pipe(map(() => this.hasAssets));
+    }
+    get hasAssets() {
+        const quoteDraft = this.quoteSubj$.value;
+        return this.filterByActivePriceList(quoteDraft?.currentState || []).some(li => li.assetId || li.openOrderLineItemId);
     }
-    constructor(context, quoteApiService, priceApiService) {
+    constructor(context, quoteApiService, priceApiService, integrationState) {
         this.context = context;
         this.quoteApiService = quoteApiService;
         this.priceApiService = priceApiService;
+        this.integrationState = integrationState;
         this.quoteSubj$ = new BehaviorSubject(null);
         this.resetSubj$ = new BehaviorSubject(true);
         this.isInitializedSubj$ = new BehaviorSubject(false);
@@ -317,12 +615,13 @@ class QuoteDraftService {
         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));
         this.isInitializedSubj$
-            .pipe(filter(isInitialized => isInitialized), switchMap(() => this.quoteSubj$.asObservable()), skip(1), tap(quote => this.markAsUpdated(quote)))
+            .pipe(filter(isInitialized => isInitialized), switchMap$1(() => this.quoteSubj$.asObservable()), skip(1), tap(quote => this.markAsUpdated(quote)))
             .subscribe();
     }
     reset() {
         this.resetSubj$.next(true);
         this.quoteSubj$.next(null);
+        this.isInitialized = false;
         this.hasUnsavedChanges = false;
     }
     init(quoteId, params) {
@@ -333,6 +632,11 @@ class QuoteDraftService {
             this.populateActivePriceLists$();
         }), map(() => noop()), take(1));
     }
+    finalizeInit() {
+        this.initializeModifiedAssetsMap();
+        this.isInitialized = true;
+        this.hasUnsavedChanges = false;
+    }
     setCurrentLineItemState(lineItems) {
         const quoteDraft = this.quoteSubj$.value;
         if (!quoteDraft) {
@@ -492,252 +796,616 @@ class QuoteDraftService {
             this.hasUnsavedChanges = !isEqual(this.initialCurrentState, quote?.currentState);
         }
     }
+    initializeModifiedAssetsMap() {
+        this.integrationState.patchState({
+            modifiedAssets: generateModifiedAssetsMap(this.currentState),
+        });
+    }
 }
-QuoteDraftService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", 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: "15.2.8", ngImport: i0, type: QuoteDraftService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: QuoteDraftService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: ContextService }, { type: i1.QuoteApiService }, { type: i1.PriceApiService }]; } });
+QuoteDraftService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: QuoteDraftService, deps: [{ token: ContextService }, { token: i1.QuoteApiService }, { token: i1.PriceApiService }, { token: IntegrationState }], target: i0.ɵɵFactoryTarget.Injectable });
+QuoteDraftService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: QuoteDraftService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: QuoteDraftService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: ContextService }, { type: i1.QuoteApiService }, { type: i1.PriceApiService }, { type: IntegrationState }]; } });
 
-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;
+class FlowStateService {
+    constructor(contextService, quoteDraftService, flowInfoService, flowConfiguration, processorsApiService, flowStateApiService, quoteApiService, toastService, customizationService) {
+        this.contextService = contextService;
+        this.quoteDraftService = quoteDraftService;
+        this.flowInfoService = flowInfoService;
+        this.flowConfiguration = flowConfiguration;
+        this.processorsApiService = processorsApiService;
+        this.flowStateApiService = flowStateApiService;
+        this.quoteApiService = quoteApiService;
+        this.toastService = toastService;
+        this.customizationService = customizationService;
+        this.NOT_INITIALIZED = Symbol();
+        this.EXECUTION_BUFFER_TIME = 100;
+        this.executedFunctions = {};
+        this.stateId$ = new BehaviorSubject(null);
+        this._hasStatefulUnsavedChanges = true;
+        this.processors = {};
+        this.subscriptions = {};
+        this.flowStore = {};
+        this.statefulExecutionInProgress$ = new BehaviorSubject(false);
+        this.statefulRequestStream$ = new Subject();
+        this.cleanup$ = new Subject();
+        this.statefulExecutionRequest$ = this.initBufferedRequest$();
+        /*
+          In stateless mode watch QuoteDraft changes and call executeRequest so that
+          all subscriptions get their updates according to updated QuoteDraft
+        */
+        this.isInitialized$()
+            .pipe(filter$1(Boolean), filter$1(() => !this.getFlowSafe().properties.stateful), switchMap(() => this.flowConfiguration.updated$), switchMap(() => this.executeRequest$({}, true)))
+            .subscribe();
+        this.charges$ = this.flowInfoService.flow$.pipe(filter$1(isDefined), switchMap(flow => {
+            if (!flow.properties.stateful) {
+                return this.quoteDraftService.quoteDraft$.pipe(map$1(quoteDraft => quoteDraft.charges));
+            }
+            else {
+                return this.subscribe$(UITemplateType.FLOW_ENGINE, 'CHARGES', null, {
+                    cold: true,
+                }).pipe(map$1(response => (response.success ? response.result : {})));
+            }
+        }), filter$1(isDefined), shareReplay$1());
+        this.charges$.subscribe();
+        this.pricePlans$ = this.flowInfoService.flow$.pipe(filter$1(isDefined), switchMap(flow => {
+            if (!flow.properties.stateful) {
+                return this.quoteDraftService.quoteDraft$.pipe(map$1(quoteDraft => quoteDraft.pricePlans));
+            }
+            else {
+                return this.subscribe$(UITemplateType.FLOW_ENGINE, 'PRICE_PLANS', null, {
+                    cold: true,
+                }).pipe(map$1(response => (response.success ? response.result : {})));
+            }
+        }), filter$1(isDefined), shareReplay$1());
+        this.pricePlans$.subscribe();
+        this.activeMetrics$ = this.flowInfoService.flow$.pipe(filter$1(isDefined), switchMap(flow => {
+            if (!flow.properties.stateful) {
+                return this.quoteDraftService.quoteDraft$.pipe(map$1(quoteDraft => quoteDraft.activeMetrics));
+            }
+            else {
+                return this.subscribe$(UITemplateType.FLOW_ENGINE, 'ACTIVE_METRICS', null, {
+                    cold: true,
+                }).pipe(map$1(response => (response.success ? response.result : [])));
+            }
+        }), filter$1(isDefined), shareReplay$1());
+        this.activeMetrics$.subscribe();
+    }
+    init$() {
+        return this.initProcessors$().pipe(switchMap(() => {
+            if (this.getFlowSafe().properties.stateful) {
+                return this.initStateful$();
+            }
+            else {
+                return this.initStateless$();
+            }
+        }));
+    }
+    cleanup() {
+        Object.values(this.subscriptions).forEach(({ data$ }) => data$.complete());
+        this.subscriptions = {};
+        if (this.stateId$.value) {
+            this.flowStateApiService.cancel(this.stateId$.value).subscribe();
+            this.stateId$.next(null);
         }
-        currentLevel = flatten(currentLevel.map(parent => parent.lineItems));
+        this.processors = {};
+        this.flowStore = {};
+        this.cleanup$.next();
     }
-    return;
-};
-const insertLineItem = (lineItem, parentId, toInsert) => {
-    const insertData = lineItem.id === parentId ? [toInsert] : [];
-    return {
-        ...lineItem,
-        lineItems: [
-            ...insertData,
-            ...lineItem.lineItems.map(li => {
-                return insertLineItem(li, parentId, toInsert);
-            }),
-        ],
-    };
-};
-const removeLineItem = (lineItem, idToRemove) => {
-    return {
-        ...lineItem,
-        lineItems: lineItem.lineItems
-            .map(li => {
-            if (li.id === idToRemove) {
-                return;
+    get hasUnsavedChanges() {
+        return this.getFlowSafe().properties.stateful
+            ? this._hasStatefulUnsavedChanges
+            : this.quoteDraftService.hasUnsavedChanges;
+    }
+    get stateId() {
+        return this.stateId$.value;
+    }
+    get isExecutionInProgress$() {
+        return this.statefulExecutionInProgress$.asObservable();
+    }
+    isInitialized$() {
+        return combineLatest([this.stateId$, this.quoteDraftService.isInitialized$]).pipe(map$1(values => values.some(Boolean)));
+    }
+    isInitialized() {
+        return Boolean(this.stateId$.value) || this.quoteDraftService.isInitialized;
+    }
+    execute$(scope, exec) {
+        const request = this.execToRequest(scope, exec);
+        return this.executeRequest$(request).pipe(map$1(result => {
+            // Keep only requested results
+            const actualSelectors = Object.entries(result.selectors).reduce((trunk, [requestId, result]) => {
+                if (exec.selectors?.[requestId]) {
+                    trunk[requestId] = result;
+                }
+                return trunk;
+            }, {});
+            return actualSelectors;
+        }));
+    }
+    dispatch$(scope, action, inputData) {
+        const exec = {
+            actions: [{ name: action, inputData }],
+        };
+        const request = this.execToRequest(scope, exec);
+        return this.executeRequest$(request).pipe(map$1(noop));
+    }
+    select$(scope, selectorName, inputData) {
+        const requestId = this.generateRequestId(scope, selectorName, inputData);
+        const request = this.execToRequest(scope, {
+            selectors: {
+                [requestId]: {
+                    name: selectorName,
+                    inputData,
+                },
+            },
+        });
+        return this.executeRequest$(request).pipe(map$1(response => response.selectors[requestId]));
+    }
+    subscribe$(scope, selectorName, inputData, options) {
+        const requestId = this.generateRequestId(scope, selectorName, inputData);
+        if (!this.subscriptions[requestId]) {
+            const request = this.execToRequest(scope, {
+                selectors: {
+                    [requestId]: {
+                        name: selectorName,
+                        inputData,
+                    },
+                },
+            });
+            this.subscriptions[requestId] = {
+                request,
+                data$: new BehaviorSubject(this.NOT_INITIALIZED),
+            };
+            if (!options?.cold) {
+                this.executeRequest$(request).subscribe();
             }
-            else if (li.lineItems.length) {
-                return removeLineItem(li, idToRemove);
+        }
+        return this.subscriptions[requestId].data$.pipe(filter$1(data => data != this.NOT_INITIALIZED), map$1(data => data), finalize(() => {
+            if (!this.subscriptions[requestId].data$.observed) {
+                delete this.subscriptions[requestId];
+            }
+        }));
+    }
+    save$() {
+        if (this.getFlowSafe().properties.stateful) {
+            if (this.stateId$.value) {
+                return this.flowStateApiService.save(this.stateId$.value);
             }
-            return li;
-        })
-            .filter(r => !!r),
-    };
-};
-const replaceLineItem = (lineItem, replaceTo, skipCardinalityCalculation = false) => {
-    if (lineItem.id === replaceTo.id) {
-        if (!skipCardinalityCalculation) {
-            return { ...recalculateCardinalityVariables(lineItem, replaceTo) };
         }
         else {
-            return { ...replaceTo };
+            const quoteDraft = this.quoteDraftService.quoteDraftForActivePriceList;
+            if (quoteDraft) {
+                return this.quoteApiService.upsertQuote(quoteDraft);
+            }
+        }
+        return of({ quoteId: '' });
+    }
+    submit$() {
+        if (this.getFlowSafe().properties.stateful) {
+            if (this.stateId$.value) {
+                return this.flowStateApiService.submit(this.stateId$.value);
+            }
+        }
+        else {
+            const quoteDraft = this.quoteDraftService.quoteDraftForActivePriceList;
+            if (quoteDraft) {
+                return this.quoteApiService.submitQuote(quoteDraft);
+            }
+        }
+        return of({ quoteId: '' });
+    }
+    getFlowStore() {
+        return this.flowStore;
+    }
+    getOwnerIdByScope(scope) {
+        const ownerId = this.flowInfoService.templates[scope]?.id;
+        if (!ownerId) {
+            throw `OwnerId is not found for scope ${scope}`;
+        }
+        return ownerId;
+    }
+    getScopeByOwnerId(id) {
+        for (const template of Object.values(this.flowInfoService.templates)) {
+            if (template.id === id) {
+                return template.type;
+            }
+        }
+        return;
+    }
+    execToRequest(scope, exec) {
+        const ownerId = this.getOwnerIdByScope(scope);
+        return {
+            actions: exec.actions?.map(action => ({ apiName: action.name, ownerId, inputData: action.inputData ?? {} })),
+            selectors: exec.selectors &&
+                Object.entries(exec.selectors).reduce((trunk, [key, selector]) => ({
+                    ...trunk,
+                    [key]: { apiName: selector.name, ownerId, inputData: selector.inputData ?? {} },
+                }), {}),
+        };
+    }
+    executeRequest$(request, forceSubscriptions = false) {
+        const fullRequest = cloneDeep(request);
+        if (fullRequest.actions?.length || forceSubscriptions) {
+            for (const subscription of Object.values(this.subscriptions)) {
+                fullRequest.selectors = assign(fullRequest.selectors, subscription.request.selectors);
+            }
+        }
+        const execution$ = this.getFlowSafe().properties.stateful
+            ? this.executeStateful$(fullRequest)
+            : this.executeStateless$(fullRequest);
+        return execution$.pipe(tap$1(result => this.handleSelectorsResponse(result.selectors)));
+    }
+    handleSelectorsResponse(selectors) {
+        Object.entries(selectors).forEach(([requestId, selectorResult]) => {
+            if (!selectorResult.success) {
+                this.toastService.add({ severity: ToastType.error, summary: selectorResult.errorMessage });
+            }
+            const subscription$ = this.subscriptions[requestId]?.data$;
+            if (subscription$ && subscription$.value !== selectorResult) {
+                subscription$.next(selectorResult);
+            }
+        });
+    }
+    initStateful$() {
+        // Subscriptions
+        this.subscribe$(UITemplateType.FLOW_ENGINE, 'CONTEXT', null, { cold: true })
+            .pipe(tap$1(response => {
+            if (response.success) {
+                this.contextService.update(response.result);
+            }
+        }), takeUntil(this.cleanup$))
+            .subscribe();
+        const processorsList = flatten(Object.values(this.processors).map(ownerMap => Object.values(ownerMap ?? {})));
+        const processors = processorsList.length ? processorsList : undefined;
+        const selectors = Object.values(this.subscriptions)
+            .map(({ request }) => request.selectors)
+            .filter(isDefined)
+            .reduce((trunk, selectors) => ({ ...trunk, ...selectors }), {});
+        const request = this.getDefaultExecutionRequestDTO();
+        return this.flowStateApiService
+            .init({
+            quoteId: this.contextService.resolve().headerId,
+            params: this.flowInfoService.params ?? {},
+            actionsOverride: processors?.filter(processor => processor.type === ConfigurationProcessorTypes.ACTION),
+            selectorsOverride: processors?.filter(processor => processor.type === ConfigurationProcessorTypes.SELECTOR),
+            selectors: { ...selectors, ...request.selectors },
+            actions: request.actions,
+        })
+            .pipe(map$1(({ stateId, selectors }) => {
+            this.handleSelectorsResponse(selectors);
+            this.stateId$.next(stateId);
+        }));
+    }
+    initBufferedRequest$() {
+        return this.statefulRequestStream$.pipe(buffer(this.statefulRequestStream$.pipe(debounceTime(this.EXECUTION_BUFFER_TIME))), switchMap(requests => {
+            if (!this.stateId$.value) {
+                throw 'Stateful session is not initialized';
+            }
+            // merge buffered requests
+            const request = {
+                actions: requests.flatMap(({ actions }) => actions).filter(isDefined),
+                selectors: requests
+                    .map(({ selectors }) => selectors)
+                    .filter(isDefined)
+                    .reduce((acc, selectorsMap) => Object.assign(acc, selectorsMap), {}),
+            };
+            this.statefulExecutionInProgress$.next(true);
+            return this.flowStateApiService.execute(this.stateId$.value, request);
+        }), tap$1(({ stateId }) => this.stateId$.next(stateId)), share(), tap$1(() => this.statefulExecutionInProgress$.next(false)), catchError(e => {
+            this.statefulExecutionInProgress$.next(false);
+            return throwError(() => e);
+        }));
+    }
+    executeStateful$(request) {
+        return this.statefulExecutionInProgress$.pipe(filter$1(inProgress => !inProgress), take$1(1), switchMap(() => 
+        // make sure stream switches to statefulExecutionRequest$ before pushing an execution request
+        combineLatest([
+            this.statefulExecutionRequest$,
+            of(undefined).pipe(tap$1(() => this.statefulRequestStream$.next(request))),
+        ])), map$1(([response]) => response), take$1(1));
+    }
+    initStateless$() {
+        const { headerId } = this.contextService.resolve();
+        return this.quoteDraftService.init(headerId, this.flowInfoService.params ?? {}).pipe(switchMap(() => this.executeRequest$(this.getDefaultExecutionRequestDTO())), switchMap(() => this.calculate$()), tap$1(() => this.quoteDraftService.finalizeInit()), map$1(noop));
+    }
+    calculate$() {
+        const flowState = this.quoteDraftService.quoteDraft;
+        if (!flowState) {
+            return of(undefined);
+        }
+        /*
+          Don't execute procedures when:
+            * Initializing a standalone product configuration UI, as procedure is execute in /price call
+            * Initializing an empty account (account with no assets)
+        */
+        const isEmptyAccountMode = this.contextService.mode === ConfigurationContextMode.ACCOUNT &&
+            !this.quoteDraftService.hasProducts &&
+            !this.quoteDraftService.hasAssets &&
+            !this.quoteDraftService.quoteDraft?.initialState.length;
+        if (this.quoteDraftService.isStandalone || isEmptyAccountMode) {
+            return of(undefined);
+        }
+        return this.flowConfiguration.calculate$(flowState);
+    }
+    executeStateless$(request) {
+        return of(undefined).pipe(tap$1(() => this.executeStatelessActions(request)), switchMap(() => {
+            /*
+              Skip price calculation in case
+              1. No actions in the request
+              2. Initialization process execution (state not initialized yet)
+            */
+            if (!request.actions?.length || !this.isInitialized()) {
+                return of(undefined);
+            }
+            else {
+                return this.calculate$();
+            }
+        }), map$1(() => this.executeStatelessSelectors(request)));
+    }
+    executeStatelessActions(request) {
+        if (!this.quoteDraftService.quoteDraft || !request.actions?.length) {
+            return;
+        }
+        let flowState = this.quoteDraftService.quoteDraft;
+        request.actions.forEach(action => {
+            try {
+                flowState = this.executeActionScript(flowState, action) ?? flowState;
+            }
+            catch (e) {
+                console.error(e);
+                this.toastService.add({ severity: ToastType.error, summary: String(e) });
+                throw e;
+            }
+        });
+        this.quoteDraftService.updateQuoteDraft(flowState);
+    }
+    executeStatelessSelectors(request) {
+        if (!this.quoteDraftService.quoteDraft) {
+            throw 'QuoteDraft is not initialized';
+        }
+        const flowState = this.quoteDraftService.quoteDraft;
+        return EntityUtil.entries(request.selectors ?? {}).reduce((result, [key, selector]) => {
+            try {
+                result.selectors[key] = {
+                    success: true,
+                    result: this.executeSelectorScript(flowState, selector),
+                };
+            }
+            catch (e) {
+                console.error(e);
+                result.selectors[key] = {
+                    success: false,
+                    errorMessage: String(e),
+                };
+            }
+            return result;
+        }, { stateId: '', selectors: {} });
+    }
+    getFlowSafe() {
+        if (!this.flowInfoService.flow) {
+            throw 'Flow is not defined';
         }
+        return this.flowInfoService.flow;
     }
-    return {
-        ...lineItem,
-        lineItems: lineItem.lineItems.map(li => replaceLineItem(li, replaceTo, skipCardinalityCalculation)),
-    };
-};
-const calculateCardinalityVariables = (lineItems) => {
-    const cardVars = new Map();
-    lineItems
-        .filter(({ port, type }) => !!port && !!type)
-        .forEach(li => {
-        const cardinalityVariableName = `#CV-${li.type}@${li.port}`;
-        cardVars.set(cardinalityVariableName, (cardVars.get(cardinalityVariableName) ?? 0) + li.qty);
-    });
-    return cardVars;
-};
-const recalculateCardinalityVariables = (original, updated) => {
-    const cardinalityVariables = calculateCardinalityVariables(updated.lineItems);
-    const originalCardinalityVariables = calculateCardinalityVariables(original.lineItems);
-    originalCardinalityVariables.forEach((value, key) => {
-        if (cardinalityVariables.get(key) === value) {
-            // no need to update cardinality if no changes
-            cardinalityVariables.delete(key);
+    initProcessors$() {
+        const hasOverrides = Boolean(this.customizationService?.getTemplateConfigurationProcessors);
+        const flow = this.getFlowSafe();
+        if (flow.properties.stateful && !hasOverrides) {
+            // Skip initialization as backend will take processors from SF
+            return of(undefined);
         }
-        else if (!cardinalityVariables.has(key)) {
-            // remove last item from port
-            cardinalityVariables.set(key, 0);
+        const owners$ = Object.values(this.flowInfoService.templates)
+            .map(template => {
+            if (!template) {
+                return;
+            }
+            const localProcessors$ = this.customizationService?.getTemplateConfigurationProcessors?.(template.name) ?? of(null);
+            return localProcessors$.pipe(switchMap(processors => processors ? of(processors) : this.processorsApiService.fetchConfigurationProcessors$(template.id)), tap$1(processors => {
+                const processorsMap = processors.reduce((acc, p) => {
+                    acc[p.apiName] = p;
+                    return acc;
+                }, {});
+                this.processors[template.id] = processorsMap;
+            }));
+        })
+            .filter(isDefined);
+        if (!owners$.length) {
+            return of(undefined);
         }
-    });
-    return {
-        ...updated,
-        attributes: upsertAttributes(updated.attributes, [...cardinalityVariables].map(([name, value]) => ({ name, value, cfgStatus: 'Changed' }))),
-    };
-};
-const mapAttributes = (attributes) => {
-    return attributes.reduce((acc, { name, value }) => ({ ...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),
-            { ...(origAttr ?? { name }), cfgStatus: origAttr ? 'Changed' : 'User', value },
-        ];
-    }, originalAttributes);
-};
-const patchAttributes = (rootLineItem, id, attrs, skipCardinalityCalculation = false) => {
-    const lineItem = findLineItem(id, [rootLineItem]);
-    if (!lineItem) {
-        return rootLineItem;
+        return forkJoin(owners$).pipe(map$1(noop));
     }
-    const attributes = upsertAttributes(lineItem.attributes, attrs);
-    return replaceLineItem(rootLineItem, { ...lineItem, attributes }, skipCardinalityCalculation);
-};
-const getAttributeValue = (attributes, name) => attributes.find(attr => attr.name === name)?.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) => {
-    const domainType = portDomain.domainTypes.find(({ name }) => name === type);
-    const [net, list] = domainType?.recommendedPrices
-        ?.filter(({ chargeMethod }) => chargeMethod === 'ONE_TIME')
-        .reduce((acc, rp) => {
-        const [netPrice, listPrice] = acc;
-        return [netPrice + rp.netPrice, listPrice + rp.listPrice];
-    }, [0, 0]) ?? [0, 0];
-    return { net, list };
-};
-const generateModifiedAssetsMap = (lineItems) => {
-    return lineItems.reduce((acc, li) => {
-        const isModified = isLineItemModified(li);
-        if (!isModified) {
-            return acc;
-        }
-        const target = getOriginParent(lineItems, li);
-        const id = target?.assetId ?? target?.openOrderLineItemId;
-        if (id) {
-            acc[id] = true;
+    executeActionScript(request, executable) {
+        const configurationProcessor = this.processors[executable.ownerId]?.[executable.apiName];
+        if (!configurationProcessor?.script) {
+            const scope = this.getScopeByOwnerId(executable.ownerId);
+            const scopeText = scope ? ` in ${scope}` : '';
+            throw `ConfigurationProcessor ${executable.apiName}${scopeText} not found`;
         }
-        return acc;
-    }, {});
-};
-const getOriginParent = (lineItems, currentLineItem) => {
-    let target = currentLineItem;
-    while (target && target.rampInstanceId) {
-        target = lineItems.find(sub => sub.id === currentLineItem.rampInstanceId);
+        return this.executeProcessorScript(request, configurationProcessor, executable.inputData);
     }
-    return target;
-};
-const isLineItemModified = (lineItem) => {
-    if (lineItem.actionCode === 'EXIST' && lineItem.status === 'PENDING') {
-        return false;
+    executeSelectorScript(request, executable) {
+        const configurationProcessor = this.processors[executable.ownerId]?.[executable.apiName];
+        if (!configurationProcessor?.script) {
+            const scope = this.getScopeByOwnerId(executable.ownerId);
+            const scopeText = scope ? ` in ${scope}` : '';
+            throw `ConfigurationProcessor ${executable.apiName}${scopeText} not found`;
+        }
+        return this.executeProcessorScript(request, configurationProcessor, executable.inputData);
     }
-    return lineItem.actionCode !== 'EXIST';
-};
-const multiplyLineItems = (lineItem, qty, split) => {
-    if (split) {
-        const unifyIds = (lineItem) => ({
-            ...lineItem,
-            id: UUID.UUID(),
-            lineItems: lineItem.lineItems.map(unifyIds),
+    executeProcessorScript(request, configurationProcessor, inputData) {
+        const scope = configurationProcessor.ownerId && this.getScopeByOwnerId(configurationProcessor.ownerId);
+        let functionToExecute = this.executedFunctions[scope + configurationProcessor.apiName];
+        if (!functionToExecute) {
+            const script = `${configurationProcessor.script}\nreturn transform;`;
+            const sourceMap = `\n//# sourceURL=${scope ? scope + '/' : ''}${configurationProcessor.apiName}.js`;
+            functionToExecute = new Function(script + sourceMap)();
+            this.executedFunctions[scope + configurationProcessor.apiName] = functionToExecute;
+        }
+        return functionToExecute({
+            request,
+            inputData,
+            flowStore: this.flowStore,
         });
-        return map$1(new Array(qty), () => unifyIds(lineItem));
     }
-    else {
-        return [
-            {
-                ...lineItem,
-                qty: qty,
-            },
-        ];
+    generateRequestId(scope, selectorName, inputData) {
+        const inputDataHash = UUID.hex(JSON.stringify(inputData) || '').slice(0, 8);
+        return `${scope}/${selectorName}/${inputDataHash}`;
     }
-};
-const isTechnicalAttribute = (name) => {
-    return name.startsWith('#') || name.startsWith('$');
-};
-const filterOutTechnicalAttributes = (attributes) => {
-    return attributes.filter(({ name }) => !isTechnicalAttribute(name));
-};
-
-var lineItem_utils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    calculateCardinalityVariables: calculateCardinalityVariables,
-    filterOutTechnicalAttributes: filterOutTechnicalAttributes,
-    findLineItem: findLineItem,
-    findLineItemWithComparator: findLineItemWithComparator,
-    generateLineItem: generateLineItem,
-    generateModifiedAssetsMap: generateModifiedAssetsMap,
-    getAttributeValue: getAttributeValue,
-    getAttributes: getAttributes,
-    getOriginParent: getOriginParent,
-    getRecommendedPrices: getRecommendedPrices,
-    insertLineItem: insertLineItem,
-    isLineItemModified: isLineItemModified,
-    isTechnicalAttribute: isTechnicalAttribute,
-    mapAttributes: mapAttributes,
-    multiplyLineItems: multiplyLineItems,
-    patchAttributes: patchAttributes,
-    recalculateCardinalityVariables: recalculateCardinalityVariables,
-    removeLineItem: removeLineItem,
-    replaceLineItem: replaceLineItem,
-    upsertAttributes: upsertAttributes
-});
+    getDefaultExecutionRequestDTO() {
+        const request = {
+            actions: [],
+            selectors: {},
+        };
+        if (this.getFlowSafe().properties.standalone) {
+            return request;
+        }
+        const ownerId = this.getOwnerIdByScope(UITemplateType.FLOW_ENGINE);
+        request.actions?.push({
+            apiName: 'UPDATE_PRICE_LIST',
+            ownerId,
+            inputData: {},
+        });
+        request.actions?.push({
+            apiName: 'UPDATE_ASSET_IDS',
+            ownerId,
+            inputData: {},
+        });
+        request.actions?.push({
+            apiName: 'UPDATE_CONTEXT_PROPERTIES',
+            ownerId,
+            inputData: this.contextService.resolve().properties,
+        });
+        return request;
+    }
+}
+FlowStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateService, deps: [{ token: ContextService }, { token: QuoteDraftService }, { token: FlowInfoService }, { token: FlowConfigurationService }, { token: i1.ConfigurationProcessorsApiService }, { token: i1.FlowStateApiService }, { token: i1.QuoteApiService }, { token: i6.ToastService }, { token: FLOW_CUSTOMIZATION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: ContextService }, { type: QuoteDraftService }, { type: FlowInfoService }, { type: FlowConfigurationService }, { type: i1.ConfigurationProcessorsApiService }, { type: i1.FlowStateApiService }, { type: i1.QuoteApiService }, { type: i6.ToastService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FLOW_CUSTOMIZATION]
+                }] }]; } });
 
-class LineItemWorker {
-    constructor(src) {
-        this.li = { ...src };
+class RuntimeSettingsService {
+    constructor(configurationSettingsApiService) {
+        this.configurationSettingsApiService = configurationSettingsApiService;
+        this.configurationSettings$ = new BehaviorSubject({});
+        this.currencySettings$ = new BehaviorSubject({
+            iso: DEFAULT_CURRENCY_ISO_CODE,
+            symbol: DEFAULT_CURRENCY_SYMBOL,
+        });
+        this.shoppingCartSettings$ = new BehaviorSubject([]);
+        this.getCurrencySymbol = (locale, currency) => {
+            return (0)
+                .toLocaleString(locale, { style: 'currency', currency, minimumFractionDigits: 0, maximumFractionDigits: 0 })
+                .replace(/\d/g, '')
+                .trim();
+        };
     }
-    insert(parentId, toInsert) {
-        return new LineItemWorker(insertLineItem(this.li, parentId, toInsert));
+    create() {
+        return this.configurationSettingsApiService.fetchSettings().pipe(map$1(settings => this.parseConfigurationSettings(settings)), tap$1(configurationSettings => {
+            this.configurationSettings$.next(configurationSettings);
+            this.addShoppingCartSettings(configurationSettings['shopping-cart'] ?? []);
+            this.formattingSettings = this.getFormattingSettings();
+        }), map$1(() => undefined));
     }
-    remove(id) {
-        return new LineItemWorker(removeLineItem(this.li, id));
+    initCurrency(iso) {
+        if (iso) {
+            const symbol = this.getCurrencySymbol('en-US', iso);
+            this.currencySettings$.next({ iso, symbol });
+        }
     }
-    replace(toReplace, skipCardinalityCalculation = false) {
-        return new LineItemWorker(replaceLineItem(this.li, toReplace, skipCardinalityCalculation));
+    getFormattingSettings() {
+        if (this.formattingSettings) {
+            return this.formattingSettings;
+        }
+        const shoppingCartSettings = this.getConfigurationSettings()['shopping-cart']?.reduce((acc, setting) => {
+            return { ...acc, [setting.id]: setting.properties };
+        }, {});
+        const currencySettings = this.getCurrencySettings();
+        const dateFormat = (validateDateFormat(shoppingCartSettings?.DATE_FORMAT ?? '') && shoppingCartSettings?.DATE_FORMAT) ||
+            DEFAULT_DATE_FORMAT;
+        const decimalSeparator = shoppingCartSettings?.DECIMAL_SEPARATOR;
+        const thousandsSeparator = shoppingCartSettings?.THOUSANDS_SEPARATOR;
+        // the number of decimal places can be 0
+        const priceScale = shoppingCartSettings?.PRICE_SCALE;
+        const decimalsCount = priceScale !== null && priceScale !== '' && !isNaN(Number(priceScale)) && Number(priceScale) >= 0
+            ? Number(priceScale)
+            : DEFAULT_DECIMALS_COUNT;
+        const actionCodeSettings = shoppingCartSettings?.STATUS_LABEL;
+        return {
+            currencySymbol: currencySettings.symbol,
+            dateFormats: getSupportedDateFormats(dateFormat),
+            decimalsCount,
+            decimalSeparator: decimalSeparator !== undefined && ['.', ','].includes(decimalSeparator)
+                ? decimalSeparator
+                : DEFAULT_DECIMAL_SEPARATOR,
+            // thousands separator can be a blank value, so it can also be null
+            thousandsSeparator: thousandsSeparator !== undefined && ['.', ',', '', null].includes(thousandsSeparator)
+                ? thousandsSeparator || ''
+                : DEFAULT_THOUSANDS_SEPARATOR,
+            actionCodeLabels: actionCodeSettings?.length
+                ? actionCodeSettings.reduce((result, setting) => ({ ...result, [setting.status_label]: setting.custom_label }), {})
+                : DEFAULT_ACTION_CODE_LABELS,
+        };
     }
-    patchAttribute(attrs, id, skipCardinalityCalculation = false) {
-        return new LineItemWorker(patchAttributes(this.li, id ?? this.li.id, attrs, skipCardinalityCalculation));
+    getConfigurationSettings() {
+        return this.configurationSettings$.value;
+    }
+    getShoppingCartSettings() {
+        return this.shoppingCartSettings$.value;
+    }
+    getCurrencySettings() {
+        return this.currencySettings$.value;
+    }
+    parseConfigurationSettings(settings) {
+        return settings.reduce((acc, setting) => {
+            switch (setting.key) {
+                case 'shopping-cart':
+                    acc['shopping-cart'] = parseJsonSafely(setting.value, []);
+                    break;
+                case 'navigation':
+                    acc.navigation = parseJsonSafely(setting.value, {});
+                    break;
+                case 'flows':
+                    acc.flows = parseJsonSafely(setting.value, []);
+                    break;
+                default:
+                    acc[setting.key] = setting.value;
+            }
+            return acc;
+        }, {});
+    }
+    addShoppingCartSettings(settings) {
+        // uniqBy removes items with the biggest index
+        const newSettings = uniqBy([...settings, ...this.shoppingCartSettings$.value], 'id');
+        this.shoppingCartSettings$.next(newSettings);
     }
 }
+RuntimeSettingsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RuntimeSettingsService, deps: [{ token: i1.ConfigurationSettingsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+RuntimeSettingsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RuntimeSettingsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RuntimeSettingsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ConfigurationSettingsApiService }]; } });
 
 class ConfigurationService {
-    constructor(quoteDraftService, runtimeService, contextService, configurationApiService, messageService, dialogService) {
+    constructor(quoteDraftService, runtimeService, contextService, configurationApiService, messageService, dialogService, runtimeSettings) {
         this.quoteDraftService = quoteDraftService;
         this.runtimeService = runtimeService;
         this.contextService = contextService;
         this.configurationApiService = configurationApiService;
         this.messageService = messageService;
         this.dialogService = dialogService;
+        this.runtimeSettings = runtimeSettings;
         this.mode = ConfigurationMode.SEARCH;
         this.lineItem = new BehaviorSubject(undefined);
         this.charges = new BehaviorSubject({});
         this.pricePlans = new BehaviorSubject({});
+        this.procedureContext = new BehaviorSubject({});
         this.isLoadingSubj$ = new BehaviorSubject(false);
         this.isLoading$ = this.isLoadingSubj$.asObservable();
         this.hasUnsavedChanges = false;
@@ -756,7 +1424,7 @@ class ConfigurationService {
         }
         const skipCardinalityCalculation = options?.skipCardinalityCalculation || this.contextSnapshot.properties['#skipCardinalityCalculation'] === 'true';
         this.configurableRamp = new LineItemWorker(this.lineItem.value).replace(lineItem, skipCardinalityCalculation).li;
-        return this.configure().pipe(catchError(error => {
+        return this.configure().pipe(catchError$1(error => {
             console.error(error);
             if (!this.runtimeService.uiDefinitionProperties.suppressToastMessages) {
                 this.messageService.add({ severity: 'error', summary: error });
@@ -814,6 +1482,12 @@ class ConfigurationService {
     get pricePlansSnapshot() {
         return this.pricePlans.value;
     }
+    get procedureContext$() {
+        return this.procedureContext.asObservable();
+    }
+    get procedureContextSnapshot() {
+        return this.procedureContext.value;
+    }
     configure() {
         return this.configureRequest$(this.generateRequest());
     }
@@ -823,11 +1497,20 @@ class ConfigurationService {
         const uiDefinitionProperties = this.getUIDefinitionProperties();
         const mainPricingEnabled = runtimeContext.properties?.PricingEnabled;
         const pricingEnabled = mainPricingEnabled ? mainPricingEnabled === 'true' : uiDefinitionProperties.pricingEnabled;
+        const customPriceApi = this.runtimeSettings.getConfigurationSettings()['CUSTOM_PRICE_API'];
         this.isLoadingSubj$.next(true);
-        return this.configurationApiService.configureLineItem({ configurationRequest, runtimeModel, pricingEnabled }).pipe(tap(({ lineItem, context, charges, pricePlans, deletedLineItems }) => {
+        const configure$ = pricingEnabled && customPriceApi
+            ? this.configurationApiService.customConfigurePrice({ url: customPriceApi, configurationRequest, runtimeModel })
+            : this.configurationApiService.configureLineItem({
+                configurationRequest,
+                runtimeModel,
+                pricingEnabled,
+            });
+        return configure$.pipe(tap(({ lineItem, context, charges, pricePlans, deletedLineItems, procedureContext }) => {
             this.contextService.update(context ?? {});
             this.charges.next(charges ?? {});
             this.pricePlans.next(pricePlans ?? {});
+            this.procedureContext.next(procedureContext ?? {});
             if (lineItem) {
                 this.lineItem.next(lineItem);
             }
@@ -835,32 +1518,48 @@ class ConfigurationService {
                 this.showInactiveProductsConfirmation();
             }
             this.configurableRamp = lineItem;
-        }), map(({ lineItem }) => lineItem), catchError(error => throwError(() => new Error(error.error?.message || error.message || JSON.stringify(error)))), finalize(() => this.isLoadingSubj$.next(false)));
+        }), map(({ lineItem }) => lineItem), catchError$1(error => throwError(() => new Error(error.error?.message || error.message || JSON.stringify(error)))), finalize$1(() => this.isLoadingSubj$.next(false)));
     }
     configureExternal$(props) {
         return this.runtimeService
             .init({ productId: props.productId, defaultQty: props.qty, attributesMap: props.attributesMap })
-            .pipe(switchMap(() => this.configure()), first(), catchError(error => {
+            .pipe(switchMap$1(() => this.configure()), first(), catchError$1(error => {
             this.messageService.add({ severity: ToastType.error, summary: error });
             throw error;
-        }), finalize(() => this.reset()));
+        }), finalize$1(() => this.reset()));
     }
     configureGuidedSelling$(data) {
         return this.configurationApiService
             .configureLineItem({
-            configurationRequest: getGuidedSellingConfigurationRequest(data),
+            configurationRequest: getGuidedSellingConfigurationRequest(data, this.contextService.resolve()),
         })
-            .pipe(catchError(error => {
+            .pipe(catchError$1(error => {
             if (error instanceof HttpErrorResponse) {
                 this.messageService.add({ severity: ToastType.error, summary: error.error.message || error.error });
             }
             throw error;
         }));
     }
-    generateRequest() {
+    generateRequest(lightMode = true) {
+        const lineItem = this.generateLineItem();
+        let request = {
+            lineItem,
+            mode: this.mode,
+            step: !this.lineItem.value ? RuntimeStep.START : RuntimeStep.UPDATE,
+            attributeDomainMode: 'ALL',
+            context: this.contextService.resolve(),
+            lineItems: this.quoteDraftService.quoteDraft?.currentState || [],
+            asset: this.getAsset(),
+        };
+        if (lightMode) {
+            request = ConfigurationTranslatorUtils.lightenConfigurationRequest(request);
+        }
+        return request;
+    }
+    generateLineItem() {
         const runtimeContext = this.getRuntimeContext();
         const uiDefinitionProperties = this.getUIDefinitionProperties();
-        let lineItem = this.configurableRamp;
+        let lineItem = cloneDeep(this.configurableRamp);
         if (!lineItem) {
             const { initializationProps } = this.runtimeService ?? {};
             lineItem = getDefaultLineItem(runtimeContext, uiDefinitionProperties, initializationProps?.defaultQty);
@@ -870,21 +1569,11 @@ class ConfigurationService {
                 lineItem = new LineItemWorker(lineItem).patchAttribute(attributes).li;
             }
         }
-        let request = {
-            lineItem,
-            mode: this.mode,
-            step: !this.lineItem.value ? RuntimeStep.START : RuntimeStep.UPDATE,
-            attributeDomainMode: 'ALL',
-            context: this.contextService.resolve(),
-            lineItems: this.quoteDraftService.quoteDraft?.currentState || [],
-            asset: this.getAsset(),
-        };
-        request = ConfigurationTranslatorUtils.lightenConfigurationRequest(request);
-        return request;
+        return lineItem;
     }
     getUIDefinitionProperties() {
         return {
-            ...getUIDefinitionProperties(this.getRuntimeContext().uiDefinitionContainer),
+            ...(this.getRuntimeContext().uiDefinitionContainer?.source.properties ?? {}),
             ...(this.runtimeService.uiDefinitionProperties ?? {}),
         };
     }
@@ -920,148 +1609,11 @@ class ConfigurationService {
         return this.quoteDraftService.quoteDraft?.initialState.find(a => a.id === lineItem.openOrderLineItemId || a.id === lineItem.assetId);
     }
 }
-ConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationService, deps: [{ token: QuoteDraftService }, { token: ConfigurationRuntimeService }, { token: ContextService }, { token: i1.ConfigurationApiService }, { token: i5.MessageService }, { token: i6.DialogService }], target: i0.ɵɵFactoryTarget.Injectable });
-ConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: QuoteDraftService }, { type: ConfigurationRuntimeService }, { type: ContextService }, { type: i1.ConfigurationApiService }, { type: i5.MessageService }, { type: i6.DialogService }]; } });
-
-class ConfigurationState {
-    constructor(statefulConfigurationApiService, runtimeService, configurationService, toastService) {
-        this.statefulConfigurationApiService = statefulConfigurationApiService;
-        this.runtimeService = runtimeService;
-        this.configurationService = configurationService;
-        this.toastService = toastService;
-        this.stateSubj$ = new BehaviorSubject({});
-        this.state$ = this.stateSubj$.asObservable();
-        this.stateId = null;
-    }
-    init$() {
-        return this.configurationService.configure().pipe(switchMap$1(() => {
-            if (!this.isStatefulConfiguration) {
-                return of(undefined);
-            }
-            const { actions, selectors } = this.runtimeService.runtimeContext?.uiDefinitionContainer ?? {};
-            return this.statefulConfigurationApiService.init({
-                request: this.configurationService.generateRequest(),
-                actions: actions?.map(action => ({ name: action.apiName, script: action.script })),
-                selectors: selectors?.map(selector => ({ name: selector.apiName, script: selector.script })),
-            });
-        }), tap$1(stateId => (this.stateId = stateId || null)), map$2(() => undefined));
-    }
-    cleanup() {
-        this.stateId = null;
-        this.configurationService.reset();
-        this.stateSubj$.next({});
-    }
-    execute$(req) {
-        if (this.isStatefulConfiguration) {
-            return this.executeStateful$(req);
-        }
-        else {
-            return this.executeStateless$(req);
-        }
-    }
-    dispatch$(actionName, inputData) {
-        return this.execute$({ actions: [{ name: actionName, inputData }] });
-    }
-    select$(selectorName, inputData) {
-        const requestId = UUID.UUID();
-        return this.execute$({
-            selectors: {
-                [requestId]: {
-                    name: selectorName,
-                    inputData,
-                },
-            },
-        }).pipe(map$2(() => this.stateSubj$.value[requestId]), tap$1(() => this.stateSubj$.next(omit(this.stateSubj$.value, requestId))));
-    }
-    get isStatefulConfiguration() {
-        return this.runtimeService.uiDefinitionProperties.statefulConfigurationEnabled ?? false;
-    }
-    executeStateless$(request) {
-        return of(undefined).pipe(switchMap$1(() => {
-            // Apply actions and execute configuration/price call
-            // No need to run configuration if no actions in the request
-            if (!request.actions?.length) {
-                return of(undefined);
-            }
-            let configurationRequest = this.configurationService.generateRequest();
-            request.actions.forEach(action => {
-                configurationRequest = this.executeActionScript(configurationRequest, action) ?? configurationRequest;
-            });
-            return this.configurationService.configureRequest$(configurationRequest);
-        }), tap$1(() => {
-            if (!request.selectors) {
-                return;
-            }
-            // Run selectors and apply them to the state
-            const finalConfigurationRequest = this.configurationService.generateRequest();
-            const selectorsResult = EntityUtil.entries(request.selectors).reduce((trunk, [key, selector]) => {
-                trunk[key] = this.executeSelectorScript(finalConfigurationRequest, selector);
-                return trunk;
-            }, {});
-            this.stateSubj$.next({
-                ...this.stateSubj$.value,
-                ...selectorsResult,
-            });
-        }), map$2(() => undefined));
-    }
-    executeStateful$(request) {
-        if (!this.stateId) {
-            return of(undefined);
-        }
-        return this.statefulConfigurationApiService.execute(this.stateId, request).pipe(tap$1(response => {
-            this.stateId = response.stateId;
-            const updatedState = this.stateSubj$.value;
-            EntityUtil.entries(response.selectors).forEach(([key, value]) => {
-                if (!value.success) {
-                    if (!this.runtimeService.uiDefinitionProperties.suppressToastMessages) {
-                        this.toastService.add({ summary: value.errorMessage, severity: ToastType.error });
-                    }
-                    return;
-                }
-                updatedState[key] = value.result;
-            });
-            this.stateSubj$.next(updatedState);
-        }), map$2(() => undefined));
-    }
-    executeActionScript(request, processor) {
-        const { actions } = this.runtimeService.runtimeContext?.uiDefinitionContainer ?? {};
-        const script = actions?.find(action => action.apiName === processor.name)?.script;
-        if (!script) {
-            return null;
-        }
-        return this.executeProcessorScript(request, script, processor.inputData);
-    }
-    executeSelectorScript(request, processor) {
-        const { selectors } = this.runtimeService.runtimeContext?.uiDefinitionContainer ?? {};
-        const script = selectors?.find(selector => selector.apiName === processor.name)?.script;
-        if (!script) {
-            return null;
-        }
-        return this.executeProcessorScript(request, script, processor.inputData);
-    }
-    executeProcessorScript(request, script, inputData) {
-        return new Function(`${script}\nreturn transform;`)()({
-            request,
-            inputData: inputData,
-        });
-    }
-}
-ConfigurationState.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationState, deps: [{ token: i1.StatefulConfigurationApiService }, { token: ConfigurationRuntimeService }, { token: ConfigurationService }, { token: i4.ToastService }], target: i0.ɵɵFactoryTarget.Injectable });
-ConfigurationState.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationState });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationState, decorators: [{
+ConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationService, deps: [{ token: QuoteDraftService }, { token: ConfigurationRuntimeService }, { token: ContextService }, { token: i1.ConfigurationApiService }, { token: i5.MessageService }, { token: i6$1.DialogService }, { token: RuntimeSettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.StatefulConfigurationApiService }, { type: ConfigurationRuntimeService }, { type: ConfigurationService }, { type: i4.ToastService }]; } });
-
-function extractMetadata(uiDefinition) {
-    return omit(uiDefinition, [
-        'children',
-        'pages',
-        'components',
-    ]);
-}
+        }], ctorParameters: function () { return [{ type: QuoteDraftService }, { type: ConfigurationRuntimeService }, { type: ContextService }, { type: i1.ConfigurationApiService }, { type: i5.MessageService }, { type: i6$1.DialogService }, { type: RuntimeSettingsService }]; } });
 
 class FlowUpdateService {
     update(rootLineItems, updates, charges) {
@@ -1189,9 +1741,9 @@ class FlowUpdateService {
         return true;
     }
 }
-FlowUpdateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowUpdateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-FlowUpdateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowUpdateService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowUpdateService, decorators: [{
+FlowUpdateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowUpdateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FlowUpdateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowUpdateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowUpdateService, decorators: [{
             type: Injectable
         }] });
 
@@ -1202,6 +1754,8 @@ class FlowConfigurationService {
         this.quoteDraftService = quoteDraftService;
         this.updateService = updateService;
         this.configurationService = configurationService;
+        this.updatedSubj$ = new Subject();
+        this.updated$ = this.updatedSubj$.asObservable();
     }
     calculate$(quoteDraft) {
         return this.proceduresApiService.apply$(quoteDraft).pipe(tap$1(result => {
@@ -1211,7 +1765,7 @@ class FlowConfigurationService {
                 .slice()
                 .sort((a, b) => initialStateIds.indexOf(a.integrationId) - initialStateIds.indexOf(b.integrationId));
             this.quoteDraftService.updateQuoteDraft(result);
-        }), map$2(noop));
+        }), map$1(noop));
     }
     calculate(quoteDraft) {
         this.calculate$(quoteDraft).subscribe();
@@ -1221,11 +1775,11 @@ class FlowConfigurationService {
         if (!quoteDraft) {
             return of(null);
         }
-        return of([]).pipe(map$2(() => {
+        return of([]).pipe(map$1(() => {
             const updatedState = cloneDeep(quoteDraft.currentState);
             this.updateService.update(updatedState, updates, quoteDraft.charges);
             return updatedState;
-        }), switchMap$1(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })), map$2(() => this.quoteDraftService.quoteDraft), this.handleErrorAndBounceBack());
+        }), switchMap(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })), map$1(() => this.quoteDraftService.quoteDraft), tap$1(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
     }
     update(updates) {
         this.update$(updates).subscribe();
@@ -1244,7 +1798,7 @@ class FlowConfigurationService {
         updatedState.splice(currentLineItemIndex, 1, initialLineItem);
         return of([]).pipe(tap$1(() => {
             this.quoteDraftService.setCurrentLineItemState(updatedState);
-        }), switchMap$1(() => this.calculate$({ ...quoteDraft, currentState: updatedState })), map$2(() => this.quoteDraftService.quoteDraft), this.handleErrorAndBounceBack());
+        }), switchMap(() => this.calculate$({ ...quoteDraft, currentState: updatedState })), map$1(() => this.quoteDraftService.quoteDraft), tap$1(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
     }
     revert(lineItemId) {
         this.revert$(lineItemId).subscribe();
@@ -1255,7 +1809,7 @@ class FlowConfigurationService {
         if (!quoteDraft) {
             return of(null);
         }
-        return of([]).pipe(map$2(() => ids.reduce((result, id) => this.updateService.delete(result, id), currentState)), switchMap$1(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })), map$2(() => this.quoteDraftService.quoteDraft), this.handleErrorAndBounceBack());
+        return of([]).pipe(map$1(() => ids.reduce((result, id) => this.updateService.delete(result, id), currentState)), switchMap(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })), map$1(() => this.quoteDraftService.quoteDraft), tap$1(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
     }
     delete(ids) {
         this.delete$(ids).subscribe();
@@ -1266,34 +1820,34 @@ class FlowConfigurationService {
             return of(null);
         }
         const updatedState = [...quoteDraft.currentState, term];
-        return of([]).pipe(switchMap$1(() => this.calculate$({ ...quoteDraft, currentState: updatedState })), map$2(() => this.quoteDraftService.quoteDraft), this.handleErrorAndBounceBack());
+        return of([]).pipe(switchMap(() => this.calculate$({ ...quoteDraft, currentState: updatedState })), map$1(() => this.quoteDraftService.quoteDraft), tap$1(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
     }
     addToCart$(props) {
         const quoteDraft = this.quoteDraftService.quoteDraft;
         if (!quoteDraft) {
             return of(null);
         }
-        return this.configurationService.configureExternal$(props).pipe(map$2(lineItem => {
+        return this.configurationService.configureExternal$(props).pipe(map$1(lineItem => {
             const model = this.configurationService.getRuntimeModel();
             const split = model?.types.find(type => type.name === lineItem.type)?.split ?? false;
             const lineItems = multiplyLineItems(lineItem, props.qty ?? 1, split);
             return [...quoteDraft.currentState, ...lineItems];
-        }), switchMap$1(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })), map$2(() => this.quoteDraftService.quoteDraft), this.handleErrorAndBounceBack());
+        }), switchMap(updatedState => this.calculate$({ ...quoteDraft, currentState: updatedState })), map$1(() => this.quoteDraftService.quoteDraft), tap$1(() => this.updatedSubj$.next()), this.handleErrorAndBounceBack());
     }
     get() {
-        return this.quoteDraftService.quoteDraft$.pipe(map$2(() => this.quoteDraftService.activeCurrentState), shareReplay$1());
+        return this.quoteDraftService.quoteDraft$.pipe(map$1(() => this.quoteDraftService.activeCurrentState), shareReplay$1());
     }
     getSnapshot() {
         return this.quoteDraftService?.currentState.slice() ?? [];
     }
     get charges$() {
-        return this.quoteDraftService.quoteDraft$.pipe(map$2(({ charges }) => charges));
+        return this.quoteDraftService.quoteDraft$.pipe(map$1(({ charges }) => charges));
     }
     get pricePlans$() {
-        return this.quoteDraftService.quoteDraft$.pipe(map$2(({ pricePlans }) => pricePlans));
+        return this.quoteDraftService.quoteDraft$.pipe(map$1(({ pricePlans }) => pricePlans));
     }
     get activeMetrics$() {
-        return this.quoteDraftService.quoteDraft$.pipe(map$2(({ activeMetrics }) => activeMetrics));
+        return this.quoteDraftService.quoteDraft$.pipe(map$1(({ activeMetrics }) => activeMetrics));
     }
     get chargesSnapshot() {
         return this.quoteDraftService.quoteDraft?.charges ?? {};
@@ -1301,307 +1855,543 @@ class FlowConfigurationService {
     get pricePlansSnapshot() {
         return this.quoteDraftService.quoteDraft?.pricePlans ?? {};
     }
-    get activeMetricsSnapshot() {
-        return this.quoteDraftService.quoteDraft?.activeMetrics ?? [];
+    get activeMetricsSnapshot() {
+        return this.quoteDraftService.quoteDraft?.activeMetrics ?? [];
+    }
+    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);
+                    this.updatedSubj$.next();
+                }
+                return throwError(() => error);
+            }));
+        };
+    }
+}
+FlowConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", 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: "15.2.9", ngImport: i0, type: FlowConfigurationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", 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: "15.2.9", ngImport: i0, type: FlowConfigurationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FlowConfigurationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: FlowConfigurationModule, imports: [ApiModule] });
+FlowConfigurationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowConfigurationModule, providers: [FlowConfigurationService, FlowUpdateService], imports: [ApiModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowConfigurationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ApiModule],
+                    providers: [FlowConfigurationService, FlowUpdateService],
+                }]
+        }] });
+
+class FlowStateConfigurationService {
+    constructor(flowInfoService, flowConfigurationService, flowStateApiService, flowStateService) {
+        this.flowInfoService = flowInfoService;
+        this.flowConfigurationService = flowConfigurationService;
+        this.flowStateApiService = flowStateApiService;
+        this.flowStateService = flowStateService;
+        this.configurationStateId$ = new BehaviorSubject(null);
+    }
+    get configurationStateId() {
+        return this.configurationStateId$.value;
+    }
+    addToCart$(props) {
+        let request$;
+        const stateful = this.flowInfoService.flow?.properties.stateful;
+        if (stateful) {
+            const stateId = this.flowStateService.stateId;
+            if (!stateId) {
+                request$ = of();
+            }
+            else {
+                const lineItem = generateConfigurationLineItem(props, props.qty);
+                request$ = this.flowStateApiService.newConfiguration(stateId, { lineItem }).pipe(tap$1(r => this.configurationStateId$.next(r.stateId)), switchMap(() => {
+                    if (!this.configurationStateId) {
+                        return of();
+                    }
+                    return this.flowStateApiService.saveConfiguration(stateId, this.configurationStateId).pipe(tap$1(() => this.configurationStateId$.next(null)), map$1(noop));
+                }));
+            }
+        }
+        else {
+            request$ = this.flowConfigurationService.addToCart$(props).pipe(map$1(noop));
+        }
+        return request$.pipe(switchMap(() => this.flowStateService.executeRequest$({}, true)), map$1(noop));
+    }
+}
+FlowStateConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateConfigurationService, deps: [{ token: FlowInfoService }, { token: FlowConfigurationService }, { token: i1.FlowStateApiService }, { token: FlowStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowStateConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateConfigurationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateConfigurationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: FlowInfoService }, { type: FlowConfigurationService }, { type: i1.FlowStateApiService }, { type: FlowStateService }]; } });
+
+class ProductImagesService {
+    constructor(productApiService) {
+        this.productApiService = productApiService;
+        this.imagesMap$ = new BehaviorSubject({});
+    }
+    getImageUrl$(productId) {
+        if (this.imagesMap$.value[productId] == null) {
+            this.imagesMap$.next({ ...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({ ...this.imagesMap$.value, [productId]: url })))
+            .subscribe();
+    }
+}
+ProductImagesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProductImagesService, deps: [{ token: i1.ProductApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductImagesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProductImagesService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProductImagesService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ProductApiService }]; } });
+
+class RuntimeContextService {
+    constructor(configurationApiService) {
+        this.configurationApiService = configurationApiService;
+    }
+    getRuntimeContext(productId, offeringId) {
+        return this.configurationApiService.getRuntimeDataByProductId(productId, offeringId).pipe(map(runtimeData => {
+            const uiDefinitionContainer = this.getUIDefinitionContainer(runtimeData);
+            const runtimeModel = RuntimeModel.create(runtimeData.types, runtimeData.products);
+            const { productName, properties } = Array.from(runtimeModel.components.values()).find(c => c.productId === productId) ?? {};
+            const uiDefinitionProperties = uiDefinitionContainer?.source.properties;
+            return {
+                modelId: runtimeData.modelId,
+                uiDefinitionContainer: uiDefinitionContainer,
+                runtimeModel: runtimeModel,
+                runtimeMode: RuntimeMode.PROD,
+                productId: productId,
+                productType: properties?.['displayName'] || productName,
+                offeringId: offeringId,
+                properties: {
+                    PricingEnabled: uiDefinitionProperties?.pricingEnabled ? 'true' : 'false',
+                    PriceListId: uiDefinitionProperties?.priceList,
+                },
+            };
+        }));
+    }
+    getUIDefinitionContainer(runtimeData) {
+        const containers = runtimeData.uiDefinitions.filter(container => isNotLegacyUIDefinition(container.source));
+        return containers.find(container => container.source.primary) ?? containers[0];
+    }
+}
+RuntimeContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RuntimeContextService, deps: [{ token: i1.ConfigurationApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+RuntimeContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RuntimeContextService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", 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.initializationProps = undefined;
+        this.uiDefinitionProperties = {};
+    }
+    initTestMode(uiDefinitionContainer) {
+        this.uiDefinitionProperties = uiDefinitionContainer.source.properties ?? {};
+        const uiDefinitionExternals = uiDefinitionContainer.source.externals ?? {};
+        return combineLatest([
+            this.apiService.getRuntimeDataByModelId(uiDefinitionContainer.modelId),
+            this.contextService.initTestMode(),
+        ]).pipe(first(), map(([runtimeData, context]) => {
+            this.contextService.update({
+                properties: {
+                    ...this.runtimeContext?.properties,
+                    ...context.properties,
+                    ModelId: uiDefinitionContainer.modelId,
+                    PricingEnabled: this.uiDefinitionProperties.pricingEnabled ? 'true' : 'false',
+                    PriceListId: this.uiDefinitionProperties.priceList,
+                    offeringId: this.uiDefinitionProperties.offeringId,
+                    ...uiDefinitionExternals,
+                },
+            });
+            this._runtimeContext = {
+                modelId: uiDefinitionContainer.modelId,
+                runtimeModel: RuntimeModel.create(runtimeData.types, runtimeData.products),
+                runtimeMode: RuntimeMode.TEST,
+                uiDefinitionContainer,
+            };
+            return this._runtimeContext;
+        }), tap(() => (this._isInitialized = true)));
+    }
+    init(props) {
+        this.initializationProps = props;
+        const context = this.contextService.resolve();
+        return this.runtimeContextService.getRuntimeContext(props.productId, props.offeringId).pipe(tap(runtimeContext => {
+            this.uiDefinitionProperties = runtimeContext.uiDefinitionContainer?.source.properties ?? {};
+            const { PriceListId } = context.properties ?? {};
+            const mergeContext = {
+                ...runtimeContext,
+                properties: {
+                    ...runtimeContext.properties,
+                    ...context.properties,
+                    PricingEnabled: PriceListId ? 'true' : 'false',
+                },
+            };
+            this.id15to18('AccountId', mergeContext.properties);
+            this._runtimeContext = mergeContext;
+            if (context.properties && this._runtimeContext.properties?.StartDate) {
+                this.contextService.update({
+                    properties: {
+                        ...this._runtimeContext.properties,
+                        ...context.properties,
+                    },
+                });
+            }
+            return this._runtimeContext;
+        }), tap(() => (this._isInitialized = true)));
+    }
+    overrideUIDefinition(uiDefinitionContainer) {
+        if (!this._runtimeContext) {
+            return;
+        }
+        this._runtimeContext.uiDefinitionContainer = uiDefinitionContainer;
+        this.uiDefinitionProperties = uiDefinitionContainer.source.properties ?? {};
+    }
+    id15to18(propertyName, source) {
+        if (!source) {
+            return;
+        }
+        const value = source[propertyName];
+        if (typeof value === 'string' && value.length === 15) {
+            source[propertyName] = SalesforceIdUtils.generateId18FromId15(value);
+        }
     }
-    get contextSnapshot() {
-        return this.contextService.resolve();
+    get isInitialized() {
+        return this._isInitialized;
     }
-    get context$() {
-        return this.contextService.resolve$();
+    get runtimeModel() {
+        return this.runtimeContext?.runtimeModel;
     }
-    handleErrorAndBounceBack() {
-        return (source$) => {
-            return source$.pipe(catchError$1(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);
-            }));
-        };
+    get runtimeContext() {
+        return this._runtimeContext;
     }
 }
-FlowConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", 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: "15.2.8", ngImport: i0, type: FlowConfigurationService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowConfigurationService, decorators: [{
+ConfigurationRuntimeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", 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: "15.2.9", ngImport: i0, type: ConfigurationRuntimeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationRuntimeService, 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: "15.2.8", ngImport: i0, type: FlowConfigurationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-FlowConfigurationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: FlowConfigurationModule });
-FlowConfigurationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowConfigurationModule, providers: [FlowConfigurationService, FlowUpdateService, PriceApiService] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FlowConfigurationModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [],
-                    providers: [FlowConfigurationService, FlowUpdateService, PriceApiService],
-                }]
-        }] });
-
-class ConfigurationModule {
-}
-ConfigurationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ConfigurationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationModule, imports: [ConfirmationDialogModule] });
-ConfigurationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationModule, providers: [
-        ContextApiService,
-        ProductModelApiService,
-        ConfigurationApiService,
-        ConfigurationRuntimeService,
-        RuntimeContextService,
-        ConfigurationService,
-        ConfigurationState,
-    ], imports: [ConfirmationDialogModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ConfigurationModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [ConfirmationDialogModule],
-                    providers: [
-                        ContextApiService,
-                        ProductModelApiService,
-                        ConfigurationApiService,
-                        ConfigurationRuntimeService,
-                        RuntimeContextService,
-                        ConfigurationService,
-                        ConfigurationState,
-                    ],
-                }]
-        }] });
+        }], ctorParameters: function () { return [{ type: i1.ConfigurationApiService }, { type: ContextService }, { type: RuntimeContextService }]; } });
 
-function calculateMetricByMethod(lineItems, metric, method) {
-    const items = getLineItemsByMethod(lineItems, method);
-    return items.reduce((acc, li) => {
-        let value = li.reduce((accProduct, item) => accProduct + ((item.totalMetrics && item.totalMetrics[metric]) || 0), 0);
-        if (method === 'avg' && li.length > 0) {
-            value /= li.length;
-        }
-        return acc + value;
-    }, 0);
-}
-function getLineItemsByMethod(lineItems, method) {
-    switch (method) {
-        case 'first': {
-            return lineItems.filter(li => !li.rampInstanceId).map(item => [item]);
-        }
-        case 'last': {
-            const rootTermItems = lineItems.filter(li => !li.rampInstanceId);
-            const products = rootTermItems.map(lineItem => [
-                lineItem,
-                ...lineItems.filter(li => li.rampInstanceId === lineItem.id),
-            ]);
-            return products
-                .map(items => [...items].sort((a, b) => getDateValue(a.endDate || '') - getDateValue(b.endDate || '')).pop())
-                .filter((li) => Boolean(li))
-                .map(item => [item]);
+class ConfigurationStateService {
+    constructor(configurationRuntimeService, configurationService, quoteDraftService, toastService, flowStateService, flowInfoService, flowConfigurationService, flowStateApiService, quoteApiService) {
+        this.configurationRuntimeService = configurationRuntimeService;
+        this.configurationService = configurationService;
+        this.quoteDraftService = quoteDraftService;
+        this.toastService = toastService;
+        this.flowStateService = flowStateService;
+        this.flowInfoService = flowInfoService;
+        this.flowConfigurationService = flowConfigurationService;
+        this.flowStateApiService = flowStateApiService;
+        this.quoteApiService = quoteApiService;
+        this.isInitialized$ = new BehaviorSubject(false);
+        this.canceledConfiguration$ = new Subject();
+        this.NOT_INITIALIZED = Symbol();
+        this.executedFunctions = {};
+        this.stateId = null;
+        this.ownerId = '';
+        this.subscriptions = {};
+        this.configurationStore = {};
+    }
+    init$() {
+        let request$;
+        if (this.flowStateService.stateId && this.isStatefulConfiguration) {
+            request$ = this.initStateful$();
         }
-        case 'avg': {
-            const rootTermItems = lineItems.filter(li => !li.rampInstanceId);
-            return rootTermItems.map(lineItem => [lineItem, ...lineItems.filter(li => li.rampInstanceId === lineItem.id)]);
+        else {
+            request$ = this.initStateless$();
+        }
+        return request$.pipe(finalize(() => {
+            this.isInitialized$.next(true);
+            this.canceledConfiguration$ = new Subject();
+        }));
+    }
+    cleanup() {
+        this.stateId = null;
+        this.configurationStore = {};
+        this.configurationService.reset();
+    }
+    execute$(req, forceSubscriptions) {
+        const fullRequest = cloneDeep(req);
+        if (fullRequest.actions?.length || forceSubscriptions) {
+            for (const subscription of Object.values(this.subscriptions)) {
+                fullRequest.selectors = assign(fullRequest.selectors, subscription.request.selectors);
+            }
         }
-        case 'sum': {
-            return lineItems.map(item => [item]);
+        let execution$;
+        if (this.isStatefulConfiguration) {
+            execution$ = this.executeStateful$(fullRequest);
         }
-        default: {
-            return lineItems.map(item => [item]);
+        else {
+            execution$ = this.executeStateless$(fullRequest);
         }
+        return execution$.pipe(tap$1(result => this.handleSelectorsResponse(result.selectors)));
     }
-}
-function getDateValue(date) {
-    return date ? new Date(date).getTime() : 0;
-}
-
-class MetricsCalculationService {
-    get onMetricsUpdate$() {
-        return this.metricsUpdated$.asObservable();
-    }
-    constructor(quoteDraftService, flowConfiguration, settingsService) {
-        this.quoteDraftService = quoteDraftService;
-        this.flowConfiguration = flowConfiguration;
-        this.settingsService = settingsService;
-        this.metricsUpdated$ = new Subject();
-        this.quoteMetricsSettings = {};
-        this.metricsCalculationMethodMap = {};
-        this.metricsData = {};
-        this.activeMetricRules = [];
-        this.activeMetricRules = this.flowConfiguration.activeMetricsSnapshot.filter(metricRule => metricRule.metrics.some(metric => !!metric.totalName));
-        combineLatest([
-            this.quoteDraftService.currentState$,
-            this.settingsService.fetchSetting('QUOTE_LEVEL_METRIC_CALCULATION_METHOD').pipe(take$1(1)),
-        ]).subscribe(([lineItems, setting]) => {
-            let settingsData = {};
-            try {
-                settingsData = JSON.parse(setting?.value || '{}');
+    handleSelectorsResponse(selectors) {
+        Object.entries(selectors).forEach(([requestId, selectorResult]) => {
+            if (!selectorResult.success) {
+                this.toastService.add({ severity: ToastType.error, summary: selectorResult.errorMessage });
             }
-            catch (error) {
-                settingsData = {};
+            const subscription$ = this.subscriptions[requestId]?.data$;
+            if (subscription$) {
+                subscription$.next(selectorResult);
             }
-            this.quoteMetricsSettings = settingsData;
-            this.updateMetrics(lineItems);
         });
     }
-    getMetricValue(metric) {
-        return this.metricsData[metric] || 0;
-    }
-    updateMetrics(lineItems) {
-        const metricKeys = this.collectMetricKeys(lineItems).filter(key => !key.includes('Effective_'));
-        this.metricsCalculationMethodMap = this.buildMetricsCalculationMethods(metricKeys, this.metricsCalculationMethodMap);
-        this.metricsData = metricKeys.reduce((acc, key) => ({ ...acc, [key]: this.calculateMetric(lineItems, key) }), {});
-        this.metricsUpdated$.next();
+    dispatch$(actionName, inputData = {}) {
+        return this.execute$({ actions: [{ apiName: actionName, inputData, ownerId: this.ownerId }] });
     }
-    calculateMetric(lineItems, metric) {
-        return calculateMetricByMethod(lineItems, metric, this.metricsCalculationMethodMap[metric] || 'sum');
+    select$(selectorName, inputData = {}) {
+        const requestId = UUID.UUID();
+        return this.execute$({
+            selectors: {
+                [requestId]: {
+                    apiName: selectorName,
+                    inputData,
+                    ownerId: this.ownerId,
+                },
+            },
+        }).pipe(map$1(response => response.selectors[requestId]));
     }
-    buildMetricsCalculationMethods(metricKeys, initial) {
-        return metricKeys.reduce((acc, name) => {
-            if (acc[name]) {
-                return acc;
+    subscribe$(selectorName, inputData = {}, options) {
+        const requestId = UUID.UUID();
+        if (!this.subscriptions[requestId]) {
+            const request = {
+                selectors: {
+                    [requestId]: {
+                        apiName: selectorName,
+                        inputData,
+                        ownerId: this.ownerId,
+                    },
+                },
+            };
+            this.subscriptions[requestId] = {
+                request,
+                data$: new BehaviorSubject(this.NOT_INITIALIZED),
+            };
+            if (!options?.cold) {
+                this.execute$(request).subscribe();
             }
-            acc = { ...acc, [name]: 'sum' };
-            const metricRule = this.getMetricRuleByTotalMetricName(name);
-            const settingKey = metricRule?.metrics?.find(metric => metric.totalName === name)?.name || name;
-            if (this.quoteMetricsSettings[settingKey]) {
-                acc = { ...acc, [name]: this.quoteMetricsSettings[settingKey] };
+        }
+        return this.subscriptions[requestId].data$.pipe(filter$1(data => data != this.NOT_INITIALIZED), map$1(data => data), finalize(() => {
+            if (!this.subscriptions[requestId]) {
+                return;
             }
-            return acc;
-        }, initial);
+            if (!this.subscriptions[requestId].data$.observed) {
+                delete this.subscriptions[requestId];
+            }
+        }), takeUntil(this.canceledConfiguration$));
     }
-    collectMetricKeys(lineItems) {
-        const keys = [];
-        lineItems.forEach(lineItem => {
-            keys.push(...Object.keys(lineItem.totalMetrics || {}));
-            keys.push(...this.collectMetricKeys(lineItem.lineItems));
-        });
-        return uniq(keys);
+    saveConfiguration(quoteId, flow) {
+        if (this.isStatefulConfiguration) {
+            return this.flowStateApiService
+                .saveConfiguration(this.flowStateService.stateId ?? '', this.stateId ?? '')
+                .pipe(switchMap(r => this.flowStateService.executeRequest$({}, true).pipe(map$1(() => r))));
+        }
+        else {
+            if (!flow) {
+                if (!quoteId) {
+                    return of({ quoteId: '' });
+                }
+                const rootLineItem = this.configurationService.getSnapshot();
+                const currentState = rootLineItem ? [rootLineItem] : [];
+                return this.quoteApiService
+                    .getQuoteDraft(quoteId)
+                    .pipe(switchMap(quoteDraft => this.quoteApiService.upsertQuote({ ...quoteDraft, currentState })));
+            }
+            else {
+                const quoteDraft = this.quoteDraftService.quoteDraft;
+                const lineItem = this.configurationService.getSnapshot();
+                if (!quoteDraft || !lineItem) {
+                    return of({ quoteId: '' });
+                }
+                const isNewLineItem = quoteDraft.currentState.every(li => li.id !== lineItem.id);
+                let updatedState;
+                if (isNewLineItem) {
+                    updatedState = [...quoteDraft.currentState, lineItem];
+                }
+                else {
+                    updatedState = quoteDraft.currentState.map(li => (li.id === lineItem.id ? lineItem : li));
+                }
+                return this.flowConfigurationService
+                    .calculate$({ ...quoteDraft, currentState: updatedState })
+                    .pipe(map$1(() => ({ quoteId: '' })));
+            }
+        }
     }
-    getMetricRuleByTotalMetricName(name) {
-        return this.activeMetricRules.find(metricRule => metricRule.metrics.find(metric => metric.totalName === name));
+    cancelConfiguration() {
+        if (!this.isInitialized$.value) {
+            return of(undefined);
+        }
+        this.canceledConfiguration$.next();
+        this.canceledConfiguration$.complete();
+        this.subscriptions = {};
+        this.isInitialized$.next(false);
+        if (!this.isInitialized$.value || !this.isStatefulConfiguration) {
+            return of(undefined);
+        }
+        return this.flowStateApiService.cancelConfiguration(this.flowStateService.stateId ?? '', this.stateId ?? '');
     }
-}
-MetricsCalculationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: MetricsCalculationService, deps: [{ token: QuoteDraftService }, { token: FlowConfigurationService }, { token: i1.ConfigurationSettingsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
-MetricsCalculationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: MetricsCalculationService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: MetricsCalculationService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: QuoteDraftService }, { type: FlowConfigurationService }, { type: i1.ConfigurationSettingsApiService }]; } });
-
-class ProductImagesService {
-    constructor(productApiService) {
-        this.productApiService = productApiService;
-        this.imagesMap$ = new BehaviorSubject({});
+    get isStatefulConfiguration() {
+        return this.flowInfoService.flow?.properties.stateful ?? false;
     }
-    getImageUrl$(productId) {
-        if (this.imagesMap$.value[productId] == null) {
-            this.imagesMap$.next({ ...this.imagesMap$.value, [productId]: '' });
-            this.fetchProductImage(productId);
+    initStateful$() {
+        this.ownerId = this.configurationRuntimeService.runtimeContext?.uiDefinitionContainer?.id ?? '';
+        const lineItemId = this.configurationRuntimeService.runtimeContext?.properties?.lineItemId;
+        if (!this.flowStateService.stateId) {
+            return of(undefined);
         }
-        return this.imagesMap$.pipe(map$2(imagesMap => imagesMap[productId]), distinctUntilChanged());
-    }
-    fetchProductImage(productId) {
-        this.productApiService
-            .fetchImage$(productId)
-            .pipe(map$2(file => URL.createObjectURL(file)), catchError$1(() => of('')), tap$1(url => this.imagesMap$.next({ ...this.imagesMap$.value, [productId]: url })))
-            .subscribe();
+        const container = this.configurationRuntimeService.runtimeContext?.uiDefinitionContainer;
+        const lineItem = this.configurationService.generateLineItem();
+        let request$;
+        if (!lineItemId) {
+            request$ = this.flowStateApiService.newConfiguration(this.flowStateService.stateId, {
+                lineItem,
+                actionsOverride: container?.actions?.map(processor => ({ ...processor, ownerId: this.ownerId })),
+                selectorsOverride: container?.selectors?.map(processor => ({ ...processor, ownerId: this.ownerId })),
+            });
+        }
+        else {
+            request$ = this.flowStateApiService.startConfiguration(this.flowStateService.stateId, {
+                lineItemId,
+                actionsOverride: container?.actions?.map(processor => ({ ...processor, ownerId: this.ownerId })),
+                selectorsOverride: container?.selectors?.map(processor => ({ ...processor, ownerId: this.ownerId })),
+            });
+        }
+        return request$.pipe(map$1(r => {
+            this.stateId = r.stateId;
+            return undefined;
+        }));
     }
-}
-ProductImagesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ProductImagesService, deps: [{ token: i1.ProductApiService }], target: i0.ɵɵFactoryTarget.Injectable });
-ProductImagesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ProductImagesService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ProductImagesService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: i1.ProductApiService }]; } });
-
-class RuntimeSettingsService {
-    constructor(configurationSettingsApiService) {
-        this.configurationSettingsApiService = configurationSettingsApiService;
-        this.configurationSettings$ = new BehaviorSubject({});
-        this.currencySettings$ = new BehaviorSubject({
-            iso: DEFAULT_CURRENCY_ISO_CODE,
-            symbol: DEFAULT_CURRENCY_SYMBOL,
-        });
-        this.getCurrencySymbol = (locale, currency) => {
-            return (0)
-                .toLocaleString(locale, { style: 'currency', currency, minimumFractionDigits: 0, maximumFractionDigits: 0 })
-                .replace(/\d/g, '')
-                .trim();
-        };
+    initStateless$() {
+        return this.configurationService.configure().pipe(map$1(() => undefined));
     }
-    create() {
-        return this.configurationSettingsApiService.fetchSettings().pipe(map$2(settings => this.parseConfigurationSettings(settings)), tap$1(configurationSettings => {
-            this.configurationSettings$.next(configurationSettings);
-            this.formattingSettings = this.getFormattingSettings();
-        }), map$2(() => undefined));
+    executeStateless$(request) {
+        return of(undefined).pipe(switchMap(() => {
+            // Apply actions and execute configuration/price call
+            // No need to run configuration if no actions in the request
+            if (!request.actions?.length) {
+                return of(undefined);
+            }
+            let configurationRequest = this.configurationService.generateRequest();
+            request.actions.forEach(action => {
+                try {
+                    configurationRequest = this.executeActionScript(configurationRequest, action) ?? configurationRequest;
+                }
+                catch (e) {
+                    console.error(e);
+                    this.toastService.add({ severity: ToastType.error, summary: String(e) });
+                    throw e;
+                }
+            });
+            return this.configurationService.configureRequest$(configurationRequest);
+        }), map$1(() => {
+            // Run selectors and apply them to the state
+            const finalConfigurationRequest = this.configurationService.generateRequest(false);
+            const selectorsResult = EntityUtil.entries(request.selectors ?? {}).reduce((result, [key, selector]) => {
+                try {
+                    result.selectors[key] = {
+                        success: true,
+                        result: this.executeSelectorScript(finalConfigurationRequest, selector),
+                    };
+                }
+                catch (e) {
+                    console.error(e);
+                    result.selectors[key] = {
+                        success: false,
+                        errorMessage: String(e),
+                    };
+                }
+                return result;
+            }, { stateId: '', selectors: {} });
+            return selectorsResult;
+        }));
     }
-    initCurrency(iso) {
-        if (iso) {
-            const symbol = this.getCurrencySymbol('en-US', iso);
-            this.currencySettings$.next({ iso, symbol });
+    executeStateful$(request) {
+        if (!this.flowStateService.stateId || !this.stateId) {
+            return of();
         }
+        return this.flowStateApiService.executeConfiguration(this.flowStateService.stateId, this.stateId, request).pipe(tap$1(response => {
+            this.stateId = response.stateId;
+        }));
     }
-    getFormattingSettings() {
-        if (this.formattingSettings) {
-            return this.formattingSettings;
+    executeActionScript(request, processor) {
+        const { actions } = this.configurationRuntimeService.runtimeContext?.uiDefinitionContainer ?? {};
+        const configurationProcessor = actions?.find(action => action.apiName === processor.apiName);
+        if (!configurationProcessor?.script) {
+            return request;
         }
-        const shoppingCartSettings = this.getConfigurationSettings()['shopping-cart']?.reduce((acc, setting) => {
-            return { ...acc, [setting.id]: setting.properties };
-        }, {});
-        const currencySettings = this.getCurrencySettings();
-        const dateFormat = (validateDateFormat(shoppingCartSettings?.DATE_FORMAT ?? '') && shoppingCartSettings?.DATE_FORMAT) ||
-            DEFAULT_DATE_FORMAT;
-        const decimalSeparator = shoppingCartSettings?.DECIMAL_SEPARATOR;
-        const thousandsSeparator = shoppingCartSettings?.THOUSANDS_SEPARATOR;
-        // the number of decimal places can be 0
-        const priceScale = shoppingCartSettings?.PRICE_SCALE;
-        const decimalsCount = priceScale !== null && priceScale !== '' && !isNaN(Number(priceScale)) && Number(priceScale) >= 0
-            ? Number(priceScale)
-            : DEFAULT_DECIMALS_COUNT;
-        return {
-            currencySymbol: currencySettings.symbol,
-            dateFormats: getSupportedDateFormats(dateFormat),
-            decimalsCount,
-            decimalSeparator: decimalSeparator !== undefined && ['.', ','].includes(decimalSeparator)
-                ? decimalSeparator
-                : DEFAULT_DECIMAL_SEPARATOR,
-            // thousands separator can be a blank value, so it can also be null
-            thousandsSeparator: thousandsSeparator !== undefined && ['.', ',', '', null].includes(thousandsSeparator)
-                ? thousandsSeparator || ''
-                : DEFAULT_THOUSANDS_SEPARATOR,
-        };
+        return this.executeProcessorScript(request, configurationProcessor, processor.inputData);
     }
-    getConfigurationSettings() {
-        return this.configurationSettings$.value;
-    }
-    getCurrencySettings() {
-        return this.currencySettings$.value;
+    executeSelectorScript(request, processor) {
+        const { selectors } = this.configurationRuntimeService.runtimeContext?.uiDefinitionContainer ?? {};
+        const configurationProcessor = selectors?.find(selector => selector.apiName === processor.apiName);
+        if (!configurationProcessor?.script) {
+            return null;
+        }
+        return this.executeProcessorScript(request, configurationProcessor, processor.inputData);
     }
-    parseConfigurationSettings(settings) {
-        return settings.reduce((acc, setting) => {
-            switch (setting.key) {
-                case 'shopping-cart':
-                    acc['shopping-cart'] = parseJsonSafely(setting.value, []);
-                    break;
-                case 'navigation':
-                    acc.navigation = parseJsonSafely(setting.value, {});
-                    break;
-                case 'flows':
-                    acc.flows = parseJsonSafely(setting.value, []);
-                    break;
-                default:
-                    acc[setting.key] = setting.value;
-            }
-            return acc;
-        }, {});
+    executeProcessorScript(request, configurationProcessor, inputData) {
+        let functionToExecute = this.executedFunctions[configurationProcessor.apiName];
+        if (!functionToExecute) {
+            const script = `${configurationProcessor.script}\nreturn transform;`;
+            const sourceMap = `\n//# sourceURL=${configurationProcessor.apiName}.js`;
+            functionToExecute = new Function(script + sourceMap)();
+            this.executedFunctions[configurationProcessor.apiName] = functionToExecute;
+        }
+        return functionToExecute({
+            request,
+            inputData,
+            flowStore: this.flowStateService.getFlowStore(),
+            configurationStore: this.configurationStore,
+        });
     }
 }
-RuntimeSettingsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: RuntimeSettingsService, deps: [{ token: i1.ConfigurationSettingsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
-RuntimeSettingsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: RuntimeSettingsService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: RuntimeSettingsService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: i1.ConfigurationSettingsApiService }]; } });
+ConfigurationStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationStateService, deps: [{ token: ConfigurationRuntimeService }, { token: ConfigurationService }, { token: QuoteDraftService }, { token: i6.ToastService }, { token: FlowStateService }, { token: FlowInfoService }, { token: FlowConfigurationService }, { token: i1.FlowStateApiService }, { token: i1.QuoteApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationStateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationStateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: ConfigurationRuntimeService }, { type: ConfigurationService }, { type: QuoteDraftService }, { type: i6.ToastService }, { type: FlowStateService }, { type: FlowInfoService }, { type: FlowConfigurationService }, { type: i1.FlowStateApiService }, { type: i1.QuoteApiService }]; } });
+
+class ConfigurationModule {
+}
+ConfigurationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ConfigurationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationModule, imports: [ConfirmationDialogModule, ApiModule] });
+ConfigurationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationModule, providers: [ConfigurationRuntimeService, RuntimeContextService, ConfigurationService, ConfigurationStateService], imports: [ConfirmationDialogModule, ApiModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ConfigurationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ConfirmationDialogModule, ApiModule],
+                    providers: [ConfigurationRuntimeService, RuntimeContextService, ConfigurationService, ConfigurationStateService],
+                }]
+        }] });
 
 const DEFAULT_FORMATTING_SETTINGS = {
     currencySymbol: DEFAULT_CURRENCY_SYMBOL,
@@ -1609,31 +2399,38 @@ const DEFAULT_FORMATTING_SETTINGS = {
     dateFormats: getSupportedDateFormats(DEFAULT_DATE_FORMAT),
     decimalSeparator: DEFAULT_DECIMAL_SEPARATOR,
     thousandsSeparator: DEFAULT_THOUSANDS_SEPARATOR,
+    actionCodeLabels: DEFAULT_ACTION_CODE_LABELS,
 };
 class SdkCoreModule {
 }
-SdkCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SdkCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SdkCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: SdkCoreModule, imports: [ConfigurationModule, FlowConfigurationModule] });
-SdkCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SdkCoreModule, providers: [
+SdkCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SdkCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SdkCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: SdkCoreModule, imports: [ConfigurationModule, FlowConfigurationModule] });
+SdkCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SdkCoreModule, providers: [
         ContextService,
+        FlowInfoService,
         QuoteDraftService,
         ProductImagesService,
-        MetricsCalculationService,
+        IntegrationState,
+        FlowStateService,
+        FlowStateConfigurationService,
         RuntimeSettingsService,
         {
             provide: FORMATTING_SETTINGS_TOKEN,
             useExisting: RuntimeSettingsService,
         },
     ], imports: [ConfigurationModule, FlowConfigurationModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SdkCoreModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SdkCoreModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [ConfigurationModule, FlowConfigurationModule],
                     providers: [
                         ContextService,
+                        FlowInfoService,
                         QuoteDraftService,
                         ProductImagesService,
-                        MetricsCalculationService,
+                        IntegrationState,
+                        FlowStateService,
+                        FlowStateConfigurationService,
                         RuntimeSettingsService,
                         {
                             provide: FORMATTING_SETTINGS_TOKEN,
@@ -1666,9 +2463,9 @@ class CalendarDirective {
         }
     }
 }
-CalendarDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: CalendarDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-CalendarDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", type: CalendarDirective, selector: "[vlCalendar]", inputs: { vlCalendar: "vlCalendar" }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: CalendarDirective, decorators: [{
+CalendarDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CalendarDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CalendarDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: CalendarDirective, selector: "[vlCalendar]", inputs: { vlCalendar: "vlCalendar" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CalendarDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[vlCalendar]',
@@ -1679,10 +2476,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImpor
 
 class SdkDirectivesModule {
 }
-SdkDirectivesModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SdkDirectivesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SdkDirectivesModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: SdkDirectivesModule, declarations: [CalendarDirective], exports: [CalendarDirective] });
-SdkDirectivesModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SdkDirectivesModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SdkDirectivesModule, decorators: [{
+SdkDirectivesModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SdkDirectivesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SdkDirectivesModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: SdkDirectivesModule, declarations: [CalendarDirective], exports: [CalendarDirective] });
+SdkDirectivesModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SdkDirectivesModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SdkDirectivesModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [CalendarDirective],
@@ -1701,21 +2498,27 @@ class DatePipe {
         this.destroy$.next();
         this.destroy$.complete();
     }
-    transform(date) {
+    transform(date, type = 'date') {
         if (!date) {
             return '';
         }
+        const dateFormat = this.formattingSettings?.dateFormats.datePipeFormat || DEFAULT_DATE_FORMAT;
+        const formatMap = {
+            date: dateFormat,
+            time: DEFAULT_TIME_FORMAT,
+            datetime: `${dateFormat} ${DEFAULT_TIME_FORMAT}`,
+        };
         try {
-            return formatDate(date, this.formattingSettings?.dateFormats.datePipeFormat || DEFAULT_DATE_FORMAT, this.locale, this.defaultOptions?.timezone);
+            return formatDate(date, formatMap[type], this.locale, this.defaultOptions?.timezone);
         }
         catch (error) {
             return new Date(date).toString();
         }
     }
 }
-DatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: DatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-DatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: DatePipe, name: "vlDate" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: DatePipe, decorators: [{
+DatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+DatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: DatePipe, name: "vlDate" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DatePipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'vlDate',
@@ -1735,9 +2538,9 @@ class NumberPipe {
         return formatNumber(price, this.formattingSettings?.thousandsSeparator, this.formattingSettings?.decimalSeparator, this.formattingSettings?.decimalsCount);
     }
 }
-NumberPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NumberPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-NumberPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: NumberPipe, name: "vlNumber" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NumberPipe, decorators: [{
+NumberPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: NumberPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NumberPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: NumberPipe, name: "vlNumber" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: NumberPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'vlNumber',
@@ -1760,25 +2563,42 @@ class PricePipe {
         return `${this.formattingSettings?.currencySymbol || DEFAULT_CURRENCY_SYMBOL}${formatNumber(price, this.formattingSettings?.thousandsSeparator, this.formattingSettings?.decimalSeparator, this.formattingSettings?.decimalsCount)}`;
     }
 }
-PricePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: PricePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-PricePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: PricePipe, name: "vlPrice" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: PricePipe, decorators: [{
+PricePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PricePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+PricePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: PricePipe, name: "vlPrice" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PricePipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'vlPrice',
                 }]
         }] });
 
+class ActionCodePipe {
+    constructor() {
+        this.formattingSettings = inject(FORMATTING_SETTINGS_TOKEN, { optional: true })?.getFormattingSettings();
+    }
+    transform(actionCode) {
+        return this.formattingSettings?.actionCodeLabels[actionCode] ?? actionCode;
+    }
+}
+ActionCodePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ActionCodePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ActionCodePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: ActionCodePipe, name: "vlActionCode" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ActionCodePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'vlActionCode',
+                }]
+        }] });
+
 class SdkPipesModule {
 }
-SdkPipesModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SdkPipesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SdkPipesModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: SdkPipesModule, declarations: [NumberPipe, PricePipe, DatePipe], exports: [NumberPipe, PricePipe, DatePipe] });
-SdkPipesModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SdkPipesModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SdkPipesModule, decorators: [{
+SdkPipesModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SdkPipesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SdkPipesModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: SdkPipesModule, declarations: [NumberPipe, PricePipe, DatePipe, ActionCodePipe], exports: [NumberPipe, PricePipe, DatePipe, ActionCodePipe] });
+SdkPipesModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SdkPipesModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SdkPipesModule, decorators: [{
             type: NgModule,
             args: [{
-                    declarations: [NumberPipe, PricePipe, DatePipe],
-                    exports: [NumberPipe, PricePipe, DatePipe],
+                    declarations: [NumberPipe, PricePipe, DatePipe, ActionCodePipe],
+                    exports: [NumberPipe, PricePipe, DatePipe, ActionCodePipe],
                 }]
         }] });
 
@@ -1786,5 +2606,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { CalendarDirective, ConfigurationRuntimeService, ConfigurationService, ConfigurationState, ContextService, DEFAULT_FORMATTING_SETTINGS, DatePipe, FORMATTING_SETTINGS_TOKEN, FlowConfigurationModule, FlowConfigurationService, FlowUpdateService, LineItemWorker, MetricsCalculationService, NumberPipe, PricePipe, ProductImagesService, QuoteDraftService, RuntimeMode, RuntimeOperation, RuntimeSettingsService, RuntimeStep, SdkCoreModule, SdkDirectivesModule, SdkPipesModule, UI_DEFINITION_VERSION, calculateCardinalityVariables, extractMetadata, filterOutTechnicalAttributes, findLineItem, findLineItemWithComparator, generateLineItem, generateModifiedAssetsMap, getAttributeValue, getAttributes, getDefaultLineItem, getGuidedSellingConfigurationRequest, getOriginParent, getRecommendedPrices, insertLineItem, isLineItemModified, isTechnicalAttribute, lineItem_utils as lineItemUtils, mapAttributes, multiplyLineItems, patchAttributes, recalculateCardinalityVariables, removeLineItem, replaceLineItem, upsertAttributes };
+export { ActionCodePipe, CalendarDirective, ConfigurationRuntimeService, ConfigurationService, ConfigurationStateService, ContextService, DEFAULT_FORMATTING_SETTINGS, DatePipe, FLOW_CUSTOMIZATION, FORMATTING_SETTINGS_TOKEN, FlowConfigurationModule, FlowConfigurationService, FlowInfoService, FlowStateConfigurationService, FlowStateService, FlowUpdateService, IntegrationState, LineItemWorker, NumberPipe, PricePipe, ProductImagesService, QuoteDraftService, RuntimeMode, RuntimeOperation, RuntimeSettingsService, RuntimeStep, SdkCoreModule, SdkDirectivesModule, SdkPipesModule, UI_DEFINITION_VERSION, extractMetadata, filterOutTechnicalAttributes, findLineItem, findLineItemWithComparator, generateConfigurationLineItem, generateLineItem, generateModifiedAssetsMap, getAttributeValue, getAttributes, getDefaultLineItem, getGuidedSellingConfigurationRequest, getOriginParent, getRecommendedPrices, insertLineItem, isLineItemModified, isTechnicalAttribute, lineItem_utils as lineItemUtils, mapAttributes, multiplyLineItems, patchAttributes, recalculateCardinalityVariables, removeLineItem, replaceLineItem, upsertAttributes };
 //# sourceMappingURL=veloceapps-sdk-core.mjs.map