@veloceapps/sdk 11.0.0-1 → 11.0.0-100

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,75 +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;
+        };
+    };
 }
-/**
- * @deprecated
- * Use FlowAction namespace instead
- */
-export declare const ConfigureProductAction: ({ lineItemId, productId, }: {
-    lineItemId?: string | undefined;
-    productId?: string | undefined;
-}) => IntegrationAction;
-/**
- * @deprecated
- * Use FlowAction namespace instead
- */
-export declare const NavigateBackAction: () => IntegrationAction;
-/**
- * @deprecated
- * Use FlowAction namespace instead
- */
-export declare const NavigateToCatalogAction: () => IntegrationAction;
-/**
- * @deprecated
- * Use FlowAction namespace instead
- */
-export declare const ApplyProductConfigurationAction: () => IntegrationAction;
-/**
- * @deprecated
- * Use FlowAction namespace instead
- */
-export declare const RemoteApplyAction: () => IntegrationAction;
-/**
- * @deprecated
- * Use FlowAction namespace instead
- */
-export declare const RemoteCancelAction: () => IntegrationAction;
-/**
- * @deprecated
- * Use FlowAction namespace instead
- */
-export declare const SwitchObjectAction: (payload: {
-    id: string;
-}) => IntegrationAction;
 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";
@@ -93,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,10 +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, QuoteApiService, RampApiService, SalesforceApiService, ShoppingCartSettingsApiService } from '@veloceapps/api';
+import { ContractedPriceApiService } from '@veloceapps/api';
+import { CatalogApiService, ConfigurationSettingsApiService, GuidedSellingApiService, DocumentAttachmentApiService, SalesforceApiService, SalesTransactionApiService, ShoppingCartSettingsApiService } from '@veloceapps/api/v2';
 import { ToastService, ToastType } from '@veloceapps/components';
-import { ConfigurationContextMode, Operator, Predicate, parseJsonSafely, parseJwt } from '@veloceapps/core';
-import { ActionCodePipe, ConfigurationService, ConfigurationStateService, ContextService, 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, GuidedSellingService, ConfigurationStateService, DatePipe, filterSuccessfulExecute, FlowConfigurationService, FlowInfoService, FlowStateConfigurationService, FlowStateService, IntegrationState, NumberPipe, PricePipe, ProductImagesService, RuntimeSettingsService, SalesTransactionService, TransactionItemWorker } from '@veloceapps/sdk/core';
 import lodash from 'lodash';
 import * as rxjs from 'rxjs';
 import * as rxjsOperators from 'rxjs/operators';
@@ -12,98 +13,56 @@ import * as cmsActions from './cms.actions';
 import { ResourcesService } from './services/resources.service';
 import { TemplatesService } from './services/templates.service';
 export declare const vendorMap: {
-    '@angular/core': typeof angularCore;
-    '@angular/forms': typeof angularForms;
-    '@angular/cdk/collections': {
-        DataSource: typeof DataSource;
-    };
-    rxjs: typeof rxjs;
-    'rxjs/operators': typeof rxjsOperators;
-    lodash: lodash.LoDashStatic;
     '@veloceapps/core': {
         isDefined: <T>(value: T) => value is Exclude<T, null | undefined>;
         Operator: typeof Operator;
         Predicate: typeof Predicate;
         parseJsonSafely: typeof parseJsonSafely;
-        ConfigurationContextMode: typeof ConfigurationContextMode;
         parseJwt: typeof parseJwt;
+        TokenInfoService: typeof TokenInfoService;
+        UITemplateType: typeof UITemplateType;
     };
     '@veloceapps/components': {
         ToastService: typeof ToastService;
         ToastType: typeof ToastType;
     };
     '@veloceapps/api': {
-        SalesforceApiService: typeof SalesforceApiService;
-        QuoteApiService: typeof QuoteApiService;
-        DocumentAttachmentApiService: typeof DocumentAttachmentApiService;
-        RampApiService: typeof RampApiService;
+        ContractedPriceApiService: typeof ContractedPriceApiService;
+    };
+    '@veloceapps/api/v2': {
         CatalogApiService: typeof CatalogApiService;
-        DeltaApiService: typeof DeltaApiService;
-        PicklistsApiService: typeof PicklistsApiService;
-        PriceApiService: typeof PriceApiService;
-        ShoppingCartSettingsApiService: typeof ShoppingCartSettingsApiService;
         ConfigurationSettingsApiService: typeof ConfigurationSettingsApiService;
+        DocumentAttachmentApiService: typeof DocumentAttachmentApiService;
         GuidedSellingApiService: typeof GuidedSellingApiService;
-        ContractedPriceApiService: typeof ContractedPriceApiService;
+        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;
-        ContextService: typeof ContextService;
         RuntimeSettingsService: typeof RuntimeSettingsService;
         ActionCodePipe: typeof ActionCodePipe;
         DatePipe: typeof DatePipe;
         NumberPipe: typeof NumberPipe;
         PricePipe: typeof PricePipe;
+        SalesTransactionService: typeof SalesTransactionService;
     };
     '@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;
-        ConfigureProductAction: ({ lineItemId, productId, }: {
-            lineItemId?: string | undefined;
-            productId?: string | undefined;
-        }) => import("@veloceapps/sdk/core").IntegrationAction<any>;
-        NavigateBackAction: () => import("@veloceapps/sdk/core").IntegrationAction<any>;
-        NavigateToCatalogAction: () => import("@veloceapps/sdk/core").IntegrationAction<any>;
-        ApplyProductConfigurationAction: () => import("@veloceapps/sdk/core").IntegrationAction<any>;
-        RemoteApplyAction: () => import("@veloceapps/sdk/core").IntegrationAction<any>;
-        RemoteCancelAction: () => import("@veloceapps/sdk/core").IntegrationAction<any>;
-        SwitchObjectAction: (payload: {
-            id: string;
-        }) => import("@veloceapps/sdk/core").IntegrationAction<any>;
         CmsAction: typeof cmsActions.CmsAction;
         DEFAULT_PLUGINS_TOKEN: angularCore.InjectionToken<typeof import("./engine/models/plugin").Plugin[]>;
         UI_DEFINITION_METADATA: angularCore.InjectionToken<import("@veloceapps/core").UIDefinitionMetadata>;
@@ -111,5 +70,13 @@ export declare const vendorMap: {
         SHARED_ELEMENT_METADATA: angularCore.InjectionToken<import("@veloceapps/sdk/cms").ElementMetadata | undefined>;
         ELEMENT_CONFIG: angularCore.InjectionToken<import("@veloceapps/sdk/cms").ElementConfig>;
     };
+    '@angular/core': typeof angularCore;
+    '@angular/forms': typeof angularForms;
+    '@angular/cdk/collections': {
+        DataSource: typeof DataSource;
+    };
+    rxjs: typeof rxjs;
+    'rxjs/operators': typeof rxjsOperators;
+    lodash: lodash.LoDashStatic;
 };
 export type VendorMap = typeof vendorMap;

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,28 +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 { ContextService } from '../../../services';
-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 contextService;
-    private runtimeContextService;
-    private _runtimeContext?;
-    private _isInitialized;
+    private pcmApiService;
+    uiDefinitionContainer: UIDefinitionContainer | null;
     initializationProps?: RuntimeInitializationProps;
-    uiDefinitionProperties: UIDefinitionProps;
-    constructor(apiService: ConfigurationApiService, contextService: ContextService, 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,8 +1,9 @@
-import { FlowStateApiService, QuoteApiService, SaveQuoteResponse } from '@veloceapps/api';
+import { FlowStateApiService } from '@veloceapps/api';
+import { SalesTransactionApiService, SalesTransactionUpsertResponse } from '@veloceapps/api/v2';
 import { ToastService } from '@veloceapps/components';
 import { FlowStateExecutionRequest, FlowStateExecutionResult, FlowStateSelectorResponse } from '@veloceapps/core';
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
-import { FlowInfoService, FlowStateService, QuoteDraftService } from '../../../services';
+import { FlowInfoService, FlowStateService, SalesTransactionService } from '../../../services';
 import { FlowStateSubscriptionOptions } from '../../../types/flow-state.types';
 import { FlowConfigurationService } from '../../flow-configuration';
 import { ConfigurationRuntimeService } from './configuration-runtime.service';
@@ -11,13 +12,13 @@ import * as i0 from "@angular/core";
 export declare class ConfigurationStateService {
     private configurationRuntimeService;
     private configurationService;
-    private quoteDraftService;
-    private toastService;
     private flowStateService;
     private flowInfoService;
     private flowConfigurationService;
     private flowStateApiService;
-    private quoteApiService;
+    private salesTransactionService;
+    private salesTransactionApiService;
+    private toastService;
     isInitialized$: BehaviorSubject<boolean>;
     canceledConfiguration$: Subject<void>;
     private readonly NOT_INITIALIZED;
@@ -31,7 +32,7 @@ export declare class ConfigurationStateService {
     private statefulRequestStream$;
     private statefulExecutionRequest$;
     private statelessExecutionRequest$;
-    constructor(configurationRuntimeService: ConfigurationRuntimeService, configurationService: ConfigurationService, quoteDraftService: QuoteDraftService, toastService: ToastService, flowStateService: FlowStateService, flowInfoService: FlowInfoService, flowConfigurationService: FlowConfigurationService, flowStateApiService: FlowStateApiService, quoteApiService: QuoteApiService);
+    constructor(configurationRuntimeService: ConfigurationRuntimeService, configurationService: ConfigurationService, flowStateService: FlowStateService, flowInfoService: FlowInfoService, flowConfigurationService: FlowConfigurationService, flowStateApiService: FlowStateApiService, salesTransactionService: SalesTransactionService, salesTransactionApiService: SalesTransactionApiService, toastService: ToastService);
     get isExecutionInProgress$(): Observable<boolean>;
     init$(): Observable<void>;
     cleanup(): void;
@@ -39,15 +40,10 @@ export declare class ConfigurationStateService {
     dispatch$(actionName: string, inputData?: unknown): Observable<FlowStateExecutionResult>;
     select$<Response = unknown>(selectorName: string, inputData?: unknown): Observable<FlowStateSelectorResponse<Response>>;
     subscribe$<Response = unknown>(selectorName: string, inputData?: unknown, options?: FlowStateSubscriptionOptions): Observable<FlowStateSelectorResponse<Response>>;
-    saveConfiguration(flow?: boolean): Observable<SaveQuoteResponse>;
-    /**
-     * @deprecated Will be removed in @veloceapps/sdk@9
-     */
-    saveConfiguration(quoteId?: string, flow?: boolean): Observable<SaveQuoteResponse>;
+    saveConfiguration(): Observable<SalesTransactionUpsertResponse>;
     cancelConfiguration(): Observable<void>;
     private get isStatefulConfiguration();
     private initStateful$;
-    private initStateless$;
     private execToRequest;
     private handleSelectorsResponse;
     private executeRequest$;