@veloceapps/sdk 12.0.0-13 → 12.0.0-14

package/core/index.d.ts

@@ -1,8 +1,525 @@
-export * from './core.module';
-export * from './directives';
-export * from './modules';
-export * from './operators';
-export * from './pipes';
-export * from './services';
-export * from './types';
-export * from './utils';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy, PipeTransform } from '@angular/core';
+import { FlowContext, UIDefinitionContainer, UITemplate, TemplateComponentWithAttachments, ConfigurationProcessor, Prettify, VlDateSettings, PCMModel, UIDefinitionProps, RuntimeConfigurationSettings, ShoppingCartSetting, RuntimeCurrencySettings, Flow, UITemplateType, Product, TransactionContext, SalesTransactionItem, FlowStateExecutionRequest, FlowStateExecutionResult, FlowStateSelectorResponse, FlowStateExecutionRequestDTO, CatalogProducts, PCMProduct, UIDefinition, UIDefinitionMetadata } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import * as i1 from '@veloceapps/components';
+import { ToastService } from '@veloceapps/components';
+import * as i2 from '@veloceapps/api';
+import { FlowStateApiService } from '@veloceapps/api';
+import { Calendar } from 'primeng/calendar';
+import { PCMApiService, ConfigurationSettingsApiService, UITemplatesAdminApiService, OrchestrationsApiService, SalesTransactionApiService, ConfigurationProcessorsApiService, ProductsAdminApiService, SalesTransactionUpsertResponse, SalesforceApiService } from '@veloceapps/api/v2';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject, Subject } from 'rxjs';
+import { Params } from '@angular/router';
+import { MessageService } from 'primeng/api';
+
+declare const FLOW_CUSTOMIZATION: InjectionToken<FlowCustomization>;
+interface FlowCustomization {
+    getUiDefinition?(flowContext: FlowContext): Observable<UIDefinitionContainer | null>;
+    getTemplates?(): Observable<UITemplate[]>;
+    getTemplateComponents?(templateName: string): Observable<TemplateComponentWithAttachments[] | null>;
+    getTemplateConfigurationProcessors?(templateName: string): Observable<ConfigurationProcessor[] | null>;
+}
+
+declare const FORMATTING_SETTINGS_TOKEN: InjectionToken<{
+    getFormattingSettings: (...args: unknown[]) => FormattingSettings;
+}>;
+type FormattingSettings = Prettify<{
+    currencySymbol: string;
+    thousandsSeparator: string;
+    decimalSeparator: string;
+    decimalsCount: number;
+    actionCodeLabels: Dictionary<string>;
+} & VlDateSettings>;
+
+interface IntegrationAction<T = any> {
+    type: string;
+    payload?: T;
+}
+type IntegrationStateModel = {
+    guidedSelling?: Dictionary<any>;
+    flowPath: string;
+    dialogResult?: boolean;
+} & Dictionary<any>;
+
+type DateType = 'date' | 'datetime' | 'time';
+
+declare const UI_DEFINITION_VERSION = 3;
+
+declare class ConfigurationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationModule, never, [typeof i1.ConfirmationDialogModule, typeof i2.ApiModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ConfigurationModule>;
+}
+
+declare class FlowConfigurationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowConfigurationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowConfigurationModule, never, [typeof i2.ApiModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowConfigurationModule>;
+}
+
+declare const DEFAULT_FORMATTING_SETTINGS: FormattingSettings;
+declare class SdkCoreModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdkCoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SdkCoreModule, never, [typeof ConfigurationModule, typeof FlowConfigurationModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SdkCoreModule>;
+}
+
+declare class CalendarDirective implements OnInit, OnDestroy {
+    set vlCalendar(calendar: Calendar);
+    private calendar;
+    private ngControl;
+    private formattingSettings;
+    private destroy$;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CalendarDirective, "[vlCalendar]", never, { "vlCalendar": { "alias": "vlCalendar"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SdkDirectivesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdkDirectivesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SdkDirectivesModule, [typeof CalendarDirective], never, [typeof CalendarDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SdkDirectivesModule>;
+}
+
+interface RuntimeInitializationProps {
+    productId: string;
+}
+
+declare class ConfigurationRuntimeService {
+    private pcmApiService;
+    uiDefinitionContainer: UIDefinitionContainer | null;
+    initializationProps?: RuntimeInitializationProps;
+    pcmModelSubj$: BehaviorSubject<PCMModel | null>;
+    constructor(pcmApiService: PCMApiService);
+    get uiDefinitionProps(): UIDefinitionProps;
+    get pcmModel(): PCMModel | null;
+    get pcmModel$(): Observable<PCMModel | null>;
+    reset(): void;
+    init$(props: RuntimeInitializationProps): Observable<PCMModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationRuntimeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationRuntimeService>;
+}
+
+declare class RuntimeSettingsService {
+    private configurationSettingsApiService;
+    private configurationSettings$;
+    private currencySettings$;
+    private formattingSettings;
+    private shoppingCartSettings$;
+    constructor(configurationSettingsApiService: ConfigurationSettingsApiService);
+    create(): Observable<void>;
+    initCurrency(iso?: string): void;
+    getFormattingSettings(): FormattingSettings;
+    getConfigurationSettings(): RuntimeConfigurationSettings;
+    getShoppingCartSettings(): ShoppingCartSetting[];
+    getCurrencySettings(): RuntimeCurrencySettings;
+    private parseConfigurationSettings;
+    private getCurrencySymbol;
+    addShoppingCartSettings(settings: ShoppingCartSetting[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuntimeSettingsService>;
+}
+
+declare class FlowInfoService {
+    private runtimeSettingsService;
+    private templatesAdminApiService;
+    private customizationService?;
+    flow$: Observable<Flow | null>;
+    templates$: Observable<{
+        [key in UITemplateType]?: UITemplate;
+    }>;
+    private readonly defaultTemplates;
+    private flowSubj$;
+    private templatesSubj$;
+    private contextSubj$;
+    constructor(runtimeSettingsService: RuntimeSettingsService, templatesAdminApiService: UITemplatesAdminApiService, customizationService?: FlowCustomization | undefined);
+    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 isFlowEngineInitialized$(): Observable<boolean>;
+    get isStateful(): boolean;
+    reset(): void;
+    init$(flowId: string, routeQueryParams: Params): Observable<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>;
+}
+
+interface GuidedSellingSubmitData {
+    orchestrationName: string;
+    attributesMap: Record<string, any>;
+}
+interface ExternalConfigurationProps {
+    productId: string;
+    qty?: number;
+    attributesMap?: Record<string, any>;
+}
+interface NewConfigurationProps extends ExternalConfigurationProps {
+    product: Product;
+}
+interface TestModeConfigurationOptions {
+    customizationMode?: boolean;
+}
+interface QuantityChangeProps {
+    id: string;
+    qty: number;
+}
+
+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>;
+}
+
+declare class ConfigurationService {
+    private flowInfoService;
+    private messageService;
+    private configurationRuntimeService;
+    private salesTransactionService;
+    private orchestrationsApiService;
+    private guidedSellingService;
+    isLoading$: Observable<boolean>;
+    hasUnsavedChanges: boolean;
+    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;
+    init$(): Observable<void>;
+    patch$(transactionItem: SalesTransactionItem): Observable<void>;
+    patch(transactionItem: SalesTransactionItem): void;
+    configure$(transactionContext: TransactionContext): Observable<TransactionContext>;
+    justConfigureRequest$(transactionContext: TransactionContext): Observable<TransactionContext>;
+    getPCMModel(): PCMModel;
+    getPCMModel$(): Observable<PCMModel | null>;
+    swapProduct$(productId: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationService>;
+}
+
+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>;
+}
+
+declare class FlowConfigurationService {
+    private orchestrationsApiService;
+    private salesTransactionService;
+    private flowInfoService;
+    updated$: Observable<void>;
+    private updatedSubj$;
+    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;
+    private handleErrorAndBounceBack;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowConfigurationService>;
+}
+
+interface FlowStateSubscriptionOptions {
+    /**
+     * When 'true', don't execute action to retrieve current value
+     */
+    cold?: boolean;
+    trackedChanges?: boolean;
+}
+
+declare class FlowStateService {
+    private flowConfiguration;
+    private flowInfoService;
+    private flowStateApiService;
+    private processorsApiService;
+    private salesTransactionApiService;
+    private salesTransactionService;
+    private toastService;
+    private customizationService?;
+    private readonly NOT_INITIALIZED;
+    private readonly EXECUTION_BUFFER_TIME;
+    private executedFunctions;
+    private stateId$;
+    private initialStatefulData;
+    private trackedStatefulChangesMap;
+    private processors;
+    private subscriptions;
+    private flowStore;
+    private executionInProgress$;
+    private statefulRequestStream$;
+    private statefulExecutionRequest$;
+    private cleanup$;
+    constructor(flowConfiguration: FlowConfigurationService, flowInfoService: FlowInfoService, flowStateApiService: FlowStateApiService, processorsApiService: ConfigurationProcessorsApiService, salesTransactionApiService: SalesTransactionApiService, salesTransactionService: SalesTransactionService, toastService: ToastService, customizationService?: FlowCustomization | undefined);
+    init$(): Observable<void>;
+    reset(): 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<{
+        id: 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 executeStateless$;
+    private executeStatelessActions;
+    private executeStatelessSelectors;
+    private initProcessors$;
+    private executeActionScript;
+    private executeSelectorScript;
+    private executeProcessorScript;
+    private generateRequestId;
+    private checkStatefulChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowStateService, [null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowStateService>;
+}
+
+declare class FlowStateConfigurationService {
+    private flowInfoService;
+    private flowStateService;
+    private configurationService;
+    private salesTransactionService;
+    private flowConfigurationService;
+    private pcmApiService;
+    private pcmCache;
+    constructor(flowInfoService: FlowInfoService, flowStateService: FlowStateService, configurationService: ConfigurationService, salesTransactionService: SalesTransactionService, flowConfigurationService: FlowConfigurationService, pcmApiService: PCMApiService);
+    updateQuantity$(props: QuantityChangeProps): Observable<void>;
+    addToCart$(props: NewConfigurationProps): Observable<void>;
+    private configureExternal$;
+    private getPCMProduct$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowStateConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowStateConfigurationService>;
+}
+
+declare class IntegrationState<S = IntegrationStateModel> {
+    private readonly stateSubj$;
+    private readonly action$;
+    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>;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntegrationState<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IntegrationState<any>>;
+}
+
+declare class ProductImagesService {
+    private productsAdminApiService;
+    private imagesMap$;
+    constructor(productsAdminApiService: ProductsAdminApiService);
+    getImageUrl$(productId: string): Observable<string | null>;
+    private fetchProductImage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductImagesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductImagesService>;
+}
+
+declare class CatalogProductsService {
+    private stateSubj$;
+    state$: rxjs.Observable<CatalogProducts>;
+    get state(): CatalogProducts | null;
+    reset(): void;
+    setState(state: CatalogProducts): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogProductsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogProductsService>;
+}
+
+declare class ConfigurationStateService {
+    private configurationRuntimeService;
+    private configurationService;
+    private flowStateService;
+    private flowInfoService;
+    private flowConfigurationService;
+    private flowStateApiService;
+    private salesTransactionService;
+    private salesTransactionApiService;
+    private toastService;
+    private pcmApiService;
+    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 executionInProgress$;
+    private statefulRequestStream$;
+    private statefulExecutionRequest$;
+    private statelessExecutionRequest$;
+    constructor(configurationRuntimeService: ConfigurationRuntimeService, configurationService: ConfigurationService, flowStateService: FlowStateService, flowInfoService: FlowInfoService, flowConfigurationService: FlowConfigurationService, flowStateApiService: FlowStateApiService, salesTransactionService: SalesTransactionService, salesTransactionApiService: SalesTransactionApiService, toastService: ToastService, pcmApiService: PCMApiService);
+    get isExecutionInProgress$(): Observable<boolean>;
+    init$(): Observable<void>;
+    cleanup(): void;
+    execute$(exec: FlowStateExecutionRequest): Observable<FlowStateExecutionResult['selectors']>;
+    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(): Observable<SalesTransactionUpsertResponse>;
+    cancelConfiguration(): Observable<void>;
+    private get isStatefulConfiguration();
+    private initStateful$;
+    private execToRequest;
+    private handleSelectorsResponse;
+    private executeRequest$;
+    private executeStateless$;
+    private initBufferedRequest$;
+    private executeStateful$;
+    private executeActionScript;
+    private executeSelectorScript;
+    private executeProcessorScript;
+    private runStatelessSelectors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationStateService>;
+}
+
+declare class TestModeConfigurationService {
+    private flowInfoService;
+    private configurationService;
+    private configurationRuntimeService;
+    private salesTransactionService;
+    private runtimeSettingsService;
+    private sfApiService;
+    private isInitialized;
+    private pcmModel?;
+    constructor(flowInfoService: FlowInfoService, configurationService: ConfigurationService, configurationRuntimeService: ConfigurationRuntimeService, salesTransactionService: SalesTransactionService, runtimeSettingsService: RuntimeSettingsService, sfApiService: SalesforceApiService);
+    initTestMode$(uiDefinitionContainer: UIDefinitionContainer, options?: TestModeConfigurationOptions): Observable<void>;
+    private initConfiguration$;
+    private getPriceBookId;
+    private getTestTransactionContext;
+    private checkInitialized;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TestModeConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TestModeConfigurationService>;
+}
+
+declare function filterSuccessfulExecute<T>(): (source: Observable<FlowStateSelectorResponse<T>>) => Observable<T>;
+
+declare class DatePipe implements PipeTransform, OnDestroy {
+    private locale;
+    private defaultOptions;
+    private formattingSettings;
+    private destroy$;
+    ngOnDestroy(): void;
+    transform(date: string | number | Date | undefined | null, type?: DateType): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DatePipe, "vlDate", false>;
+}
+
+declare class NumberPipe implements PipeTransform, OnDestroy {
+    private formattingSettings;
+    private destroy$;
+    ngOnDestroy(): void;
+    transform(price: string | number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NumberPipe, "vlNumber", false>;
+}
+
+declare class PricePipe implements PipeTransform, OnDestroy {
+    private formattingSettings;
+    private destroy$;
+    ngOnDestroy(): void;
+    transform(price: string | number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PricePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PricePipe, "vlPrice", false>;
+}
+
+declare class ActionCodePipe implements PipeTransform {
+    private formattingSettings;
+    transform(actionCode: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionCodePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ActionCodePipe, "vlActionCode", false>;
+}
+
+declare class SdkPipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdkPipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SdkPipesModule, [typeof NumberPipe, typeof PricePipe, typeof DatePipe, typeof ActionCodePipe], never, [typeof NumberPipe, typeof PricePipe, typeof DatePipe, typeof ActionCodePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SdkPipesModule>;
+}
+
+declare class PCMUtils {
+    static mapByPrcId(pcm: PCMProduct): Dictionary<PCMProduct>;
+}
+
+declare const findTransactionItem: (id: string, items: SalesTransactionItem[]) => SalesTransactionItem | undefined;
+declare const findTransactionItemWithComparator: (items: SalesTransactionItem[], comparator: (ti: SalesTransactionItem) => boolean) => SalesTransactionItem | undefined;
+declare const insertTransactionItem: (item: SalesTransactionItem, parentId: string, toInsert: SalesTransactionItem) => SalesTransactionItem;
+declare const removeTransactionItem: (item: SalesTransactionItem, idToRemove: string) => SalesTransactionItem;
+declare const replaceTransactionItem: (item: SalesTransactionItem, replaceTo: SalesTransactionItem) => SalesTransactionItem;
+declare const generateTransactionItem: (option: PCMModel, salesTransactionId?: string, qty?: number, parentTi?: SalesTransactionItem) => SalesTransactionItem;
+declare const generateTransactionItemFromPCM: (option: PCMModel, salesTransactionId?: string, parentTi?: SalesTransactionItem) => SalesTransactionItem;
+declare const flattenTransactionItem: (ti: SalesTransactionItem) => SalesTransactionItem[];
+declare const updateQuantity: (ti: SalesTransactionItem, qty: number, pcm: PCMProduct, parentQty?: number) => SalesTransactionItem;
+
+declare class TransactionItemWorker {
+    ti: SalesTransactionItem;
+    constructor(src: SalesTransactionItem);
+    insert(parentId: string, toInsert: SalesTransactionItem): TransactionItemWorker;
+    remove(id: string): TransactionItemWorker;
+    replace(toReplace: SalesTransactionItem): TransactionItemWorker;
+}
+
+declare function extractMetadata(uiDefinition: UIDefinition): UIDefinitionMetadata;
+
+export { ActionCodePipe, CalendarDirective, CatalogProductsService, ConfigurationRuntimeService, ConfigurationService, ConfigurationStateService, DEFAULT_FORMATTING_SETTINGS, DatePipe, FLOW_CUSTOMIZATION, FORMATTING_SETTINGS_TOKEN, FlowConfigurationService, FlowInfoService, FlowStateConfigurationService, FlowStateService, GuidedSellingService, IntegrationState, NumberPipe, PCMUtils, PricePipe, ProductImagesService, RuntimeSettingsService, SalesTransactionService, SdkCoreModule, SdkDirectivesModule, SdkPipesModule, TestModeConfigurationService, TransactionItemWorker, UI_DEFINITION_VERSION, extractMetadata, filterSuccessfulExecute, findTransactionItem, findTransactionItemWithComparator, flattenTransactionItem, generateTransactionItem, generateTransactionItemFromPCM, insertTransactionItem, removeTransactionItem, replaceTransactionItem, updateQuantity };
+export type { DateType, ExternalConfigurationProps, FlowCustomization, FormattingSettings, GuidedSellingSubmitData, IntegrationAction, IntegrationStateModel, NewConfigurationProps, QuantityChangeProps, RuntimeInitializationProps, TestModeConfigurationOptions };