@veloceapps/sdk 11.0.0-16 → 11.0.0-17

package/cms/cms.actions.d.ts

@@ -1,5 +1,4 @@
 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,30 +15,80 @@ 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, }: {
+        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;
+    }) => {
+        type: string;
+        payload: {
+            transactionItemId: string | undefined;
+            productId: string | 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";
@@ -53,37 +102,64 @@ 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;
+    const UpdateCustomization: (value: any) => {
+        type: string;
+        payload: {
+            value: any;
+        };
+    };
     /**
      * Emit customization page changes
      *
      * @param changes - object with customization page changes
      */
-    const EmitCustomizationChanges: (changes: CustomizationChanges) => IntegrationAction;
+    const EmitCustomizationChanges: (changes: CustomizationChanges) => {
+        type: string;
+        payload: {
+            changes: CustomizationChanges;
+        };
+    };
     /**
      * 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/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

@@ -5,7 +5,7 @@ import { CatalogApiService, ConfigurationSettingsApiService, ContractedPriceApiS
 import { SalesTransactionApiService } 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 { ActionCodePipe, ConfigurationService, ConfigurationStateService, DatePipe, FlowConfigurationService, 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';
@@ -42,49 +42,26 @@ export declare const vendorMap: {
         SalesTransactionApiService: typeof SalesTransactionApiService;
     };
     '@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;
         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;
     };
     '@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

@@ -5,4 +5,3 @@ 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,3 @@
-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';

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

@@ -1,26 +1,9 @@
-import { ConfigurationApiService } from '@veloceapps/api';
-import { RuntimeModel, 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 { UIDefinitionContainer, UIDefinitionProps } from '@veloceapps/core';
 import * as i0 from "@angular/core";
 export declare class ConfigurationRuntimeService {
-    private apiService;
-    private runtimeContextService;
-    private _runtimeContext?;
-    private _isInitialized;
-    initializationProps?: RuntimeInitializationProps;
-    uiDefinitionProperties: UIDefinitionProps;
-    constructor(apiService: ConfigurationApiService, runtimeContextService: RuntimeContextService);
+    uiDefinitionContainer: UIDefinitionContainer | null;
+    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;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationRuntimeService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationRuntimeService>;
 }

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

@@ -12,13 +12,13 @@ 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;
     isInitialized$: BehaviorSubject<boolean>;
     canceledConfiguration$: Subject<void>;
     private readonly NOT_INITIALIZED;
@@ -32,7 +32,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);
     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 { ProceduresApiService } from '@veloceapps/api/v2';
+import { SalesTransaction, SalesTransactionItem } 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 { FlowInfoService, SalesTransactionService } from '../../../services';
 import { ExternalConfigurationProps, GuidedSellingSubmitData } from '../types/configuration.types';
 import { ConfigurationRuntimeService } from './configuration-runtime.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 proceduresApiService;
     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$;
+    get state$(): Observable<SalesTransaction>;
+    get state(): SalesTransaction | null;
+    get previousState(): SalesTransaction | null;
+    get asset(): SalesTransactionItem | null;
+    get root$(): Observable<SalesTransactionItem>;
+    get root(): SalesTransactionItem | null;
+    constructor(flowInfoService: FlowInfoService, messageService: MessageService, configurationRuntimeService: ConfigurationRuntimeService, salesTransactionService: SalesTransactionService, proceduresApiService: ProceduresApiService);
     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;
+    configureRequest$(salesTransaction: SalesTransaction): Observable<SalesTransaction>;
+    configureExternal$(props: ExternalConfigurationProps): Observable<SalesTransaction>;
+    configureGuidedSelling$(data: GuidedSellingSubmitData): Observable<SalesTransaction>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationService>;
 }

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

@@ -1,4 +1 @@
-export * from './flow-configuration.module';
 export * from './services/flow-configuration.service';
-export * from './services/flow-update.service';
-export * from './types/update.types';

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

@@ -1,28 +1,20 @@
 import { ProceduresApiService } from '@veloceapps/api/v2';
-import { SalesTransaction, SalesTransactionItem } from '@veloceapps/core';
+import { SalesTransaction } from '@veloceapps/core';
 import { Observable } from 'rxjs';
-import { FlowInfoService, SalesTransactionService } from '../../../services';
-import { ExternalConfigurationProps } from '../../configuration';
-import { ConfigurationService } from '../../configuration/services/configuration.service';
-import { FlowUpdateService } from './flow-update.service';
+import { SalesTransactionService } from '../../../services/sales-transaction.service';
 import * as i0 from "@angular/core";
 export declare class FlowConfigurationService {
     private proceduresApiService;
     private salesTransactionService;
-    private updateService;
-    private configurationService;
-    private flowInfoService;
     updated$: Observable<void>;
     private updatedSubj$;
-    constructor(proceduresApiService: ProceduresApiService, salesTransactionService: SalesTransactionService, updateService: FlowUpdateService, configurationService: ConfigurationService, flowInfoService: FlowInfoService);
+    constructor(proceduresApiService: ProceduresApiService, salesTransactionService: SalesTransactionService);
     calculate$(state: SalesTransaction): Observable<void>;
     calculate(state: SalesTransaction): void;
-    revert$(lineItemId: string): Observable<SalesTransaction | null>;
-    revert(lineItemId: string): void;
+    revert$(transactionItemId: string): Observable<SalesTransaction | null>;
+    revert(transactionItemId: string): void;
     delete$(ids: string[]): Observable<SalesTransaction | null>;
     delete(ids: string[]): void;
-    addTerm$(term: SalesTransactionItem): Observable<SalesTransaction | null>;
-    addToCart$(props: ExternalConfigurationProps): Observable<SalesTransaction | null>;
     private handleErrorAndBounceBack;
     static ɵfac: i0.ɵɵFactoryDeclaration<FlowConfigurationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FlowConfigurationService>;

package/core/services/flow-info.service.d.ts

@@ -2,7 +2,7 @@ import { Params } from '@angular/router';
 import { UITemplatesApiService } from '@veloceapps/api/v2';
 import { Flow, FlowContext, UITemplate, UITemplateType } from '@veloceapps/core';
 import { Observable } from 'rxjs';
-import { FlowCustomization } from '../types';
+import { FlowCustomization } from '../types/flow-customization.types';
 import { RuntimeSettingsService } from './runtime-settings.service';
 import * as i0 from "@angular/core";
 export declare class FlowInfoService {
@@ -31,8 +31,9 @@ export declare class FlowInfoService {
     private templatesSubj$;
     private contextSubj$;
     constructor(runtimeSettingsService: RuntimeSettingsService, templatesApiService: UITemplatesApiService, customizationService?: FlowCustomization | undefined);
-    cleanup(): void;
+    reset(): void;
     init$(flowId: string, routeQueryParams: Params): Observable<void>;
+    updateContext(update: Partial<FlowContext>): void;
     private initFlow$;
     private initFlowTemplates$;
     private remapTemplateName;

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

@@ -1,18 +1,12 @@
-import { FlowStateApiService } from '@veloceapps/api';
 import { Observable } from 'rxjs';
-import { NewConfigurationProps } from '../modules/configuration';
-import { FlowConfigurationService } from '../modules/flow-configuration';
+import { NewConfigurationProps } from '../modules/configuration/types/configuration.types';
 import { FlowInfoService } from './flow-info.service';
 import { FlowStateService } from './flow-state.service';
 import * as i0 from "@angular/core";
 export declare class FlowStateConfigurationService {
     private flowInfoService;
-    private flowConfigurationService;
-    private flowStateApiService;
     private flowStateService;
-    private configurationStateId$;
-    constructor(flowInfoService: FlowInfoService, flowConfigurationService: FlowConfigurationService, flowStateApiService: FlowStateApiService, flowStateService: FlowStateService);
-    get configurationStateId(): string | null;
+    constructor(flowInfoService: FlowInfoService, flowStateService: FlowStateService);
     addToCart$(props: NewConfigurationProps): Observable<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FlowStateConfigurationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FlowStateConfigurationService>;

package/core/services/flow-state.service.d.ts

@@ -1,8 +1,7 @@
 import { FlowStateApiService } from '@veloceapps/api';
 import { ConfigurationProcessorsApiService, SalesTransactionApiService } from '@veloceapps/api/v2';
 import { ToastService } from '@veloceapps/components';
-import { Charge, CompiledPricePlan, FlowStateExecutionRequest, FlowStateExecutionRequestDTO, FlowStateExecutionResult, FlowStateSelectorResponse, MetricRule, UITemplateType } from '@veloceapps/core';
-import { Dictionary } from 'lodash';
+import { FlowStateExecutionRequest, FlowStateExecutionRequestDTO, FlowStateExecutionResult, FlowStateSelectorResponse, UITemplateType } from '@veloceapps/core';
 import { Observable } from 'rxjs';
 import { FlowConfigurationService } from '../modules';
 import { FlowCustomization } from '../types/flow-customization.types';
@@ -11,18 +10,14 @@ import { FlowInfoService } from './flow-info.service';
 import { SalesTransactionService } from './sales-transaction.service';
 import * as i0 from "@angular/core";
 export declare class FlowStateService {
-    private salesTransactionService;
-    private flowInfoService;
     private flowConfiguration;
-    private processorsApiService;
+    private flowInfoService;
     private flowStateApiService;
+    private processorsApiService;
     private salesTransactionApiService;
+    private salesTransactionService;
     private toastService;
     private customizationService?;
-    charges$: Observable<Dictionary<Charge>>;
-    pricePlans$: Observable<Dictionary<CompiledPricePlan>>;
-    activeMetrics$: Observable<MetricRule[]>;
-    isPriceListLocked$: Observable<boolean>;
     private readonly NOT_INITIALIZED;
     private readonly EXECUTION_BUFFER_TIME;
     private executedFunctions;
@@ -36,9 +31,9 @@ export declare class FlowStateService {
     private statefulRequestStream$;
     private statefulExecutionRequest$;
     private cleanup$;
-    constructor(salesTransactionService: SalesTransactionService, flowInfoService: FlowInfoService, flowConfiguration: FlowConfigurationService, processorsApiService: ConfigurationProcessorsApiService, flowStateApiService: FlowStateApiService, salesTransactionApiService: SalesTransactionApiService, toastService: ToastService, customizationService?: FlowCustomization | undefined);
+    constructor(flowConfiguration: FlowConfigurationService, flowInfoService: FlowInfoService, flowStateApiService: FlowStateApiService, processorsApiService: ConfigurationProcessorsApiService, salesTransactionApiService: SalesTransactionApiService, salesTransactionService: SalesTransactionService, toastService: ToastService, customizationService?: FlowCustomization | undefined);
     init$(): Observable<void>;
-    cleanup(): void;
+    reset(): void;
     get hasUnsavedChanges(): boolean;
     get stateId(): string | null;
     get isExecutionInProgress$(): Observable<boolean>;
@@ -67,7 +62,6 @@ export declare class FlowStateService {
     private executeStateless$;
     private executeStatelessActions;
     private executeStatelessSelectors;
-    private getFlowSafe;
     private initProcessors$;
     private executeActionScript;
     private executeSelectorScript;

package/core/services/index.d.ts

@@ -3,6 +3,5 @@ export * from './flow-state-configuration.service';
 export * from './flow-state.service';
 export * from './integration.state';
 export * from './product-images.service';
-export * from './quote-draft.service';
 export * from './runtime-settings.service';
 export * from './sales-transaction.service';

package/core/services/integration.state.d.ts

@@ -10,7 +10,7 @@ export declare class IntegrationState<S = IntegrationStateModel> {
     dispatch(action: IntegrationAction): void;
     listen$<P = any>(actionType: string): Observable<P>;
     listenAll$<T extends IntegrationAction>(): Observable<T>;
-    clear(): void;
+    reset(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<IntegrationState<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<IntegrationState<any>>;
 }

package/core/services/sales-transaction.service.d.ts

@@ -9,7 +9,7 @@ export declare class SalesTransactionService {
     private stateSubj$;
     private isInitializedSubj$;
     private hasUnsavedChangesSubj$;
-    private initialCurrentState;
+    private initialState;
     hasUnsavedChanges$: Observable<boolean>;
     state$: Observable<SalesTransaction>;
     get isInitialized$(): Observable<boolean>;
@@ -17,11 +17,13 @@ export declare class SalesTransactionService {
     set hasUnsavedChanges(value: boolean);
     get hasUnsavedChanges(): boolean;
     get state(): SalesTransaction | null;
+    get hasAssets(): boolean;
+    get hasProducts(): boolean;
     constructor(flowInfoService: FlowInfoService, salesTransactionApiService: SalesTransactionApiService);
     init(headerId: string, params: Record<string, string>): Observable<SalesTransaction>;
     finalizeInit(): void;
     reset(): void;
-    getInitialCurrentState(): SalesTransactionItem[];
+    getInitialState(): SalesTransactionItem[];
     setState(state: SalesTransaction): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SalesTransactionService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SalesTransactionService>;