@veloceapps/sdk 0.0.0-watch

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

@@ -0,0 +1,27 @@
+import { FormGroup } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { FlowsApiService } from '@veloce/api';
+import { FlowProperties } from '@veloce/core';
+import { ContextService, FlowConfigurationService, QuoteDraftService } from '@veloce/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 flowConfiguration;
+    private quoteDraftService;
+    readonly objectNames: string[];
+    form: FormGroup;
+    selectedFlow?: FlowPropertiesExt;
+    flows$: Observable<FlowPropertiesExt[]>;
+    constructor(flowsApiService: FlowsApiService, router: Router, activatedRoute: ActivatedRoute, context: ContextService, flowConfiguration: FlowConfigurationService, 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/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 '@veloce/api';
+import { LineItem } from '@veloce/core';
+import { ContextService, QuoteDraftService } from '@veloce/sdk/core';
+import { CurrentStateService, RuntimeContextService, RuntimeService, SolutionReadyAware, SolutionUpdatedAware } from '@veloce/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 "@veloce/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,30 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ConfigurationRuntimeService, ConfigurationService, ContextService, QuoteDraftService, UIDefinition } from '@veloce/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 conigurationService;
+    private quoteDraftService;
+    private messageService;
+    private customizationService?;
+    private destroy$;
+    uiDefinition?: UIDefinition;
+    state$: BehaviorSubject<State>;
+    constructor(contextService: ContextService, runtimeService: ConfigurationRuntimeService, conigurationService: ConfigurationService, quoteDraftService: QuoteDraftService, messageService: MessageService, customizationService?: FlowCustomization | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private customize;
+    private init;
+    private getLineItemId;
+    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 "@veloce/sdk/cms";
+import * as i4 from "@veloce/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/shopping-cart/shopping-cart.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 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 "@veloce/sdk/cms";
+import * as i4 from "@veloce/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,14 @@
+import { ActivatedRouteSnapshot, Resolve, Router } from '@angular/router';
+import { FlowsApiService } from '@veloce/api';
+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;
+    constructor(router: Router, flowsApiService: FlowsApiService, routerService: FlowRouterService);
+    private handleError;
+    resolve(route: ActivatedRouteSnapshot): Promise<boolean> | import("rxjs").Observable<Promise<boolean>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowResolver>;
+}

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

@@ -0,0 +1,18 @@
+import { ActivatedRouteSnapshot, Resolve, Router } from '@angular/router';
+import { ContextService, FlowConfigurationService, QuoteDraftService } from '@veloce/sdk/core';
+import { Observable } from 'rxjs';
+import { FlowRouterService } from '../services/flow-router.service';
+import * as i0 from "@angular/core";
+export declare class QuoteResolver implements Resolve<void | boolean> {
+    private router;
+    private quoteDraftService;
+    private routerService;
+    private contextService;
+    private flowConfiguration;
+    constructor(router: Router, quoteDraftService: QuoteDraftService, routerService: FlowRouterService, contextService: ContextService, flowConfiguration: FlowConfigurationService);
+    private handleError;
+    private initFlow$;
+    resolve(route: ActivatedRouteSnapshot): Observable<void | boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuoteResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QuoteResolver>;
+}

package/src/services/flow-dialog.service.d.ts

@@ -0,0 +1,20 @@
+import { ContextService } from '@veloce/sdk/core';
+import { DialogService } from 'primeng/dynamicdialog';
+import { Observable } from 'rxjs';
+import { FlowDialogConfig } from '../components/dialog/dialog.types';
+import * as i0 from "@angular/core";
+export declare class FlowDialogService {
+    private dialogService;
+    private contextService;
+    constructor(dialogService: DialogService, contextService: ContextService);
+    show(config: FlowDialogConfig): Observable<boolean>;
+    showEmptyCartDialog(): Observable<boolean>;
+    showReadonlyModeDialog(): Observable<boolean>;
+    showQuoteReadonlyModeDialog(): Observable<boolean>;
+    showAccountNoChangesDialog(): Observable<boolean>;
+    showUnsavedChangesDialog(): Observable<boolean>;
+    showReadonlyQuoteSubmitFailureDialog(): Observable<boolean>;
+    showAccountSubmitFailureDialog(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowDialogService>;
+}

package/src/services/flow-router.service.d.ts

@@ -0,0 +1,35 @@
+import { ActivatedRoute, ActivatedRouteSnapshot, Params, Router } from '@angular/router';
+import { ContextService } from '@veloce/sdk/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FlowRouterService {
+    private router;
+    private route;
+    private contextService;
+    private routeChange$;
+    private lastChildParams$;
+    private lastChildRoute$;
+    private urlHistory;
+    loading$: Observable<boolean>;
+    constructor(router: Router, route: ActivatedRoute, contextService: ContextService);
+    getFlowRootRoute(route: ActivatedRouteSnapshot): ActivatedRouteSnapshot | undefined;
+    getFlowRootPath(route: ActivatedRouteSnapshot): string;
+    get route$(): Observable<ActivatedRouteSnapshot>;
+    get params$(): Observable<Params>;
+    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>;
+    navigateBack(): void;
+    navigateToProductConfiguration(productId: string, lineItemId?: string): void;
+    navigateToShoppingCart(): void;
+    navigateToCatalog(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowRouterService>;
+}

package/src/services/flow.service.d.ts

@@ -0,0 +1,17 @@
+import { IntegrationState } from '@veloce/sdk/cms';
+import { ConfigurationService, FlowConfigurationService, QuoteDraftService } from '@veloce/sdk/core';
+import { FlowRouterService } from './flow-router.service';
+import * as i0 from "@angular/core";
+export declare class FlowService {
+    private integrationState;
+    private flowRouterService;
+    private quoteDraftService;
+    private configurationService;
+    private flowConfigurationService;
+    private cleanup$;
+    constructor(integrationState: IntegrationState, flowRouterService: FlowRouterService, quoteDraftService: QuoteDraftService, configurationService: ConfigurationService, flowConfigurationService: FlowConfigurationService);
+    initSubscriptions(): void;
+    cleanup(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowService>;
+}

package/src/services/index.d.ts

@@ -0,0 +1 @@
+export * from './flow.service';

package/src/types/context-route.types.d.ts

@@ -0,0 +1,5 @@
+import { ConfigurationContextMode } from '@veloce/core';
+export interface ContextRouteData {
+    mode: ConfigurationContextMode;
+    headerId: string;
+}

package/src/types/flow-customization.types.d.ts

@@ -0,0 +1,11 @@
+import { InjectionToken } from '@angular/core';
+import { TemplateComponentWithAttachments, UIDefinition as LegacyUIDefinition } from '@veloce/core';
+import { UIDefinition } from '@veloce/sdk/core';
+import { Observable } from 'rxjs';
+export declare const FLOW_CUSTOMIZATION: InjectionToken<FlowCustomization>;
+export interface FlowCustomization {
+    getUiDefinition?(productId: string): Observable<UIDefinition | null>;
+    getLegacyUiDefinition?(productId: string): Observable<LegacyUIDefinition | null>;
+    getShoppingCartComponent?(templateName: string): Observable<TemplateComponentWithAttachments | null>;
+    getCatalogComponent?(templateName: string): Observable<TemplateComponentWithAttachments | null>;
+}

package/src/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './context-route.types';
+export * from './flow-customization.types';

package/src/types/route.types.d.ts

@@ -0,0 +1,9 @@
+import { Route } from '@angular/router';
+export interface FlowObjectIdProperties {
+    accountId?: string;
+    quoteId?: string;
+    orderId?: string;
+}
+export interface RouteWithId extends Route {
+    id?: string;
+}

package/src/utils/flow.utils.d.ts

@@ -0,0 +1 @@
+export declare const getFlowObjectIdPropertyName: (objectName?: string | undefined) => "accountId" | "orderId" | "quoteId";

package/src/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './flow.utils';

package/veloce-sdk.d.ts

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