@veloceapps/sdk 12.0.0-9 → 13.0.0-0

package/index.d.ts

@@ -1 +1,330 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ChangeDetectorRef } from '@angular/core';
+import * as i1 from '@angular/common';
+import * as i3 from '@veloceapps/components';
+import { ToastService } from '@veloceapps/components';
+import * as i1$1 from '@angular/router';
+import { ActivatedRoute, Router, ActivatedRouteSnapshot, Params, Route } from '@angular/router';
+import * as i2 from '@veloceapps/sdk/cms';
+import { CMSPreviewConfig, IntegrationState as IntegrationState$1 } from '@veloceapps/sdk/cms';
+import { UIDefinitionContainer, UIDefinition } from '@veloceapps/core';
+import * as i8 from '@veloceapps/sdk/core';
+import { ConfigurationRuntimeService, ConfigurationStateService, FlowInfoService, FlowCustomization, FlowStateService, RuntimeSettingsService, IntegrationState, ConfigurationService } from '@veloceapps/sdk/core';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { UITemplatesAdminApiService } from '@veloceapps/api/v2';
+import * as i4 from '@veloceapps/api';
+import * as i2$1 from 'primeng/button';
+import { DynamicDialogConfig, DynamicDialogRef, DialogService } from 'primeng/dynamicdialog';
+
+declare const VELOCE_FLOW_ROOT_ROUTE = "VELOCE_FLOW_ROOT_ROUTE";
+
+declare class ProductComponent implements OnInit, OnDestroy {
+    private configurationRuntimeService;
+    private configurationStateService;
+    private flowService;
+    private route;
+    config: CMSPreviewConfig;
+    uiDefinitionContainer$: BehaviorSubject<UIDefinitionContainer | null>;
+    showNotFound$: BehaviorSubject<boolean>;
+    isInitialized$: BehaviorSubject<boolean>;
+    private destroy$;
+    constructor(configurationRuntimeService: ConfigurationRuntimeService, configurationStateService: ConfigurationStateService, flowService: FlowInfoService, route: ActivatedRoute);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private init$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductComponent, "vl-flow-product", never, {}, {}, never, never, true, never>;
+}
+
+declare class ProductModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductModule, never, [typeof i1.CommonModule, typeof i2.PreviewModule, typeof i3.LoaderModule, typeof i3.LetDirectiveModule, typeof ProductComponent], [typeof ProductComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductModule>;
+}
+
+interface State$2 {
+    loading: boolean;
+    failure: boolean;
+}
+declare class ShoppingCartComponent implements OnInit, OnDestroy {
+    private templatesAdminApiService;
+    private cdr;
+    private toastService;
+    private flowInfo;
+    private customizationService?;
+    uiDefinition?: UIDefinition;
+    state$: BehaviorSubject<State$2>;
+    private templateApiName;
+    private destroyed$;
+    constructor(templatesAdminApiService: UITemplatesAdminApiService, cdr: ChangeDetectorRef, toastService: ToastService, flowInfo: FlowInfoService, customizationService?: FlowCustomization | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private getLocalMeta$;
+    private getOrgMeta$;
+    private generateUIDefinition$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShoppingCartComponent, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ShoppingCartComponent, "vl-flow-shopping-cart", never, {}, {}, never, never, true, never>;
+}
+
+declare class ShoppingCartModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShoppingCartModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ShoppingCartModule, never, [typeof i1.CommonModule, typeof i2.PreviewModule, typeof i3.LoaderModule, typeof ShoppingCartComponent], [typeof ShoppingCartComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ShoppingCartModule>;
+}
+
+interface State$1 {
+    loading: boolean;
+    failure: boolean;
+}
+declare class CatalogComponent implements OnInit, OnDestroy {
+    private templatesAdminApiService;
+    private cdr;
+    private toastService;
+    private flowInfo;
+    private customizationService?;
+    uiDefinition?: UIDefinition;
+    state$: BehaviorSubject<State$1>;
+    private templateApiName;
+    private destroyed$;
+    constructor(templatesAdminApiService: UITemplatesAdminApiService, cdr: ChangeDetectorRef, toastService: ToastService, flowInfo: FlowInfoService, customizationService?: FlowCustomization | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private getLocalMeta$;
+    private getOrgMeta$;
+    private generateUIDefinition$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogComponent, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogComponent, "vl-flow-catalog", never, {}, {}, never, never, true, never>;
+}
+
+declare class CatalogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogModule, never, [typeof i1.CommonModule, typeof i2.PreviewModule, typeof i3.LoaderModule, typeof i2.RuntimeModule, typeof CatalogComponent], [typeof CatalogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogModule>;
+}
+
+interface State {
+    loading: boolean;
+    failure: boolean;
+}
+declare class AssetsComponent implements OnInit, OnDestroy {
+    private templatesAdminApiService;
+    private cdr;
+    private toastService;
+    private flowInfo;
+    private customizationService?;
+    uiDefinition?: UIDefinition;
+    state$: BehaviorSubject<State>;
+    private templateApiName;
+    private destroyed$;
+    constructor(templatesAdminApiService: UITemplatesAdminApiService, cdr: ChangeDetectorRef, toastService: ToastService, flowInfo: FlowInfoService, customizationService?: FlowCustomization | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private getLocalMeta$;
+    private getOrgMeta$;
+    private generateUIDefinition$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetsComponent, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AssetsComponent, "vl-flow-assets", never, {}, {}, never, never, true, never>;
+}
+
+declare class AssetsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AssetsModule, never, [typeof i1.CommonModule, typeof i2.PreviewModule, typeof i3.LoaderModule, typeof AssetsComponent], [typeof AssetsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AssetsModule>;
+}
+
+declare class FlowRoutingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowRoutingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowRoutingModule, never, [typeof i1$1.RouterModule, typeof ProductModule, typeof ShoppingCartModule, typeof CatalogModule, typeof AssetsModule], [typeof i1$1.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowRoutingModule>;
+}
+
+declare class FlowHeaderComponent implements OnDestroy {
+    private templatesAdminApiService;
+    private flowStateService;
+    private flowInfo;
+    private toastService;
+    private customizationService?;
+    uiDefinition$: BehaviorSubject<UIDefinition | null>;
+    private templateApiName;
+    private destroy$;
+    constructor(templatesAdminApiService: UITemplatesAdminApiService, flowStateService: FlowStateService, flowInfo: FlowInfoService, toastService: ToastService, customizationService?: FlowCustomization | undefined);
+    ngOnDestroy(): void;
+    private initialize;
+    private getLocalMeta$;
+    private getOrgMeta$;
+    private generateUIDefinition$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowHeaderComponent, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FlowHeaderComponent, "vl-flow-new-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class FlowNewHeaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowNewHeaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowNewHeaderModule, never, [typeof i1.CommonModule, typeof i2.PreviewModule, typeof FlowHeaderComponent], [typeof FlowHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowNewHeaderModule>;
+}
+
+interface FlowDialogConfig {
+    title: string;
+    description?: string;
+    primaryButton: string;
+    secondaryButton?: string;
+    oppositeButtonActions?: boolean;
+}
+
+declare class FlowDialogComponent {
+    private dialogConfig;
+    private ref;
+    config: FlowDialogConfig;
+    constructor(dialogConfig: DynamicDialogConfig, ref: DynamicDialogRef);
+    cancelHandler(): void;
+    confirmHandler(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FlowDialogComponent, "vl-flow-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class FlowDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowDialogModule, never, [typeof i1.CommonModule, typeof i2$1.ButtonModule, typeof FlowDialogComponent], [typeof FlowDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowDialogModule>;
+}
+
+declare class GuidedSellingComponent implements OnDestroy {
+    private templatesAdminApiService;
+    private flowStateService;
+    private flowInfo;
+    private toastService;
+    private customizationService?;
+    uiDefinition$: BehaviorSubject<UIDefinition | null>;
+    private templateApiName;
+    private destroy$;
+    constructor(templatesAdminApiService: UITemplatesAdminApiService, flowStateService: FlowStateService, flowInfo: FlowInfoService, toastService: ToastService, customizationService?: FlowCustomization | undefined);
+    ngOnDestroy(): void;
+    private initialize;
+    private getLocalMeta$;
+    private getOrgMeta$;
+    private generateUIDefinition$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuidedSellingComponent, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GuidedSellingComponent, "vl-flow-guided-selling", never, {}, {}, never, never, true, never>;
+}
+
+declare class GuidedSellingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuidedSellingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GuidedSellingModule, never, [typeof i1.CommonModule, typeof i2.PreviewModule, typeof GuidedSellingComponent], [typeof GuidedSellingComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GuidedSellingModule>;
+}
+
+type FlowDialogFn = keyof Omit<FlowDialogService, 'show' | 'constructor'>;
+declare class FlowDialogService {
+    private dialogService;
+    private runtimeSettings;
+    private flowInfoService;
+    constructor(dialogService: DialogService, runtimeSettings: RuntimeSettingsService, flowInfoService: FlowInfoService);
+    show(config: FlowDialogConfig): Observable<boolean>;
+    showEmptyCartDialog(): Observable<boolean>;
+    showReadonlyModeDialog(): Observable<boolean>;
+    showQuoteReadonlyModeDialog(): Observable<boolean>;
+    showQuoteInConfiguratorDialog(): Observable<boolean>;
+    showAccountNoChangesDialog(): Observable<boolean>;
+    showUnsavedChangesDialog(): Observable<boolean>;
+    showTermsLimitReachedDialog(): Observable<boolean>;
+    showDialog(dialog: FlowDialogFn): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowDialogService>;
+}
+
+declare class FlowRouterService {
+    private router;
+    private route;
+    private integrationState;
+    private flowInfoService;
+    loading$: Observable<boolean>;
+    private routeChange$;
+    private lastChildParams$;
+    private lastChildRoute$;
+    private urlHistory;
+    constructor(router: Router, route: ActivatedRoute, integrationState: IntegrationState, flowInfoService: FlowInfoService);
+    get route$(): Observable<ActivatedRouteSnapshot>;
+    get params$(): Observable<Params>;
+    get params(): Params;
+    getFlowRootRoute(route: ActivatedRouteSnapshot): ActivatedRouteSnapshot | undefined;
+    getFlowRootPath(route: ActivatedRouteSnapshot): string;
+    getLastChildRoute: (route: ActivatedRoute) => ActivatedRoute;
+    getNthChildRoute: (route: ActivatedRoute, index: number) => ActivatedRoute;
+    getLastChildRouteSnapshot: (route: ActivatedRouteSnapshot) => ActivatedRouteSnapshot;
+    watchLastChildRoute$: (route: ActivatedRoute) => Observable<ActivatedRouteSnapshot>;
+    getLastChildParams: (route: ActivatedRouteSnapshot) => Params;
+    watchLastChildParams$: (route: ActivatedRoute) => Observable<Params>;
+    getFlowSubpath$: () => Observable<string>;
+    isConfigurationRoute$(): Observable<boolean>;
+    isCartRoute$(): Observable<boolean>;
+    isCatalogRoute$(): Observable<boolean>;
+    isAssetsRoute$(): Observable<boolean>;
+    navigateBack(): void;
+    navigateTo(path: string, productId?: string, transactionItemId?: string): void;
+    navigateToProductConfiguration(productId: string, transactionItemId?: string): void;
+    navigateToShoppingCart(): void;
+    navigateToCatalog(): void;
+    navigateToAssets(): void;
+    showErrorPage$(message: string, details?: string[]): Observable<false>;
+    switchObject(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowRouterService>;
+}
+
+declare class FlowService {
+    private integrationState;
+    private flowRouterService;
+    private configurationService;
+    private configurationStateService;
+    private flowDialogService;
+    private flowStateService;
+    private flowInfoService;
+    private cleanup$;
+    constructor(integrationState: IntegrationState$1, flowRouterService: FlowRouterService, configurationService: ConfigurationService, configurationStateService: ConfigurationStateService, flowDialogService: FlowDialogService, flowStateService: FlowStateService, flowInfoService: FlowInfoService);
+    cleanup(): void;
+    initSubscriptions(): void;
+    private updateFlowParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowService>;
+}
+
+declare class FlowGuidedSellingService {
+    private integrationState;
+    private cleanup$;
+    private isVisibleSubj$;
+    isVisible$: rxjs.Observable<boolean>;
+    constructor(integrationState: IntegrationState);
+    cleanup(): void;
+    private initSubscriptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowGuidedSellingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowGuidedSellingService>;
+}
+
+declare class FlowComponent implements OnDestroy {
+    private routerService;
+    private flowService;
+    private flowInfoService;
+    private guidedSellingService;
+    isLoading$: Observable<boolean>;
+    showHeader$: Observable<boolean>;
+    isStandalone$: Observable<boolean>;
+    guidedSellingVisible$: Observable<boolean>;
+    constructor(routerService: FlowRouterService, flowService: FlowService, flowInfoService: FlowInfoService, guidedSellingService: FlowGuidedSellingService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FlowComponent, "vl-flow", never, {}, {}, never, never, true, never>;
+}
+
+declare class FlowModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowModule, never, [typeof i1.CommonModule, typeof i3.LetDirectiveModule, typeof FlowRoutingModule, typeof i4.ApiModule, typeof i2.LauncherModule, typeof i3.LoaderModule, typeof FlowNewHeaderModule, typeof FlowDialogModule, typeof i8.SdkCoreModule, typeof GuidedSellingModule, typeof FlowComponent], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowModule>;
+}
+
+interface RouteWithId extends Route {
+    id?: string;
+}
+
+export { FlowDialogService, FlowModule, FlowRouterService, FlowService, VELOCE_FLOW_ROOT_ROUTE };
+export type { FlowDialogFn, RouteWithId };

package/package.json

@@ -1,26 +1,25 @@
 {
   "name": "@veloceapps/sdk",
-  "version": "12.0.0-9",
+  "version": "13.0.0-0",
   "private": false,
   "peerDependencies": {
-    "@angular/animations": "~15.2.0",
-    "@angular/common": "~15.2.0",
-    "@angular/core": "~15.2.0",
-    "@angular/forms": "~15.2.0",
-    "@angular/platform-browser-dynamic": "~15.2.0",
-    "@angular/platform-browser": "~15.2.0",
-    "@veloceapps/core": "^12.0.0-0",
-    "@veloceapps/api": "^12.0.0-0",
-    "@veloceapps/components": "^12.0.0-0",
+    "@angular/animations": "~20.1.4",
+    "@angular/common": "~20.1.4",
+    "@angular/core": "~20.1.4",
+    "@angular/forms": "~20.1.4",
+    "@angular/platform-browser-dynamic": "~20.1.4",
+    "@angular/platform-browser": "~20.1.4",
+    "@veloceapps/core": "^13.0.0-0",
+    "@veloceapps/api": "^13.0.0-0",
+    "@veloceapps/components": "^13.0.0-0",
     "rxjs": "~7.8.0",
-    "zone.js": "~0.12.0",
-    "sass": "1.69.5"
+    "zone.js": "~0.12.0"
   },
   "dependencies": {
-    "@angular/cdk": "^15.2.0",
-    "@angular/cdk-experimental": "^15.2.0",
-    "@angular/compiler": "~15.2.0",
-    "@angular-architects/module-federation": "^15.0.3",
+    "@angular/cdk": "~20.1.4",
+    "@angular/cdk-experimental": "~20.1.4",
+    "@angular/compiler": "~20.1.4",
+    "@angular-architects/module-federation": "20.0.0",
     "@babel/standalone": "^7.17.1",
     "moment": "^2.29.1",
     "ngx-drag-drop": "^13.0.1",
@@ -32,11 +31,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "module": "fesm2015/veloceapps-sdk.mjs",
-  "es2020": "fesm2020/veloceapps-sdk.mjs",
-  "esm2020": "esm2020/veloceapps-sdk.mjs",
-  "fesm2020": "fesm2020/veloceapps-sdk.mjs",
-  "fesm2015": "fesm2015/veloceapps-sdk.mjs",
+  "module": "fesm2022/veloceapps-sdk.mjs",
   "typings": "index.d.ts",
   "exports": {
     "./package.json": {
@@ -44,27 +39,15 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2020": "./esm2020/veloceapps-sdk.mjs",
-      "es2020": "./fesm2020/veloceapps-sdk.mjs",
-      "es2015": "./fesm2015/veloceapps-sdk.mjs",
-      "node": "./fesm2015/veloceapps-sdk.mjs",
-      "default": "./fesm2020/veloceapps-sdk.mjs"
-    },
-    "./cms": {
-      "types": "./cms/index.d.ts",
-      "esm2020": "./esm2020/cms/veloceapps-sdk-cms.mjs",
-      "es2020": "./fesm2020/veloceapps-sdk-cms.mjs",
-      "es2015": "./fesm2015/veloceapps-sdk-cms.mjs",
-      "node": "./fesm2015/veloceapps-sdk-cms.mjs",
-      "default": "./fesm2020/veloceapps-sdk-cms.mjs"
+      "default": "./fesm2022/veloceapps-sdk.mjs"
     },
     "./core": {
       "types": "./core/index.d.ts",
-      "esm2020": "./esm2020/core/veloceapps-sdk-core.mjs",
-      "es2020": "./fesm2020/veloceapps-sdk-core.mjs",
-      "es2015": "./fesm2015/veloceapps-sdk-core.mjs",
-      "node": "./fesm2015/veloceapps-sdk-core.mjs",
-      "default": "./fesm2020/veloceapps-sdk-core.mjs"
+      "default": "./fesm2022/veloceapps-sdk-core.mjs"
+    },
+    "./cms": {
+      "types": "./cms/index.d.ts",
+      "default": "./fesm2022/veloceapps-sdk-cms.mjs"
     }
   }
-}
+}

package/cms/cms.actions.d.ts

@@ -1,154 +0,0 @@
-export 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 | undefined;
-        productId?: string | undefined;
-        qty?: number | undefined;
-    }) => {
-        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;
-        } | undefined;
-    };
-    const SubmitGuidedSelling: (payload: {
-        result: Record<string, any>;
-    }) => {
-        type: string;
-        payload: {
-            result: Record<string, any>;
-        };
-    };
-    const OpenDialog: (dialog: string) => {
-        type: string;
-        payload: {
-            dialog: string;
-        };
-    };
-}
-export 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;
-    };
-}

package/cms/cms.default.d.ts

@@ -1,5 +0,0 @@
-import { UIDefinitionType } from '@veloceapps/core';
-import { Plugin } from './engine/models/plugin';
-export declare const DEFAULT_PLUGINS: {
-    [key in UIDefinitionType]: (typeof Plugin)[];
-};

package/cms/cms.elements.d.ts

@@ -1,4 +0,0 @@
-import { ELEMENT_TYPE, ElementConfig } from './types/common.types';
-export declare const CONFIG: {
-    [key in ELEMENT_TYPE]: ElementConfig;
-};

package/cms/cms.layouts.d.ts

@@ -1,4 +0,0 @@
-import { PageLayout, PageLayoutConfig } from './types/layouts.types';
-export declare const LAYOUT: {
-    [key in PageLayout]: PageLayoutConfig;
-};

package/cms/components/element-children/element-children.component.d.ts

@@ -1,22 +0,0 @@
-import { ChangeDetectorRef, OnDestroy } from '@angular/core';
-import { Observable } from 'rxjs';
-import { RuntimeEditorService } from '../../modules/runtime/services/runtime-editor.service';
-import { RuntimeService } from '../../modules/runtime/services/runtime.service';
-import { ElementContextService } from '../../services/element-context.service';
-import { ElementMetadata } from '../../types/common.types';
-import * as i0 from "@angular/core";
-export 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": "filter"; }, {}, never, never, false, never>;
-}

package/cms/components/element-children/element-children.module.d.ts

@@ -1,11 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./element-children.component";
-import * as i2 from "@angular/common";
-import * as i3 from "@veloceapps/components";
-import * as i4 from "../element-renderer/element-renderer.module";
-import * as i5 from "../element-drop-handle/element-drop-handle.module";
-export declare class ElementChildrenModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ElementChildrenModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementChildrenModule, [typeof i1.ElementChildrenComponent], [typeof i2.CommonModule, typeof i3.LetDirectiveModule, typeof i4.ElementRendererModule, typeof i5.ElementDropHandleModule], [typeof i1.ElementChildrenComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ElementChildrenModule>;
-}

package/cms/components/element-drop-handle/element-drop-handle.component.d.ts

@@ -1,12 +0,0 @@
-import { DndDropEvent } from 'ngx-drag-drop';
-import { RuntimeEditorService } from '../../modules/runtime/services/runtime-editor.service';
-import * as i0 from "@angular/core";
-export 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": "index"; "parentPath": "parentPath"; }, {}, never, never, false, never>;
-}

package/cms/components/element-drop-handle/element-drop-handle.module.d.ts

@@ -1,9 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./element-drop-handle.component";
-import * as i2 from "@angular/common";
-import * as i3 from "ngx-drag-drop";
-export declare class ElementDropHandleModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ElementDropHandleModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementDropHandleModule, [typeof i1.ElementDropHandleComponent], [typeof i2.CommonModule, typeof i3.DndModule], [typeof i1.ElementDropHandleComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ElementDropHandleModule>;
-}