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, true, never>;
}

declare class SdkDirectivesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SdkDirectivesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SdkDirectivesModule, never, [typeof CalendarDirective], [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>;
    patchState$(context: TransactionContext): Observable<void>;
    patchState(context: TransactionContext): 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", true>;
}

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", true>;
}

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", true>;
}

declare class ActionCodePipe implements PipeTransform {
    private formattingSettings;
    transform(actionCode: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionCodePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ActionCodePipe, "vlActionCode", true>;
}

declare class SdkPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SdkPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SdkPipesModule, never, [typeof NumberPipe, typeof PricePipe, typeof DatePipe, typeof ActionCodePipe], [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 };