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 };