@veloceapps/sdk 4.0.21-0

package/src/components/header/cart-overlay/cart-preview.component.d.ts

@@ -0,0 +1,36 @@
+import { AfterViewInit, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FlowConfigurationService, ProductImagesService, QuoteDraftService } from '@veloceapps/sdk/core';
+import { OverlayPanel } from 'primeng/overlaypanel';
+import { Observable } from 'rxjs';
+import { FlowRouterService } from '../../../services/flow-router.service';
+import { HeaderProduct } from '../header.types';
+import * as i0 from "@angular/core";
+export declare class CartPreviewComponent implements OnChanges, AfterViewInit, OnDestroy {
+    private flowConfiguration;
+    private routerService;
+    private productImagesService;
+    private quoteDraftService;
+    overlayPanel: OverlayPanel;
+    products: HeaderProduct[];
+    readonly productRowHeight = 97;
+    form: FormGroup;
+    lockedProductId$: Observable<string | null>;
+    isEditMode$: Observable<boolean>;
+    hasTermInProducts: boolean;
+    scrollHeight: number;
+    private shouldUpdate$;
+    private destroyed$;
+    constructor(flowConfiguration: FlowConfigurationService, routerService: FlowRouterService, productImagesService: ProductImagesService, quoteDraftService: QuoteDraftService);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    getImageUrl(productId: string): Observable<string | null>;
+    navigateToProductConfiguration(productId: string, lineItemId: string): void;
+    controlBlurHandler(product: HeaderProduct): void;
+    deleteHandler(product: HeaderProduct): void;
+    deleteAllHandler(): void;
+    private updateControls;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CartPreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CartPreviewComponent, "vl-cart-preview", never, { "products": "products"; }, {}, never, never>;
+}

package/src/components/header/cart-overlay/cart-preview.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./cart-preview.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "primeng/button";
+import * as i5 from "primeng/overlaypanel";
+import * as i6 from "@veloceapps/components";
+import * as i7 from "primeng/inputnumber";
+import * as i8 from "primeng/virtualscroller";
+export declare class CartPreviewModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CartPreviewModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CartPreviewModule, [typeof i1.CartPreviewComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.ButtonModule, typeof i5.OverlayPanelModule, typeof i6.LetDirectiveModule, typeof i7.InputNumberModule, typeof i8.VirtualScrollerModule], [typeof i1.CartPreviewComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CartPreviewModule>;
+}

package/src/components/header/header.component.d.ts

@@ -0,0 +1,63 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { QuoteApiService, SalesforceApiService } from '@veloceapps/api';
+import { ContextProperties, PriceList } from '@veloceapps/core';
+import { IntegrationState } from '@veloceapps/sdk/cms';
+import { ContextService, FlowConfigurationService, QuoteDraftService } from '@veloceapps/sdk/core';
+import { MenuItem } from 'primeng/api';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { FlowDialogService } from '../../services/flow-dialog.service';
+import { FlowRouterService } from '../../services/flow-router.service';
+import { CartPreviewComponent } from './cart-overlay/cart-preview.component';
+import { HeaderObjectDetails, HeaderProduct } from './header.types';
+import * as i0 from "@angular/core";
+export declare class FlowHeaderComponent implements OnInit, OnDestroy {
+    private contextService;
+    private quoteDraftService;
+    private quoteApiService;
+    private sfApiService;
+    private flowConfiguration;
+    private routerService;
+    private dialogService;
+    private integrationState;
+    objectName: string;
+    contextProperties: ContextProperties;
+    assetPriceLists: PriceList[];
+    activePriceList$: Observable<PriceList | null>;
+    isReadonlyMode$: Observable<boolean>;
+    status$: Observable<string>;
+    objectDetails$: BehaviorSubject<HeaderObjectDetails>;
+    products$: Observable<HeaderProduct[]>;
+    isConfigurationRoute$: Observable<boolean>;
+    isCartRoute$: Observable<boolean>;
+    isCatalogRoute$: Observable<boolean>;
+    isEditMode$: Observable<boolean>;
+    isSaveInProgress$: BehaviorSubject<boolean>;
+    isSubmitInProgress$: BehaviorSubject<boolean>;
+    totalMRR$: Observable<string>;
+    totalNRR$: Observable<string>;
+    private mode?;
+    private destroyed$;
+    constructor(contextService: ContextService, quoteDraftService: QuoteDraftService, quoteApiService: QuoteApiService, sfApiService: SalesforceApiService, flowConfiguration: FlowConfigurationService, routerService: FlowRouterService, dialogService: FlowDialogService, integrationState: IntegrationState);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get isAccountMode(): boolean;
+    get isQuoteMode(): boolean;
+    getSplitButtonActions(isCartRoute: boolean): MenuItem[];
+    back(objectId?: string): void;
+    getSalesforceObjectLink(objectId?: string): string;
+    navigateToShoppingCart(): void;
+    navigateToCatalog(): void;
+    docGenButtonClickHandler(isCartRoute: boolean): void;
+    saveButtonClickHandler(isCartRoute: boolean): void;
+    submitButtonClickHandler(isCartRoute: boolean): void;
+    selectPriceList(priceListId: string): void;
+    toggleCartOverlay(cart: CartPreviewComponent, event: Event): void;
+    private saveQuote$;
+    private queryName$;
+    private populateObjectDetails;
+    private formatMetric;
+    private generateProducts;
+    private isReadonlyMode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FlowHeaderComponent, "vl-flow-header", never, {}, {}, never, never>;
+}

package/src/components/header/header.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./header.component";
+import * as i2 from "@angular/common";
+import * as i3 from "primeng/overlaypanel";
+import * as i4 from "@veloceapps/components";
+import * as i5 from "primeng/tooltip";
+import * as i6 from "primeng/button";
+import * as i7 from "./cart-overlay/cart-preview.module";
+import * as i8 from "primeng/splitbutton";
+export declare class FlowHeaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowHeaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowHeaderModule, [typeof i1.FlowHeaderComponent], [typeof i2.CommonModule, typeof i3.OverlayPanelModule, typeof i4.LetDirectiveModule, typeof i5.TooltipModule, typeof i6.ButtonModule, typeof i7.CartPreviewModule, typeof i8.SplitButtonModule], [typeof i1.FlowHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowHeaderModule>;
+}

package/src/components/header/header.types.d.ts

@@ -0,0 +1,20 @@
+export interface HeaderObjectDetails {
+    accountId?: string;
+    accountName?: string;
+    opportunityId?: string;
+    opportunityName?: string;
+    quoteId?: string;
+    quoteName?: string;
+    quoteNumber?: string;
+}
+export interface HeaderProduct {
+    id: string;
+    productId: string;
+    name: string;
+    configurable: boolean;
+    deleted: boolean;
+    hasTerm: boolean;
+    qty: number;
+    mrr: string;
+    nrr: string;
+}

package/src/constants.d.ts

@@ -0,0 +1 @@
+export declare const VELOCE_FLOW_ROOT_ROUTE = "VELOCE_FLOW_ROOT_ROUTE";

package/src/flow-routing.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./pages/product/product.module";
+import * as i3 from "./pages/legacy-product/legacy-product.module";
+import * as i4 from "./pages/shopping-cart/shopping-cart.module";
+import * as i5 from "./pages/catalog/catalog.module";
+import * as i6 from "./pages/remote/remote.module";
+import * as i7 from "./pages/empty-account/empty-account.module";
+export declare class FlowRoutingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowRoutingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowRoutingModule, never, [typeof i1.RouterModule, typeof i2.ProductModule, typeof i3.LegacyProductModule, typeof i4.ShoppingCartModule, typeof i5.CatalogModule, typeof i6.RemoteModule, typeof i7.EmptyAccountModule], [typeof i1.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowRoutingModule>;
+}

package/src/flow.component.d.ts

@@ -0,0 +1,23 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { IntegrationState } from '@veloceapps/sdk/cms';
+import { QuoteDraftService } from '@veloceapps/sdk/core';
+import { Observable } from 'rxjs';
+import { FlowService } from './services';
+import { FlowDocGenService } from './services/doc-gen.service';
+import { FlowRouterService } from './services/flow-router.service';
+import * as i0 from "@angular/core";
+export declare class FlowComponent implements OnInit, OnDestroy {
+    private routerService;
+    private quoteDraftService;
+    private flowService;
+    private docGenService;
+    private integrationState;
+    isLoading$: Observable<boolean>;
+    showHeader$: Observable<boolean>;
+    isStandalone$: Observable<boolean>;
+    constructor(routerService: FlowRouterService, quoteDraftService: QuoteDraftService, flowService: FlowService, docGenService: FlowDocGenService, integrationState: IntegrationState);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FlowComponent, "vl-flow", never, {}, {}, never, never>;
+}

package/src/flow.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./flow.component";
+import * as i2 from "@angular/common";
+import * as i3 from "./flow-routing.module";
+import * as i4 from "@veloceapps/api";
+import * as i5 from "@veloceapps/sdk/cms";
+import * as i6 from "@veloceapps/components";
+import * as i7 from "./components/header/header.module";
+import * as i8 from "./components/dialog/dialog.module";
+import * as i9 from "@veloceapps/sdk/core";
+import * as i10 from "./components/doc-gen/doc-gen.module";
+export declare class FlowModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowModule, [typeof i1.FlowComponent], [typeof i2.CommonModule, typeof i3.FlowRoutingModule, typeof i4.ApiModule, typeof i5.LauncherModule, typeof i6.LoaderModule, typeof i7.FlowHeaderModule, typeof i8.FlowDialogModule, typeof i9.SdkCoreModule, typeof i10.DocGenModule, typeof i6.LetDirectiveModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowModule>;
+}

package/src/guards/context.guard.d.ts

@@ -0,0 +1,19 @@
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, Router } from '@angular/router';
+import { ContextService } from '@veloceapps/sdk/core';
+import { Observable } from 'rxjs';
+import { FlowRouterService } from '../services/flow-router.service';
+import * as i0 from "@angular/core";
+export declare class ContextGuard implements CanActivate, CanActivateChild {
+    private router;
+    private routerService;
+    private contextService;
+    constructor(router: Router, routerService: FlowRouterService, contextService: ContextService);
+    checkActivation(route: ActivatedRouteSnapshot): Observable<boolean>;
+    canActivate(route: ActivatedRouteSnapshot): Observable<boolean> | Promise<boolean> | boolean;
+    canActivateChild(childRoute: ActivatedRouteSnapshot): Observable<boolean> | Promise<boolean> | boolean;
+    private get rpcMessageId();
+    private getConfigurationContextMode;
+    private handleError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextGuard>;
+}

package/src/guards/index.d.ts

@@ -0,0 +1 @@
+export * from './context.guard';

package/src/guards/product-unload.guard.d.ts

@@ -0,0 +1,16 @@
+import { Component } from '@angular/core';
+import { ActivatedRouteSnapshot, CanDeactivate, Router, RouterStateSnapshot } from '@angular/router';
+import { ConfigurationService, ContextService, QuoteDraftService } from '@veloceapps/sdk/core';
+import { FlowDialogService } from '../services/flow-dialog.service';
+import * as i0 from "@angular/core";
+export declare class ProductUnloadGuard implements CanDeactivate<any> {
+    private router;
+    private contextService;
+    private quoteDraftService;
+    private configurationService;
+    private flowDialogService;
+    constructor(router: Router, contextService: ContextService, quoteDraftService: QuoteDraftService, configurationService: ConfigurationService, flowDialogService: FlowDialogService);
+    canDeactivate(_: Component, route: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): import("rxjs").Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductUnloadGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductUnloadGuard>;
+}

package/src/guards/root.guard.d.ts

@@ -0,0 +1,15 @@
+import { ActivatedRouteSnapshot, CanActivate, CanDeactivate, Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { FlowRouterService } from '../services/flow-router.service';
+import * as i0 from "@angular/core";
+export declare class RootGuard implements CanActivate, CanDeactivate<any> {
+    private router;
+    private routerService;
+    private initialized;
+    private navToRestore;
+    constructor(router: Router, routerService: FlowRouterService);
+    canActivate(route: ActivatedRouteSnapshot): Observable<boolean> | Promise<boolean> | boolean;
+    canDeactivate(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RootGuard>;
+}

package/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './constants';
+export * from './flow.module';
+export * from './guards';
+export * from './services';
+export * from './types';
+export * from './utils';

package/src/pages/catalog/catalog.component.d.ts

@@ -0,0 +1,32 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { UITemplatesApiService } from '@veloceapps/api';
+import { ToastService } from '@veloceapps/components';
+import { ContextService, UIDefinition } from '@veloceapps/sdk/core';
+import { BehaviorSubject } from 'rxjs';
+import { FlowCustomization } from '../../types';
+import * as i0 from "@angular/core";
+interface State {
+    loading: boolean;
+    failure: boolean;
+}
+export declare class CatalogComponent implements OnInit, OnDestroy {
+    private templatesApi;
+    private contextService;
+    private cdr;
+    private toastService;
+    private customizationService?;
+    uiDefinition?: UIDefinition;
+    state$: BehaviorSubject<State>;
+    private templateApiName;
+    private destroyed$;
+    constructor(templatesApi: UITemplatesApiService, contextService: ContextService, cdr: ChangeDetectorRef, toastService: ToastService, customizationService?: FlowCustomization | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private getTemplateRootComponent$;
+    private getLocalCatalogComponentMeta$;
+    private getCatalogComponentMeta$;
+    private generateUIDefinition$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogComponent, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogComponent, "vl-flow-catalog", never, {}, {}, never, never>;
+}
+export {};

package/src/pages/catalog/catalog.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./catalog.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@veloceapps/sdk/cms";
+import * as i4 from "@veloceapps/components";
+export declare class CatalogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogModule, [typeof i1.CatalogComponent], [typeof i2.CommonModule, typeof i3.PreviewModule, typeof i4.LoaderModule], [typeof i1.CatalogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogModule>;
+}

package/src/pages/debug/debug.component.d.ts

@@ -0,0 +1,25 @@
+import { FormGroup } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { FlowsApiService } from '@veloceapps/api';
+import { FlowProperties } from '@veloceapps/core';
+import { ContextService, QuoteDraftService } from '@veloceapps/sdk/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface FlowPropertiesExt extends FlowProperties {
+    queryParamsStr: string;
+}
+export declare class DebugComponent {
+    private flowsApiService;
+    private router;
+    private activatedRoute;
+    private context;
+    private quoteDraftService;
+    form: FormGroup;
+    selectedFlow?: FlowPropertiesExt;
+    flows$: Observable<FlowPropertiesExt[]>;
+    constructor(flowsApiService: FlowsApiService, router: Router, activatedRoute: ActivatedRoute, context: ContextService, quoteDraftService: QuoteDraftService);
+    runFlow(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebugComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DebugComponent, "vl-flow-debug", never, {}, {}, never, never>;
+}
+export {};

package/src/pages/debug/debug.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./debug.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/router";
+import * as i5 from "primeng/radiobutton";
+import * as i6 from "primeng/button";
+import * as i7 from "primeng/inputtext";
+import * as i8 from "primeng/dropdown";
+export declare class DebugModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebugModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DebugModule, [typeof i1.DebugComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i4.RouterModule, typeof i5.RadioButtonModule, typeof i6.ButtonModule, typeof i7.InputTextModule, typeof i8.DropdownModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DebugModule>;
+}

package/src/pages/empty-account/empty-account.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class EmptyAccountComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyAccountComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyAccountComponent, "vl-empty-account", never, {}, {}, never, never>;
+}

package/src/pages/empty-account/empty-account.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./empty-account.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@veloceapps/sdk/cms";
+import * as i4 from "@veloceapps/components";
+export declare class EmptyAccountModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyAccountModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EmptyAccountModule, [typeof i1.EmptyAccountComponent], [typeof i2.CommonModule, typeof i3.PreviewModule, typeof i4.LoaderModule, typeof i4.EmptyStateModule], [typeof i1.EmptyAccountComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EmptyAccountModule>;
+}

package/src/pages/legacy-product/legacy-product.component.d.ts

@@ -0,0 +1,37 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { QuoteApiService } from '@veloceapps/api';
+import { LineItem } from '@veloceapps/core';
+import { ContextService, QuoteDraftService } from '@veloceapps/sdk/core';
+import { CurrentStateService, RuntimeContextService, RuntimeService, SolutionReadyAware, SolutionUpdatedAware } from '@veloceapps/sdk/runtime';
+import { FlowCustomization } from '../../types';
+import * as i0 from "@angular/core";
+export declare class LegacyProductComponent implements OnInit, OnDestroy, SolutionUpdatedAware, SolutionReadyAware {
+    private route;
+    private quoteDraftService;
+    private quoteApiService;
+    private contextService;
+    private runtimeContextService;
+    private runtimeService;
+    private currentStateService;
+    private customizationService?;
+    private destroyed$;
+    private assets?;
+    constructor(route: ActivatedRoute, quoteDraftService: QuoteDraftService, quoteApiService: QuoteApiService, contextService: ContextService, runtimeContextService: RuntimeContextService, runtimeService: RuntimeService, currentStateService: CurrentStateService, customizationService?: FlowCustomization | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onSolutionReady(lineItem: LineItem): void;
+    onSolutionCancel(): void;
+    onSolutionUpdated(lineItem: LineItem): void;
+    onSolutionStop(lineItem: LineItem): void;
+    private init;
+    private getLineItemId;
+    private configure;
+    private reConfigure;
+    private getAsset;
+    private startRuntime;
+    private customizeContext;
+    private getRuntimeContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LegacyProductComponent, [null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LegacyProductComponent, "ng-component", never, {}, {}, never, never>;
+}

package/src/pages/legacy-product/legacy-product.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./legacy-product.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@veloceapps/sdk/runtime";
+import * as i4 from "ngx-bootstrap/tooltip";
+export declare class LegacyProductModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LegacyProductModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LegacyProductModule, [typeof i1.LegacyProductComponent], [typeof i2.CommonModule, typeof i3.RuntimeModule, typeof i4.TooltipModule], [typeof i1.LegacyProductComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LegacyProductModule>;
+}

package/src/pages/product/product.component.d.ts

@@ -0,0 +1,32 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ConfigurationRuntimeService, ConfigurationService, ContextService, QuoteDraftService, UIDefinition } from '@veloceapps/sdk/core';
+import { MessageService } from 'primeng/api';
+import { BehaviorSubject } from 'rxjs';
+import { FlowCustomization } from '../../types/flow-customization.types';
+import * as i0 from "@angular/core";
+interface State {
+    loading: boolean;
+    failure: boolean;
+}
+export declare class ProductComponent implements OnInit, OnDestroy {
+    private contextService;
+    private runtimeService;
+    private configurationService;
+    private quoteDraftService;
+    private messageService;
+    private customizationService?;
+    private destroy$;
+    uiDefinition?: UIDefinition;
+    state$: BehaviorSubject<State>;
+    constructor(contextService: ContextService, runtimeService: ConfigurationRuntimeService, configurationService: ConfigurationService, quoteDraftService: QuoteDraftService, messageService: MessageService, customizationService?: FlowCustomization | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private customize;
+    private init;
+    private throwIfNoUIDefinition;
+    private getLineItemId;
+    private getAsset;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductComponent, [null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductComponent, "vl-flow-product", never, {}, {}, never, never>;
+}
+export {};

package/src/pages/product/product.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./product.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@veloceapps/sdk/cms";
+import * as i4 from "@veloceapps/components";
+export declare class ProductModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductModule, [typeof i1.ProductComponent], [typeof i2.CommonModule, typeof i3.PreviewModule, typeof i4.LoaderModule], [typeof i1.ProductComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductModule>;
+}

package/src/pages/record-not-found/record-not-found.component.d.ts

@@ -0,0 +1,11 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class RecordNotFoundComponent {
+    private router;
+    private route;
+    message: string;
+    subMessage: string;
+    constructor(router: Router, route: ActivatedRoute);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecordNotFoundComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RecordNotFoundComponent, "vl-flow-record-not-found", never, {}, {}, never, never>;
+}

package/src/pages/record-not-found/record-not-found.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./record-not-found.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/router";
+export declare class RecordNotFoundModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecordNotFoundModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RecordNotFoundModule, [typeof i1.RecordNotFoundComponent], [typeof i2.CommonModule, typeof i3.RouterModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RecordNotFoundModule>;
+}

package/src/pages/remote/remote.component.d.ts

@@ -0,0 +1,47 @@
+import { Location } from '@angular/common';
+import { OnDestroy } from '@angular/core';
+import { QuoteApiService } from '@veloceapps/api';
+import { IntegrationState } from '@veloceapps/sdk/cms';
+import { ConfigurationRuntimeService, ConfigurationService, ContextService, QuoteDraftService, UIDefinition } from '@veloceapps/sdk/core';
+import { MessageService } from 'primeng/api';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+interface State {
+    loading: boolean;
+    failure: boolean;
+}
+export declare class RemoteComponent implements OnDestroy {
+    private contextService;
+    private quoteDraftService;
+    private quoteApiService;
+    private runtimeService;
+    private configurationService;
+    private messageService;
+    private integrationState;
+    private location;
+    uiDefinition?: UIDefinition;
+    state$: BehaviorSubject<State>;
+    private readonly DYNAMIC_OPTION_PRODUCTS_KEY;
+    private rpcMessage;
+    private destroyed$;
+    constructor(contextService: ContextService, quoteDraftService: QuoteDraftService, quoteApiService: QuoteApiService, runtimeService: ConfigurationRuntimeService, configurationService: ConfigurationService, messageService: MessageService, integrationState: IntegrationState, location: Location);
+    ngOnDestroy(): void;
+    private initConfiguration;
+    private throwIfNoUIDefinition;
+    private initSubscriptions;
+    private createLineItem;
+    private createRootLineItem;
+    private toParentChildMap;
+    private saveRpcMessage;
+    private updateHasChildrenFlag;
+    private flattenChildLineItems;
+    private updateContentData;
+    private computeNetPrice;
+    private getChargeNameSet;
+    private sumNetPrice;
+    private mapAttributesTo;
+    private getOptionConfigurations;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RemoteComponent, "vl-flow-remote", never, {}, {}, never, never>;
+}
+export {};

package/src/pages/remote/remote.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./remote.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@veloceapps/sdk/cms";
+import * as i4 from "@veloceapps/components";
+export declare class RemoteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RemoteModule, [typeof i1.RemoteComponent], [typeof i2.CommonModule, typeof i3.PreviewModule, typeof i4.LoaderModule], [typeof i1.RemoteComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RemoteModule>;
+}

package/src/pages/remote/remote.types.d.ts

@@ -0,0 +1,4 @@
+import { LineItem } from '@veloceapps/core';
+export interface LineItemWithParent extends LineItem {
+    parentLineItem?: LineItem;
+}

package/src/pages/shopping-cart/shopping-cart.component.d.ts

@@ -0,0 +1,32 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { UITemplatesApiService } from '@veloceapps/api';
+import { ToastService } from '@veloceapps/components';
+import { ContextService, UIDefinition } from '@veloceapps/sdk/core';
+import { BehaviorSubject } from 'rxjs';
+import { FlowCustomization } from '../../types';
+import * as i0 from "@angular/core";
+interface State {
+    loading: boolean;
+    failure: boolean;
+}
+export declare class ShoppingCartComponent implements OnInit, OnDestroy {
+    private templatesApi;
+    private contextService;
+    private cdr;
+    private toastService;
+    private customizationService?;
+    uiDefinition?: UIDefinition;
+    state$: BehaviorSubject<State>;
+    private templateApiName;
+    private destroyed$;
+    constructor(templatesApi: UITemplatesApiService, contextService: ContextService, cdr: ChangeDetectorRef, toastService: ToastService, customizationService?: FlowCustomization | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private getTemplateRootComponent$;
+    private getLocalShoppingCartComponentMeta$;
+    private getShoppingCartComponentMeta$;
+    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>;
+}
+export {};

package/src/pages/shopping-cart/shopping-cart.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./shopping-cart.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@veloceapps/sdk/cms";
+import * as i4 from "@veloceapps/components";
+export declare class ShoppingCartModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShoppingCartModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ShoppingCartModule, [typeof i1.ShoppingCartComponent], [typeof i2.CommonModule, typeof i3.PreviewModule, typeof i4.LoaderModule], [typeof i1.ShoppingCartComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ShoppingCartModule>;
+}

package/src/resolvers/flow.resolver.d.ts

@@ -0,0 +1,16 @@
+import { ActivatedRouteSnapshot, Resolve, Router } from '@angular/router';
+import { FlowsApiService } from '@veloceapps/api';
+import { ContextService } from '@veloceapps/sdk/core';
+import { FlowRouterService } from '../services/flow-router.service';
+import * as i0 from "@angular/core";
+export declare class FlowResolver implements Resolve<Promise<boolean>> {
+    private router;
+    private flowsApiService;
+    private routerService;
+    private contextService;
+    constructor(router: Router, flowsApiService: FlowsApiService, routerService: FlowRouterService, contextService: ContextService);
+    private handleError;
+    resolve(route: ActivatedRouteSnapshot): Promise<boolean> | import("rxjs").Observable<Promise<boolean>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowResolver>;
+}