@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/runtime/base/services/app.manager.service.d.ts

@@ -0,0 +1,142 @@
+import { OnDestroy } from '@angular/core';
+import { Router } from '@angular/router';
+import { DatePipe } from '@angular/common';
+import { AbstractDialogService, AbstractHttpService, AbstractI18nService, AbstractSpinnerService, App } from '@wm/core';
+import { SecurityService } from '@wm/security';
+import { MetadataService, VariablesService } from '@wm/variables';
+import * as i0 from "@angular/core";
+export declare class AppManagerService implements OnDestroy {
+    private $http;
+    private $security;
+    private $dialog;
+    private $router;
+    private $app;
+    private $variables;
+    private $metadata;
+    private $spinner;
+    private $i18n;
+    private $datePipe;
+    static readonly SERVICE_NAME = "AppManagerService";
+    private appVariablesLoaded;
+    private appVariablesFired;
+    private _noRedirect;
+    private templates;
+    private lastLoggedUserId;
+    private appSubscriptions;
+    private windowMessageListener;
+    private sessionTimeoutUnsubscribe;
+    constructor($http: AbstractHttpService, $security: SecurityService, $dialog: AbstractDialogService, $router: Router, $app: App, $variables: VariablesService, $metadata: MetadataService, $spinner: AbstractSpinnerService, $i18n: AbstractI18nService, $datePipe: DatePipe);
+    /**
+     * On session timeout, if the session timeout config is set to a dialog, then open login dialog
+     */
+    private showLoginDialog;
+    loadAppJS(): void;
+    loadCommonPage(): void;
+    loadSecurityConfig(forceFlag?: boolean): Promise<any>;
+    loadMetadata(): Promise<any>;
+    loadAppVariables(variables?: any): any;
+    /**
+     * getter and setter for the property appVariablesFired
+     * this flag determines if the app variables(with startUpdate:true) have been fired
+     * they should get fired only once through app lifecycle
+     * @param {boolean} isFired
+     * @returns {boolean}
+     */
+    isAppVariablesFired(isFired?: boolean): boolean;
+    private clearLoggedInUserVariable;
+    private updateLoggedInUserVariable;
+    /**
+     * Overriding the app variable supported locale with the wmProperties i18n DataValues
+     *
+     * TODO[Vibhu]:
+     * Can write a simple migration to sync the supportedLocale variable with '_WM_APP_PROPERTIES.supportedLanguages'
+     * Hence, this may not be required
+     *
+     */
+    updateSupportedLocaleVariable(): void;
+    handleSSOLogin(config: any, options: any): void;
+    /**
+     * Handles the app when a XHR request returns 401 response
+     * If no user was logged in before 401 occurred, First time Login is simulated
+     * Else, a session timeout has occurred and the same is simulated
+     * @param page  if provided, represents the page name for which XHR request returned 401, on re-login
+     *              if not provided, a service request returned 401
+     * @param onSuccess success handler
+     * @param onError error handler
+     */
+    handle401(page?: any, options?: any): void;
+    /**
+     * Updates data dependent on logged in user
+     * Reloads security config, metadata
+     * Updates the loggedInUserVariable
+     * @returns {Promise<void>}
+     */
+    reloadAppData(): Promise<any>;
+    noRedirect(value?: boolean): boolean;
+    /**
+     * invokes session failure requests
+     */
+    executeSessionFailureRequests(): void;
+    pushToSessionFailureRequests(callback: any): void;
+    getDeployedURL(): string;
+    /**
+     * Fetches the customurlscheme for a mobile app
+     * which is used for redirection back to the app from browser in implicit oAuth flow
+     * @returns {string}
+     */
+    getCustomUrlScheme(): string;
+    notify(eventName: any, data: any): void;
+    subscribe(eventName: any, data: any): () => void;
+    getActivePage(): any;
+    getAppLocale(): any;
+    getSelectedLocale(): string;
+    notifyApp(template: any, type: any, title?: any): void;
+    /**
+     * Triggers the onBeforeService method defined in app.js of the app
+     * @param requestParams
+     */
+    appOnBeforeServiceCall(requestParams: any): any;
+    /**
+     * Triggers the onServiceSuccess method defined in app.js of the app
+     * @param data
+     * @param xhrObj
+     */
+    appOnServiceSuccess(data: any, xhrObj: any): any;
+    /**
+     * Triggers the onServiceError method defined in app.js of the app
+     * @param data
+     * @param xhrOb
+     */
+    appOnServiceError(data: any, xhrOb?: any): any;
+    /**
+     * Triggers the appVariablesReady method defined in app.js of the app
+     */
+    appVariablesReady(): void;
+    /**
+     * Triggers the onBeforeAppReady method defined in app.js of the app
+     */
+    beforeAppReady(): any;
+    /**
+     * Returns the pipe based on the input
+     */
+    getPipe(pipe: any): DatePipe;
+    private setLandingPage;
+    /**
+     * return true if prefab type app
+     * @returns {boolean}
+     */
+    isPrefabType(): boolean;
+    /**
+     * return true if template bundle type app
+     * @returns {boolean}
+     */
+    isTemplateBundleType(): boolean;
+    postMessage(content: any): void;
+    showTemplate(idx: any): void;
+    postTemplateBundleInfo(): Promise<any>;
+    postAppTypeInfo(): Promise<any>;
+    initAppModes(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppManagerService>;
+}

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

@@ -0,0 +1,70 @@
+import { Injector, OnDestroy } from '@angular/core';
+import { RouteReuseStrategy } from '@angular/router';
+import { AbstractHttpService, AbstractI18nService, StatePersistence } from '@wm/core';
+import { SecurityService } from '@wm/security';
+import * as i0 from "@angular/core";
+export declare class AppRef implements OnDestroy {
+    private inj;
+    private i18nService;
+    private statePersistence;
+    private httpService;
+    private securityService;
+    private routeReuseStrategy;
+    Variables: any;
+    Actions: any;
+    onAppVariablesReady: (...args: any[]) => void;
+    onBeforeAppReady: (...args: any[]) => void;
+    onSessionTimeout: (...args: any[]) => void;
+    onPageReady: (...args: any[]) => void;
+    onBeforePageLeave: (...args: any[]) => void;
+    onBeforeServiceCall: (...args: any[]) => void;
+    onServiceSuccess: (...args: any[]) => void;
+    onServiceError: (...args: any[]) => void;
+    dynamicComponentContainerRef: {};
+    projectName: string;
+    isPrefabType: boolean;
+    isApplicationType: boolean;
+    isTabletApplicationType: boolean;
+    isTemplateBundleType: boolean;
+    isPrism: boolean;
+    targetPlatform: string;
+    appLocale: any;
+    modes: any;
+    changeLocale: any;
+    getSelectedLocale: any;
+    setTimezone: any;
+    setwidgetLocale: any;
+    private _eventNotifier;
+    private sessionTimeoutUnsubscribe;
+    landingPageName: any;
+    reload(): void;
+    constructor(inj: Injector, i18nService: AbstractI18nService, statePersistence: StatePersistence, httpService: AbstractHttpService, securityService: SecurityService, routeReuseStrategy: RouteReuseStrategy);
+    clearPageCache(pageName?: string): void;
+    notify(eventName: string, ...data: Array<any>): void;
+    importModule(moduleName: string): Promise<any> | typeof import("moment");
+    getDependency(injToken: any): any;
+    /**
+     * triggers the onSessionTimeout callback in app.js
+     */
+    on401(): void;
+    subscribe(eventName: any, callback: (data: any) => void): () => void;
+    notifyApp(template: any, type: any, title: any): void;
+    /**
+     * function to register bind expressions from app variables
+     * it will be called from app.js in generated angular app
+     * @param expressions, map of bind expression vs generated function
+     */
+    registerExpressions(expressions: any): void;
+    /**
+     * Utility method to check if an object has a property
+     * This is commonly used in expressions to check object properties
+     * @param obj The object to check
+     * @param prop The property name to check
+     * @returns true if the object has the property, false otherwise
+     */
+    hasOwnObjectProperty(obj: any, prop: string): boolean;
+    setMode(modes: Record<string, string>, shouldPersist?: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppRef, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppRef>;
+}

package/runtime/base/services/dynamic-component-ref-provider.service.d.ts

@@ -0,0 +1,26 @@
+import { Compiler } from '@angular/core';
+import { App } from '@wm/core';
+import { AppManagerService } from './app.manager.service';
+import * as i0 from "@angular/core";
+export declare class DynamicComponentRefProviderService {
+    private app;
+    private appManager;
+    private compiler;
+    private counter;
+    constructor(app: App, appManager: AppManagerService, compiler: Compiler);
+    getComponentFactoryRef(selector: string, markup: string, options?: any): Promise<any>;
+    /**
+     * Creates the component dynamically and add it to the DOM
+     * @param target: HTML element where we need to append the created component
+     * @param markup: Template of the component
+     * @param context: Scope of the component
+     * @param options: We have options like
+                       selector: selector of the component
+                       transpile: flag for transpiling HTML. By default it is true
+                       nocache: flag for render it from cache or not. By default it is true
+     * @returns ComponentRef - the created component reference for cleanup
+     */
+    addComponent(target: HTMLElement, markup: string, context?: {}, options?: any): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicComponentRefProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicComponentRefProviderService>;
+}

package/runtime/base/services/http-interceptor.services.d.ts

@@ -0,0 +1,17 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * This Interceptor intercepts all network calls and if a network call fails
+ * due to session timeout, then it calls a function to handle session timeout.
+ */
+export declare class HttpCallInterceptor implements HttpInterceptor {
+    wmHttpRequest: any;
+    wmHttpResponse: any;
+    constructor();
+    createSubject(): Subject<unknown>;
+    isAbsoluteUrl(url: string): boolean;
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpCallInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpCallInterceptor>;
+}

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

@@ -0,0 +1,58 @@
+import { Injector } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { BsLocaleService } from 'ngx-bootstrap/datepicker';
+import { AbstractI18nService, AppDefaults } from '@wm/core';
+import * as i0 from "@angular/core";
+export declare class I18nServiceImpl extends AbstractI18nService {
+    private $http;
+    private bsLocaleService;
+    private appDefaults;
+    private inj;
+    private selectedLocale;
+    private defaultSupportedLocale;
+    private readonly appLocale;
+    private readonly prefabLocale;
+    private messages;
+    private _isAngularLocaleLoaded;
+    private formatsByLocale;
+    private get app();
+    private bundleLoaded;
+    constructor($http: HttpClient, bsLocaleService: BsLocaleService, appDefaults: AppDefaults, inj: Injector);
+    private updateLocaleDirection;
+    private init;
+    getSelectedLocale(): string;
+    getDefaultSupportedLocale(): string;
+    getAppLocale(): any;
+    getPrefabLocaleBundle(prefabName: string): any;
+    private extendPrefabMessages;
+    private extendMessages;
+    private loadResource;
+    protected loadAppLocaleBundle(): void;
+    protected loadMomentLocaleBundle(momentLocale: any): void;
+    protected loadScriptForMoment(momentLocale: any): void;
+    protected loadAngularLocaleBundle(angLocale: any): Promise<void>;
+    protected loadMomentTimeZoneBundle(): Promise<any>;
+    protected loadLocaleBundles(libLocale: any): Promise<void>;
+    setTimezone(locale: any, compInstance?: any): void;
+    setTimezoneEarly(): Promise<any>;
+    getTimezone(compInstance?: any): any;
+    getFormatsByLocale(): {
+        timezone: string;
+        number: string;
+    };
+    setSelectedLocale(locale: any): Promise<void>;
+    private deduceAppLocale;
+    loadDefaultLocale(): Promise<void>;
+    getLocalizedMessage(message: any, ...args: any[]): any;
+    getAcceptedLanguages(): Lowercase<any>[];
+    initCalendarLocale(): Promise<any>;
+    isAngularLocaleLoaded(): boolean;
+    setwidgetLocale(locale: any): void;
+    getwidgetLocale(): {
+        timezone: string;
+        number: string;
+    };
+    private notifyLocaleChanged;
+    static ɵfac: i0.ɵɵFactoryDeclaration<I18nServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<I18nServiceImpl>;
+}

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

@@ -0,0 +1,45 @@
+import { NgZone } from '@angular/core';
+import { Router } from '@angular/router';
+import { App, NavigationOptions, AbstractNavigationService } from '@wm/core';
+import * as i0 from "@angular/core";
+export declare class NavigationServiceImpl implements AbstractNavigationService {
+    private app;
+    private router;
+    zone: NgZone;
+    private history;
+    private transition;
+    private isPageAddedToHistory;
+    constructor(app: App, router: Router, zone: NgZone);
+    getPageTransition(): string;
+    /**
+     * Navigates to particular page
+     * @param pageName
+     * @param options
+     */
+    goToPage(pageName: string, options: NavigationOptions): void;
+    /**
+     * Navigates to last visited page.
+     */
+    goToPrevious(): void;
+    /** Todo[Shubham] Need to handle gotoElement in other partials
+     * Navigates to particular view
+     * @param viewName
+     * @param options
+     * @param variable
+     */
+    goToView(viewName: string, options: NavigationOptions, variable: any): void;
+    private goToElementView;
+    private getViewElementInActivePage;
+    /**
+     * checks if the pagecontainer has the pageName.
+     */
+    private isPartialWithNameExists;
+    /**
+     * checks if the pagecontainer has the prefab.
+     */
+    private isPrefabWithNameExists;
+    private showAncestors;
+    private showAncestorDialog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationServiceImpl>;
+}

package/runtime/base/services/pipe-provider.service.d.ts

@@ -0,0 +1,31 @@
+import { Compiler, Injector, Pipe } from '@angular/core';
+import { AbstractI18nService } from '@wm/core';
+import { DomSanitizer } from "@angular/platform-browser";
+import * as i0 from "@angular/core";
+export declare class PipeProvider {
+    private compiler;
+    private injector;
+    private domSanitizer;
+    private i18service;
+    _pipeMeta: any;
+    _locale: string;
+    formatsByLocale: any;
+    preparePipeMeta: (reference: Pipe, name: string, pure: boolean, diDeps?: any[]) => {
+        type: {
+            reference: Pipe;
+            diDeps: any[];
+        };
+        name: string;
+        pure: boolean;
+    };
+    _pipeData: any[];
+    setPipeData(): void;
+    unknownPipe(name: any): void;
+    constructor(compiler: Compiler, injector: Injector, domSanitizer: DomSanitizer, i18service: AbstractI18nService);
+    meta(name: any): any;
+    getPipeNameVsIsPureMap(): Map<any, any>;
+    resolveDep(dep: any): any;
+    getInstance(name: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PipeProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PipeProvider>;
+}

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

@@ -0,0 +1,12 @@
+import { PipeProvider } from "./pipe-provider.service";
+import { App } from "@wm/core";
+import * as i0 from "@angular/core";
+export declare class PipeService {
+    private pipeProvider;
+    private $app;
+    constructor(pipeProvider: PipeProvider, $app: App);
+    private supportedPipes;
+    getPipe(name: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PipeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PipeService>;
+}

package/runtime/base/services/prefab-manager.service.d.ts

@@ -0,0 +1,25 @@
+import { MetadataService } from '@wm/variables';
+import { PrefabConfigProvider } from '../types/types';
+import * as i0 from "@angular/core";
+export declare class PrefabManagerService {
+    private $metadata;
+    private prefabConfigProvider;
+    constructor($metadata: MetadataService, prefabConfigProvider: PrefabConfigProvider);
+    getConfig(prefabName: any): Promise<any>;
+    loadServiceDefs(prefabName: any): Promise<any>;
+    protected loadStyles(prefabName: any, { resources: { styles } }?: {
+        resources: {
+            styles: any[];
+        };
+    }): Promise<void>;
+    protected loadScripts(prefabName: any, { resources: { scripts } }?: {
+        resources: {
+            scripts: any[];
+        };
+    }): Promise<any>;
+    private setInProgress;
+    private resolveInProgress;
+    loadDependencies(prefabName: any): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrefabManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PrefabManagerService>;
+}

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

@@ -0,0 +1,49 @@
+import { OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { AbstractSpinnerService } from '@wm/core';
+import * as i0 from "@angular/core";
+export declare class SpinnerServiceImpl extends AbstractSpinnerService implements OnDestroy {
+    spinnerId: number;
+    messageSource: Subject<unknown>;
+    messagesByContext: {};
+    constructor();
+    /**
+     * returns the message source subject
+     * @returns {Subject<any>}
+     */
+    getMessageSource(): Subject<unknown>;
+    /**
+     * show spinner on a container element
+     */
+    showContextSpinner(ctx: string, message: string, id: string): string;
+    /**
+     * show the app spinner with provided message
+     * @param msg
+     * @returns {string}
+     */
+    showAppSpinner(msg: any, id: any): void;
+    /**
+     * hides the spinner on a particular container(context)
+     * @param ctx
+     * @param id
+     */
+    hideContextSpinner(ctx: any, id: any): void;
+    /**
+     * show spinner
+     * @param message
+     * @param id
+     * @param spinnerClass
+     * @param spinnerContext
+     * @param variableScopeId
+     * @returns {any}
+     */
+    show(message: any, id?: any, spinnerClass?: any, spinnerContext?: any, variableScopeId?: any): any;
+    /**
+     * hide the spinner
+     * @param spinnerId
+     */
+    hide(id: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpinnerServiceImpl>;
+}

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

@@ -0,0 +1,23 @@
+import { ToastrService } from 'ngx-toastr';
+import { AbstractToasterService } from '@wm/core';
+import * as i0 from "@angular/core";
+export declare class ToasterServiceImpl extends AbstractToasterService {
+    private toaster;
+    constructor(toaster: ToastrService);
+    private _showToaster;
+    success(title: any, desc: any): any;
+    error(title: any, desc: any): any;
+    info(title: any, desc: any): any;
+    warn(title: any, desc: any): any;
+    show(type: any, title: any, desc: any, options: any): any;
+    hide(toasterObj: any): void;
+    showCustom(page: any, options: any): import("ngx-toastr").ActiveToast<any>;
+    /**
+     * Updates the Global Toaster options based on the passed object. Useful in cases where
+     * a user wants to display multiple toasts at the same time, newest on bottom etc
+     * @param {options} Object
+     */
+    setToasterConfig(options: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToasterServiceImpl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToasterServiceImpl>;
+}

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

@@ -0,0 +1,25 @@
+export declare enum ComponentType {
+    PAGE = 0,
+    PREFAB = 1,
+    PARTIAL = 2,
+    WIDGET = 3
+}
+export declare abstract class ComponentRefProvider {
+    abstract getComponentFactoryRef(componentName: string, componentType: ComponentType): Promise<any>;
+    clearComponentFactoryRefCache(): void;
+}
+export declare abstract class PrefabConfigProvider {
+    abstract getConfig(prefabName: string): Promise<any>;
+}
+export declare abstract class CustomwidgetConfigProvider {
+    abstract getConfig(widgetname: string): Promise<any>;
+}
+export declare abstract class AppJSProvider {
+    abstract getAppScriptFn(): Promise<Function>;
+}
+export declare abstract class AppVariablesProvider {
+    abstract getAppVariables(): Promise<any>;
+}
+export declare abstract class AppExtensionProvider {
+    abstract loadFormatterConfigScript(callback: Function): void;
+}

package/runtime/base/util/fragment-monitor.d.ts

@@ -0,0 +1,22 @@
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare abstract class FragmentMonitor {
+    fragments: number;
+    viewInit$: Subject<any>;
+    isViewInitialized: boolean;
+    isPageComponent: boolean;
+    fragmentsLoaded$: Subject<unknown>;
+    private viewInitSubscription;
+    constructor();
+    init(): void;
+    /**
+     * MEMORY LEAK FIX: Clean up FragmentMonitor resources
+     * Should be called from implementing class's ngOnDestroy
+     */
+    protected cleanupFragmentMonitor(): void;
+    registerFragment(): void;
+    resolveFragment(): void;
+    isReady(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FragmentMonitor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FragmentMonitor, never, never, {}, {}, never, never, false, never>;
+}

package/runtime/base/util/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const isPrefabInPreview: (prefabName: string) => prefabName is "__self__";
+export declare const getPrefabBaseUrl: (prefabName: string) => string;
+export declare const getPrefabConfigUrl: (prefabName: string) => string;
+export declare const getPrefabMinJsonUrl: (prefabName: string) => string;
+export declare const getPrefabPartialJsonUrl: (prefabName: string, partialName: string) => string;
+export declare const getModesFromLocalStorage: () => any;

package/runtime/base/util/wm-route-reuse-strategy.d.ts

@@ -0,0 +1,29 @@
+import { ActivatedRouteSnapshot, DetachedRouteHandle, RouteReuseStrategy } from '@angular/router';
+export declare const CACHE_PAGE = "_cache_page";
+export declare const MAX_CACHE_SIZE = "REUSE_ROUTE_STRATEGY.MAX_CACHE_SIZE";
+export declare const MAX_CACHE_AGE = "REUSE_ROUTE_STRATEGY.MAX_CACHE_AGE";
+export declare class WmDefaultRouteReuseStrategy {
+    private cache;
+    private currentRouteKey;
+    private paramsToIgnore;
+    constructor(maxCacheSize?: number, maxCacheAge?: number);
+    private getKey;
+    protected getSize: (obj: object | null) => number;
+    protected isSameQueryParams(future: any, current: any): boolean;
+    private isCacheEnabled;
+    shouldDetach(route: ActivatedRouteSnapshot): boolean;
+    shouldAttach(route: ActivatedRouteSnapshot): boolean;
+    store(route: ActivatedRouteSnapshot, handle: DetachedRouteHandle): void;
+    retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle | null;
+    reset(pageName?: string): void;
+}
+export declare class WmRouteReuseStrategy extends WmDefaultRouteReuseStrategy implements RouteReuseStrategy {
+    constructor();
+    private isSameRoute;
+    shouldReuseRoute(future: ActivatedRouteSnapshot, current: ActivatedRouteSnapshot): boolean;
+}
+export declare class WmNgRouteReuseStrategy extends WmDefaultRouteReuseStrategy implements RouteReuseStrategy {
+    constructor();
+    private isSameRoute;
+    shouldReuseRoute(future: ActivatedRouteSnapshot, current: ActivatedRouteSnapshot): boolean;
+}

package/runtime/dynamic/.npmignore

@@ -0,0 +1,2 @@
+# Nested package.json's are only needed for development.
+**/package.json

package/runtime/dynamic/app/app.config.d.ts

@@ -0,0 +1,5 @@
+import { ApplicationConfig } from "@angular/core";
+export declare const xsrfHeaderName: any;
+export declare function InitializeApp(I18nService: any, AppJSResolve: any, AppBeforeLoadResolve: any, AppVariablesResolve: any, AppExtensionJSResolve: any): () => Promise<any>;
+export declare function setAngularLocale(I18nService: any): any;
+export declare const appConfig: ApplicationConfig;

package/runtime/dynamic/app/app.module.d.ts

@@ -0,0 +1,37 @@
+import { Injector, ModuleWithProviders } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { HttpClientXsrfModule } from '@angular/common/http';
+import { TypeaheadModule } from 'ngx-bootstrap/typeahead';
+import { TimepickerModule as ngxTimepickerModule } from 'ngx-bootstrap/timepicker';
+import { ProgressbarModule } from 'ngx-bootstrap/progressbar';
+import { PaginationModule as ngxPaginationModule } from 'ngx-bootstrap/pagination';
+import { ModalModule } from 'ngx-bootstrap/modal';
+import { TooltipModule } from 'ngx-bootstrap/tooltip';
+import { BsDatepickerModule } from 'ngx-bootstrap/datepicker';
+import { BsDropdownModule } from 'ngx-bootstrap/dropdown';
+import { PopoverModule as ngxPopoverModule } from 'ngx-bootstrap/popover';
+import { NgCircleProgressModule } from 'ng-circle-progress';
+import { ToastNoAnimationModule } from 'ngx-toastr';
+import { CarouselModule as ngxCarouselModule } from 'ngx-bootstrap/carousel';
+import { App } from '@wm/core';
+import { ComponentRefProvider } from '@wm/runtime/base';
+export declare const routerModule: ModuleWithProviders<RouterModule>;
+export declare const toastrModule: ModuleWithProviders<ToastNoAnimationModule>;
+export declare const httpClientXsrfModule: ModuleWithProviders<HttpClientXsrfModule>;
+export declare const modalModule: ModuleWithProviders<ModalModule>;
+export declare const bsDatePickerModule: ModuleWithProviders<BsDatepickerModule>;
+export declare const timepickerModule: ModuleWithProviders<ngxTimepickerModule>;
+export declare const bsDropdownModule: ModuleWithProviders<BsDropdownModule>;
+export declare const paginationModule: ModuleWithProviders<ngxPaginationModule>;
+export declare const typeaheadModule: ModuleWithProviders<TypeaheadModule>;
+export declare const progressbarModule: ModuleWithProviders<ProgressbarModule>;
+export declare const carouselModule: ModuleWithProviders<ngxCarouselModule>;
+export declare const popoverModule: ModuleWithProviders<ngxPopoverModule>;
+export declare const ngCircleProgressModule: ModuleWithProviders<NgCircleProgressModule>;
+export declare const tooltipModule: ModuleWithProviders<TooltipModule>;
+export declare class AppModule {
+    private app;
+    private inj;
+    private componentRefProvider;
+    constructor(app: App, inj: Injector, componentRefProvider: ComponentRefProvider);
+}

package/runtime/dynamic/app/app.routes.d.ts

@@ -0,0 +1,2 @@
+import { Routes } from '@angular/router';
+export declare const routes: Routes;