@veloceapps/sdk 11.0.0-1 → 11.0.0-100

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

@@ -1,60 +1,36 @@
-import { ConfigurationApiService } from '@veloceapps/api';
-import { Charge, CompiledPricePlan, ConfigurationContext, ConfigurationRequest, ConfigurePrice, LineItem, PatchLineItemOptions, RuntimeModel } from '@veloceapps/core';
-import { Dictionary } from 'lodash';
+import { OrchestrationsApiService } from '@veloceapps/api/v2';
+import { PCMModel, SalesTransactionItem, TransactionContext } from '@veloceapps/core';
 import { MessageService } from 'primeng/api';
-import { DialogService } from 'primeng/dynamicdialog';
 import { Observable } from 'rxjs';
-import { ContextService } from '../../../services/context.service';
-import { QuoteDraftService } from '../../../services/quote-draft.service';
-import { RuntimeSettingsService } from '../../../services/runtime-settings.service';
-import { RuntimeContext } from '../../../types';
-import { ExternalConfigurationProps, GuidedSellingSubmitData } from '../types/configuration.types';
+import { FlowInfoService, SalesTransactionService } from '../../../services';
 import { ConfigurationRuntimeService } from './configuration-runtime.service';
+import { GuidedSellingService } from './guided-selling.service';
 import * as i0 from "@angular/core";
 export declare class ConfigurationService {
-    private quoteDraftService;
-    private runtimeService;
-    private contextService;
-    private configurationApiService;
+    private flowInfoService;
     private messageService;
-    private dialogService;
-    private runtimeSettings;
-    private mode;
-    private configurableRamp;
-    private configurationState;
-    private previousConfigurationState;
-    private isLoadingSubj$;
+    private configurationRuntimeService;
+    private salesTransactionService;
+    private orchestrationsApiService;
+    private guidedSellingService;
     isLoading$: Observable<boolean>;
     hasUnsavedChanges: boolean;
-    constructor(quoteDraftService: QuoteDraftService, runtimeService: ConfigurationRuntimeService, contextService: ContextService, configurationApiService: ConfigurationApiService, messageService: MessageService, dialogService: DialogService, runtimeSettings: RuntimeSettingsService);
+    private configurationStateSubj$;
+    private previousConfigurationStateSubj$;
+    private isLoadingSubj$;
+    constructor(flowInfoService: FlowInfoService, messageService: MessageService, configurationRuntimeService: ConfigurationRuntimeService, salesTransactionService: SalesTransactionService, orchestrationsApiService: OrchestrationsApiService, guidedSellingService: GuidedSellingService);
+    get state$(): Observable<TransactionContext>;
+    get state(): TransactionContext | null;
+    get previousState(): TransactionContext | null;
+    get root$(): Observable<SalesTransactionItem>;
+    get root(): SalesTransactionItem | null;
     reset(): void;
-    patch$(lineItem: LineItem, options?: PatchLineItemOptions): Observable<LineItem>;
-    patch(lineItem: LineItem, options?: PatchLineItemOptions): 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 contextSnapshot(): ConfigurationContext;
-    get context$(): Observable<ConfigurationContext>;
-    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;
+    init$(): Observable<void>;
+    patch$(transactionItem: SalesTransactionItem): Observable<void>;
+    patch(transactionItem: SalesTransactionItem): void;
+    configure$(transactionContext: TransactionContext): Observable<TransactionContext>;
+    justConfigureRequest$(transactionContext: TransactionContext): Observable<TransactionContext>;
+    getPCMModel(): PCMModel;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationService>;
 }

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

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

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

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

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

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

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

@@ -1,7 +1,6 @@
 import { Product } from '@veloceapps/core';
 export interface GuidedSellingSubmitData {
-    modelId: string;
-    modelType: string;
+    orchestrationName: string;
     attributesMap: Record<string, any>;
 }
 export interface ExternalConfigurationProps {
@@ -12,3 +11,6 @@ export interface ExternalConfigurationProps {
 export interface NewConfigurationProps extends ExternalConfigurationProps {
     product: Product;
 }
+export interface TestModeConfigurationOptions {
+    customizationMode?: boolean;
+}

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

@@ -0,0 +1,2 @@
+export * from './configuration.types';
+export * from './configuration-runtime.types';

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,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,19 +1,20 @@
-import { FlowStateApiService } from '@veloceapps/api';
 import { Observable } from 'rxjs';
-import { NewConfigurationProps } from '../modules/configuration';
-import { FlowConfigurationService } from '../modules/flow-configuration';
+import { ConfigurationService } from '../modules/configuration/services/configuration.service';
+import { NewConfigurationProps } from '../modules/configuration/types/configuration.types';
+import { FlowConfigurationService } from '../modules/flow-configuration/services/flow-configuration.service';
 import { FlowInfoService } from './flow-info.service';
 import { FlowStateService } from './flow-state.service';
+import { SalesTransactionService } from './sales-transaction.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;
+    private configurationService;
+    private salesTransactionService;
+    private flowConfigurationService;
+    constructor(flowInfoService: FlowInfoService, flowStateService: FlowStateService, configurationService: ConfigurationService, salesTransactionService: SalesTransactionService, flowConfigurationService: FlowConfigurationService);
     addToCart$(props: NewConfigurationProps): Observable<void>;
+    private configureExternal$;
     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,7 @@ 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;
-    }>;
-    submit$(): Observable<{
-        quoteId: string;
+        id: string;
     }>;
     getFlowStore(): Record<string, unknown>;
     private getOwnerIdByScope;
@@ -65,18 +56,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,21 +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>;
-    /**
-     * @deprecated Use `getTemplateComponents` instead
-     */
-    getShoppingCartComponent?(templateName: string): Observable<TemplateComponentWithAttachments | null>;
-    /**
-     * @deprecated Use `getTemplateComponents` instead
-     */
-    getCatalogComponent?(templateName: string): Observable<TemplateComponentWithAttachments | null>;
-    /**
-     * @deprecated Use `getTemplateComponents` instead
-     */
-    getAssetsComponent?(templateName: string): Observable<TemplateComponentWithAttachments | 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;
+}