@veloceapps/sdk 11.0.0-7 → 11.0.0-70

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

@@ -1,50 +1,23 @@
-import { ProceduresApiService } from '@veloceapps/api';
-import { Charge, CompiledPricePlan, ConfigurationContext, LineItem, MetricRule, QuoteDraft } from '@veloceapps/core';
-import { Dictionary } from 'lodash';
+import { OrchestrationsApiService } from '@veloceapps/api/v2';
+import { TransactionContext } from '@veloceapps/core';
 import { Observable } from 'rxjs';
-import { ContextService } from '../../../services/context.service';
-import { QuoteDraftService } from '../../../services/quote-draft.service';
-import { ExternalConfigurationProps } from '../../configuration';
-import { ConfigurationService } from '../../configuration/services/configuration.service';
-import { FlowUpdateParams } from '../types/update.types';
-import { FlowUpdateService } from './flow-update.service';
 import { FlowInfoService } from '../../../services';
+import { SalesTransactionService } from '../../../services/sales-transaction.service';
 import * as i0 from "@angular/core";
 export declare class FlowConfigurationService {
-    private proceduresApiService;
-    private contextService;
-    private quoteDraftService;
-    private updateService;
-    private configurationService;
+    private orchestrationsApiService;
+    private salesTransactionService;
     private flowInfoService;
-    /**
-     * An event being fired when QuoteDraft was updated
-     */
     updated$: Observable<void>;
     private updatedSubj$;
-    constructor(proceduresApiService: ProceduresApiService, contextService: ContextService, quoteDraftService: QuoteDraftService, updateService: FlowUpdateService, configurationService: ConfigurationService, flowInfoService: FlowInfoService);
-    calculate$(quoteDraft: QuoteDraft): Observable<void>;
-    calculate(quoteDraft: QuoteDraft): void;
-    update$(updates: FlowUpdateParams[]): Observable<QuoteDraft | null>;
-    update(updates: FlowUpdateParams[]): void;
-    revert$(lineItemId: string): Observable<QuoteDraft | null>;
-    revert(lineItemId: string): void;
-    delete$(ids: string[]): Observable<QuoteDraft | null>;
+    constructor(orchestrationsApiService: OrchestrationsApiService, salesTransactionService: SalesTransactionService, flowInfoService: FlowInfoService);
+    calculate$(state: TransactionContext): Observable<void>;
+    calculate(state: TransactionContext): void;
+    revert$(transactionItemId: string): Observable<TransactionContext | null>;
+    revert(transactionItemId: string): void;
+    delete$(ids: string[]): Observable<TransactionContext | null>;
     delete(ids: string[]): void;
-    addTerm$(term: LineItem): Observable<QuoteDraft | null>;
-    addToCart$(props: ExternalConfigurationProps): Observable<QuoteDraft | null>;
-    get(): Observable<LineItem[]>;
-    getSnapshot(): LineItem[];
-    get charges$(): Observable<Dictionary<Charge>>;
-    get pricePlans$(): Observable<Dictionary<CompiledPricePlan>>;
-    get activeMetrics$(): Observable<MetricRule[]>;
-    get chargesSnapshot(): Dictionary<Charge>;
-    get pricePlansSnapshot(): Dictionary<CompiledPricePlan>;
-    get activeMetricsSnapshot(): MetricRule[];
-    get contextSnapshot(): ConfigurationContext;
-    get context$(): Observable<ConfigurationContext>;
     private handleErrorAndBounceBack;
-    private extendedApply$;
     static ɵfac: i0.ɵɵFactoryDeclaration<FlowConfigurationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FlowConfigurationService>;
 }

package/core/operators/filter-successful-execute.operator.d.ts

@@ -0,0 +1,3 @@
+import { FlowStateSelectorResponse } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+export declare function filterSuccessfulExecute<T>(): (source: Observable<FlowStateSelectorResponse<T>>) => Observable<T>;

package/core/operators/index.d.ts

@@ -0,0 +1 @@
+export * from './filter-successful-execute.operator';

package/core/services/catalog-products.service.d.ts

@@ -0,0 +1,11 @@
+import { CatalogProducts } from '@veloceapps/core';
+import * as i0 from "@angular/core";
+export declare class CatalogProductsService {
+    private stateSubj$;
+    state$: import("rxjs").Observable<CatalogProducts>;
+    get state(): CatalogProducts | null;
+    reset(): void;
+    setState(state: CatalogProducts): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogProductsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogProductsService>;
+}

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

@@ -1,29 +1,44 @@
 import { Params } from '@angular/router';
-import { FlowsApiService, UITemplatesApiService } from '@veloceapps/api';
-import { Flow, UITemplate, UITemplateType } from '@veloceapps/core';
+import { UITemplatesAdminApiService } 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 {
-    private flowsApiService;
-    private templatesApiService;
+    private runtimeSettingsService;
+    private templatesAdminApiService;
     private customizationService?;
     flow$: Observable<Flow | null>;
-    params?: Params;
-    templates: {
+    templates$: Observable<{
         [key in UITemplateType]?: UITemplate;
+    }>;
+    get flow(): Flow;
+    get isFlowInitialized(): boolean;
+    get context(): FlowContext;
+    get context$(): Observable<FlowContext>;
+    get templates(): {
+        SHOPPING_CART?: UITemplate | undefined;
+        CONFIGURATION_UI?: UITemplate | undefined;
+        CATALOG?: UITemplate | undefined;
+        GUIDED_SELLING?: UITemplate | undefined;
+        FLOW_ENGINE?: UITemplate | undefined;
+        FLOW_HEADER?: UITemplate | undefined;
     };
-    get flow(): Flow | null;
-    set flow(value: Flow | null);
-    get isLegacy(): boolean;
+    get isFlowEngineInitialized$(): Observable<boolean>;
     get isStateful(): boolean;
     private readonly defaultTemplates;
     private flowSubj$;
-    constructor(flowsApiService: FlowsApiService, templatesApiService: UITemplatesApiService, customizationService?: FlowCustomization | undefined);
+    private templatesSubj$;
+    private contextSubj$;
+    constructor(runtimeSettingsService: RuntimeSettingsService, templatesAdminApiService: UITemplatesAdminApiService, customizationService?: FlowCustomization | undefined);
+    reset(): void;
     init$(flowId: string, routeQueryParams: Params): Observable<void>;
-    cleanup(): void;
+    updateContext(update: Partial<FlowContext>): void;
+    private initFlow$;
     private initFlowTemplates$;
     private remapTemplateName;
+    private getFlowContextMode;
     static ɵfac: i0.ɵɵFactoryDeclaration<FlowInfoService, [null, null, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FlowInfoService>;
 }

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,29 +1,23 @@
-import { ConfigurationProcessorsApiService, FlowStateApiService, QuoteApiService } from '@veloceapps/api';
+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';
 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 { SalesTransactionService } from './sales-transaction.service';
 import * as i0 from "@angular/core";
 export declare class FlowStateService {
-    private contextService;
-    private quoteDraftService;
-    private flowInfoService;
     private flowConfiguration;
-    private processorsApiService;
+    private flowInfoService;
     private flowStateApiService;
-    private quoteApiService;
+    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;
@@ -37,9 +31,9 @@ export declare class FlowStateService {
     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);
+    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>;
@@ -50,10 +44,10 @@ export declare class FlowStateService {
     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;
+        id: string;
     }>;
     submit$(): Observable<{
-        quoteId: string;
+        id: string;
     }>;
     getFlowStore(): Record<string, unknown>;
     private getOwnerIdByScope;
@@ -65,18 +59,15 @@ export declare class FlowStateService {
     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;
     private checkStatefulChanges;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FlowStateService, [null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowStateService, [null, null, null, null, null, null, null, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FlowStateService>;
 }

package/core/services/index.d.ts

@@ -1,8 +1,8 @@
-export * from './context.service';
 export * from './flow-info.service';
-export * from './flow-state.service';
 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';
+export * from './catalog-products.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/product-images.service.d.ts

@@ -1,10 +1,10 @@
-import { ProductApiService } from '@veloceapps/api';
+import { ProductsAdminApiService } from '@veloceapps/api/v2';
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class ProductImagesService {
-    private productApiService;
+    private productsAdminApiService;
     private imagesMap$;
-    constructor(productApiService: ProductApiService);
+    constructor(productsAdminApiService: ProductsAdminApiService);
     getImageUrl$(productId: string): Observable<string | null>;
     private fetchProductImage;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProductImagesService, never>;

package/core/services/runtime-settings.service.d.ts

@@ -1,4 +1,4 @@
-import { ConfigurationSettingsApiService } from '@veloceapps/api';
+import { ConfigurationSettingsApiService } from '@veloceapps/api/v2';
 import { RuntimeConfigurationSettings, RuntimeCurrencySettings, ShoppingCartSetting } from '@veloceapps/core';
 import { Observable } from 'rxjs';
 import { FormattingSettings } from '../types';

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

@@ -0,0 +1,27 @@
+import { SalesTransactionApiService } from '@veloceapps/api/v2';
+import { SalesTransactionItem, TransactionContext } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SalesTransactionService {
+    private salesTransactionApiService;
+    private stateSubj$;
+    private isInitializedSubj$;
+    private hasUnsavedChangesSubj$;
+    private initialState;
+    hasUnsavedChanges$: Observable<boolean>;
+    state$: Observable<TransactionContext>;
+    get isInitialized$(): Observable<boolean>;
+    get isInitialized(): boolean;
+    set hasUnsavedChanges(value: boolean);
+    get hasUnsavedChanges(): boolean;
+    get state(): TransactionContext | null;
+    get hasProducts(): boolean;
+    constructor(salesTransactionApiService: SalesTransactionApiService);
+    init(headerId: string, params: Record<string, string>): Observable<TransactionContext>;
+    finalizeInit(): void;
+    reset(): void;
+    getInitialState(): SalesTransactionItem[];
+    setState(state: TransactionContext): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SalesTransactionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SalesTransactionService>;
+}

package/core/types/flow-customization.types.d.ts

@@ -1,9 +1,9 @@
 import { InjectionToken } from '@angular/core';
-import { ConfigurationProcessor, TemplateComponentWithAttachments, UIDefinitionContainer, UITemplate } from '@veloceapps/core';
+import { ConfigurationProcessor, FlowContext, TemplateComponentWithAttachments, UIDefinitionContainer, UITemplate } from '@veloceapps/core';
 import { Observable } from 'rxjs';
 export declare const FLOW_CUSTOMIZATION: InjectionToken<FlowCustomization>;
 export interface FlowCustomization {
-    getUiDefinition?(productId: string): Observable<UIDefinitionContainer | null>;
+    getUiDefinition?(flowContext: FlowContext): Observable<UIDefinitionContainer | null>;
     getTemplates?(): Observable<UITemplate[]>;
     getTemplateComponents?(templateName: string): Observable<TemplateComponentWithAttachments[] | null>;
     getTemplateConfigurationProcessors?(templateName: string): Observable<ConfigurationProcessor[] | null>;

package/core/types/flow-state.types.d.ts

@@ -1,4 +1,4 @@
-import { AccountAssetsState } from '@veloceapps/core';
+import { SalesTransactionItem } from '@veloceapps/core';
 export interface FlowStateSubscriptionOptions {
     /**
      * When 'true', don't execute action to retrieve current value
@@ -7,6 +7,6 @@ export interface FlowStateSubscriptionOptions {
     trackedChanges?: boolean;
 }
 export interface FlowStore {
-    assets?: AccountAssetsState;
+    assets?: SalesTransactionItem[];
     [key: string]: unknown;
 }

package/core/types/index.d.ts

@@ -2,5 +2,4 @@ export * from './flow-customization.types';
 export * from './formatting-settings.types';
 export * from './integration.types';
 export * from './pipe.types';
-export * from './runtime.types';
 export * from './ui-definition.types';

package/core/utils/index.d.ts

@@ -1,3 +1,3 @@
-export * from './line-item.utils';
-export * from './line-item.worker';
+export * from './transaction-item.utils';
+export * from './transaction-item.worker';
 export * from './ui-definition.utils';

package/core/utils/transaction-item.utils.d.ts

@@ -0,0 +1,7 @@
+import { SalesTransactionItem } from '@veloceapps/core';
+export declare const findTransactionItem: (id: string, items: SalesTransactionItem[]) => SalesTransactionItem | undefined;
+export declare const findTransactionItemWithComparator: (items: SalesTransactionItem[], comparator: (ti: SalesTransactionItem) => boolean) => SalesTransactionItem | undefined;
+export declare const insertTransactionItem: (item: SalesTransactionItem, parentId: string, toInsert: SalesTransactionItem) => SalesTransactionItem;
+export declare const removeTransactionItem: (item: SalesTransactionItem, idToRemove: string) => SalesTransactionItem;
+export declare const replaceTransactionItem: (item: SalesTransactionItem, replaceTo: SalesTransactionItem) => SalesTransactionItem;
+export declare const generateTransactionItem: (productId: string) => SalesTransactionItem;

package/core/utils/transaction-item.worker.d.ts

@@ -0,0 +1,8 @@
+import { SalesTransactionItem } from '@veloceapps/core';
+export declare class TransactionItemWorker {
+    ti: SalesTransactionItem;
+    constructor(src: SalesTransactionItem);
+    insert(parentId: string, toInsert: SalesTransactionItem): TransactionItemWorker;
+    remove(id: string): TransactionItemWorker;
+    replace(toReplace: SalesTransactionItem): TransactionItemWorker;
+}

package/esm2020/cms/cms.actions.mjs

@@ -15,58 +15,79 @@ export var FlowAction;
     FlowAction.SUBMIT_GUIDED_SELLING = '[FLOW]_SUBMIT_GUIDED_SELLING';
     FlowAction.CLOSE_GUIDED_SELLING = '[FLOW]_CLOSE_GUIDED_SELLING';
     FlowAction.OPEN_DIALOG = '[FLOW]_OPEN_DIALOG';
-    FlowAction.ConfigureProductAction = ({ lineItemId, productId, }) => ({
-        type: FlowAction.FLOW_CONFIGURE_PRODUCT,
-        payload: { lineItemId, productId },
-    });
-    FlowAction.NavigateBackAction = () => ({
-        type: FlowAction.FLOW_NAVIGATE_BACK,
-    });
-    FlowAction.NavigateToAction = (path, productId, lineItemId) => ({
+    FlowAction.ConfigureProductAction = ({ transactionItemId, productId, }) => {
+        return {
+            type: FlowAction.FLOW_CONFIGURE_PRODUCT,
+            payload: { transactionItemId, productId },
+        };
+    };
+    FlowAction.NavigateBackAction = () => {
+        return {
+            type: FlowAction.FLOW_NAVIGATE_BACK,
+        };
+    };
+    FlowAction.NavigateToAction = (path, productId, transactionItemId) => ({
         type: FlowAction.FLOW_NAVIGATE_TO,
-        payload: { path, productId, lineItemId },
+        payload: { path, productId, transactionItemId },
     });
     FlowAction.NavigateToCatalogAction = () => ({
         type: FlowAction.FLOW_NAVIGATE_TO_CATALOG,
     });
-    FlowAction.NavigateToShoppingCartAction = () => ({
-        type: FlowAction.FLOW_NAVIGATE_TO_SHOPPING_CART,
-    });
-    FlowAction.ApplyProductConfigurationAction = () => ({
-        type: FlowAction.FLOW_APPLY_PRODUCT_CONFIGURATION,
-    });
-    FlowAction.RemoteApplyAction = () => ({
-        type: FlowAction.REMOTE_APPLY,
-    });
-    FlowAction.RemoteCancelAction = () => ({
-        type: FlowAction.REMOTE_CANCEL,
-    });
-    FlowAction.SwitchObjectAction = (payload) => ({
-        type: FlowAction.FLOW_SWITCH_OBJECT,
-        payload,
-    });
-    FlowAction.OpenGuidedSelling = (payload) => ({
-        type: FlowAction.OPEN_GUIDED_SELLING,
-        payload,
-    });
-    FlowAction.CloseGuidedSelling = (payload) => ({
-        type: FlowAction.CLOSE_GUIDED_SELLING,
-        payload,
-    });
-    FlowAction.SubmitGuidedSelling = (payload) => ({
-        type: FlowAction.SUBMIT_GUIDED_SELLING,
-        payload,
-    });
-    FlowAction.OpenDialog = (dialog) => ({
-        type: FlowAction.OPEN_DIALOG,
-        payload: { dialog },
-    });
+    FlowAction.NavigateToShoppingCartAction = () => {
+        return {
+            type: FlowAction.FLOW_NAVIGATE_TO_SHOPPING_CART,
+        };
+    };
+    FlowAction.ApplyProductConfigurationAction = () => {
+        return {
+            type: FlowAction.FLOW_APPLY_PRODUCT_CONFIGURATION,
+        };
+    };
+    FlowAction.RemoteApplyAction = () => {
+        return {
+            type: FlowAction.REMOTE_APPLY,
+        };
+    };
+    FlowAction.RemoteCancelAction = () => {
+        return {
+            type: FlowAction.REMOTE_CANCEL,
+        };
+    };
+    FlowAction.SwitchObjectAction = (payload) => {
+        return {
+            type: FlowAction.FLOW_SWITCH_OBJECT,
+            payload,
+        };
+    };
+    FlowAction.OpenGuidedSelling = (payload) => {
+        return {
+            type: FlowAction.OPEN_GUIDED_SELLING,
+            payload,
+        };
+    };
+    FlowAction.CloseGuidedSelling = (payload) => {
+        return {
+            type: FlowAction.CLOSE_GUIDED_SELLING,
+            payload,
+        };
+    };
+    FlowAction.SubmitGuidedSelling = (payload) => {
+        return {
+            type: FlowAction.SUBMIT_GUIDED_SELLING,
+            payload,
+        };
+    };
+    FlowAction.OpenDialog = (dialog) => {
+        return {
+            type: FlowAction.OPEN_DIALOG,
+            payload: { dialog },
+        };
+    };
 })(FlowAction || (FlowAction = {}));
 export var CmsAction;
 (function (CmsAction) {
     CmsAction.GO_TO_PAGE = '[CMS]_GO_TO_PAGE';
     CmsAction.UPDATE_CUSTOMIZATION = '[CMS]_UPDATE_CUSTOMIZATION';
-    CmsAction.EMIT_CUSTOMIZATION_CHANGES = '[CMS]_EMIT_CUSTOMIZATION_CHANGES';
     CmsAction.SHOW_OVERLAY = '[CMS]_SHOW_OVERLAY';
     CmsAction.HIDE_OVERLAY = '[CMS]_HIDE_OVERLAY';
     CmsAction.HIDE_ALL_OVERLAYS = '[CMS]_HIDE_ALL_OVERLAYS';
@@ -75,55 +96,56 @@ export var CmsAction;
      *
      * @param pageName name of the page
      */
-    CmsAction.GoToPage = (pageName) => ({
-        type: CmsAction.GO_TO_PAGE,
-        payload: { pageName },
-    });
+    CmsAction.GoToPage = (pageName) => {
+        return {
+            type: CmsAction.GO_TO_PAGE,
+            payload: { pageName },
+        };
+    };
     /**
      * Update UI definition customization state
      *
      * @param pageName name of the page
      */
-    CmsAction.UpdateCustomization = (value) => ({
-        type: CmsAction.UPDATE_CUSTOMIZATION,
-        payload: { value },
-    });
-    /**
-     * Emit customization page changes
-     *
-     * @param changes - object with customization page changes
-     */
-    CmsAction.EmitCustomizationChanges = (changes) => ({
-        type: CmsAction.EMIT_CUSTOMIZATION_CHANGES,
-        payload: { changes },
-    });
+    CmsAction.UpdateCustomization = (value) => {
+        return {
+            type: CmsAction.UPDATE_CUSTOMIZATION,
+            payload: { value },
+        };
+    };
     /**
      * Show an Overlay on the selected page
      *
      * @param name - name of the overlay
      * @returns void
      */
-    CmsAction.ShowOverlay = (name) => ({
-        type: CmsAction.SHOW_OVERLAY,
-        payload: { name },
-    });
+    CmsAction.ShowOverlay = (name) => {
+        return {
+            type: CmsAction.SHOW_OVERLAY,
+            payload: { name },
+        };
+    };
     /**
      * Hide an Overlay on the selected page
      *
      * @param name - name of the overlay
      * @returns void
      */
-    CmsAction.HideOverlay = (name) => ({
-        type: CmsAction.HIDE_OVERLAY,
-        payload: { name },
-    });
+    CmsAction.HideOverlay = (name) => {
+        return {
+            type: CmsAction.HIDE_OVERLAY,
+            payload: { name },
+        };
+    };
     /**
      * Hide all Overlays on the selected page
      *
      * @returns void
      */
-    CmsAction.HideAllOverlays = () => ({
-        type: CmsAction.HIDE_ALL_OVERLAYS,
-    });
+    CmsAction.HideAllOverlays = () => {
+        return {
+            type: CmsAction.HIDE_ALL_OVERLAYS,
+        };
+    };
 })(CmsAction || (CmsAction = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cms.actions.js","sourceRoot":"","sources":["../../../../../libs/sdk/cms/cms.actions.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-namespace */\nimport { CustomizationChanges } from '@veloceapps/core';\nimport { IntegrationAction } from '@veloceapps/sdk/core';\n\nexport namespace FlowAction {\n  export const FLOW_CONFIGURE_PRODUCT = '[FLOW]_CONFIGURE_PRODUCT';\n  export const FLOW_NAVIGATE_BACK = '[FLOW]_NAVIGATE_BACK';\n  export const FLOW_NAVIGATE_TO = '[FLOW]_NAVIGATE_TO';\n  export const FLOW_NAVIGATE_TO_CATALOG = '[FLOW]_NAVIGATE_TO_CATALOG';\n  export const FLOW_NAVIGATE_TO_SHOPPING_CART = '[FLOW]_NAVIGATE_TO_SHOPPING_CART';\n  export const FLOW_APPLY_PRODUCT_CONFIGURATION = '[FLOW]_APPLY_PRODUCT_CONFIGURATION';\n  export const FLOW_OPEN_DOC_GEN = '[FLOW]_OPEN_DOC_GEN';\n  export const FLOW_CLOSE_DOC_GEN = '[FLOW]_CLOSE_DOC_GEN';\n  export const FLOW_SWITCH_OBJECT = '[FLOW]_SWITCH_OBJECT';\n  export const REMOTE_APPLY = '[FLOW]_REMOTE_APPLY';\n  export const REMOTE_CANCEL = '[FLOW]_REMOTE_CANCEL';\n  export const OPEN_GUIDED_SELLING = '[FLOW]_OPEN_GUIDED_SELLING';\n  export const SUBMIT_GUIDED_SELLING = '[FLOW]_SUBMIT_GUIDED_SELLING';\n  export const CLOSE_GUIDED_SELLING = '[FLOW]_CLOSE_GUIDED_SELLING';\n  export const OPEN_DIALOG = '[FLOW]_OPEN_DIALOG';\n\n  export const ConfigureProductAction = ({\n    lineItemId,\n    productId,\n  }: {\n    lineItemId?: string;\n    productId?: string;\n  }): IntegrationAction => ({\n    type: FlowAction.FLOW_CONFIGURE_PRODUCT,\n    payload: { lineItemId, productId },\n  });\n\n  export const NavigateBackAction = (): IntegrationAction => ({\n    type: FlowAction.FLOW_NAVIGATE_BACK,\n  });\n\n  export const NavigateToAction = (path: string, productId?: string, lineItemId?: string): IntegrationAction => ({\n    type: FlowAction.FLOW_NAVIGATE_TO,\n    payload: { path, productId, lineItemId },\n  });\n\n  export const NavigateToCatalogAction = (): IntegrationAction => ({\n    type: FlowAction.FLOW_NAVIGATE_TO_CATALOG,\n  });\n\n  export const NavigateToShoppingCartAction = (): IntegrationAction => ({\n    type: FlowAction.FLOW_NAVIGATE_TO_SHOPPING_CART,\n  });\n\n  export const ApplyProductConfigurationAction = (): IntegrationAction => ({\n    type: FlowAction.FLOW_APPLY_PRODUCT_CONFIGURATION,\n  });\n\n  export const RemoteApplyAction = (): IntegrationAction => ({\n    type: FlowAction.REMOTE_APPLY,\n  });\n\n  export const RemoteCancelAction = (): IntegrationAction => ({\n    type: FlowAction.REMOTE_CANCEL,\n  });\n\n  export const SwitchObjectAction = (payload: { id: string }): IntegrationAction => ({\n    type: FlowAction.FLOW_SWITCH_OBJECT,\n    payload,\n  });\n\n  export const OpenGuidedSelling = (payload: { guidedSellingId: string }): IntegrationAction => ({\n    type: FlowAction.OPEN_GUIDED_SELLING,\n    payload,\n  });\n\n  export const CloseGuidedSelling = (payload?: { keepState?: boolean }): IntegrationAction => ({\n    type: FlowAction.CLOSE_GUIDED_SELLING,\n    payload,\n  });\n\n  export const SubmitGuidedSelling = (payload: { result: Record<string, any> }): IntegrationAction => ({\n    type: FlowAction.SUBMIT_GUIDED_SELLING,\n    payload,\n  });\n\n  export const OpenDialog = (dialog: string): IntegrationAction => ({\n    type: FlowAction.OPEN_DIALOG,\n    payload: { dialog },\n  });\n}\n\nexport namespace CmsAction {\n  export const GO_TO_PAGE = '[CMS]_GO_TO_PAGE';\n  export const UPDATE_CUSTOMIZATION = '[CMS]_UPDATE_CUSTOMIZATION';\n  export const EMIT_CUSTOMIZATION_CHANGES = '[CMS]_EMIT_CUSTOMIZATION_CHANGES';\n  export const SHOW_OVERLAY = '[CMS]_SHOW_OVERLAY';\n  export const HIDE_OVERLAY = '[CMS]_HIDE_OVERLAY';\n  export const HIDE_ALL_OVERLAYS = '[CMS]_HIDE_ALL_OVERLAYS';\n\n  /**\n   * Navigate UI definition to a specific page\n   *\n   * @param pageName name of the page\n   */\n  export const GoToPage = (pageName: string): IntegrationAction => ({\n    type: GO_TO_PAGE,\n    payload: { pageName },\n  });\n\n  /**\n   * Update UI definition customization state\n   *\n   * @param pageName name of the page\n   */\n  export const UpdateCustomization = (value: any): IntegrationAction => ({\n    type: UPDATE_CUSTOMIZATION,\n    payload: { value },\n  });\n\n  /**\n   * Emit customization page changes\n   *\n   * @param changes - object with customization page changes\n   */\n  export const EmitCustomizationChanges = (changes: CustomizationChanges): IntegrationAction => ({\n    type: EMIT_CUSTOMIZATION_CHANGES,\n    payload: { changes },\n  });\n\n  /**\n   * Show an Overlay on the selected page\n   *\n   * @param name - name of the overlay\n   * @returns void\n   */\n  export const ShowOverlay = (name: string): IntegrationAction => ({\n    type: SHOW_OVERLAY,\n    payload: { name },\n  });\n\n  /**\n   * Hide an Overlay on the selected page\n   *\n   * @param name - name of the overlay\n   * @returns void\n   */\n  export const HideOverlay = (name: string): IntegrationAction => ({\n    type: HIDE_OVERLAY,\n    payload: { name },\n  });\n\n  /**\n   * Hide all Overlays on the selected page\n   *\n   * @returns void\n   */\n  export const HideAllOverlays = (): IntegrationAction => ({\n    type: HIDE_ALL_OVERLAYS,\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cms.actions.js","sourceRoot":"","sources":["../../../../../libs/sdk/cms/cms.actions.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-namespace */\nimport { IntegrationAction } from '@veloceapps/sdk/core';\n\nexport namespace FlowAction {\n  export const FLOW_CONFIGURE_PRODUCT = '[FLOW]_CONFIGURE_PRODUCT';\n  export const FLOW_NAVIGATE_BACK = '[FLOW]_NAVIGATE_BACK';\n  export const FLOW_NAVIGATE_TO = '[FLOW]_NAVIGATE_TO';\n  export const FLOW_NAVIGATE_TO_CATALOG = '[FLOW]_NAVIGATE_TO_CATALOG';\n  export const FLOW_NAVIGATE_TO_SHOPPING_CART = '[FLOW]_NAVIGATE_TO_SHOPPING_CART';\n  export const FLOW_APPLY_PRODUCT_CONFIGURATION = '[FLOW]_APPLY_PRODUCT_CONFIGURATION';\n  export const FLOW_OPEN_DOC_GEN = '[FLOW]_OPEN_DOC_GEN';\n  export const FLOW_CLOSE_DOC_GEN = '[FLOW]_CLOSE_DOC_GEN';\n  export const FLOW_SWITCH_OBJECT = '[FLOW]_SWITCH_OBJECT';\n  export const REMOTE_APPLY = '[FLOW]_REMOTE_APPLY';\n  export const REMOTE_CANCEL = '[FLOW]_REMOTE_CANCEL';\n  export const OPEN_GUIDED_SELLING = '[FLOW]_OPEN_GUIDED_SELLING';\n  export const SUBMIT_GUIDED_SELLING = '[FLOW]_SUBMIT_GUIDED_SELLING';\n  export const CLOSE_GUIDED_SELLING = '[FLOW]_CLOSE_GUIDED_SELLING';\n  export const OPEN_DIALOG = '[FLOW]_OPEN_DIALOG';\n\n  export const ConfigureProductAction = ({\n    transactionItemId,\n    productId,\n  }: {\n    transactionItemId?: string;\n    productId?: string;\n  }) => {\n    return {\n      type: FlowAction.FLOW_CONFIGURE_PRODUCT,\n      payload: { transactionItemId, productId },\n    } satisfies IntegrationAction;\n  };\n\n  export const NavigateBackAction = () => {\n    return {\n      type: FlowAction.FLOW_NAVIGATE_BACK,\n    } satisfies IntegrationAction;\n  };\n\n  export const NavigateToAction = (path: string, productId?: string, transactionItemId?: string) =>\n    ({\n      type: FlowAction.FLOW_NAVIGATE_TO,\n      payload: { path, productId, transactionItemId },\n    } satisfies IntegrationAction);\n\n  export const NavigateToCatalogAction = () =>\n    ({\n      type: FlowAction.FLOW_NAVIGATE_TO_CATALOG,\n    } satisfies IntegrationAction);\n\n  export const NavigateToShoppingCartAction = () => {\n    return {\n      type: FlowAction.FLOW_NAVIGATE_TO_SHOPPING_CART,\n    } satisfies IntegrationAction;\n  };\n\n  export const ApplyProductConfigurationAction = () => {\n    return {\n      type: FlowAction.FLOW_APPLY_PRODUCT_CONFIGURATION,\n    } satisfies IntegrationAction;\n  };\n\n  export const RemoteApplyAction = () => {\n    return {\n      type: FlowAction.REMOTE_APPLY,\n    } satisfies IntegrationAction;\n  };\n\n  export const RemoteCancelAction = () => {\n    return {\n      type: FlowAction.REMOTE_CANCEL,\n    } satisfies IntegrationAction;\n  };\n\n  export const SwitchObjectAction = (payload: { id: string }) => {\n    return {\n      type: FlowAction.FLOW_SWITCH_OBJECT,\n      payload,\n    } satisfies IntegrationAction;\n  };\n\n  export const OpenGuidedSelling = (payload: { guidedSellingId: string }) => {\n    return {\n      type: FlowAction.OPEN_GUIDED_SELLING,\n      payload,\n    } satisfies IntegrationAction;\n  };\n\n  export const CloseGuidedSelling = (payload?: { keepState?: boolean }) => {\n    return {\n      type: FlowAction.CLOSE_GUIDED_SELLING,\n      payload,\n    } satisfies IntegrationAction;\n  };\n\n  export const SubmitGuidedSelling = (payload: { result: Record<string, any> }) => {\n    return {\n      type: FlowAction.SUBMIT_GUIDED_SELLING,\n      payload,\n    } satisfies IntegrationAction;\n  };\n\n  export const OpenDialog = (dialog: string) => {\n    return {\n      type: FlowAction.OPEN_DIALOG,\n      payload: { dialog },\n    } satisfies IntegrationAction;\n  };\n}\n\ntype A = ReturnType<typeof FlowAction.OpenDialog>['payload'];\n\nexport namespace CmsAction {\n  export const GO_TO_PAGE = '[CMS]_GO_TO_PAGE';\n  export const UPDATE_CUSTOMIZATION = '[CMS]_UPDATE_CUSTOMIZATION';\n  export const SHOW_OVERLAY = '[CMS]_SHOW_OVERLAY';\n  export const HIDE_OVERLAY = '[CMS]_HIDE_OVERLAY';\n  export const HIDE_ALL_OVERLAYS = '[CMS]_HIDE_ALL_OVERLAYS';\n\n  /**\n   * Navigate UI definition to a specific page\n   *\n   * @param pageName name of the page\n   */\n  export const GoToPage = (pageName: string) => {\n    return {\n      type: GO_TO_PAGE,\n      payload: { pageName },\n    } satisfies IntegrationAction;\n  };\n\n  /**\n   * Update UI definition customization state\n   *\n   * @param pageName name of the page\n   */\n  export const UpdateCustomization = (value: any) => {\n    return {\n      type: UPDATE_CUSTOMIZATION,\n      payload: { value },\n    } satisfies IntegrationAction;\n  };\n\n  /**\n   * Show an Overlay on the selected page\n   *\n   * @param name - name of the overlay\n   * @returns void\n   */\n  export const ShowOverlay = (name: string) => {\n    return {\n      type: SHOW_OVERLAY,\n      payload: { name },\n    } satisfies IntegrationAction;\n  };\n\n  /**\n   * Hide an Overlay on the selected page\n   *\n   * @param name - name of the overlay\n   * @returns void\n   */\n  export const HideOverlay = (name: string) => {\n    return {\n      type: HIDE_OVERLAY,\n      payload: { name },\n    } satisfies IntegrationAction;\n  };\n\n  /**\n   * Hide all Overlays on the selected page\n   *\n   * @returns void\n   */\n  export const HideAllOverlays = () => {\n    return {\n      type: HIDE_ALL_OVERLAYS,\n    } satisfies IntegrationAction;\n  };\n}\n"]}