@bnsights/bbsf-admin-portal 1.0.0

package/lib/_metronic/configs/default-layout.config.d.ts

@@ -0,0 +1,139 @@
+export interface ILayoutComponent {
+    componentName: string;
+}
+export interface ILoader extends ILayoutComponent {
+    display?: boolean;
+    type: 'default' | 'spinner-message' | 'spinner-logo';
+}
+export interface IScrollTop extends ILayoutComponent {
+    display: boolean;
+}
+export interface IHeader extends ILayoutComponent {
+    display: boolean;
+    width: 'fixed' | 'fluid';
+    left: 'menu' | 'page-title';
+    fixed: {
+        desktop: boolean;
+        tabletAndMobile: boolean;
+    };
+    menuIcon: 'svg' | 'font';
+}
+export interface IMegaMenu extends ILayoutComponent {
+    display: boolean;
+}
+export interface IAside extends ILayoutComponent {
+    display: boolean;
+    theme: 'dark' | 'light';
+    menu: 'main' | 'documentation';
+    fixed: boolean;
+    minimized: boolean;
+    minimize: boolean;
+    hoverable: boolean;
+    menuIcon: 'svg' | 'font';
+}
+export interface IContent extends ILayoutComponent {
+    width: 'fixed' | 'fluid';
+    layout: 'default' | 'docs';
+}
+export interface IFooter extends ILayoutComponent {
+    width: 'fixed' | 'fluid';
+}
+export interface ISidebar extends ILayoutComponent {
+    display: boolean;
+    toggle: boolean;
+    shown: boolean;
+    content: 'general' | 'user' | 'shop';
+    bgColor: 'bg-white' | 'bg-info';
+    displayFooter: boolean;
+    displayFooterButton: boolean;
+}
+export interface IToolbar extends ILayoutComponent {
+    display: boolean;
+    width: 'fixed' | 'fluid';
+    fixed: {
+        desktop: boolean;
+        tabletAndMobileMode: boolean;
+    };
+    layout: 'toolbar1' | 'toolbar2' | 'toolbar3' | 'toolbar4' | 'toolbar5';
+    layouts: {
+        toolbar1: {
+            height: string;
+            heightAndTabletMobileMode: string;
+        };
+        toolbar2: {
+            height: string;
+            heightAndTabletMobileMode: string;
+        };
+        toolbar3: {
+            height: string;
+            heightAndTabletMobileMode: string;
+        };
+        toolbar4: {
+            height: string;
+            heightAndTabletMobileMode: string;
+        };
+        toolbar5: {
+            height: string;
+            heightAndTabletMobileMode: string;
+        };
+    };
+}
+export interface IPageTitle extends ILayoutComponent {
+    display: boolean;
+    breadCrumbs: boolean;
+    description: boolean;
+    layout: 'default' | 'select';
+    direction: 'row' | 'column';
+    responsive: boolean;
+    responsiveBreakpoint: 'lg' | 'md' | 'lg' | '300px';
+    responsiveTarget: string;
+}
+export interface IMain extends ILayoutComponent {
+    body?: {
+        backgroundImage?: string;
+        class: string;
+    };
+    primaryColor: string;
+    darkSkinEnabled: boolean;
+    type: 'blank' | 'default' | 'none';
+}
+export interface ILayout {
+    loader: ILoader;
+    scrolltop: IScrollTop;
+    header: IHeader;
+    megaMenu: IMegaMenu;
+    aside: IAside;
+    content: IContent;
+    toolbar: IToolbar;
+    footer: IFooter;
+    sidebar?: ISidebar;
+    main?: IMain;
+    pageTitle?: IPageTitle;
+}
+export interface ILayoutCSSClasses {
+    header: Array<string>;
+    headerContainer: Array<string>;
+    headerMobile: Array<string>;
+    headerMenu: Array<string>;
+    aside: Array<string>;
+    asideMenu: Array<string>;
+    asideToggle: Array<string>;
+    sidebar: Array<string>;
+    toolbar: Array<string>;
+    toolbarContainer: Array<string>;
+    content: Array<string>;
+    contentContainer: Array<string>;
+    footerContainer: Array<string>;
+    pageTitle: Array<string>;
+}
+export interface ILayoutHTMLAttributes {
+    asideMenu: Map<string, string | number | boolean>;
+    headerMobile: Map<string, string | number | boolean>;
+    headerMenu: Map<string, string | number | boolean>;
+    headerContainer: Map<string, string | number | boolean>;
+    pageTitle: Map<string, string | number | boolean>;
+}
+export interface ILayoutCSSVariables {
+    body: Map<string, string | number | boolean>;
+}
+export declare const DefaultLayoutConfig: ILayout;

package/lib/_metronic/core/_utils/DomHelpers.d.ts

@@ -0,0 +1,29 @@
+import { OffsetModel } from './models/OffsetModel';
+import { ViewPortModel } from './models/ViewPortModel';
+declare function getCSS(el: HTMLElement, styleProp: string): string;
+declare function getCSSVariableValue(variableName: string): string;
+declare function getElementActualCss(el: HTMLElement, prop: any, cache: boolean): number;
+declare function getElementActualHeight(el: HTMLElement): number;
+declare function getElementActualWidth(el: HTMLElement, cache?: boolean): number;
+declare function getElementIndex(element: HTMLElement): number;
+declare function getElementMatches(element: HTMLElement, selector: string): any;
+declare function getElementOffset(el: HTMLElement): OffsetModel;
+declare function getElementParents(element: Element, selector: string): any[];
+declare function getHighestZindex(el: HTMLElement): number;
+declare function getScrollTop(): number;
+declare function getViewPort(): ViewPortModel;
+declare function insertAfterElement(el: HTMLElement, referenceNode: HTMLElement): HTMLElement;
+declare function isElementHasClasses(element: HTMLElement, classesStr: string): boolean;
+declare function isVisibleElement(element: HTMLElement): boolean;
+declare function throttle(timer: number | undefined, func: Function, delay?: number): void;
+declare function getElementChildren(element: HTMLElement, selector: string): Array<HTMLElement> | null;
+declare function getElementChild(element: HTMLElement, selector: string): HTMLElement | null;
+declare function isMobileDevice(): boolean;
+declare function slide(el: HTMLElement, dir: string, speed: number, callback: any): void;
+declare function slideUp(el: HTMLElement, speed: number, callback: any): void;
+declare function slideDown(el: HTMLElement, speed: number, callback: any): void;
+declare function getBreakpoint(breakpoint: string): string | number;
+declare function getAttributeValueByBreakpoint(incomingAttr: string): string | JSON;
+declare function colorLighten(color: string, amount: number): string;
+declare function colorDarken(color: string, amount: number): string;
+export { getBreakpoint, getCSS, getCSSVariableValue, getElementActualCss, getElementActualHeight, getElementActualWidth, getElementIndex, getElementMatches, getElementOffset, getElementParents, getHighestZindex, getScrollTop, getViewPort, insertAfterElement, isElementHasClasses, isVisibleElement, throttle, getElementChildren, getElementChild, isMobileDevice, slide, slideUp, slideDown, getAttributeValueByBreakpoint, colorLighten, colorDarken, };

package/lib/_metronic/core/_utils/ElementAnimateUtil.d.ts

@@ -0,0 +1,10 @@
+export declare class ElementAnimateUtil {
+    static animate(from: number, to: number, duration: number, update: Function, complete?: Function): void;
+    static animateClass(element: HTMLElement, animationName: string, callBack?: Function): void;
+    static transitionEnd(element: HTMLElement, callBack: Function): void;
+    static animationEnd(element: HTMLElement, callBack: Function): void;
+    static animationDelay(element: HTMLElement, value: string): void;
+    static animationDuration(element: HTMLElement, value: string): void;
+    static scrollTo(element: HTMLElement | null, offset: number, duration?: number): void;
+    static scrollTop(offset: number, duration: number): void;
+}

package/lib/_metronic/core/_utils/EventHandlerUtil.d.ts

@@ -0,0 +1,20 @@
+export interface EventMeta {
+    name: string;
+    callback: Function;
+    one: boolean;
+    fired: boolean;
+}
+export declare class EventHandlerUtil {
+    static store: Map<string, Map<string, EventMeta>>;
+    private static setEventMetasByName;
+    private static getEventMetasByName;
+    private static setEventMetaByNameAndHandlerId;
+    private static getEventsMetaByHandlerId;
+    private static setFiredByNameAndHandlerId;
+    private static addEvent;
+    private static removeEvent;
+    static trigger(element: HTMLElement, name: string, e?: Event): any;
+    static on: (element: HTMLElement, name: string, callBack: Function) => void;
+    static one(element: HTMLElement, name: string, callBack: Function): void;
+    static off(element: HTMLElement, name: string): void;
+}

package/lib/_metronic/core/_utils/_DOMEventHandlerUtil.d.ts

@@ -0,0 +1,6 @@
+export declare class DOMEventHandlerUtil {
+    static store: Map<any, any>;
+    static on(element: HTMLElement, selector: string, eventName: string, callBack: any): string;
+    static off(element: HTMLElement, eventName: string, eventId: string): void;
+    static one(element: HTMLElement, eventName: string, callBack: Function): void;
+}

package/lib/_metronic/core/_utils/_DataUtil.d.ts

@@ -0,0 +1,8 @@
+export declare class DataUtil {
+    static store: Map<HTMLElement, Map<string, any>>;
+    static set(instance: HTMLElement | undefined, key: string, data: any): void;
+    static get(instance: HTMLElement, key: string): any | undefined;
+    static remove(instance: HTMLElement, key: string): void;
+    static has(instance: HTMLElement, key: string): boolean;
+    static getAllInstancesByKey(key: string): any[];
+}

package/lib/_metronic/core/_utils/_ElementStyleUtil.d.ts

@@ -0,0 +1,5 @@
+export declare class ElementStyleUtil {
+    static set(element: HTMLElement, property: string, value?: any, important?: boolean): void;
+    static get(element: HTMLElement, attributeName: string): string;
+    static remove(element: HTMLElement, attibuteName: string): void;
+}

package/lib/_metronic/core/_utils/_TypesHelpers.d.ts

@@ -0,0 +1,10 @@
+declare function getObjectPropertyValueByKey(obj: any, key: string): any | undefined;
+/**
+ * Generates unique ID for give prefix.
+ * @param {string} prefix Prefix for generated ID
+ * @returns {boolean}
+ */
+declare function getUniqueIdWithPrefix(prefix: string | undefined): string;
+declare function stringSnakeToCamel(str: string): string;
+declare function toJSON(value: string | JSON): JSON | undefined;
+export { getObjectPropertyValueByKey, getUniqueIdWithPrefix, stringSnakeToCamel, toJSON };

package/lib/_metronic/core/_utils/models/OffsetModel.d.ts

@@ -0,0 +1,4 @@
+export interface OffsetModel {
+    top: number;
+    left: number;
+}

package/lib/_metronic/core/_utils/models/ViewPortModel.d.ts

@@ -0,0 +1,4 @@
+export interface ViewPortModel {
+    width: number;
+    height: number;
+}

package/lib/_metronic/core/components/MenuComponent.d.ts

@@ -0,0 +1,88 @@
+export interface MenuOptions {
+    dropdown: {
+        hoverTimeout: number;
+        zindex: number;
+    };
+    accordion: {
+        slideSpeed: number;
+        expand: boolean;
+    };
+}
+declare const defaultMenuOptions: MenuOptions;
+declare class MenuComponent {
+    element: HTMLElement;
+    options: MenuOptions;
+    instanceUid: string;
+    triggerElement: HTMLElement | null;
+    constructor(_element: HTMLElement, options: MenuOptions);
+    private _setTriggerElement;
+    private _isTriggerElement;
+    private _getItemOption;
+    private _getItemElement;
+    private _getItemParentElement;
+    private _getItemParentElements;
+    private _getDropdownPopperConfig;
+    private _getItemChildElement;
+    private _getItemChildElements;
+    private _getItemSubElement;
+    private _getCss;
+    private _getItemSubType;
+    private _isItemSubShown;
+    private _isItemDropdownPermanent;
+    private _isItemParentShown;
+    private _isItemSubElement;
+    private _hasItemSub;
+    private _getItemLinkElement;
+    private _getItemToggleElement;
+    private _showDropdown;
+    private initDropdownPopper;
+    private _hideDropdown;
+    private destroyDropdownPopper;
+    private _showAccordion;
+    private _hideAccordion;
+    private _hideAccordions;
+    private _reset;
+    private _destroy;
+    private _update;
+    private _hide;
+    private _show;
+    private _toggle;
+    private _mouseout;
+    private _mouseover;
+    private _dismiss;
+    private _link;
+    private _click;
+    click: (element: HTMLElement, e: Event) => void;
+    link: (element: HTMLElement, e: Event) => void;
+    dismiss: (element: HTMLElement, e: Event) => void;
+    mouseover: (element: HTMLElement, e: Event) => void;
+    mouseout: (element: HTMLElement, e: Event) => void;
+    getItemTriggerType: (item: HTMLElement) => any;
+    getItemSubType: (element: HTMLElement) => "dropdown" | "accordion";
+    show: (item: HTMLElement) => void;
+    hide: (item: HTMLElement) => void;
+    reset: (item: HTMLElement) => void;
+    update: () => void;
+    getElement: () => HTMLElement;
+    getItemLinkElement: (item: HTMLElement) => HTMLElement;
+    getItemToggleElement: (item: HTMLElement) => HTMLElement;
+    getItemSubElement: (item: HTMLElement) => any;
+    getItemParentElements: (item: HTMLElement) => any[];
+    isItemSubShown: (item: HTMLElement) => any;
+    isItemParentShown: (item: HTMLElement) => boolean;
+    getTriggerElement: () => HTMLElement;
+    isItemDropdownPermanent: (item: HTMLElement) => boolean;
+    hideAccordions: (item: HTMLElement) => void;
+    on: (name: string, handler: any) => void;
+    one: (name: string, handler: any) => void;
+    off: (name: string) => void;
+    static getInstance: (element: HTMLElement) => any;
+    static hideDropdowns: (skip: HTMLElement | undefined) => void;
+    static updateDropdowns: () => void;
+    static createInstances: (selector: string) => void;
+    static initGlobalHandlers: () => void;
+    static bootstrap: () => void;
+    static reinitialization: () => void;
+    static createInsance: (selector: string, options?: MenuOptions) => MenuComponent | undefined;
+}
+export { MenuComponent, defaultMenuOptions };

package/lib/_metronic/core/components/_CookieComponent.d.ts

@@ -0,0 +1,25 @@
+export declare class CookieComponent {
+    /**
+     * Returns the cookie with the given name, or undefined if not found
+     *
+     * @param  {string} name - cookie name
+     * @returns string | null
+     */
+    static get(name: string): string | undefined;
+    /**
+     * Please note that a cookie value is encoded,
+     * so getCookie uses a built-in decodeURIComponent function to decode it.
+     *
+     * @param  {string} name - cookie name
+     * @param  {string | number | boolean} value - cookie value
+     * @param  {any} cookieOptions - cookie options
+     * @returns void
+     */
+    static set(name: string, value: string | number | boolean, cookieOptions: any): void;
+    /**
+     * To delete a cookie, we can call it with a negative expiration date
+     *
+     * @param  {string} name
+     */
+    static delete(name: string): void;
+}

package/lib/_metronic/core/components/_DrawerComponent.d.ts

@@ -0,0 +1,49 @@
+export interface DrawerOptions {
+    overlay: boolean;
+    baseClass: string;
+    overlayClass: string;
+    direction: string;
+}
+declare const defaultDrawerOptions: DrawerOptions;
+declare class DrawerComponent {
+    element: HTMLElement;
+    overlayElement: HTMLElement | null;
+    toggleElement: HTMLElement | null;
+    options: DrawerOptions;
+    instanceUid: string;
+    name: string;
+    shown: boolean;
+    lastWidth: number;
+    closeElement: HTMLElement | null;
+    constructor(_element: HTMLElement, options: DrawerOptions);
+    private _handlers;
+    private _update;
+    private _getOption;
+    private _toggle;
+    private _hide;
+    private _show;
+    private _createOverlay;
+    private _deleteOverlay;
+    private _getDirection;
+    private _getWidth;
+    toggle: () => void;
+    show: () => void;
+    hide: () => void;
+    isShown: () => boolean;
+    update: () => void;
+    goElement: () => HTMLElement;
+    on: (name: string, handler: Function) => void;
+    one: (name: string, handler: Function) => void;
+    off: (name: string) => void;
+    trigger: (name: string, event: Event) => any;
+    static hasInstace: (element: HTMLElement) => boolean;
+    static getInstance: (element: HTMLElement) => any;
+    static hideAll: () => void;
+    static updateAll: () => void;
+    static createInstances(selector: string): void;
+    static handleDismiss: () => void;
+    static initGlobalHandlers(): void;
+    static bootstrap: () => void;
+    static reinitialization: () => void;
+}
+export { DrawerComponent, defaultDrawerOptions };

package/lib/_metronic/core/components/_ScrollComponent.d.ts

@@ -0,0 +1,31 @@
+export interface ScrollOptions {
+    saveState?: boolean;
+}
+declare const defaultScrollOptions: ScrollOptions;
+declare class ScrollComponent {
+    element: HTMLElement;
+    options: ScrollOptions;
+    id: string;
+    constructor(_element: HTMLElement, options: ScrollOptions);
+    private getOption;
+    private getHeightType;
+    private getAutoHeight;
+    private setupHeight;
+    private setupState;
+    private setupScrollHandler;
+    private scrollHandler;
+    private destroyScrollHandler;
+    private resetHeight;
+    update: () => void;
+    getHeight: () => any;
+    getElement: () => HTMLElement;
+    static hasInstace(element: HTMLElement): boolean;
+    static getInstance(element: HTMLElement): any;
+    static createInstances(selector: string): void;
+    static destroyAll(attr?: string): void;
+    static bootstrap(attr?: string): void;
+    static createInstance: (element: HTMLElement, options?: ScrollOptions) => ScrollComponent | undefined;
+    static reinitialization(attr?: string): void;
+    static resize(): void;
+}
+export { ScrollComponent, defaultScrollOptions };

package/lib/_metronic/core/components/_ScrollTopComponent.d.ts

@@ -0,0 +1,24 @@
+export interface IScrollTopOptions {
+    offset: number;
+    speed: number;
+}
+declare const defaultScrollTopOptions: IScrollTopOptions;
+declare class ScrollTopComponent {
+    element: HTMLElement;
+    options: IScrollTopOptions;
+    instanceUid: string;
+    constructor(_element: HTMLElement, options: IScrollTopOptions);
+    private _handlers;
+    private _scroll;
+    private _go;
+    private _getOption;
+    go: () => void;
+    getElement: () => HTMLElement;
+    static getInstance: (el: HTMLElement) => any;
+    static createInstances: (selector: string) => void;
+    static createInsance: (selector: string, options?: IScrollTopOptions) => ScrollTopComponent | undefined;
+    static bootstrap: () => void;
+    static reinitialization: () => void;
+    static goTop: () => void;
+}
+export { ScrollTopComponent, defaultScrollTopOptions };

package/lib/_metronic/core/components/_ToggleComponent.d.ts

@@ -0,0 +1,36 @@
+export interface ToggleOptions {
+    saveState: boolean;
+    targetState?: string;
+    toggleState?: string;
+    targetToggleMode?: string;
+}
+declare const defaultToggleOptions: ToggleOptions;
+declare class ToggleComponent {
+    element: HTMLElement;
+    instanceUid: string;
+    options: ToggleOptions;
+    state: string;
+    target: HTMLElement | null;
+    attribute: string;
+    constructor(_element: HTMLElement, options: ToggleOptions);
+    private _handlers;
+    private _toggle;
+    private _enable;
+    private _disable;
+    private _isEnabled;
+    toggle: () => this;
+    enable: () => this;
+    disable: () => false | this;
+    isEnabled: () => boolean;
+    goElement: () => HTMLElement;
+    on: (name: string, handler: Function) => void;
+    one: (name: string, handler: Function) => void;
+    off: (name: string) => void;
+    trigger: (name: string, event?: Event) => any;
+    static getInstance: (el: HTMLElement) => any;
+    static createInstances: (selector: string) => void;
+    static createInsance: (selector: string, options?: ToggleOptions) => ToggleComponent | undefined;
+    static reinitialization: () => void;
+    static bootstrap: () => void;
+}
+export { ToggleComponent, defaultToggleOptions };

package/lib/_metronic/core/services/layout-init.service.d.ts

@@ -0,0 +1,18 @@
+import { ILayout } from '../../configs/default-layout.config';
+import { LayoutService } from './layout.service';
+import * as i0 from "@angular/core";
+export declare class LayoutInitService {
+    private layout;
+    constructor(layout: LayoutService);
+    init(): void;
+    update(fieldsToUpdate: Partial<ILayout>): void;
+    private initLayout;
+    private initHeader;
+    private initPageTitle;
+    private initToolbar;
+    private initContent;
+    private initAside;
+    private initFooter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutInitService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutInitService>;
+}

package/lib/_metronic/core/services/layout.service.d.ts

@@ -0,0 +1,38 @@
+import { BehaviorSubject } from 'rxjs';
+import { ILayout, ILayoutCSSVariables } from '../../configs/default-layout.config';
+import * as i0 from "@angular/core";
+export declare type LayoutType = ILayout | undefined;
+export declare const getEmptyCSSVariables: () => ILayoutCSSVariables;
+export declare function getEmptyHTMLAttributes(): {
+    [key: string]: {
+        [attrName: string]: string | boolean;
+    };
+};
+export declare function getEmptyCssClasses(): {
+    [key: string]: string[];
+};
+export declare class LayoutService {
+    layoutConfigSubject: BehaviorSubject<LayoutType>;
+    private classes;
+    private attrs;
+    private cssVariables;
+    constructor();
+    initConfig(): void;
+    private removeConfig;
+    refreshConfigToDefault(): void;
+    getConfig(): ILayout;
+    setConfig(config: LayoutType): void;
+    updateConfig(fieldsToUpdate: Partial<ILayout>): void;
+    setConfigWithoutLocalStorageChanges(config: LayoutType): void;
+    setConfigWithPageRefresh(config: LayoutType): void;
+    getProp(path: string): string | boolean | undefined | Object;
+    setCSSClass(path: string, classesInStr: string): void;
+    getCSSClasses(path: string): string[];
+    getStringCSSClasses(path: string): string;
+    getHTMLAttributes(path: string): {
+        [attrName: string]: string | boolean;
+    };
+    setHTMLAttribute(path: string, attrKey: string, attrValue: string | boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
+}

package/lib/_metronic/core/services/page-info.service.d.ts

@@ -0,0 +1,32 @@
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface PageLink {
+    title: string;
+    path: string;
+    isActive: boolean;
+    isSeparator?: boolean;
+}
+export declare class PageInfo {
+    breadcrumbs: Array<PageLink>;
+    title: string;
+}
+export declare class PageInfoService {
+    title: BehaviorSubject<string>;
+    description: BehaviorSubject<string>;
+    breadcrumbs: BehaviorSubject<Array<PageLink>>;
+    constructor();
+    setTitle(_title: string): void;
+    static PageTitle: string;
+    static PageBreadcrumbs: any[];
+    updateTitle(_title: string): void;
+    setDescription(_title: string): void;
+    updateDescription(_description: string): void;
+    setBreadcrumbs(_bs: Array<PageLink>): void;
+    updateBreadcrumbs(_bs: Array<PageLink>): void;
+    calculateTitle(): void;
+    calculateTitleInMenu(menuId: string): string | undefined;
+    calculateBreadcrumbs(): void;
+    calculateBreadcrumbsInMenu(menuId: string): Array<PageLink> | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageInfoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PageInfoService>;
+}

package/lib/masterlayout-routing.module.d.ts

@@ -0,0 +1,13 @@
+import { Injector } from '@angular/core';
+import { MasterlayoutComponent } from './masterlayout.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export declare let AppInjector: Injector;
+export declare class MasterlayoutRoutingModule {
+    private injector;
+    constructor(injector: Injector);
+    static components: (typeof MasterlayoutComponent)[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MasterlayoutRoutingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MasterlayoutRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MasterlayoutRoutingModule>;
+}