@veloceapps/sdk 11.0.0-8 → 11.0.0-81

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,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,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,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;
+}