@veloceapps/sdk 8.0.0-99 → 9.0.0-1

package/cms/README.md

@@ -2,26 +2,6 @@
 
 [← Back to SDK](../)
 
-## IntegrationState
-
-An application state, which helps to cover cross-component communication. Contains reactive store and event system.
-
-`get state$(): Observable<S>`
-
-`get state(): S`
-
-`patchState(update: Partial<S>): void`
-
-`dispatch(action: IntegrationAction): void`
-
-`listen$<P = any>(actionType: string): Observable<P>`
-
-`listenAll$<T extends IntegrationAction>(): Observable<T>`
-
-`clear(): void`
-
-**Important!** Don't overuse it, otherwise application can become messy and hardly supportable.
-
 ## ResourcesService
 
 A service provides an ability to load scripts and styles from external resources.

package/cms/cms.actions.d.ts

@@ -1,4 +1,5 @@
-import { IntegrationAction } from './types';
+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";
@@ -95,6 +96,7 @@ export declare const SwitchObjectAction: (payload: {
 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";
@@ -110,6 +112,12 @@ export declare namespace CmsAction {
      * @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;
     /**
      * Show an Overlay on the selected page
      *

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

@@ -1,10 +1,9 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import { ToastService } from '@veloceapps/components';
 import { UIDefinition } from '@veloceapps/core';
-import { ConfigurationState } from '@veloceapps/sdk/core';
+import { ConfigurationStateService, IntegrationState } from '@veloceapps/sdk/core';
 import { BehaviorSubject, Observable } from 'rxjs';
 import { RuntimeService } from '../../modules/runtime/services/runtime.service';
-import { IntegrationState } from '../../services';
 import { ElementMetadata } from '../../types/common.types';
 import { CMSPreviewConfig } from './preview.types';
 import * as i0 from "@angular/core";
@@ -22,7 +21,7 @@ export declare class PreviewComponent implements OnInit, OnDestroy {
     state$: BehaviorSubject<State>;
     elements$: Observable<ElementMetadata[]>;
     private destroy$;
-    constructor(runtimeService: RuntimeService, configurationState: ConfigurationState, toastService: ToastService, integrationState: IntegrationState);
+    constructor(runtimeService: RuntimeService, configurationState: ConfigurationStateService, toastService: ToastService, integrationState: IntegrationState);
     ngOnInit(): void;
     ngOnDestroy(): void;
     trackBy(_: number, el: ElementMetadata): ElementMetadata;

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

@@ -13,6 +13,10 @@ 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/index.d.ts

@@ -1,3 +1,4 @@
+export { IntegrationAction, IntegrationState, IntegrationStateModel } from '@veloceapps/sdk/core';
 export * from './cms.actions';
 export * from './cms.layouts';
 export * from './components';

package/cms/modules/runtime/services/runtime.service.d.ts

@@ -1,10 +1,10 @@
 import { Injector, NgModule, NgModuleRef, Type } from '@angular/core';
 import { UIDefinition } from '@veloceapps/core';
+import { IntegrationState } from '@veloceapps/sdk/core';
 import { Patch } from 'rfc6902';
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
 import { CMSPreviewConfig } from '../../../components/preview/preview.types';
 import { Entity } from '../../../engine/models/entity';
-import { IntegrationState } from '../../../services/integration.state';
 import { ElementMetadata } from '../../../types';
 import * as i0 from "@angular/core";
 export declare class RuntimeService {

package/cms/services/index.d.ts

@@ -1,3 +1,2 @@
-export * from './integration.state';
 export * from './resources.service';
 export * from './templates.service';

package/cms/services/resources.service.d.ts

@@ -1,4 +1,5 @@
 import { Observable } from 'rxjs';
+import { ScriptHost } from '../types';
 import * as i0 from "@angular/core";
 export declare class ResourcesService {
     private scripts;
@@ -12,6 +13,7 @@ export declare class ResourcesService {
     private amd;
     loadScript(url: string): Observable<void>;
     loadStyles(url: string): Observable<void>;
+    loadStyles(host: ScriptHost, url: string): Observable<void>;
     private persistAMDLoader;
     private restoreAMDLoader;
     static ɵfac: i0.ɵɵFactoryDeclaration<ResourcesService, never>;

package/cms/types/index.d.ts

@@ -2,7 +2,6 @@ export * from '../modules/runtime/types/compilation.types';
 export * from './common.types';
 export * from './configuration.types';
 export * from './elements.types';
-export * from './integration.types';
 export * from './layouts.types';
 export * from './pages.types';
 export * from './path.types';

package/cms/utils/element-metadata-worker.d.ts

@@ -0,0 +1,11 @@
+import { UIElement } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { ElementMetadata } from '../types/common.types';
+export declare class ElementMetadataWorker {
+    private elements;
+    constructor(elements: UIElement[]);
+    get$(): Observable<ElementMetadata[]>;
+    private processAsync;
+    private processLevelAsync;
+    private elementToMetadataAsync;
+}

package/cms/utils/elements-resolver.d.ts

@@ -13,8 +13,6 @@ export declare class ElementsResolver {
     constructor(uiDef: UIDefinitionMetadata, elements: ElementMetadata[], sharedElements?: ElementMetadata[], config?: CMSPreviewConfig | undefined);
     addElement(element: ElementMetadata): void;
     getNgComponents(): Record<string, Type<Entity>>;
-    private transpile;
-    private transpileScripts;
     private flattenElements;
     private isSharedElement;
     private getRenderableElements;

package/cms/utils/index.d.ts

@@ -1,5 +1,8 @@
+export * from './element-metadata-worker';
 export * from './element.utils';
 export * from './elements-resolver';
+export * from './encoding.utils';
 export * from './path.utils';
+export * from './transpilation-worker';
 export * from './ui-builder-layout.utils';
 export * from './ui-definition.utils';

package/cms/utils/transpilation-worker.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { ElementMetadata } from '../types/common.types';
+export declare class TranspilationWorker {
+    private elements;
+    constructor(elements: ElementMetadata[]);
+    get$(): Observable<ElementMetadata[]>;
+    get(): ElementMetadata[];
+    private transpileScripts;
+    private transpileScriptsAsync;
+    private processLevelAsync;
+    private transpileMetadataAsync;
+    private transpile;
+}

package/cms/vendor-map.d.ts

@@ -1,19 +1,22 @@
 import * as angularCore from '@angular/core';
 import * as angularForms from '@angular/forms';
+import { DataSource } from '@angular/cdk/collections';
 import { CatalogApiService, ConfigurationSettingsApiService, ContractedPriceApiService, DeltaApiService, DocumentAttachmentApiService, DocumentTemplatesApiService, GuidedSellingApiService, PicklistsApiService, PriceApiService, QuoteApiService, RampApiService, SalesforceApiService, ShoppingCartSettingsApiService } from '@veloceapps/api';
 import { ToastService, ToastType } from '@veloceapps/components';
 import { ConfigurationContextMode, Operator, parseJsonSafely, Predicate } from '@veloceapps/core';
-import { ActionCodePipe, ConfigurationService, ConfigurationState, ContextService, DatePipe, FlowConfigurationService, LineItemWorker, MetricsCalculationService, NumberPipe, PricePipe, ProductImagesService, QuoteDraftService, RuntimeSettingsService } from '@veloceapps/sdk/core';
+import { ActionCodePipe, ConfigurationService, ConfigurationStateService, ContextService, DatePipe, FlowConfigurationService, FlowStateConfigurationService, FlowStateService, IntegrationState, LineItemWorker, NumberPipe, PricePipe, ProductImagesService, QuoteDraftService, RuntimeSettingsService } from '@veloceapps/sdk/core';
 import lodash from 'lodash';
 import * as rxjs from 'rxjs';
 import * as rxjsOperators from 'rxjs/operators';
 import * as cmsActions from './cms.actions';
-import { IntegrationState } from './services/integration.state';
 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;
@@ -49,7 +52,6 @@ export declare const vendorMap: {
         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;
-        calculateCardinalityVariables: (lineItems: import("@veloceapps/core").LineItem[]) => Map<string, number>;
         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[];
@@ -61,23 +63,24 @@ export declare const vendorMap: {
             net: number;
             list: number;
         };
-        generateModifiedAssetsMap: (lineItems: import("@veloceapps/core").LineItem[]) => Record<string, boolean>;
         getOriginParent: (lineItems: import("@veloceapps/core").LineItem[], currentLineItem: import("@veloceapps/core").LineItem) => import("@veloceapps/core").LineItem | undefined;
-        isLineItemModified: <T_1 extends Pick<import("@veloceapps/core").LineItem, "actionCode" | "status">>(lineItem: T_1) => boolean;
+        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_2 extends {
+        filterOutTechnicalAttributes: <T_1 extends {
             name: string;
-        }>(attributes: T_2[]) => T_2[];
+        }>(attributes: T_1[]) => T_1[];
         ConfigurationService: typeof ConfigurationService;
-        ConfigurationState: typeof ConfigurationState;
+        ConfigurationStateService: typeof ConfigurationStateService;
         QuoteDraftService: typeof QuoteDraftService;
         FlowConfigurationService: typeof FlowConfigurationService;
+        IntegrationState: typeof IntegrationState;
+        FlowStateService: typeof FlowStateService;
+        FlowStateConfigurationService: typeof FlowStateConfigurationService;
         LineItemWorker: typeof LineItemWorker;
         ProductImagesService: typeof ProductImagesService;
         ContextService: typeof ContextService;
         RuntimeSettingsService: typeof RuntimeSettingsService;
-        MetricsCalculationService: typeof MetricsCalculationService;
         ActionCodePipe: typeof ActionCodePipe;
         DatePipe: typeof DatePipe;
         NumberPipe: typeof NumberPipe;
@@ -91,17 +94,17 @@ export declare const vendorMap: {
         ConfigureProductAction: ({ lineItemId, productId, }: {
             lineItemId?: string | undefined;
             productId?: string | undefined;
-        }) => import("@veloceapps/sdk/cms").IntegrationAction<any>;
-        NavigateBackAction: () => import("@veloceapps/sdk/cms").IntegrationAction<any>;
-        NavigateToCatalogAction: () => import("@veloceapps/sdk/cms").IntegrationAction<any>;
-        ApplyProductConfigurationAction: () => import("@veloceapps/sdk/cms").IntegrationAction<any>;
-        OpenDocGenAction: () => import("@veloceapps/sdk/cms").IntegrationAction<any>;
-        CloseDocGenAction: () => import("@veloceapps/sdk/cms").IntegrationAction<any>;
-        RemoteApplyAction: () => import("@veloceapps/sdk/cms").IntegrationAction<any>;
-        RemoteCancelAction: () => import("@veloceapps/sdk/cms").IntegrationAction<any>;
+        }) => 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>;
+        OpenDocGenAction: () => import("@veloceapps/sdk/core").IntegrationAction<any>;
+        CloseDocGenAction: () => 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/cms").IntegrationAction<any>;
+        }) => 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>;

package/core/README.md

@@ -3,3 +3,23 @@
 [← Back to SDK](../)
 
 The place where configuration logic lives: services, utils, workers etc
+
+## IntegrationState
+
+An application state, which helps to cover cross-component communication. Contains reactive store and event system.
+
+`get state$(): Observable<S>`
+
+`get state(): S`
+
+`patchState(update: Partial<S>): void`
+
+`dispatch(action: IntegrationAction): void`
+
+`listen$<P = any>(actionType: string): Observable<P>`
+
+`listenAll$<T extends IntegrationAction>(): Observable<T>`
+
+`clear(): void`
+
+**Important!** Don't overuse it, otherwise application can become messy and hardly supportable.

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

@@ -1,7 +1,8 @@
 import * as i0 from "@angular/core";
 import * as i1 from "@veloceapps/components";
+import * as i2 from "@veloceapps/api";
 export declare class ConfigurationModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationModule, never, [typeof i1.ConfirmationDialogModule], never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationModule, never, [typeof i1.ConfirmationDialogModule, typeof i2.ApiModule], never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ConfigurationModule>;
 }

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

@@ -1,5 +1,6 @@
 import { ConfigurationContext, ConfigurationRequest, LineItem, UIDefinitionProps } from '@veloceapps/core';
 import { RuntimeContext } from '../../types';
-import { GuidedSellingSubmitData } from './types/configuration.types';
+import { GuidedSellingSubmitData, NewConfigurationProps } from './types/configuration.types';
 export declare const getDefaultLineItem: (context: RuntimeContext, uiDefinitionProperties: UIDefinitionProps, qty?: number) => LineItem;
 export declare const getGuidedSellingConfigurationRequest: (data: GuidedSellingSubmitData, context: ConfigurationContext) => ConfigurationRequest;
+export declare const generateConfigurationLineItem: (props: NewConfigurationProps, qty?: number) => LineItem;

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';
+export * from './services/configuration-state.service';
 export * from './types/configuration-runtime.types';
 export * from './types/configuration.types';

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

@@ -0,0 +1,54 @@
+import { FlowStateApiService, QuoteApiService, SaveQuoteResponse } from '@veloceapps/api';
+import { ToastService } from '@veloceapps/components';
+import { FlowStateExecutionRequestDTO, FlowStateExecutionResult, FlowStateSelectorResponse } from '@veloceapps/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { FlowInfoService, FlowStateService, QuoteDraftService } from '../../../services';
+import { FlowStateSubscriptionOptions } from '../../../types/flow-state.types';
+import { FlowConfigurationService } from '../../flow-configuration';
+import { ConfigurationRuntimeService } from './configuration-runtime.service';
+import { ConfigurationService } from './configuration.service';
+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;
+    isInitialized$: BehaviorSubject<boolean>;
+    canceledConfiguration$: Subject<void>;
+    private readonly NOT_INITIALIZED;
+    private readonly EXECUTION_BUFFER_TIME;
+    private executedFunctions;
+    private stateId;
+    private ownerId;
+    private subscriptions;
+    private configurationStore;
+    private statefulExecutionInProgress$;
+    private statefulRequestStream$;
+    private statefulExecutionRequest$;
+    constructor(configurationRuntimeService: ConfigurationRuntimeService, configurationService: ConfigurationService, quoteDraftService: QuoteDraftService, toastService: ToastService, flowStateService: FlowStateService, flowInfoService: FlowInfoService, flowConfigurationService: FlowConfigurationService, flowStateApiService: FlowStateApiService, quoteApiService: QuoteApiService);
+    init$(): Observable<void>;
+    cleanup(): void;
+    execute$(req: FlowStateExecutionRequestDTO, forceSubscriptions?: boolean): Observable<FlowStateExecutionResult>;
+    private handleSelectorsResponse;
+    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(quoteId?: string, flow?: boolean): Observable<SaveQuoteResponse>;
+    cancelConfiguration(): Observable<void>;
+    private get isStatefulConfiguration();
+    private initStateful$;
+    private initStateless$;
+    private executeStateless$;
+    private initBufferedRequest$;
+    private executeStateful$;
+    private executeActionScript;
+    private executeSelectorScript;
+    private executeProcessorScript;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationStateService>;
+}

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

@@ -21,10 +21,7 @@ export declare class ConfigurationService {
     private runtimeSettings;
     private mode;
     private configurableRamp;
-    private lineItem;
-    private charges;
-    private pricePlans;
-    private procedureContext;
+    private configurationState;
     private isLoadingSubj$;
     isLoading$: Observable<boolean>;
     hasUnsavedChanges: boolean;
@@ -37,6 +34,8 @@ export declare class ConfigurationService {
     getSnapshot(): LineItem | undefined;
     getRuntimeModel(): RuntimeModel;
     getRuntimeContext(): RuntimeContext;
+    get state$(): Observable<ConfigurePrice | null>;
+    get stateSnapshot(): ConfigurePrice | null;
     get contextSnapshot(): ConfigurationContext;
     get context$(): Observable<ConfigurationContext>;
     get charges$(): Observable<Dictionary<Charge>>;
@@ -49,10 +48,11 @@ export declare class ConfigurationService {
     configureRequest$(configurationRequest: ConfigurationRequest): Observable<LineItem>;
     configureExternal$(props: ExternalConfigurationProps): Observable<LineItem>;
     configureGuidedSelling$(data: GuidedSellingSubmitData): Observable<ConfigurePrice>;
-    generateRequest(): ConfigurationRequest;
+    generateRequest(lightMode?: boolean): ConfigurationRequest;
+    generateLineItem(): LineItem;
+    getAsset(): LineItem | undefined;
     private getUIDefinitionProperties;
     private showInactiveProductsConfirmation;
-    private getAsset;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationService>;
 }

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

@@ -1,3 +1,4 @@
+import { Product } from '@veloceapps/core';
 export interface GuidedSellingSubmitData {
     modelId: string;
     modelType: string;
@@ -8,3 +9,6 @@ export interface ExternalConfigurationProps {
     qty?: number;
     attributesMap?: Record<string, any>;
 }
+export interface NewConfigurationProps extends ExternalConfigurationProps {
+    product: Product;
+}

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

@@ -1,6 +1,7 @@
 import * as i0 from "@angular/core";
+import * as i1 from "@veloceapps/api";
 export declare class FlowConfigurationModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<FlowConfigurationModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowConfigurationModule, never, never, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowConfigurationModule, never, [typeof i1.ApiModule], never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<FlowConfigurationModule>;
 }

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

@@ -15,6 +15,11 @@ export declare class FlowConfigurationService {
     private quoteDraftService;
     private updateService;
     private configurationService;
+    /**
+     * An event being fired when QuoteDraft was updated
+     */
+    updated$: Observable<void>;
+    private updatedSubj$;
     constructor(proceduresApiService: ProceduresApiService, contextService: ContextService, quoteDraftService: QuoteDraftService, updateService: FlowUpdateService, configurationService: ConfigurationService);
     calculate$(quoteDraft: QuoteDraft): Observable<void>;
     calculate(quoteDraft: QuoteDraft): void;

package/core/services/context.service.d.ts

@@ -9,6 +9,8 @@ export declare class ContextService {
     get isInitialized(): boolean;
     get isInitialized$(): Observable<boolean>;
     get mode(): ConfigurationContextMode | undefined;
+    get isEditMode$(): Observable<boolean>;
+    get isEditMode(): boolean;
     resolve(): ConfigurationContext;
     resolve$(): Observable<ConfigurationContext>;
     create(headerId: string, mode: ConfigurationContextMode): Observable<ConfigurationContext>;

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

@@ -0,0 +1,29 @@
+import { Params } from '@angular/router';
+import { FlowsApiService, UITemplatesApiService } from '@veloceapps/api';
+import { Flow, UITemplate, UITemplateType } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { FlowCustomization } from '../types';
+import * as i0 from "@angular/core";
+export declare class FlowInfoService {
+    private flowsApiService;
+    private templatesApiService;
+    private customizationService?;
+    flow$: Observable<Flow | null>;
+    params?: Params;
+    templates: {
+        [key in UITemplateType]?: UITemplate;
+    };
+    get flow(): Flow | null;
+    set flow(value: Flow | null);
+    get isLegacy(): boolean;
+    get isStateful(): boolean;
+    private readonly defaultTemplates;
+    private flowSubj$;
+    constructor(flowsApiService: FlowsApiService, templatesApiService: UITemplatesApiService, customizationService?: FlowCustomization | undefined);
+    init$(flowId: string, params: Params): Observable<void>;
+    cleanup(): void;
+    private initFlowTemplates$;
+    private remapTemplateName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowInfoService, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowInfoService>;
+}

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

@@ -0,0 +1,19 @@
+import { FlowStateApiService } from '@veloceapps/api';
+import { Observable } from 'rxjs';
+import { NewConfigurationProps } from '../modules/configuration';
+import { FlowConfigurationService } from '../modules/flow-configuration';
+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;
+    addToCart$(props: NewConfigurationProps): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowStateConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowStateConfigurationService>;
+}

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

@@ -0,0 +1,80 @@
+import { ConfigurationProcessorsApiService, FlowStateApiService, QuoteApiService } from '@veloceapps/api';
+import { ToastService } from '@veloceapps/components';
+import { Charge, CompiledPricePlan, FlowStateExecutionRequest, FlowStateExecutionRequestDTO, FlowStateExecutionResult, FlowStateSelectorResponse, MetricRule, UITemplateType } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import { Observable } from 'rxjs';
+import { FlowConfigurationService } from '../modules';
+import { FlowCustomization } from '../types/flow-customization.types';
+import { FlowStateSubscriptionOptions } from '../types/flow-state.types';
+import { ContextService } from './context.service';
+import { FlowInfoService } from './flow-info.service';
+import { QuoteDraftService } from './quote-draft.service';
+import * as i0 from "@angular/core";
+export declare class FlowStateService {
+    private contextService;
+    private quoteDraftService;
+    private flowInfoService;
+    private flowConfiguration;
+    private processorsApiService;
+    private flowStateApiService;
+    private quoteApiService;
+    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;
+    private stateId$;
+    private _hasStatefulUnsavedChanges;
+    private processors;
+    private subscriptions;
+    private flowStore;
+    private statefulExecutionInProgress$;
+    private statefulRequestStream$;
+    private statefulExecutionRequest$;
+    private cleanup$;
+    constructor(contextService: ContextService, quoteDraftService: QuoteDraftService, flowInfoService: FlowInfoService, flowConfiguration: FlowConfigurationService, processorsApiService: ConfigurationProcessorsApiService, flowStateApiService: FlowStateApiService, quoteApiService: QuoteApiService, toastService: ToastService, customizationService?: FlowCustomization | undefined);
+    init$(): Observable<void>;
+    cleanup(): void;
+    get hasUnsavedChanges(): boolean;
+    get stateId(): string | null;
+    get isExecutionInProgress$(): Observable<boolean>;
+    isInitialized$(): Observable<boolean>;
+    isInitialized(): boolean;
+    execute$(scope: UITemplateType, exec: FlowStateExecutionRequest): Observable<FlowStateExecutionResult['selectors']>;
+    dispatch$(scope: UITemplateType, action: string, inputData?: unknown): Observable<void>;
+    select$<Response = unknown>(scope: UITemplateType, selectorName: string, inputData?: unknown): Observable<FlowStateSelectorResponse<Response>>;
+    subscribe$<Response = unknown>(scope: UITemplateType, selectorName: string, inputData?: unknown, options?: FlowStateSubscriptionOptions): Observable<FlowStateSelectorResponse<Response>>;
+    save$(): Observable<{
+        quoteId: string;
+    }>;
+    submit$(): Observable<{
+        quoteId: string;
+    }>;
+    getFlowStore(): Record<string, unknown>;
+    private getOwnerIdByScope;
+    private getScopeByOwnerId;
+    private execToRequest;
+    executeRequest$(request: FlowStateExecutionRequestDTO, forceSubscriptions?: boolean): Observable<FlowStateExecutionResult>;
+    private handleSelectorsResponse;
+    private initStateful$;
+    private initBufferedRequest$;
+    private executeStateful$;
+    private initStateless$;
+    private calculate$;
+    private executeStateless$;
+    private executeStatelessActions;
+    private executeStatelessSelectors;
+    private getFlowSafe;
+    private initProcessors$;
+    private executeActionScript;
+    private executeSelectorScript;
+    private executeProcessorScript;
+    private generateRequestId;
+    private getDefaultExecutionRequestDTO;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowStateService, [null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowStateService>;
+}

package/core/services/index.d.ts

@@ -1,5 +1,8 @@
 export * from './context.service';
-export * from './metric-calculation/metric-calculation.service';
+export * from './flow-info.service';
+export * from './flow-state.service';
+export * from './flow-state-configuration.service';
+export * from './integration.state';
 export * from './product-images.service';
 export * from './quote-draft.service';
 export * from './runtime-settings.service';