import * as i4 from '@veloceapps/sdk/core';
import { IntegrationState, ConfigurationService, ConfigurationStateService, GuidedSellingService, filterSuccessfulExecute, FlowInfoService, FlowConfigurationService, FlowStateService, FlowStateConfigurationService, TransactionItemWorker, ProductImagesService, RuntimeSettingsService, ActionCodePipe, DatePipe, NumberPipe, PricePipe, SalesTransactionService, PCMUtils } from '@veloceapps/sdk/core';
export { IntegrationAction, IntegrationState, IntegrationStateModel } from '@veloceapps/sdk/core';
import * as i0 from '@angular/core';
import { Injector, OnChanges, OnInit, DoCheck, AfterContentInit, AfterContentChecked, AfterViewInit, AfterViewChecked, OnDestroy, SimpleChanges, NgModuleRef, NgModule, Type, ComponentRef, ViewContainerRef, ChangeDetectorRef, InjectionToken, TemplateRef } from '@angular/core';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Observable, Subject, ReplaySubject } from 'rxjs';
import * as i2$1 from '@veloceapps/components';
import { ToastService, ToastType } from '@veloceapps/components';
import * as _veloceapps_core from '@veloceapps/core';
import { UIDefinition, UIDefinitionMetadata, UIElement, Operator, Predicate, parseJsonSafely, parseJwt, TokenInfoService, UITemplateType } from '@veloceapps/core';
import lodash, { Dictionary } from 'lodash';
import { Patch } from 'rfc6902';
import * as i1 from '@angular/common';
import * as i2 from 'ngx-drag-drop';
import { DndDropEvent } from 'ngx-drag-drop';
import * as i3 from '@veloceapps/api';
import { ContractedPriceApiService } from '@veloceapps/api';
import * as _veloceapps_sdk_cms from '@veloceapps/sdk/cms';
import { DataSource } from '@angular/cdk/collections';
import * as angularForms from '@angular/forms';
import { CatalogApiService, ConfigurationSettingsApiService, DocumentAttachmentApiService, GuidedSellingApiService, SalesforceApiService, SalesTransactionApiService, ShoppingCartSettingsApiService } from '@veloceapps/api/v2';
import * as rxjsOperators from 'rxjs/operators';

declare namespace FlowAction {
    const FLOW_CONFIGURE_PRODUCT = "[FLOW]_CONFIGURE_PRODUCT";
    const FLOW_NAVIGATE_BACK = "[FLOW]_NAVIGATE_BACK";
    const FLOW_NAVIGATE_TO = "[FLOW]_NAVIGATE_TO";
    const FLOW_NAVIGATE_TO_CATALOG = "[FLOW]_NAVIGATE_TO_CATALOG";
    const FLOW_NAVIGATE_TO_SHOPPING_CART = "[FLOW]_NAVIGATE_TO_SHOPPING_CART";
    const FLOW_APPLY_PRODUCT_CONFIGURATION = "[FLOW]_APPLY_PRODUCT_CONFIGURATION";
    const FLOW_OPEN_DOC_GEN = "[FLOW]_OPEN_DOC_GEN";
    const FLOW_CLOSE_DOC_GEN = "[FLOW]_CLOSE_DOC_GEN";
    const FLOW_SWITCH_OBJECT = "[FLOW]_SWITCH_OBJECT";
    const REMOTE_APPLY = "[FLOW]_REMOTE_APPLY";
    const REMOTE_CANCEL = "[FLOW]_REMOTE_CANCEL";
    const OPEN_GUIDED_SELLING = "[FLOW]_OPEN_GUIDED_SELLING";
    const SUBMIT_GUIDED_SELLING = "[FLOW]_SUBMIT_GUIDED_SELLING";
    const CLOSE_GUIDED_SELLING = "[FLOW]_CLOSE_GUIDED_SELLING";
    const OPEN_DIALOG = "[FLOW]_OPEN_DIALOG";
    const ConfigureProductAction: ({ transactionItemId, productId, qty, }: {
        transactionItemId?: string;
        productId?: string;
        qty?: number;
    }) => {
        type: string;
        payload: {
            transactionItemId: string | undefined;
            productId: string | undefined;
            qty: number | undefined;
        };
    };
    const NavigateBackAction: () => {
        type: string;
    };
    const NavigateToAction: (path: string, productId?: string, transactionItemId?: string) => {
        type: string;
        payload: {
            path: string;
            productId: string | undefined;
            transactionItemId: string | undefined;
        };
    };
    const NavigateToCatalogAction: () => {
        type: string;
    };
    const NavigateToShoppingCartAction: () => {
        type: string;
    };
    const ApplyProductConfigurationAction: () => {
        type: string;
    };
    const RemoteApplyAction: () => {
        type: string;
    };
    const RemoteCancelAction: () => {
        type: string;
    };
    const SwitchObjectAction: (payload: {
        id: string;
    }) => {
        type: string;
        payload: {
            id: string;
        };
    };
    const OpenGuidedSelling: (payload: {
        guidedSellingId: string;
    }) => {
        type: string;
        payload: {
            guidedSellingId: string;
        };
    };
    const CloseGuidedSelling: (payload?: {
        keepState?: boolean;
    }) => {
        type: string;
        payload: {
            keepState?: boolean;
        } | undefined;
    };
    const SubmitGuidedSelling: (payload: {
        result: Record<string, any>;
    }) => {
        type: string;
        payload: {
            result: Record<string, any>;
        };
    };
    const OpenDialog: (dialog: string) => {
        type: string;
        payload: {
            dialog: string;
        };
    };
}
declare namespace CmsAction {
    const GO_TO_PAGE = "[CMS]_GO_TO_PAGE";
    const UPDATE_CUSTOMIZATION = "[CMS]_UPDATE_CUSTOMIZATION";
    const SHOW_OVERLAY = "[CMS]_SHOW_OVERLAY";
    const HIDE_OVERLAY = "[CMS]_HIDE_OVERLAY";
    const HIDE_ALL_OVERLAYS = "[CMS]_HIDE_ALL_OVERLAYS";
    /**
     * Navigate UI definition to a specific page
     *
     * @param pageName name of the page
     */
    const GoToPage: (pageName: string) => {
        type: string;
        payload: {
            pageName: string;
        };
    };
    /**
     * Update UI definition customization state
     *
     * @param pageName name of the page
     */
    const UpdateCustomization: (value: any) => {
        type: string;
        payload: {
            value: any;
        };
    };
    /**
     * Show an Overlay on the selected page
     *
     * @param name - name of the overlay
     * @returns void
     */
    const ShowOverlay: (name: string) => {
        type: string;
        payload: {
            name: string;
        };
    };
    /**
     * Hide an Overlay on the selected page
     *
     * @param name - name of the overlay
     * @returns void
     */
    const HideOverlay: (name: string) => {
        type: string;
        payload: {
            name: string;
        };
    };
    /**
     * Hide all Overlays on the selected page
     *
     * @returns void
     */
    const HideAllOverlays: () => {
        type: string;
    };
}

/**
 * List of available layouts for Full Page Type:
 *
        LAYOUT_1
        +-------------------------+
        |        1. HEADER        |
        |-------------------------|
        |                         |
        |       2. CONTAINER      |
        |                         |
        |-------------------------|
        |        3. FOOTER        |
        +-------------------------+

        LAYOUT_2
        +-------------------------+
        |        1. HEADER        |
        |------------+------------|
        |            |            |
        | 2. LEFT    |  3. RIGHT  |
        |            |            |
        |------------+------------|
        |        4. FOOTER        |
        +-------------------------+

        LAYOUT_3
        +-------------------------+
        |                         |
        |                         |
        |       1. CONTAINER      |
        |                         |
        |                         |
        |-------------------------|
        |        2. FOOTER        |
        +-------------------------+

        LAYOUT_4
        +-------------------------+
        |            |            |
        |            |            |
        | 1. LEFT    |  2. RIGHT  |
        |            |            |
        |            |            |
        |------------+------------|
        |        3. FOOTER        |
        +-------------------------+

        LAYOUT_5
        +-------------------------+
        |        1. HEADER        |
        |-------------------------|
        |                         |
        |                         |
        |       2. CONTAINER      |
        |                         |
        |                         |
        +-------------------------+

        LAYOUT_6
        +-------------------------+
        |                         |
        |                         |
        |                         |
        |       1. CONTAINER      |
        |                         |
        |                         |
        |                         |
        +-------------------------+
 */
/**
 * List of available layouts for Sidepanel Page Type:
 *
        LAYOUT_7
        +-------------------------+
        |       |                 |
        |       |                 |
        | LEFT  |    DISABLED     |
        | SIDE  |    PAGE         |
        | PANEL |                 |
        |       |                 |
        |       |                 |
        +-------------------------+

        LAYOUT_8
        +-------------------------+
        |                 |       |
        |                 |       |
        |     DISABLED    | RIGHT |
        |     PAGE        | SIDE  |
        |                 | PANEL |
        |                 |       |
        |                 |       |
        +-------------------------+
 */
type FullPageLayout = 'LAYOUT_1' | 'LAYOUT_2' | 'LAYOUT_3' | 'LAYOUT_4' | 'LAYOUT_5' | 'LAYOUT_6';
type SidepanelPageLayout = 'LAYOUT_7' | 'LAYOUT_8';
type PageLayout = FullPageLayout | SidepanelPageLayout;
interface PageLayoutConfig {
    hasHeader: boolean;
    hasFooter: boolean;
    styles?: string;
}

declare const LAYOUT: {
    [key in PageLayout]: PageLayoutConfig;
};

declare class Plugin {
    readonly host: Entity;
    constructor(host: Entity);
}

declare class Entity {
    injector: Injector;
    protected readonly plugins: Plugin[];
    private config;
    private defaultPlugins;
    constructor(injector: Injector);
    initPlugins(): void;
    registerPlugin(plugin: Plugin): void;
}

type AngularHooks = OnChanges & OnInit & DoCheck & AfterContentInit & AfterContentChecked & AfterViewInit & AfterViewChecked & OnDestroy;
interface IPluginComponent extends Partial<AngularHooks> {
    host: ElementComponent;
}

declare class ElementComponent extends Entity implements OnChanges, OnInit, DoCheck, AfterContentInit, AfterViewInit, AfterViewChecked, OnDestroy {
    injector: Injector;
    readonly model$: BehaviorSubject<any>;
    readonly plugins: IPluginComponent[];
    constructor(injector: Injector);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngDoCheck(): void;
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
}

interface CMSPreviewConfig {
    /**
     * When `true`, IntegrationState will be cleared on component init
     */
    clearStateOnInit?: boolean;
    /**
     * When `true`, preview adds additional components/plugins needed for UIBuilder
     * (like element hover/selection or Drag&Drop zones)
     */
    uiBuilderMode?: boolean;
    /**
     * When `true`, preview renders settings page (element with `type: CUSTOMIZATION_PAGE`)
     */
    customizationMode?: boolean;
    /**
     * Custom initialization function which will be executed before starting a preview
     */
    init$?: () => Observable<void>;
}

type PageType = 'FULL_PAGE' | 'SIDEPANEL';

type ELEMENT_TYPE = 'CUSTOMIZATION_PAGE' | 'CUSTOM' | 'CONTAINER' | 'SERVICE' | 'REFERENCE' | 'PAGE' | 'REGION';
type ElementStyleDeclaration = Partial<CSSStyleDeclaration>;
interface ElementConfig {
    component: typeof Entity;
    plugins?: (typeof Plugin)[];
    defaultTemplate?: string;
    suppressTemplate?: boolean;
    suppressStyles?: boolean;
    builder?: {
        suppressRemovable?: boolean;
    };
}
interface ElementModel {
    /**
     * Defines a path for an element model.
     * It's combined with a path to a target element and an output property name.
     *
     * If target value is an Array, then the element will be repeated `n` times and each instance will get it's own value.
     *
     * Examples:
     * - `/Root/Services/DataService/:products`
     * - `../../Services/DataService/:products`
     * - `@Services/DataService/:products`
     */
    path?: string;
    /**
     * @deprecated
     * To be removed!!!
     * Used only when `UIDefinitionType = CONFIGURATION`.
     */
    lineItem?: string;
}
interface ElementDefaultMetadata {
    name: string;
    type: ELEMENT_TYPE;
    /**
     * Make component shared
     *
     * Used only when `type !== REFERENCE`
     */
    isShared?: boolean;
    /**
     * Element module name. Module is used for quick access from other elements.
     *
     * For example we have a `DataService` element, and we say it's declared in `Services` module. Then it can be accessed in other elements `model`, `inputs` or `outputs` properties this way: `@Services/DataService`
     *
     */
    module?: string;
    /**
     * Defines inputs of the element. An object where `key` is the name of the input and `value` is target path
     *
     * If `value == null`, then the element acts like a target - we expect other element to connect to it.
     *
     * Examples:
     *
     * 1. `products: '/Root/Services/DataService'`
     * The element will have `products` input which will get the data from `products` output in dataservice element
     *
     * 2. `productsList: '/Root/Services/DataService/:products'`
     * The element will have `productsList` input which will get the data from `products` output in dataservice element
     *
     * 3. `productsList: '@Services/DataService/:products'`
     * The element will have `productsList` input which will get the data from `products` output in dataservice element which is declared in `Services` module
     *
     * 4. `onProductSelect: null`
     * The element will have `onProductSelect` input, and the script could have a logic which will listen on the events
     *
     * Relative paths allowed:
     *
     * - `..`
     * - `../:products`
     * - `../../DataService/:products`
     *
     * Input which name starts with '@' is being added to the element as Angular input (suppressing '@' symbol)
     */
    inputs?: Dictionary<string | null>;
    /**
     * Defines outputs of the element. An object where `key` is the name of the output and `value` is target path
     *
     * If `value == null`, then the element acts like a target - we expect other element to connect to it.
     *
     * Examples:
     *
     * 1. `onProductSelect: '/Root/Services/DataService/:handleProductSelect'`
     * The element will have `onProductSelect` output, which will emit events to the `dataservice` element `handleProductSelect` input
     *
     * 2. `onProductSelect: '@Services/DataService/:handleProductSelect'`
     * Same output but accessing dataservice by the Service module
     *
     * * Output which name starts with '@' is being added to the element as Angular output (suppressing '@' symbol)
     */
    outputs?: Dictionary<string | null>;
    model?: ElementModel;
    /**
     * Defines a shared component name to use as a reference
     *
     * Used only when `type === REFERENCE`
     */
    reference?: string;
    children?: string[];
    /**
     * Contains styles configurable from UI builder
     */
    configuredStyles?: ElementStyleDeclaration;
    /**
     * Page layout
     *
     * Used only when `type === PAGE`
     */
    layout?: PageLayout;
    /**
     * Page Type
     *
     * Used only when `type === PAGE`
     */
    pageType?: PageType;
}
interface ElementMetadata extends Omit<ElementDefaultMetadata, 'children'> {
    path: string;
    children: ElementMetadata[];
    template?: string;
    styles?: string;
    script?: string;
    metadata?: string;
}

interface CompilationResult {
    elements: ElementMetadata[];
    moduleRef: NgModuleRef<NgModule>;
    componentTypes: Record<string, Type<Entity>>;
}

type ScriptHost<T = Record<string, any>> = Pick<ElementComponent, 'injector'> & T;

interface ElementPath {
    isAbsolute: boolean;
    segments: string[];
    module?: string;
    variable?: string;
}
interface PathBlock {
    type: string;
    property?: string;
    name?: string;
}

declare class RuntimeService {
    private injector;
    private integrationState;
    moduleRefs: NgModuleRef<NgModule>[];
    componentRefs: Dictionary<ComponentRef<Entity> | undefined>;
    componentTypes: Record<string, Type<Entity>>;
    applicationTree: ElementMetadata[];
    config?: CMSPreviewConfig;
    isInitialized$: BehaviorSubject<boolean>;
    updated$: Subject<void>;
    selectedPageName$: BehaviorSubject<string | null>;
    selectedOverlayNames$: BehaviorSubject<string[]>;
    private compilationService;
    constructor(injector: Injector, integrationState: IntegrationState);
    initialize$(uiDefinition?: UIDefinition, config?: CMSPreviewConfig): Observable<ElementMetadata[]>;
    applyPatch$(patch: Patch): Observable<void>;
    getCompiledElement$(path: string): Observable<ElementMetadata | undefined>;
    clear(): void;
    private addElement$;
    private deleteElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RuntimeService>;
}

interface State {
    loading: boolean;
    failure: boolean;
}
declare class PreviewComponent implements OnInit, OnDestroy {
    private runtimeService;
    private toastService;
    private integrationState;
    uiDefinition?: UIDefinition;
    config?: CMSPreviewConfig;
    state$: BehaviorSubject<State>;
    elements$: BehaviorSubject<ElementMetadata[]>;
    private destroy$;
    constructor(runtimeService: RuntimeService, toastService: ToastService, integrationState: IntegrationState);
    ngOnInit(): void;
    ngOnDestroy(): void;
    trackBy(_: number, el: ElementMetadata): ElementMetadata;
    private startPreview;
    private getElements$;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewComponent, "vl-cms-preview", never, { "uiDefinition": { "alias": "uiDefinition"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ElementContextService {
    metadata?: ElementMetadata;
    static ɵfac: i0.ɵɵFactoryDeclaration<ElementContextService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ElementContextService>;
}

declare class IOProviderService {
    private runtimeService;
    private inputs;
    constructor(runtimeService: RuntimeService);
    connect(el: ElementMetadata, name: string, target?: string | null): Observable<any> | undefined;
    provide(el: ElementMetadata, name: string, target?: string | null): BehaviorSubject<any> | undefined;
    private resolveTarget;
    private createSubjectSafe;
    static ɵfac: i0.ɵɵFactoryDeclaration<IOProviderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IOProviderService>;
}

declare class ElementRendererComponent implements OnInit, OnDestroy {
    private runtimeService;
    private elementContext;
    private ioProviderService;
    private cdr;
    el?: ViewContainerRef;
    meta: ElementMetadata;
    private type?;
    private refs;
    private destroy$;
    constructor(runtimeService: RuntimeService, elementContext: ElementContextService, ioProviderService: IOProviderService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private createComponents;
    private createFromPath;
    private processChildren;
    private createComponent;
    private updateComponent;
    private destroyComponent;
    private destroyComponents;
    static ɵfac: i0.ɵɵFactoryDeclaration<ElementRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ElementRendererComponent, "vl-cms-element-renderer", never, { "meta": { "alias": "meta"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ElementRendererModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ElementRendererModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementRendererModule, never, [typeof ElementRendererComponent], [typeof ElementRendererComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ElementRendererModule>;
}

interface RuntimeElementDropEvent {
    element: ElementMetadata;
    path: string;
    index: number;
}
interface RuntimeElementDeleteEvent {
    path: string;
}
interface RuntimeShowSettingsEvent {
    path: string;
}

declare class RuntimeEditorService {
    private runtimeService;
    private editorModeSubj$;
    onElementDropped$: ReplaySubject<RuntimeElementDropEvent>;
    onElementDeleted$: ReplaySubject<RuntimeElementDeleteEvent>;
    onElementSettingsToggled$: ReplaySubject<RuntimeShowSettingsEvent>;
    editorMode$: Observable<boolean>;
    dragMode$: BehaviorSubject<boolean>;
    selectedElementPath$: BehaviorSubject<string | null>;
    constructor(runtimeService: RuntimeService);
    applyPatch$(patch: Patch): Observable<void>;
    toggleEditorMode(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RuntimeEditorService>;
}

declare class ElementDropHandleComponent {
    private runtimeService;
    index: number;
    parentPath: string;
    constructor(runtimeService: RuntimeEditorService);
    handleDrop(e: DndDropEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ElementDropHandleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ElementDropHandleComponent, "vl-element-drop-handle", never, { "index": { "alias": "index"; "required": false; }; "parentPath": { "alias": "parentPath"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ElementDropHandleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ElementDropHandleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementDropHandleModule, never, [typeof i1.CommonModule, typeof i2.DndModule, typeof ElementDropHandleComponent], [typeof ElementDropHandleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ElementDropHandleModule>;
}

declare class ElementChildrenComponent implements OnDestroy {
    private elementContext;
    private runtimeService;
    private runtimeEditorService;
    private cdr;
    filter?: (elements: ElementMetadata[]) => ElementMetadata[];
    metadata$: Observable<ElementMetadata | undefined>;
    dragMode$: Observable<boolean>;
    private destroyed$;
    constructor(elementContext: ElementContextService, runtimeService: RuntimeService, runtimeEditorService: RuntimeEditorService, cdr: ChangeDetectorRef);
    ngOnDestroy(): void;
    getFilteredChildren(elements: ElementMetadata[]): ElementMetadata[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ElementChildrenComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ElementChildrenComponent, "element-children", never, { "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ElementChildrenModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ElementChildrenModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementChildrenModule, never, [typeof i1.CommonModule, typeof i2$1.LetDirectiveModule, typeof ElementRendererModule, typeof ElementDropHandleModule, typeof ElementChildrenComponent], [typeof ElementChildrenComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ElementChildrenModule>;
}

declare class ElementToolsPanelComponent {
    private readonly metadata;
    private readonly config;
    private readonly elementRef;
    runtimeEditorService?: RuntimeEditorService;
    showDeleteButton: boolean;
    constructor();
    deleteHandler(): void;
    showSettingsHandler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ElementToolsPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ElementToolsPanelComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

declare class PreviewModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PreviewModule, never, [typeof i1.CommonModule, typeof i2$1.LoaderModule, typeof ElementRendererModule, typeof ElementChildrenModule, typeof ElementDropHandleModule, typeof ElementToolsPanelComponent, typeof PreviewComponent], [typeof PreviewComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PreviewModule>;
}

declare function ElementDefinition(definition: ElementDefaultMetadata): (constructor: any) => any;

declare const DEFAULT_ELEMENT: Partial<ElementMetadata>;
declare const STARTING_PAGE_NAME = "Starting Page";
declare const STARTING_PAGE_TYPE: PageType;
declare const STARTING_PAGE_LAYOUT: FullPageLayout;
declare const STARTING_PAGE_STYLES: ElementStyleDeclaration;

declare const DEFAULT_PLUGINS_TOKEN: InjectionToken<(typeof Plugin)[]>;
declare const UI_DEFINITION_METADATA: InjectionToken<UIDefinitionMetadata>;
declare const ELEMENT_METADATA: InjectionToken<ElementMetadata>;
declare const SHARED_ELEMENT_METADATA: InjectionToken<ElementMetadata | undefined>;
declare const ELEMENT_CONFIG: InjectionToken<ElementConfig>;

declare class RuntimeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<RuntimeModule, never, [typeof i1.CommonModule, typeof _veloceapps_core.CoreModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<RuntimeModule>;
}

declare class LauncherModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LauncherModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LauncherModule, never, [typeof i1.CommonModule, typeof _veloceapps_core.CoreModule, typeof i3.ApiModule, typeof i4.SdkCoreModule, typeof RuntimeModule, typeof PreviewModule], [typeof PreviewModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LauncherModule>;
}

type FederatedModuleOptions = {
    /**
     * URL to the federated container
     * i.e. http://localhost:4200/remoteIntegrationModule.js
     */
    remoteEntry?: string;
    /**
     * Name of exposed Angular module
     */
    exposedModule?: string;
    /**
     * Suppress remote module loading process spinner
     */
    suppressLoading?: boolean;
    /**
     * Loading label. Default: LOADING
     */
    loadingLabel?: string;
    /**
     * Ready callback is called when remote module has been loaded
     */
    onReady?: () => void;
};
interface FederatedComponentInstance<D = unknown> {
    data?: D;
}

declare class MigrationsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MigrationsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MigrationsModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MigrationsModule>;
}

declare class MigrationsService {
    private toastService;
    constructor(toastService: ToastService);
    migrateUIDefinition(uiDef: UIDefinition): UIDefinition | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<MigrationsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MigrationsService>;
}

declare class ResourcesService {
    private scripts;
    private loaded$;
    /**
     * ngx-monaco-editor adds amd-loader library for loading resources when first time initialized
     * Which breaks further loading of 3rd party libaries.
     *
     * To handle this issue, in case 'amd' is defined, we clear it, and then restore when the script is loaded
     */
    private amd;
    loadScript(url: string): Observable<void>;
    loadStyles(url: string): Observable<void>;
    loadStyles(host: ScriptHost, url: string): Observable<void>;
    private persistAMDLoader;
    private restoreAMDLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResourcesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResourcesService>;
}

type Template = TemplateRef<any> | undefined;
declare class TemplatesService {
    private templates;
    register(name: string, templateRef: TemplateRef<any>): void;
    get(name: string): Template;
    get$(name: string): Observable<Template>;
    private ensureStorage;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplatesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TemplatesService>;
}

declare class ElementMetadataWorker {
    private elements;
    constructor(elements: UIElement[]);
    get$(): Observable<ElementMetadata[]>;
    private processAsync;
    private processLevelAsync;
    private elementToMetadataAsync;
}

declare class UiBuildError extends Error {
    affectedMetadata: ElementMetadata;
    constructor(message: string, affectedMetadata: ElementMetadata);
}
declare const elementToMetadata: (el: UIElement, parentPath?: string) => ElementMetadata;
declare const metadataToElement: (metadata: ElementMetadata, recursive?: boolean) => UIElement;
declare const normalizeElementMetadata: (elementMetadata: ElementDefaultMetadata) => ElementDefaultMetadata;
declare const extractElementMetadata: (script: string) => ElementDefaultMetadata;
declare const extendElementMetadata: (script: string, extend: Partial<ElementDefaultMetadata>) => string;
declare const getElementConfig: (type: ELEMENT_TYPE) => ElementConfig;
declare const doesElementSupportIO: (type: ELEMENT_TYPE) => boolean;
declare function stringifyElementMetadata(elementMetadata: ElementDefaultMetadata): string;
declare const isValidScript: (script?: string) => boolean;
declare function flattenElements(elements: ElementMetadata[]): ElementMetadata[];
declare function isSharedElement(el: ElementMetadata): boolean;
declare function isElementAngularIO(name: string): boolean;
declare function toElementAngularIO(name: string): string | null;
declare function getElementAngularIOs(names: string[]): string[];

declare class ElementsResolver {
    private uiDef;
    private config?;
    elements: ElementMetadata[];
    private renderableElements;
    private sharedElements;
    private uiDefMetadata;
    constructor(uiDef: UIDefinitionMetadata, elements: ElementMetadata[], sharedElements?: ElementMetadata[], config?: CMSPreviewConfig | undefined);
    addElement(element: ElementMetadata): void;
    getNgComponents(): Record<string, Type<Entity>>;
    private flattenElements;
    private isSharedElement;
    private getRenderableElements;
    private getSharedElement;
    private resolveElementTemplate;
    private resolveElementStyles;
    private processElementMetadata;
    private getSharedChildren;
    private resolveElement;
    private getElementStyles;
    private convertInlineStylesToCSS;
    private getDefaultCustomizationState;
}

declare function btoaSafe(str?: string): string;
declare function atobSafe(str?: string): string;

declare const cmsInject: <T = unknown>(token: string) => T;

declare const parsePath: (path: string) => ElementPath;
declare const getAbsolutePath: (elements: ElementMetadata[], subject: ElementMetadata, path: ElementPath) => string | undefined;

declare class TranspilationWorker {
    private elements;
    constructor(elements: ElementMetadata[]);
    get$(): Observable<ElementMetadata[]>;
    get(): ElementMetadata[];
    private transpileScripts;
    private transpileScriptsAsync;
    private processLevelAsync;
    private transpileMetadataAsync;
    private transpile;
}

declare const constructPageChildren: (path: string, layout: PageLayout) => ElementMetadata[];
declare const constructRegion: (name: string, parentPath: string) => ElementMetadata;
declare const constructPage: (name: string, pageType: PageType, layout: PageLayout, configuredStyles?: ElementStyleDeclaration) => ElementMetadata;

declare const insertElement: (source: ElementMetadata[], target: ElementMetadata, path: string, index: number) => ElementMetadata[];
declare const removeElement: (source: ElementMetadata[], path: string) => ElementMetadata[];
declare const findElementByPath: (source: ElementMetadata[], path: string) => ElementMetadata | undefined;
declare const findElementByModule: (elements: ElementMetadata[], module: string, elementName: string) => ElementMetadata | undefined;
declare const findElement: (source: ElementMetadata[], comparatorFn: (el: ElementMetadata) => boolean) => ElementMetadata | undefined;

declare const vendorMap: {
    '@veloceapps/core': {
        isDefined: <T>(value: T) => value is Exclude<T, null | undefined>;
        Operator: typeof Operator;
        Predicate: typeof Predicate;
        parseJsonSafely: typeof parseJsonSafely;
        parseJwt: typeof parseJwt;
        TokenInfoService: typeof TokenInfoService;
        UITemplateType: typeof UITemplateType;
    };
    '@veloceapps/components': {
        ToastService: typeof ToastService;
        ToastType: typeof ToastType;
    };
    '@veloceapps/api': {
        ContractedPriceApiService: typeof ContractedPriceApiService;
    };
    '@veloceapps/api/v2': {
        CatalogApiService: typeof CatalogApiService;
        ConfigurationSettingsApiService: typeof ConfigurationSettingsApiService;
        DocumentAttachmentApiService: typeof DocumentAttachmentApiService;
        GuidedSellingApiService: typeof GuidedSellingApiService;
        SalesforceApiService: typeof SalesforceApiService;
        SalesTransactionApiService: typeof SalesTransactionApiService;
        ShoppingCartSettingsApiService: typeof ShoppingCartSettingsApiService;
    };
    '@veloceapps/sdk/core': {
        ConfigurationService: typeof ConfigurationService;
        ConfigurationStateService: typeof ConfigurationStateService;
        GuidedSellingService: typeof GuidedSellingService;
        filterSuccessfulExecute: typeof filterSuccessfulExecute;
        FlowInfoService: typeof FlowInfoService;
        FlowConfigurationService: typeof FlowConfigurationService;
        IntegrationState: typeof IntegrationState;
        FlowStateService: typeof FlowStateService;
        FlowStateConfigurationService: typeof FlowStateConfigurationService;
        TransactionItemWorker: typeof TransactionItemWorker;
        ProductImagesService: typeof ProductImagesService;
        RuntimeSettingsService: typeof RuntimeSettingsService;
        ActionCodePipe: typeof ActionCodePipe;
        DatePipe: typeof DatePipe;
        NumberPipe: typeof NumberPipe;
        PricePipe: typeof PricePipe;
        SalesTransactionService: typeof SalesTransactionService;
        generateTransactionItem: (option: _veloceapps_core.PCMModel, salesTransactionId?: string, qty?: number, parentTi?: _veloceapps_core.SalesTransactionItem) => _veloceapps_core.SalesTransactionItem;
        updateQuantity: (ti: _veloceapps_core.SalesTransactionItem, qty: number, pcm: _veloceapps_core.PCMProduct, parentQty?: number) => _veloceapps_core.SalesTransactionItem;
        flattenTransactionItem: (ti: _veloceapps_core.SalesTransactionItem) => _veloceapps_core.SalesTransactionItem[];
        PCMUtils: typeof PCMUtils;
    };
    '@veloceapps/sdk/cms': {
        TemplatesService: typeof TemplatesService;
        IntegrationState: typeof IntegrationState;
        ResourcesService: typeof ResourcesService;
        cmsInject: <T = unknown>(token: string) => T;
        FlowAction: typeof FlowAction;
        CmsAction: typeof CmsAction;
        DEFAULT_PLUGINS_TOKEN: i0.InjectionToken<typeof Plugin[]>;
        UI_DEFINITION_METADATA: i0.InjectionToken<_veloceapps_core.UIDefinitionMetadata>;
        ELEMENT_METADATA: i0.InjectionToken<_veloceapps_sdk_cms.ElementMetadata>;
        SHARED_ELEMENT_METADATA: i0.InjectionToken<_veloceapps_sdk_cms.ElementMetadata | undefined>;
        ELEMENT_CONFIG: i0.InjectionToken<_veloceapps_sdk_cms.ElementConfig>;
    };
    '@angular/core': typeof i0;
    '@angular/forms': typeof angularForms;
    '@angular/cdk/collections': {
        DataSource: typeof DataSource;
    };
    rxjs: typeof rxjs;
    'rxjs/operators': typeof rxjsOperators;
    lodash: lodash.LoDashStatic;
};
type VendorMap = typeof vendorMap;

export { CmsAction, DEFAULT_ELEMENT, DEFAULT_PLUGINS_TOKEN, ELEMENT_CONFIG, ELEMENT_METADATA, ElementComponent, ElementDefinition, ElementMetadataWorker, ElementsResolver, FlowAction, LAYOUT, LauncherModule, MigrationsModule, MigrationsService, PreviewComponent, PreviewModule, ResourcesService, RuntimeEditorService, RuntimeModule, RuntimeService, SHARED_ELEMENT_METADATA, STARTING_PAGE_LAYOUT, STARTING_PAGE_NAME, STARTING_PAGE_STYLES, STARTING_PAGE_TYPE, TemplatesService, TranspilationWorker, UI_DEFINITION_METADATA, UiBuildError, atobSafe, btoaSafe, cmsInject, constructPage, constructPageChildren, constructRegion, doesElementSupportIO, elementToMetadata, extendElementMetadata, extractElementMetadata, findElement, findElementByModule, findElementByPath, flattenElements, getAbsolutePath, getElementAngularIOs, getElementConfig, insertElement, isElementAngularIO, isSharedElement, isValidScript, metadataToElement, normalizeElementMetadata, parsePath, removeElement, stringifyElementMetadata, toElementAngularIO };
export type { CMSPreviewConfig, CompilationResult, ELEMENT_TYPE, ElementConfig, ElementDefaultMetadata, ElementMetadata, ElementModel, ElementPath, ElementStyleDeclaration, FederatedComponentInstance, FederatedModuleOptions, FullPageLayout, PageLayout, PageLayoutConfig, PageType, PathBlock, ScriptHost, SidepanelPageLayout, VendorMap };