@veloceapps/sdk 0.0.0-watch

package/runtime/services/product-model-cache.service.d.ts

@@ -0,0 +1,14 @@
+import { ProductModelApiService } from '@veloce/api';
+import { ProductModelsContainer } from '@veloce/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ProductModelCacheService {
+    private productModelApiService;
+    constructor(productModelApiService: ProductModelApiService);
+    private cachedModel;
+    getProductModel(currentModelId: string, version?: string): Observable<ProductModelsContainer>;
+    getCachedModel(): Observable<ProductModelsContainer>;
+    clearCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductModelCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductModelCacheService>;
+}

package/runtime/services/runtime-context.service.d.ts

@@ -0,0 +1,16 @@
+import { ConfigurationApiService } from '@veloce/api';
+import { ContextService } from '@veloce/sdk/core';
+import { MessageService } from 'primeng/api';
+import { Observable } from 'rxjs';
+import { LegacyRuntimeContext } from '../types';
+import * as i0 from "@angular/core";
+export declare class RuntimeContextService {
+    private configurationApiService;
+    private messageService;
+    private contextService;
+    constructor(configurationApiService: ConfigurationApiService, messageService: MessageService, contextService: ContextService);
+    getRuntimeContext(productId: string, offeringId?: string): Observable<LegacyRuntimeContext>;
+    private getUIDefinition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuntimeContextService>;
+}

package/runtime/services/runtime-form.service.d.ts

@@ -0,0 +1,24 @@
+import { FormGroup } from '@angular/forms';
+import { LineItem, Section } from '@veloce/core';
+import * as i0 from "@angular/core";
+export declare class RuntimeFormService {
+    sections: Section[];
+    solutionLineItem?: LineItem;
+    initForm(sections: Section[], solutionLineItem: LineItem): FormGroup;
+    private populateSectionValue;
+    private populateSectionPrice;
+    private populateFormControls;
+    private createFormControl;
+    private createQtyControl;
+    private getMaxAllowed;
+    private getFormControlValidators;
+    private getQuantityValidator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuntimeFormService>;
+}
+export declare class FormServiceUtils {
+    static isPortSection(section: Section): any;
+    static isTypeSection(section: Section): any;
+    static isAttributeSection(section: Section): any;
+    static findParent(parentId: string, lineItems: LineItem[]): LineItem | undefined;
+}

package/runtime/services/runtime.service.d.ts

@@ -0,0 +1,43 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { LineItem, UIDefinition } from '@veloce/core';
+import { ContextService, QuoteStates } from '@veloce/sdk/core';
+import { MessageService } from 'primeng/api';
+import { LegacyRuntimeContext } from '../types';
+import { ConfigurationService } from './configuration.service';
+import * as i0 from "@angular/core";
+export declare class RuntimeService {
+    private configurationService;
+    private contextService;
+    private messageService;
+    private runtimeContext;
+    private solutionReadySubject;
+    onSolutionReadyEvent: import("rxjs").Observable<LineItem>;
+    private solutionUpdateStartedSubject;
+    onSolutionUpdateStartedEvent: import("rxjs").Observable<void>;
+    private solutionUpdatedSubject;
+    onSolutionUpdatedEvent: import("rxjs").Observable<LineItem | HttpErrorResponse>;
+    private solutionProcessedSubject;
+    onSolutionProcessed: import("rxjs").Observable<LineItem>;
+    private solutionStopSubject;
+    onSolutionStopEvent: import("rxjs").Observable<LineItem>;
+    private solutionCancelSubject;
+    onSolutionCancelEvent: import("rxjs").Observable<void>;
+    private uiRefreshSubject;
+    onUIRefreshEvent: import("rxjs").Observable<void>;
+    constructor(configurationService: ConfigurationService, contextService: ContextService, messageService: MessageService);
+    private displayErrorMessage;
+    startRuntime(context: LegacyRuntimeContext, states: QuoteStates, resolve?: boolean): void;
+    updateRuntime(states: QuoteStates, configurationContextProperties?: {
+        [index: string]: string;
+    }): void;
+    stopRuntime(solutionLineItem: LineItem): void;
+    cancelRuntime(): void;
+    setRuntimeContext(runtimeContext: LegacyRuntimeContext): void;
+    getRuntimeContext(): LegacyRuntimeContext | undefined;
+    solutionProcessed(lineItem: LineItem): void;
+    refreshUI(uiDefinition: UIDefinition): void;
+    private updateRuntimeContext;
+    private setRuntimeStep;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuntimeService>;
+}

package/runtime/services/section-helper.service.d.ts

@@ -0,0 +1,8 @@
+import { Section } from '@veloce/core';
+import * as i0 from "@angular/core";
+export declare class SectionHelperService {
+    static findSectionForValue(section: Section, valueOption: string): Section | undefined;
+    getTotalPrices(section: Section): Map<string, number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SectionHelperService>;
+}

package/runtime/services/section-scope.service.d.ts

@@ -0,0 +1,14 @@
+import { TemplateRef } from '@angular/core';
+import { Section } from '@veloce/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SectionScopeService {
+    get section(): Section;
+    set section(value: Section);
+    indent: number;
+    private _section;
+    templates: BehaviorSubject<TemplateRef<any>[]>;
+    private getIndent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionScopeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SectionScopeService>;
+}

package/runtime/services/section-store.service.d.ts

@@ -0,0 +1,11 @@
+import { ComponentFactory } from '@angular/core';
+import { Section } from '@veloce/core';
+import * as i0 from "@angular/core";
+export declare class SectionStoreService {
+    private _componentFactories;
+    set componentFactories(data: ComponentFactory<any>[]);
+    get componentFactories(): ComponentFactory<any>[];
+    getComponentFactory(section: Section): ComponentFactory<any> | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionStoreService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SectionStoreService>;
+}

package/runtime/services/section.service.d.ts

@@ -0,0 +1,30 @@
+import '@angular/compiler';
+import { Compiler, NgModuleRef, QueryList, TemplateRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { Section } from '@veloce/core';
+import { SectionStoreService } from './section-store.service';
+import * as i0 from "@angular/core";
+export declare class BaseSectionComponent {
+    form: FormGroup;
+    section: Section;
+    protected templates: QueryList<TemplateRef<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseSectionComponent, "ng-component", never, { "form": "form"; "section": "section"; }, {}, never, never>;
+}
+export declare class SectionsService {
+    private compiler;
+    private m;
+    private sectionStore;
+    private moduleType;
+    private moduleInstance;
+    constructor(compiler: Compiler, m: NgModuleRef<any>, sectionStore: SectionStoreService);
+    compileModule(sections: Section[], isViewEncapsulated?: boolean): void;
+    destroy(): void;
+    private getDecoratedComponents;
+    private getModuleType;
+    private applySelectorField;
+    private getUniqueSections;
+    private getTranspiledTemplate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SectionsService>;
+}

package/runtime/types/bound-data.types.d.ts

@@ -0,0 +1,13 @@
+import { ProductModelAttribute, ProductPort, ProductType, SectionPath } from '@veloce/core';
+export declare enum BoundDataType {
+    TYPE = 0,
+    ATTRIBUTE = 1,
+    PORT = 2
+}
+export interface BoundData {
+    name: string;
+    entity: ProductType | ProductModelAttribute | ProductPort;
+    entityType: string;
+    host?: string;
+    path: SectionPath;
+}

package/runtime/types/index.d.ts

@@ -0,0 +1 @@
+export * from './runtime.types';

package/runtime/types/runtime.types.d.ts

@@ -0,0 +1,19 @@
+import { LineItem, UIDefinition } from '@veloce/core';
+import { RuntimeContext } from '@veloce/sdk/core';
+import { Dictionary } from 'lodash';
+export interface SolutionReadyAware {
+    onSolutionReady(lineItem: LineItem): void;
+}
+export interface SolutionUpdatedAware {
+    onSolutionUpdated(lineItem: LineItem): void;
+}
+export interface UpdateData {
+    id: string;
+    action: string;
+    valueOption?: string;
+    selectedValueOptions?: string[];
+    options?: Dictionary<any>;
+}
+export interface LegacyRuntimeContext extends Omit<RuntimeContext, 'uiDefinition'> {
+    uiDefinition?: UIDefinition;
+}

package/runtime/types/script-registry.types.d.ts

@@ -0,0 +1,13 @@
+export declare class ScriptRegistry {
+    scope: Map<string, any>;
+    private store;
+    constructor();
+    exists(scriptId: string): boolean;
+    isRegistered(scriptId: string, sectionId: string): boolean;
+    doRegister(scriptId: string, sectionId: string): void;
+    unRegister(scriptId: string, sectionId: string): void;
+    hasGlobalForScript(globalId: string): boolean;
+    getGlobalForScript(globalId: string): any;
+    setGlobalForScript(globalId: string, globalVariable: any): void;
+    removeGlobalForScript(globalId: string): void;
+}

package/runtime/utils/line-item.util.d.ts

@@ -0,0 +1,34 @@
+import { LineItem, RuntimeModel, SectionPath } from '@veloce/core';
+export declare class LineItemPath {
+    path: string;
+    private _relativePath;
+    private _relativeAbstractPath;
+    private _abstractPath;
+    set relativePath(relativePath: string);
+    get relativePath(): string;
+    set abstractPath(abstractPath: string);
+    get abstractPath(): string;
+    set relativeAbstractPath(relativeAbstractPath: string);
+    constructor(path: string);
+    isEqualTo(sectionPath: SectionPath): boolean;
+}
+export declare class LineItemUtil {
+    static removeDeletedItems(original: LineItem): LineItem;
+    static replaceLineItemKeys(rootLineItem: LineItem): void;
+    static enrichPricingInfo(source: LineItem, pricingDto?: LineItem): LineItem;
+    static getLineItemPath(lineItem: LineItem, rootLineItem: LineItem): LineItemPath;
+    static findById(parentId: string, lineItems: LineItem[]): LineItem | undefined;
+    static countAttributeValues(scale: number, attributeDomain: any[]): number;
+    static precision(scale: number): number;
+    static splitDomainToValues(scale: number, attributeDomain: any[]): string[];
+    static splitIntervalToValues(precision: number, interval: any): any[];
+    static findLineItemsByPath(runtimeModel: RuntimeModel, lineItem: LineItem, path: SectionPath): LineItem[];
+    static findLineItemChildren(runtimeModel: RuntimeModel, lineItems: LineItem[], portName: string, typeName: string): LineItem[];
+    static findLineItemsByType(runtimeModel: RuntimeModel, lineItem: LineItem, typeName: string): LineItem[];
+    static findLineItemForValue(model: LineItem, valueOption: string): LineItem | undefined;
+    static create(product: any, qty?: number): LineItem;
+    static upsert(value: LineItem, collection: LineItem[]): void;
+    static compareSortOrder(a: LineItem, b: LineItem): number;
+    static sort(lineItems: LineItem[]): void;
+    private static compareProductName;
+}

package/runtime/utils/section.utils.d.ts

@@ -0,0 +1,2 @@
+import { Section } from '@veloce/core';
+export declare const getSectionTree: (src: Section[]) => Section[];

package/runtime/utils/sections-binder.helper.d.ts

@@ -0,0 +1,16 @@
+import { LineItem, RuntimeModel, Section } from '@veloce/core';
+export declare class SectionsBinderHelper {
+    static setLineItemsPath(runtimeModel: RuntimeModel, rootLineItem: LineItem, sections: Section[], sourceSections: Section[], filterFn: any, pricingEnabled: boolean): Section[];
+    static isAddAllowed(model: LineItem, portName: string, quantityToAdd?: number): boolean;
+    static isRemoveAllowed(model: LineItem, portName: string, quantityToRemove?: number): boolean;
+    static getMaxAllowed(lineItem: LineItem, portName: string): number;
+    static getQuantityGroupByValue(model: LineItem, portName: string): {
+        [index: string]: number;
+    };
+    private static bindMatchingLineItems;
+    private static bindLineItem;
+    private static doClone;
+    private static getQuantity;
+    private static getPortMax;
+    private static getPortMin;
+}

package/runtime/veloce-sdk-runtime.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@veloce/sdk/runtime" />
+export * from './index';

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

@@ -0,0 +1,13 @@
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+import { FlowDialogConfig } from './dialog.types';
+import * as i0 from "@angular/core";
+export 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>;
+}

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

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./dialog.component";
+import * as i2 from "@angular/common";
+import * as i3 from "primeng/button";
+export declare class FlowDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlowDialogModule, [typeof i1.FlowDialogComponent], [typeof i2.CommonModule, typeof i3.ButtonModule], [typeof i1.FlowDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowDialogModule>;
+}

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

@@ -0,0 +1,6 @@
+export interface FlowDialogConfig {
+    title: string;
+    description?: string;
+    primaryButton: string;
+    secondaryButton?: string;
+}

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

@@ -0,0 +1,31 @@
+import { AfterViewInit, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FlowConfigurationService, ProductImagesService } from '@veloce/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;
+    overlayPanel: OverlayPanel;
+    products: HeaderProduct[];
+    form: FormGroup;
+    readonlyProductId$: Observable<string | null>;
+    private shouldUpdate$;
+    private destroyed$;
+    constructor(flowConfiguration: FlowConfigurationService, routerService: FlowRouterService, productImagesService: ProductImagesService);
+    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,13 @@
+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 "@veloce/components";
+import * as i7 from "primeng/inputnumber";
+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 i1.CartPreviewComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CartPreviewModule>;
+}

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

@@ -0,0 +1,48 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { QuoteApiService, SalesforceApiService } from '@veloce/api';
+import { ContextProperties } from '@veloce/core';
+import { ContextService, FlowConfigurationService, QuoteDraftService } from '@veloce/sdk/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { FlowDialogService } from '../../services/flow-dialog.service';
+import { FlowRouterService } from '../../services/flow-router.service';
+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;
+    readonly disabledActionButtonTooltip = "Available from the Shopping Cart";
+    objectName: string;
+    contextProperties: ContextProperties;
+    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>;
+    private mode?;
+    private destroyed$;
+    constructor(contextService: ContextService, quoteDraftService: QuoteDraftService, quoteApiService: QuoteApiService, sfApiService: SalesforceApiService, flowConfiguration: FlowConfigurationService, routerService: FlowRouterService, dialogService: FlowDialogService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get isAccountMode(): boolean;
+    get isQuoteMode(): boolean;
+    back(): void;
+    getSalesforceObjectLink(objectId?: string): string;
+    navigateToShoppingCart(): void;
+    navigateToCatalog(): void;
+    saveButtonClickHandler(): void;
+    submitButtonClickHandler(): void;
+    private queryName$;
+    private populateObjectDetails;
+    private generateProducts;
+    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,13 @@
+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 "@veloce/components";
+import * as i5 from "primeng/tooltip";
+import * as i6 from "primeng/button";
+import * as i7 from "./cart-overlay/cart-preview.module";
+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 i1.FlowHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowHeaderModule>;
+}

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

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

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,11 @@
+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";
+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 i1.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowRoutingModule>;
+}

package/src/flow.component.d.ts

@@ -0,0 +1,17 @@
+import { OnDestroy } from '@angular/core';
+import { QuoteDraftService } from '@veloce/sdk/core';
+import { Observable } from 'rxjs';
+import { FlowService } from './services';
+import { FlowRouterService } from './services/flow-router.service';
+import * as i0 from "@angular/core";
+export declare class FlowComponent implements OnDestroy {
+    private routerService;
+    private quoteDraftService;
+    private flowService;
+    isLoading$: Observable<boolean>;
+    showHeader$: Observable<boolean>;
+    constructor(routerService: FlowRouterService, quoteDraftService: QuoteDraftService, flowService: FlowService);
+    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,15 @@
+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 "@veloce/api";
+import * as i5 from "@veloce/sdk/cms";
+import * as i6 from "@veloce/components";
+import * as i7 from "./components/header/header.module";
+import * as i8 from "./components/dialog/dialog.module";
+import * as i9 from "@veloce/sdk/core";
+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], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlowModule>;
+}

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

@@ -0,0 +1,18 @@
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, Router } from '@angular/router';
+import { ContextService } from '@veloce/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 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 '@veloce/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 '@veloce/api';
+import { ToastService } from '@veloce/components';
+import { ContextService, UIDefinition } from '@veloce/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 "@veloce/sdk/cms";
+import * as i4 from "@veloce/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>;
+}