@veloceapps/sdk 11.0.0-13 → 11.0.0-130

package/cms/cms.actions.d.ts

@@ -1,5 +1,3 @@
-import { CustomizationChanges } from '@veloceapps/core';
-import { IntegrationAction } from '@veloceapps/sdk/core';
 export declare namespace FlowAction {
     const FLOW_CONFIGURE_PRODUCT = "[FLOW]_CONFIGURE_PRODUCT";
     const FLOW_NAVIGATE_BACK = "[FLOW]_NAVIGATE_BACK";
@@ -16,35 +14,86 @@ export declare namespace FlowAction {
     const SUBMIT_GUIDED_SELLING = "[FLOW]_SUBMIT_GUIDED_SELLING";
     const CLOSE_GUIDED_SELLING = "[FLOW]_CLOSE_GUIDED_SELLING";
     const OPEN_DIALOG = "[FLOW]_OPEN_DIALOG";
-    const ConfigureProductAction: ({ lineItemId, productId, }: {
-        lineItemId?: string | undefined;
+    const ConfigureProductAction: ({ transactionItemId, productId, qty, }: {
+        transactionItemId?: string | undefined;
         productId?: string | undefined;
-    }) => IntegrationAction;
-    const NavigateBackAction: () => IntegrationAction;
-    const NavigateToAction: (path: string, productId?: string, lineItemId?: string) => IntegrationAction;
-    const NavigateToCatalogAction: () => IntegrationAction;
-    const NavigateToShoppingCartAction: () => IntegrationAction;
-    const ApplyProductConfigurationAction: () => IntegrationAction;
-    const RemoteApplyAction: () => IntegrationAction;
-    const RemoteCancelAction: () => IntegrationAction;
+        qty?: number | undefined;
+    }) => {
+        type: string;
+        payload: {
+            transactionItemId: string | undefined;
+            productId: string | undefined;
+            qty: number | undefined;
+        };
+    };
+    const NavigateBackAction: () => {
+        type: string;
+    };
+    const NavigateToAction: (path: string, productId?: string, transactionItemId?: string) => {
+        type: string;
+        payload: {
+            path: string;
+            productId: string | undefined;
+            transactionItemId: string | undefined;
+        };
+    };
+    const NavigateToCatalogAction: () => {
+        type: string;
+    };
+    const NavigateToShoppingCartAction: () => {
+        type: string;
+    };
+    const ApplyProductConfigurationAction: () => {
+        type: string;
+    };
+    const RemoteApplyAction: () => {
+        type: string;
+    };
+    const RemoteCancelAction: () => {
+        type: string;
+    };
     const SwitchObjectAction: (payload: {
         id: string;
-    }) => IntegrationAction;
+    }) => {
+        type: string;
+        payload: {
+            id: string;
+        };
+    };
     const OpenGuidedSelling: (payload: {
         guidedSellingId: string;
-    }) => IntegrationAction;
+    }) => {
+        type: string;
+        payload: {
+            guidedSellingId: string;
+        };
+    };
     const CloseGuidedSelling: (payload?: {
         keepState?: boolean;
-    }) => IntegrationAction;
+    }) => {
+        type: string;
+        payload: {
+            keepState?: boolean | undefined;
+        } | undefined;
+    };
     const SubmitGuidedSelling: (payload: {
         result: Record<string, any>;
-    }) => IntegrationAction;
-    const OpenDialog: (dialog: string) => IntegrationAction;
+    }) => {
+        type: string;
+        payload: {
+            result: Record<string, any>;
+        };
+    };
+    const OpenDialog: (dialog: string) => {
+        type: string;
+        payload: {
+            dialog: string;
+        };
+    };
 }
 export declare namespace CmsAction {
     const GO_TO_PAGE = "[CMS]_GO_TO_PAGE";
     const UPDATE_CUSTOMIZATION = "[CMS]_UPDATE_CUSTOMIZATION";
-    const EMIT_CUSTOMIZATION_CHANGES = "[CMS]_EMIT_CUSTOMIZATION_CHANGES";
     const SHOW_OVERLAY = "[CMS]_SHOW_OVERLAY";
     const HIDE_OVERLAY = "[CMS]_HIDE_OVERLAY";
     const HIDE_ALL_OVERLAYS = "[CMS]_HIDE_ALL_OVERLAYS";
@@ -53,37 +102,53 @@ export declare namespace CmsAction {
      *
      * @param pageName name of the page
      */
-    const GoToPage: (pageName: string) => IntegrationAction;
+    const GoToPage: (pageName: string) => {
+        type: string;
+        payload: {
+            pageName: string;
+        };
+    };
     /**
      * Update UI definition customization state
      *
      * @param pageName name of the page
      */
-    const UpdateCustomization: (value: any) => IntegrationAction;
-    /**
-     * Emit customization page changes
-     *
-     * @param changes - object with customization page changes
-     */
-    const EmitCustomizationChanges: (changes: CustomizationChanges) => IntegrationAction;
+    const UpdateCustomization: (value: any) => {
+        type: string;
+        payload: {
+            value: any;
+        };
+    };
     /**
      * Show an Overlay on the selected page
      *
      * @param name - name of the overlay
      * @returns void
      */
-    const ShowOverlay: (name: string) => IntegrationAction;
+    const ShowOverlay: (name: string) => {
+        type: string;
+        payload: {
+            name: string;
+        };
+    };
     /**
      * Hide an Overlay on the selected page
      *
      * @param name - name of the overlay
      * @returns void
      */
-    const HideOverlay: (name: string) => IntegrationAction;
+    const HideOverlay: (name: string) => {
+        type: string;
+        payload: {
+            name: string;
+        };
+    };
     /**
      * Hide all Overlays on the selected page
      *
      * @returns void
      */
-    const HideAllOverlays: () => IntegrationAction;
+    const HideAllOverlays: () => {
+        type: string;
+    };
 }

package/cms/components/element-renderer/element-renderer.component.d.ts

@@ -1,36 +1,29 @@
-import { ChangeDetectorRef, ElementRef, Injector, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';
-import { ConfigurationService } from '@veloceapps/sdk/core';
+import { ChangeDetectorRef, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';
 import { RuntimeService } from '../../modules/runtime/services/runtime.service';
 import { ElementContextService } from '../../services/element-context.service';
 import { IOProviderService } from '../../services/io-provider.service';
 import { ElementMetadata } from '../../types/common.types';
 import * as i0 from "@angular/core";
 export declare class ElementRendererComponent implements OnInit, OnDestroy {
-    private parentInjector;
     private runtimeService;
     private elementContext;
     private ioProviderService;
-    private configurationService;
-    private elementRef;
     private cdr;
     el?: ViewContainerRef;
     meta: ElementMetadata;
     private type?;
     private refs;
     private destroy$;
-    constructor(parentInjector: Injector, runtimeService: RuntimeService, elementContext: ElementContextService, ioProviderService: IOProviderService, configurationService: ConfigurationService, elementRef: ElementRef, cdr: ChangeDetectorRef);
+    constructor(runtimeService: RuntimeService, elementContext: ElementContextService, ioProviderService: IOProviderService, cdr: ChangeDetectorRef);
     ngOnInit(): void;
     ngOnDestroy(): void;
     private createComponents;
     private createFromPath;
-    private getModelComponent;
-    private createFromLineItem;
     private processChildren;
-    private getParentLineItem$;
     private createComponent;
     private updateComponent;
     private destroyComponent;
     private destroyComponents;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ElementRendererComponent, [{ skipSelf: true; }, null, null, null, null, null, null]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementRendererComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ElementRendererComponent, "vl-cms-element-renderer", never, { "meta": "meta"; }, {}, never, never, false, never>;
 }

package/cms/components/preview/preview.component.d.ts

@@ -1,8 +1,8 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import { ToastService } from '@veloceapps/components';
 import { UIDefinition } from '@veloceapps/core';
-import { ConfigurationStateService, IntegrationState } from '@veloceapps/sdk/core';
-import { BehaviorSubject, Observable } from 'rxjs';
+import { IntegrationState } from '@veloceapps/sdk/core';
+import { BehaviorSubject } from 'rxjs';
 import { RuntimeService } from '../../modules/runtime/services/runtime.service';
 import { ElementMetadata } from '../../types/common.types';
 import { CMSPreviewConfig } from './preview.types';
@@ -13,20 +13,19 @@ interface State {
 }
 export declare class PreviewComponent implements OnInit, OnDestroy {
     private runtimeService;
-    private configurationState;
     private toastService;
     private integrationState;
     uiDefinition?: UIDefinition;
     config?: CMSPreviewConfig;
     state$: BehaviorSubject<State>;
-    elements$: Observable<ElementMetadata[]>;
+    elements$: BehaviorSubject<ElementMetadata[]>;
     private destroy$;
-    constructor(runtimeService: RuntimeService, configurationState: ConfigurationStateService, toastService: ToastService, integrationState: IntegrationState);
+    constructor(runtimeService: RuntimeService, toastService: ToastService, integrationState: IntegrationState);
     ngOnInit(): void;
     ngOnDestroy(): void;
     trackBy(_: number, el: ElementMetadata): ElementMetadata;
     private startPreview;
-    private getPages$;
+    private getElements$;
     static ɵfac: i0.ɵɵFactoryDeclaration<PreviewComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<PreviewComponent, "vl-cms-preview", never, { "uiDefinition": "uiDefinition"; "config": "config"; }, {}, never, never, false, never>;
 }

package/cms/components/preview/preview.types.d.ts

@@ -13,10 +13,6 @@ export interface CMSPreviewConfig {
      * When `true`, preview renders settings page (element with `type: CUSTOMIZATION_PAGE`)
      */
     customizationMode?: boolean;
-    /**
-     * When `true`, preview component does not clear configuration state on destroy
-     */
-    persistConfigurationState?: boolean;
     /**
      * Custom initialization function which will be executed before starting a preview
      */

package/cms/services/element-context.service.d.ts

@@ -2,7 +2,6 @@ import { ElementMetadata } from '../types/common.types';
 import * as i0 from "@angular/core";
 export declare class ElementContextService {
     metadata?: ElementMetadata;
-    parentModelId?: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<ElementContextService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ElementContextService>;
 }

package/cms/types/common.types.d.ts

@@ -29,6 +29,8 @@ export interface ElementModel {
      */
     path?: string;
     /**
+     * @deprecated
+     * To be removed!!!
      * Used only when `UIDefinitionType = CONFIGURATION`.
      */
     lineItem?: string;

package/cms/types/index.d.ts

@@ -1,6 +1,5 @@
 export * from '../modules/runtime/types/compilation.types';
 export * from './common.types';
-export * from './configuration.types';
 export * from './elements.types';
 export * from './layouts.types';
 export * from './pages.types';

package/cms/utils/path.utils.d.ts

@@ -1,4 +1,3 @@
-import { ElementMetadata, ElementPath, PathBlock } from '../types';
-export declare const parseBoundPath: (path: string) => PathBlock[];
+import { ElementMetadata, ElementPath } from '../types';
 export declare const parsePath: (path: string) => ElementPath;
 export declare const getAbsolutePath: (elements: ElementMetadata[], subject: ElementMetadata, path: ElementPath) => string | undefined;

package/cms/vendor-map.d.ts

@@ -1,11 +1,11 @@
 import { DataSource } from '@angular/cdk/collections';
 import * as angularCore from '@angular/core';
 import * as angularForms from '@angular/forms';
-import { CatalogApiService, ConfigurationSettingsApiService, ContractedPriceApiService, DeltaApiService, DocumentAttachmentApiService, GuidedSellingApiService, PicklistsApiService, PriceApiService, RampApiService, SalesforceApiService, ShoppingCartSettingsApiService } from '@veloceapps/api';
-import { SalesTransactionApiService } from '@veloceapps/api/v2';
+import { ContractedPriceApiService } from '@veloceapps/api';
+import { CatalogApiService, ConfigurationSettingsApiService, DocumentAttachmentApiService, GuidedSellingApiService, SalesforceApiService, SalesTransactionApiService, ShoppingCartSettingsApiService } from '@veloceapps/api/v2';
 import { ToastService, ToastType } from '@veloceapps/components';
-import { Operator, parseJsonSafely, parseJwt, Predicate, TokenInfoService } from '@veloceapps/core';
-import { ActionCodePipe, ConfigurationService, ConfigurationStateService, DatePipe, FlowConfigurationService, FlowStateConfigurationService, FlowStateService, IntegrationState, LineItemWorker, NumberPipe, PricePipe, ProductImagesService, QuoteDraftService, RuntimeSettingsService } from '@veloceapps/sdk/core';
+import { Operator, parseJsonSafely, parseJwt, Predicate, TokenInfoService, UITemplateType } from '@veloceapps/core';
+import { ActionCodePipe, ConfigurationService, ConfigurationStateService, DatePipe, filterSuccessfulExecute, FlowConfigurationService, FlowInfoService, FlowStateConfigurationService, FlowStateService, GuidedSellingService, IntegrationState, NumberPipe, PCMUtils, PricePipe, ProductImagesService, RuntimeSettingsService, SalesTransactionService, TransactionItemWorker } from '@veloceapps/sdk/core';
 import lodash from 'lodash';
 import * as rxjs from 'rxjs';
 import * as rxjsOperators from 'rxjs/operators';
@@ -20,71 +20,52 @@ export declare const vendorMap: {
         parseJsonSafely: typeof parseJsonSafely;
         parseJwt: typeof parseJwt;
         TokenInfoService: typeof TokenInfoService;
+        UITemplateType: typeof UITemplateType;
     };
     '@veloceapps/components': {
         ToastService: typeof ToastService;
         ToastType: typeof ToastType;
     };
     '@veloceapps/api': {
-        SalesforceApiService: typeof SalesforceApiService;
-        DocumentAttachmentApiService: typeof DocumentAttachmentApiService;
-        RampApiService: typeof RampApiService;
-        CatalogApiService: typeof CatalogApiService;
-        DeltaApiService: typeof DeltaApiService;
-        PicklistsApiService: typeof PicklistsApiService;
-        PriceApiService: typeof PriceApiService;
-        ShoppingCartSettingsApiService: typeof ShoppingCartSettingsApiService;
-        ConfigurationSettingsApiService: typeof ConfigurationSettingsApiService;
-        GuidedSellingApiService: typeof GuidedSellingApiService;
         ContractedPriceApiService: typeof ContractedPriceApiService;
     };
     '@veloceapps/api/v2': {
+        CatalogApiService: typeof CatalogApiService;
+        ConfigurationSettingsApiService: typeof ConfigurationSettingsApiService;
+        DocumentAttachmentApiService: typeof DocumentAttachmentApiService;
+        GuidedSellingApiService: typeof GuidedSellingApiService;
+        SalesforceApiService: typeof SalesforceApiService;
         SalesTransactionApiService: typeof SalesTransactionApiService;
+        ShoppingCartSettingsApiService: typeof ShoppingCartSettingsApiService;
     };
     '@veloceapps/sdk/core': {
-        findLineItem: (id: string, lineItems: import("@veloceapps/core").LineItem[]) => import("@veloceapps/core").LineItem | undefined;
-        findLineItemWithComparator: (lineItems: import("@veloceapps/core").LineItem[], comparator: (li: import("@veloceapps/core").LineItem) => boolean) => import("@veloceapps/core").LineItem | undefined;
-        insertLineItem: (lineItem: import("@veloceapps/core").LineItem, parentId: string, toInsert: import("@veloceapps/core").LineItem) => import("@veloceapps/core").LineItem;
-        removeLineItem: (lineItem: import("@veloceapps/core").LineItem, idToRemove: string) => import("@veloceapps/core").LineItem;
-        replaceLineItem: (lineItem: import("@veloceapps/core").LineItem, replaceTo: import("@veloceapps/core").LineItem, skipCardinalityCalculation?: boolean | undefined) => import("@veloceapps/core").LineItem;
-        recalculateCardinalityVariables: (original: import("@veloceapps/core").LineItem, updated: import("@veloceapps/core").LineItem) => import("@veloceapps/core").LineItem;
-        mapAttributes: (attributes: import("@veloceapps/core").Attribute[]) => lodash.Dictionary<any>;
-        getAttributes: (attributes: import("@veloceapps/core").Attribute[], names?: string[] | undefined) => import("@veloceapps/core").Attribute[];
-        upsertAttributes: (originalAttributes: import("@veloceapps/core").Attribute[], attributesToUpsert: import("@veloceapps/core").NewAttribute[]) => import("@veloceapps/core").Attribute[];
-        patchAttributes: (rootLineItem: import("@veloceapps/core").LineItem, id: string, attrs: import("@veloceapps/core").NewAttribute[], skipCardinalityCalculation?: boolean | undefined) => import("@veloceapps/core").LineItem;
-        getAttributeValue: (attributes: import("@veloceapps/core").Attribute[], name: string) => any;
-        generateLineItem: (port: string, type: string, parentId: string, attributes?: import("@veloceapps/core").NewAttribute[] | undefined, lineItems?: import("@veloceapps/core").LineItem[] | undefined) => import("@veloceapps/core").LineItem;
-        getRecommendedPrices: (portDomain: import("@veloceapps/core").PortDomain, type: string) => {
-            net: number;
-            list: number;
-        };
-        getOriginParent: (lineItems: import("@veloceapps/core").LineItem[], currentLineItem: import("@veloceapps/core").LineItem) => import("@veloceapps/core").LineItem | undefined;
-        assetPredicateFn: (lineItem: import("@veloceapps/core").LineItem, assetId?: string | undefined) => boolean;
-        multiplyLineItems: (lineItem: import("@veloceapps/core").LineItem, qty: number, split: boolean) => import("@veloceapps/core").LineItem[];
-        isTechnicalAttribute: (name: string) => boolean;
-        filterOutTechnicalAttributes: <T_1 extends {
-            name: string;
-        }>(attributes: T_1[]) => T_1[];
         ConfigurationService: typeof ConfigurationService;
         ConfigurationStateService: typeof ConfigurationStateService;
-        QuoteDraftService: typeof QuoteDraftService;
+        GuidedSellingService: typeof GuidedSellingService;
+        filterSuccessfulExecute: typeof filterSuccessfulExecute;
+        FlowInfoService: typeof FlowInfoService;
         FlowConfigurationService: typeof FlowConfigurationService;
         IntegrationState: typeof IntegrationState;
         FlowStateService: typeof FlowStateService;
         FlowStateConfigurationService: typeof FlowStateConfigurationService;
-        LineItemWorker: typeof LineItemWorker;
+        TransactionItemWorker: typeof TransactionItemWorker;
         ProductImagesService: typeof ProductImagesService;
         RuntimeSettingsService: typeof RuntimeSettingsService;
         ActionCodePipe: typeof ActionCodePipe;
         DatePipe: typeof DatePipe;
         NumberPipe: typeof NumberPipe;
         PricePipe: typeof PricePipe;
+        SalesTransactionService: typeof SalesTransactionService;
+        generateTransactionItem: (option: import("@veloceapps/core").PCMProduct, salesTransactionId?: string | undefined, qty?: number | undefined, parentTi?: import("@veloceapps/core").SalesTransactionItem | undefined) => import("@veloceapps/core").SalesTransactionItem;
+        updateQuantity: (ti: import("@veloceapps/core").SalesTransactionItem, qty: number, pcm: import("@veloceapps/core").PCMProduct, parentQty?: number | undefined) => import("@veloceapps/core").SalesTransactionItem;
+        flattenTransactionItem: (ti: import("@veloceapps/core").SalesTransactionItem) => import("@veloceapps/core").SalesTransactionItem[];
+        PCMUtils: typeof PCMUtils;
     };
     '@veloceapps/sdk/cms': {
         TemplatesService: typeof TemplatesService;
         IntegrationState: typeof IntegrationState;
         ResourcesService: typeof ResourcesService;
-        cmsInject: <T_2 = unknown>(token: string) => T_2;
+        cmsInject: <T_1 = unknown>(token: string) => T_1;
         FlowAction: typeof cmsActions.FlowAction;
         CmsAction: typeof cmsActions.CmsAction;
         DEFAULT_PLUGINS_TOKEN: angularCore.InjectionToken<typeof import("./engine/models/plugin").Plugin[]>;

package/core/index.d.ts

@@ -1,8 +1,8 @@
 export * from './core.module';
 export * from './directives';
 export * from './modules';
+export * from './operators';
 export * from './pipes';
 export * from './services';
 export * from './types';
 export * from './utils';
-export * as lineItemUtils from './utils/line-item.utils';

package/core/modules/configuration/index.d.ts

@@ -1,6 +1,6 @@
-export * from './helpers';
 export * from './services/configuration-runtime.service';
-export * from './services/configuration.service';
 export * from './services/configuration-state.service';
-export * from './types/configuration-runtime.types';
-export * from './types/configuration.types';
+export * from './services/configuration.service';
+export * from './services/test-mode-configuration.service';
+export * from './services/guided-selling.service';
+export * from './types';

package/core/modules/configuration/services/configuration-runtime.service.d.ts

@@ -1,26 +1,17 @@
-import { ConfigurationApiService } from '@veloceapps/api';
-import { RuntimeModel, UIDefinitionContainer, UIDefinitionProps } from '@veloceapps/core';
+import { PCMApiService } from '@veloceapps/api/v2';
+import { PCMModel, UIDefinitionContainer, UIDefinitionProps } from '@veloceapps/core';
 import { Observable } from 'rxjs';
-import { RuntimeContext } from '../../../types';
 import { RuntimeInitializationProps } from '../types/configuration-runtime.types';
-import { RuntimeContextService } from './runtime-context.service';
 import * as i0 from "@angular/core";
 export declare class ConfigurationRuntimeService {
-    private apiService;
-    private runtimeContextService;
-    private _runtimeContext?;
-    private _isInitialized;
+    private pcmApiService;
+    uiDefinitionContainer: UIDefinitionContainer | null;
     initializationProps?: RuntimeInitializationProps;
-    uiDefinitionProperties: UIDefinitionProps;
-    constructor(apiService: ConfigurationApiService, runtimeContextService: RuntimeContextService);
+    pcmModel?: PCMModel;
+    constructor(pcmApiService: PCMApiService);
+    get uiDefinitionProps(): UIDefinitionProps;
     reset(): void;
-    initTestMode(uiDefinitionContainer: UIDefinitionContainer): Observable<RuntimeContext>;
-    init(props: RuntimeInitializationProps): Observable<RuntimeContext>;
-    overrideUIDefinition(uiDefinitionContainer: UIDefinitionContainer): void;
-    private id15to18;
-    get isInitialized(): boolean;
-    get runtimeModel(): RuntimeModel | undefined;
-    get runtimeContext(): RuntimeContext | undefined;
+    init$(props: RuntimeInitializationProps): Observable<PCMModel>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationRuntimeService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationRuntimeService>;
 }

package/core/modules/configuration/services/configuration-state.service.d.ts

@@ -1,5 +1,5 @@
 import { FlowStateApiService } from '@veloceapps/api';
-import { SalesTransactionApiService, SalesTransactionUpsertResponse } from '@veloceapps/api/v2';
+import { PCMApiService, SalesTransactionApiService, SalesTransactionUpsertResponse } from '@veloceapps/api/v2';
 import { ToastService } from '@veloceapps/components';
 import { FlowStateExecutionRequest, FlowStateExecutionResult, FlowStateSelectorResponse } from '@veloceapps/core';
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
@@ -12,13 +12,14 @@ import * as i0 from "@angular/core";
 export declare class ConfigurationStateService {
     private configurationRuntimeService;
     private configurationService;
-    private salesTransactionService;
-    private toastService;
     private flowStateService;
     private flowInfoService;
     private flowConfigurationService;
     private flowStateApiService;
+    private salesTransactionService;
     private salesTransactionApiService;
+    private toastService;
+    private pcmApiService;
     isInitialized$: BehaviorSubject<boolean>;
     canceledConfiguration$: Subject<void>;
     private readonly NOT_INITIALIZED;
@@ -32,7 +33,7 @@ export declare class ConfigurationStateService {
     private statefulRequestStream$;
     private statefulExecutionRequest$;
     private statelessExecutionRequest$;
-    constructor(configurationRuntimeService: ConfigurationRuntimeService, configurationService: ConfigurationService, salesTransactionService: SalesTransactionService, toastService: ToastService, flowStateService: FlowStateService, flowInfoService: FlowInfoService, flowConfigurationService: FlowConfigurationService, flowStateApiService: FlowStateApiService, salesTransactionApiService: SalesTransactionApiService);
+    constructor(configurationRuntimeService: ConfigurationRuntimeService, configurationService: ConfigurationService, flowStateService: FlowStateService, flowInfoService: FlowInfoService, flowConfigurationService: FlowConfigurationService, flowStateApiService: FlowStateApiService, salesTransactionService: SalesTransactionService, salesTransactionApiService: SalesTransactionApiService, toastService: ToastService, pcmApiService: PCMApiService);
     get isExecutionInProgress$(): Observable<boolean>;
     init$(): Observable<void>;
     cleanup(): void;

package/core/modules/configuration/services/configuration.service.d.ts

@@ -1,59 +1,36 @@
-import { ConfigurationApiService } from '@veloceapps/api';
-import { Charge, CompiledPricePlan, ConfigurationRequest, ConfigurePrice, LineItem, RuntimeModel } from '@veloceapps/core';
-import { Dictionary } from 'lodash';
+import { OrchestrationsApiService } from '@veloceapps/api/v2';
+import { PCMModel, SalesTransactionItem, TransactionContext } from '@veloceapps/core';
 import { MessageService } from 'primeng/api';
-import { DialogService } from 'primeng/dynamicdialog';
 import { Observable } from 'rxjs';
-import { FlowInfoService } from '../../../services';
-import { QuoteDraftService } from '../../../services/quote-draft.service';
-import { RuntimeSettingsService } from '../../../services/runtime-settings.service';
-import { RuntimeContext } from '../../../types';
-import { ExternalConfigurationProps, GuidedSellingSubmitData } from '../types/configuration.types';
+import { FlowInfoService, SalesTransactionService } from '../../../services';
 import { ConfigurationRuntimeService } from './configuration-runtime.service';
+import { GuidedSellingService } from './guided-selling.service';
 import * as i0 from "@angular/core";
 export declare class ConfigurationService {
-    private quoteDraftService;
-    private runtimeService;
-    private configurationApiService;
-    private messageService;
-    private dialogService;
-    private runtimeSettings;
     private flowInfoService;
-    private mode;
-    private configurableRamp;
-    private configurationState;
-    private previousConfigurationState;
-    private isLoadingSubj$;
+    private messageService;
+    private configurationRuntimeService;
+    private salesTransactionService;
+    private orchestrationsApiService;
+    private guidedSellingService;
     isLoading$: Observable<boolean>;
     hasUnsavedChanges: boolean;
-    constructor(quoteDraftService: QuoteDraftService, runtimeService: ConfigurationRuntimeService, configurationApiService: ConfigurationApiService, messageService: MessageService, dialogService: DialogService, runtimeSettings: RuntimeSettingsService, flowInfoService: FlowInfoService);
+    private configurationStateSubj$;
+    private previousConfigurationStateSubj$;
+    private isLoadingSubj$;
+    constructor(flowInfoService: FlowInfoService, messageService: MessageService, configurationRuntimeService: ConfigurationRuntimeService, salesTransactionService: SalesTransactionService, orchestrationsApiService: OrchestrationsApiService, guidedSellingService: GuidedSellingService);
+    get state$(): Observable<TransactionContext>;
+    get state(): TransactionContext | null;
+    get previousState(): TransactionContext | null;
+    get root$(): Observable<SalesTransactionItem>;
+    get root(): SalesTransactionItem | null;
     reset(): void;
-    patch$(lineItem: LineItem): Observable<LineItem>;
-    patch(lineItem: LineItem): void;
-    setConfigurableRamp(lineItem: LineItem): void;
-    get(): Observable<LineItem | undefined>;
-    getSnapshot(): LineItem | undefined;
-    getRuntimeModel(): RuntimeModel;
-    getRuntimeContext(): RuntimeContext;
-    get state$(): Observable<ConfigurePrice | null>;
-    get stateSnapshot(): ConfigurePrice | null;
-    get previousStateSnapshot(): ConfigurePrice | null;
-    get charges$(): Observable<Dictionary<Charge>>;
-    get chargesSnapshot(): Dictionary<Charge>;
-    get pricePlans$(): Observable<Dictionary<CompiledPricePlan>>;
-    get pricePlansSnapshot(): Dictionary<CompiledPricePlan>;
-    get procedureContext$(): Observable<Dictionary<unknown>>;
-    get procedureContextSnapshot(): Dictionary<unknown>;
-    configure(): Observable<LineItem>;
-    configureRequest$(configurationRequest: ConfigurationRequest): Observable<LineItem>;
-    configureExternal$(props: ExternalConfigurationProps): Observable<LineItem>;
-    configureGuidedSelling$(data: GuidedSellingSubmitData): Observable<ConfigurePrice>;
-    generateRequest(lightMode?: boolean): ConfigurationRequest;
-    generateLineItem(): LineItem;
-    getAsset(): LineItem | undefined;
-    private getUIDefinitionProperties;
-    private showInactiveProductsConfirmation;
-    private extendedConfigureLineItem$;
+    init$(): Observable<void>;
+    patch$(transactionItem: SalesTransactionItem): Observable<void>;
+    patch(transactionItem: SalesTransactionItem): void;
+    configure$(transactionContext: TransactionContext): Observable<TransactionContext>;
+    justConfigureRequest$(transactionContext: TransactionContext): Observable<TransactionContext>;
+    getPCMModel(): PCMModel;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationService>;
 }

package/core/modules/configuration/services/guided-selling.service.d.ts

@@ -0,0 +1,15 @@
+import { OrchestrationsApiService } from '@veloceapps/api/v2';
+import { Observable } from 'rxjs';
+import { GuidedSellingSubmitData } from '../types';
+import * as i0 from "@angular/core";
+export declare class GuidedSellingService {
+    private orchestrationsApiService;
+    private guidedSellingResult$;
+    constructor(orchestrationsApiService: OrchestrationsApiService);
+    get guidedSellingResult(): Record<string, any>;
+    configureGuidedSelling$(data: GuidedSellingSubmitData): Observable<Record<string, any>>;
+    clearGuidedSelling$(): void;
+    private getTransactionContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuidedSellingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GuidedSellingService>;
+}

package/core/modules/configuration/services/test-mode-configuration.service.d.ts

@@ -0,0 +1,26 @@
+import { SalesforceApiService } from '@veloceapps/api/v2';
+import { UIDefinitionContainer } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { FlowInfoService, RuntimeSettingsService, SalesTransactionService } from '../../../services';
+import { TestModeConfigurationOptions } from '../types';
+import { ConfigurationRuntimeService } from './configuration-runtime.service';
+import { ConfigurationService } from './configuration.service';
+import * as i0 from "@angular/core";
+export declare class TestModeConfigurationService {
+    private flowInfoService;
+    private configurationService;
+    private configurationRuntimeService;
+    private salesTransactionService;
+    private runtimeSettingsService;
+    private sfApiService;
+    private isInitialized;
+    private pcmModel?;
+    constructor(flowInfoService: FlowInfoService, configurationService: ConfigurationService, configurationRuntimeService: ConfigurationRuntimeService, salesTransactionService: SalesTransactionService, runtimeSettingsService: RuntimeSettingsService, sfApiService: SalesforceApiService);
+    initTestMode$(uiDefinitionContainer: UIDefinitionContainer, options?: TestModeConfigurationOptions): Observable<void>;
+    private initConfiguration$;
+    private getPriceBookId;
+    private getTestTransactionContext;
+    private checkInitialized;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TestModeConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TestModeConfigurationService>;
+}

package/core/modules/configuration/types/configuration-runtime.types.d.ts

@@ -1,8 +1,3 @@
 export interface RuntimeInitializationProps {
     productId: string;
-    offeringId?: string;
-    defaultQty?: number;
-    attributesMap?: Record<string, any>;
-    defaultUIDefinitionId?: string;
-    requiredUIDefinitionId?: string;
 }