@sumaris-net/ngx-components 18.12.0 → 18.12.2

package/src/app/core/graphql/graphql.utils.d.ts

@@ -0,0 +1,47 @@
+import { ApolloClient, ApolloLink, Operation } from '@apollo/client/core';
+import { Observable } from 'rxjs';
+import { PersistentStorage } from 'apollo3-cache-persist';
+import { ConnectionType } from '../services/network.types';
+import { StorageService } from '../../shared/storage/storage.service';
+export declare const NativeWebSocket: any;
+export interface EmptyObject {
+    [key: string]: any;
+}
+/**
+ * AppWebSocket class.
+ * With a hack on default Websocket, to avoid the use of protocol
+ */
+export declare const AppWebSocket: any;
+export declare function isMutationOperation(operation: Operation): boolean;
+export declare function isSubscriptionOperation(operation: Operation): boolean;
+export interface TrackedQuery {
+    id: string;
+    name: string;
+    queryJSON: string;
+    variablesJSON: string;
+    contextJSON: string;
+}
+export interface TrackableMutationContext extends Record<string, any> {
+    serializationKey?: string;
+    tracked?: boolean;
+    timeout?: number;
+}
+export declare const TRACKED_QUERIES_STORAGE_KEY = "apollo-tracker-persist";
+export declare function createTrackerLink(opts: {
+    storage?: PersistentStorage<string>;
+    onNetworkStatusChange: Observable<ConnectionType>;
+    debounce?: number;
+    debug?: boolean;
+}): ApolloLink;
+export declare function restoreTrackedQueries(opts: {
+    apolloClient: ApolloClient<any>;
+    storage: PersistentStorage<any>;
+    debug?: boolean;
+}): Promise<import("@apollo/client/core").FetchResult<any>[]>;
+export declare class StorageServiceWrapper implements PersistentStorage<string> {
+    private storage;
+    constructor(storage: StorageService);
+    getItem(key: any): Promise<any>;
+    removeItem(key: any): Promise<any>;
+    setItem(key: any, value: any): Promise<any>;
+}

package/src/app/core/home/home.d.ts

@@ -0,0 +1,109 @@
+import { ChangeDetectorRef, InjectionToken, OnDestroy } from '@angular/core';
+import { ModalController, ToastController } from '@ionic/angular';
+import { BehaviorSubject } from 'rxjs';
+import { AccountService } from '../services/account.service';
+import { Account } from '../services/model/account.model';
+import { Configuration } from '../services/model/config.model';
+import { Department } from '../services/model/department.model';
+import { LocaleConfig, LocalSettings } from '../services/model/settings.model';
+import { TranslateService } from '@ngx-translate/core';
+import { ConfigService } from '../services/config.service';
+import { PlatformService } from '../services/platform.service';
+import { LocalSettingsService } from '../services/local-settings.service';
+import { NetworkService } from '../services/network.service';
+import { IMenuItem } from '../menu/menu.model';
+import { ShowToastOptions } from '../../shared/toast/toasts';
+import { Environment } from '../../../environments/environment.class';
+import { HistoryPageReference } from '../services/model/history.model';
+import { RxState } from '@rx-angular/state';
+import { ImagesUtils } from '../../shared/file/images.utils';
+import * as i0 from "@angular/core";
+/**
+ * @param files
+ * @deprecated use `getRandomImageWithCredit()` instead
+ **/
+export declare const getRandomImage: typeof ImagesUtils.getRandomImage;
+export declare const getRandomImageWithCredit: typeof ImagesUtils.getRandomImageWithCredit;
+export declare const APP_HOME_BUTTONS: InjectionToken<IMenuItem[]>;
+export interface HomePageState {
+    loading: boolean;
+    showSpinner: boolean;
+    showPartnerBanner: boolean;
+    showLegalInformation: boolean;
+    showInstallLinks: boolean;
+    pageHistory: HistoryPageReference[];
+    darkMode: boolean;
+}
+export declare class HomePage extends RxState<HomePageState> implements OnDestroy {
+    private accountService;
+    private modalCtrl;
+    private translate;
+    private toastController;
+    private configService;
+    private platform;
+    private cd;
+    network: NetworkService;
+    settings: LocalSettingsService;
+    protected environment: Environment;
+    locales: LocaleConfig[];
+    buttons: IMenuItem[];
+    private readonly _debug;
+    private _subscription;
+    private _config;
+    protected darkMode$: import("rxjs").Observable<boolean>;
+    protected pageHistory$: import("rxjs").Observable<HistoryPageReference[]>;
+    protected loading$: import("rxjs").Observable<boolean>;
+    protected readonly mobile: boolean;
+    waitingNetwork: boolean;
+    accountName: string;
+    isLogin: boolean;
+    $partners: BehaviorSubject<Department[]>;
+    logo: string;
+    description: string;
+    appName: string;
+    isWeb: boolean;
+    canRegister: boolean;
+    contentStyle: any;
+    contentCredits: string;
+    legalInformation: IMenuItem[];
+    offline: boolean;
+    $filteredButtons: BehaviorSubject<IMenuItem[]>;
+    readonly showAccountButton: boolean;
+    set pageHistory(value: HistoryPageReference[]);
+    get pageHistory(): HistoryPageReference[];
+    set loading(value: boolean);
+    get loading(): boolean;
+    set showSpinner(value: boolean);
+    get showSpinner(): boolean;
+    set showPartnerBanner(value: boolean);
+    get showPartnerBanner(): boolean;
+    set showLegalInformation(value: boolean);
+    get showLegalInformation(): boolean;
+    set showInstallLinks(value: boolean);
+    get showInstallLinks(): boolean;
+    set darkMode(value: boolean);
+    get darkMode(): boolean;
+    get currentLocaleCode(): string;
+    get partnerBannerSize(): number;
+    constructor(accountService: AccountService, modalCtrl: ModalController, translate: TranslateService, toastController: ToastController, configService: ConfigService, platform: PlatformService, cd: ChangeDetectorRef, network: NetworkService, settings: LocalSettingsService, environment: Environment, locales: LocaleConfig[], buttons: IMenuItem[]);
+    ngOnDestroy(): void;
+    login(): Promise<void>;
+    register(): Promise<void>;
+    logout(event: any): Promise<void>;
+    changeLanguage(locale: string): void;
+    getPagePath(index: number, page: HistoryPageReference): string;
+    tryOnline(): void;
+    protected start(): Promise<void>;
+    protected showToast(opts: ShowToastOptions): Promise<void>;
+    protected onConfigLoaded(config: Configuration): void;
+    protected onSettingsChanged(settings: LocalSettings): void;
+    protected onLogin(account: Account): void;
+    protected onLogout(): void;
+    protected refreshButtons(account?: Account): void;
+    openMarkdownModal(event?: Event, item?: IMenuItem): Promise<void>;
+    protected toggleDarkMode(): Promise<void>;
+    protected removePageHistory(path: string): Promise<void>;
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HomePage, [null, null, null, null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HomePage, "app-page-home", never, {}, {}, never, never, false, never>;
+}

package/src/app/core/home/home.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./home";
+import * as i2 from "../../shared/shared.module";
+import * as i3 from "@angular/router";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "../../shared/rx-state/rx-state.module";
+import * as i6 from "../auth/auth.module";
+import * as i7 from "../install/install-upgrade-card.module";
+import * as i8 from "../../shared/markdown/markdown.module";
+export declare class AppHomePageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppHomePageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppHomePageModule, [typeof i1.HomePage], [typeof i2.SharedModule, typeof i3.RouterModule, typeof i4.TranslateModule, typeof i5.RxStateModule, typeof i6.AppAuthModule, typeof i7.AppInstallUpgradeCardModule, typeof i8.SharedMarkdownModule], [typeof i3.RouterModule, typeof i4.TranslateModule, typeof i1.HomePage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppHomePageModule>;
+}

package/src/app/core/icon/icon.component.d.ts

@@ -0,0 +1,13 @@
+import { AppColors, IconRef } from '../../shared/types';
+import * as i0 from "@angular/core";
+export declare class AppIconComponent {
+    icon: string;
+    matIcon: string;
+    matSvgIcon: string;
+    color: AppColors;
+    height: number | string;
+    width: number | string;
+    set ref(value: IconRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppIconComponent, "app-icon", never, { "icon": { "alias": "icon"; "required": false; }; "matIcon": { "alias": "matIcon"; "required": false; }; "matSvgIcon": { "alias": "matSvgIcon"; "required": false; }; "color": { "alias": "color"; "required": false; }; "height": { "alias": "height"; "required": false; }; "width": { "alias": "width"; "required": false; }; "ref": { "alias": "ref"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/core/icon/icon.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./icon.component";
+import * as i2 from "../../shared/shared.module";
+import * as i3 from "@ngx-translate/core";
+export declare class AppIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppIconModule, [typeof i1.AppIconComponent], [typeof i2.SharedModule, typeof i3.TranslateModule], [typeof i1.AppIconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppIconModule>;
+}

package/src/app/core/install/install-upgrade-card.component.d.ts

@@ -0,0 +1,63 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { AlertController, ToastController } from '@ionic/angular';
+import { ConfigService } from '../services/config.service';
+import { PlatformService } from '../services/platform.service';
+import { NetworkService } from '../services/network.service';
+import { Environment } from '../../../environments/environment.class';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+export declare interface InstallAppLink {
+    name: string;
+    url: string;
+    platform?: 'android' | 'ios' | 'electron';
+    version?: string;
+    filename?: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    downloading?: boolean;
+    location?: string;
+}
+export declare class AppInstallUpgradeCard implements OnInit, OnDestroy {
+    private configService;
+    private toastController;
+    private alertController;
+    private translate;
+    private cd;
+    platform: PlatformService;
+    network: NetworkService;
+    protected environment: Environment;
+    private _subscription;
+    loading: boolean;
+    hasDownloader: boolean;
+    downloading: boolean;
+    waitingNetwork: boolean;
+    installLinks: InstallAppLink[];
+    upgradeLinks: InstallAppLink[];
+    offline: boolean;
+    isLogin: boolean;
+    showUpgradeWarning: boolean;
+    showOfflineWarning: boolean;
+    showInstallButton: boolean;
+    debug: boolean;
+    constructor(configService: ConfigService, toastController: ToastController, alertController: AlertController, translate: TranslateService, cd: ChangeDetectorRef, platform: PlatformService, network: NetworkService, environment: Environment);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    download(event: Event, link: InstallAppLink): Promise<void>;
+    openFile(event: Event, link: InstallAppLink): Promise<void>;
+    tryOnline(): Promise<void>;
+    getPlatformName(platform: 'android' | 'ios' | 'electron'): "" | "desktop" | "Android" | "iOS";
+    asLink(value: any): InstallAppLink;
+    private checkNeedInstallOrUpdate;
+    private getCompatibleInstallLinks;
+    private getCompatibleUpgradeLinks;
+    private getLinks;
+    private listenDownloadJobs;
+    private listenDownloadJob;
+    private showDownloadFailedToast;
+    private showDownloadCompleteDialog;
+    private markForCheck;
+    private showToast;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppInstallUpgradeCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppInstallUpgradeCard, "app-install-upgrade-card", never, { "isLogin": { "alias": "isLogin"; "required": false; }; "showUpgradeWarning": { "alias": "showUpgradeWarning"; "required": false; }; "showOfflineWarning": { "alias": "showOfflineWarning"; "required": false; }; "showInstallButton": { "alias": "showInstallButton"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/core/install/install-upgrade-card.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./install-upgrade-card.component";
+import * as i2 from "../../shared/shared.module";
+import * as i3 from "@ngx-translate/core";
+export declare class AppInstallUpgradeCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppInstallUpgradeCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppInstallUpgradeCardModule, [typeof i1.AppInstallUpgradeCard], [typeof i2.SharedModule, typeof i3.TranslateModule], [typeof i3.TranslateModule, typeof i1.AppInstallUpgradeCard]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppInstallUpgradeCardModule>;
+}

package/src/app/core/menu/menu.component.d.ts

@@ -0,0 +1,66 @@
+import { ChangeDetectorRef, OnInit } from '@angular/core';
+import { IonSplitPane, MenuController, ModalController, NavController } from '@ionic/angular';
+import { Account } from '../services/model/account.model';
+import { AccountService } from '../services/account.service';
+import { TranslateService } from '@ngx-translate/core';
+import { Environment } from '../../../environments/environment.class';
+import { MenuService, SplitPaneShowWhen } from './menu.service';
+import { IMenuItem, MenuItem } from './menu.model';
+import { ActivatedRoute, Router } from '@angular/router';
+import { RxStrategyNames } from '@rx-angular/cdk/render-strategies';
+import * as i0 from "@angular/core";
+export declare class MenuComponent implements OnInit {
+    protected accountService: AccountService;
+    protected navController: NavController;
+    protected menu: MenuController;
+    protected modalCtrl: ModalController;
+    protected translate: TranslateService;
+    protected cd: ChangeDetectorRef;
+    protected menuService: MenuService;
+    protected router: Router;
+    protected environment: Environment;
+    protected route: ActivatedRoute;
+    id: string;
+    menuId: string;
+    side: string;
+    contentId: string;
+    logo: string;
+    appName: string;
+    rxStrategy: RxStrategyNames;
+    appVersion: string;
+    splitPane: IonSplitPane;
+    loading: boolean;
+    isLogin: boolean;
+    accountName: string;
+    accountAvatar: string;
+    accountEmail: string;
+    private readonly _debug;
+    private _subscription;
+    constructor(accountService: AccountService, navController: NavController, menu: MenuController, modalCtrl: ModalController, translate: TranslateService, cd: ChangeDetectorRef, menuService: MenuService, router: Router, environment: Environment, route: ActivatedRoute);
+    ngOnInit(): Promise<void>;
+    onLogin(account: Account): Promise<void>;
+    onLogout(skipRedirect?: boolean): Promise<void>;
+    trackByFn(index: number, item: IMenuItem): string;
+    enable(value: boolean): Promise<void>;
+    open(opts?: {
+        emitEvent?: boolean;
+    }): Promise<boolean>;
+    close(opts?: {
+        emitEvent?: boolean;
+    }): Promise<boolean>;
+    setSplitPaneWhen(value: SplitPaneShowWhen): Promise<void>;
+    toggleSplitPaneShow(event?: Event): Promise<void>;
+    executeAction(event: Event, item: MenuItem): Promise<void>;
+    onSwipeRight(event: any): boolean;
+    protected markAsLoaded(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected markAsLoading(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected detectChanges(): void;
+    protected markForCheck(): void;
+    protected togglePinned(event: Event, item: IMenuItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, [null, null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "app-menu", never, { "id": { "alias": "id"; "required": false; }; "menuId": { "alias": "menuId"; "required": false; }; "side": { "alias": "side"; "required": false; }; "contentId": { "alias": "contentId"; "required": false; }; "logo": { "alias": "logo"; "required": false; }; "appName": { "alias": "appName"; "required": false; }; "rxStrategy": { "alias": "rxStrategy"; "required": false; }; "appVersion": { "alias": "appVersion"; "required": false; }; }, {}, never, ["*", "[headerBottomRight]"], false, never>;
+}

package/src/app/core/menu/menu.model.d.ts

@@ -0,0 +1,144 @@
+import { UserProfileLabel } from '../services/model/person.model';
+import { Configuration } from '../services/model/config.model';
+import { AppColors, IconRef } from '../../shared/types';
+import { BehaviorSubject } from 'rxjs';
+import { MenuPathParam } from './menu.service';
+import { Account } from '../services/model/account.model';
+import { Entity, EntityAsObjectOptions } from '../services/model/entity.model';
+import { ITreeItemEntity } from '../services/model/tree-item-entity.model';
+export interface IMenuItem extends IconRef {
+    id?: number;
+    parent?: IMenuItem;
+    children?: IMenuItem[];
+    title: string;
+    path?: string;
+    after?: string;
+    before?: string;
+    static?: boolean;
+    action?: string | any;
+    profile?: UserProfileLabel;
+    exactProfile?: UserProfileLabel;
+    color?: string | AppColors;
+    cssClass?: string;
+    ifProperty?: string;
+    titleProperty?: string;
+    titleArgs?: {
+        [key: string]: string;
+    };
+    pathParams?: {
+        [key: string]: string;
+    };
+    parentPath?: string;
+    parentPathParams?: {
+        [key: string]: string;
+    };
+    pinned?: boolean;
+}
+export declare class MenuItem extends Entity<MenuItem> implements IMenuItem, ITreeItemEntity<MenuItem> {
+    static fromObject: (source: any, opts?: {
+        withChildren?: boolean;
+    }) => MenuItem;
+    parent: MenuItem;
+    parentId: number;
+    $children: BehaviorSubject<MenuItem[]>;
+    static: boolean;
+    $title: BehaviorSubject<string>;
+    titleProperty?: string;
+    titleArgs?: {
+        [key: string]: string;
+    };
+    path?: string;
+    pathParams?: {
+        [key: string]: string;
+    };
+    parentPath?: string;
+    parentPathParams?: {
+        [key: string]: string;
+    };
+    after?: string;
+    before?: string;
+    action?: string | any;
+    profile?: UserProfileLabel;
+    exactProfile?: UserProfileLabel;
+    color?: string | AppColors;
+    cssClass?: string;
+    ifProperty?: string;
+    pinned?: boolean;
+    icon?: string;
+    matIcon?: string;
+    matSvgIcon?: string;
+    fromObject(source: any, opts?: {
+        withChildren?: boolean;
+    }): void;
+    asObject(opts?: {
+        withChildren?: boolean;
+    } & EntityAsObjectOptions): any;
+    get children(): MenuItem[];
+    set children(value: MenuItem[]);
+    get title(): string;
+    set title(value: string);
+    get detached(): boolean;
+    get visible(): boolean;
+    get expanded(): boolean;
+    get ancestor(): MenuItem;
+    get divider(): boolean;
+    get pinnable(): boolean;
+    isPinned(): any;
+}
+export declare class MenuItems {
+    /**
+     * Compare, without checking the children
+     *
+     * @param mainItem
+     * @param otherItem
+     */
+    static isSame(mainItem: IMenuItem, otherItem: IMenuItem): boolean;
+    /**
+     * Compare, without checking the children and the title
+     *
+     * @param mainItem
+     * @param otherItem
+     */
+    static isSameIdOrPathAndParams(mainItem: IMenuItem, otherItem: IMenuItem): boolean;
+    /**
+     * Compare, without checking the children
+     *
+     * @param mainItem
+     * @param otherItem
+     */
+    static isSamePathAndParams(mainItem: IMenuItem, otherItem: IMenuItem): boolean;
+    /**
+     * All key/value of the mainParams should exist (and be equals) in the other params
+     *
+     * @param mainParams
+     * @param otherParams
+     */
+    static isSameParams(mainParams: {
+        [key: string]: string;
+    }, otherParams: {
+        [key: string]: string;
+    }): boolean;
+    static isParent(child: IMenuItem, parent: IMenuItem | MenuPathParam): boolean;
+    static checkIfVisible(item: IMenuItem, account: Account, config: Configuration, opts?: {
+        isLogin?: boolean;
+        debug?: boolean;
+        logPrefix?: string;
+    }): boolean;
+    static checkIfSubMenuVisible(item: MenuItem, currentPathParam: MenuPathParam): boolean;
+    static parsePathWithQuery(pathWithQuery: string): MenuPathParam;
+    static getUrl(item: IMenuItem): string;
+    static getUrlFromPathAndParams(path: string, params?: any): string;
+    static sortByParamOrIdComparator(paramName?: string): (n1: IMenuItem, n2: IMenuItem) => number;
+    static sortByTabOrId: (n1: IMenuItem, n2: IMenuItem) => number;
+}
+/**
+ * Options to configure specific behavior on projects
+ */
+export declare class MenuOptions {
+    subMenu?: {
+        enable?: boolean;
+        showPinButton?: boolean;
+        disableIcon?: boolean;
+        savePinned?: boolean;
+    };
+}

package/src/app/core/menu/menu.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./menu.component";
+import * as i2 from "./sub-menu-tab.directive";
+import * as i3 from "../../shared/shared.module";
+import * as i4 from "@angular/router";
+import * as i5 from "../../shared/rx-state/rx-state.module";
+import * as i6 from "@ngx-translate/core";
+export declare class AppMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppMenuModule, [typeof i1.MenuComponent, typeof i2.SubMenuTabDirective], [typeof i3.SharedModule, typeof i4.RouterModule, typeof i5.RxStateModule, typeof i6.TranslateModule], [typeof i6.TranslateModule, typeof i1.MenuComponent, typeof i2.SubMenuTabDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppMenuModule>;
+}

package/src/app/core/menu/menu.service.d.ts

@@ -0,0 +1,93 @@
+import { EventEmitter, InjectionToken } from '@angular/core';
+import { Router } from '@angular/router';
+import { AlertController, ModalController, NavController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Environment } from '../../../environments/environment.class';
+import { StartableObservableService } from '../../shared/services/startable-observable-service.class';
+import { AccountService } from '../services/account.service';
+import { ConfigService } from '../services/config.service';
+import { LocalSettingsService } from '../services/local-settings.service';
+import { Account } from '../services/model/account.model';
+import { IMenuItem, MenuItem, MenuOptions } from './menu.model';
+import * as i0 from "@angular/core";
+export type SplitPaneShowWhen = boolean | 'lg';
+export declare const DEFAULT_MENU_SHOW_WHEN: SplitPaneShowWhen;
+export declare const APP_MENU_ITEMS: InjectionToken<IMenuItem[]>;
+export declare const APP_MENU_OPTIONS: InjectionToken<MenuOptions>;
+export interface MenuPathParam {
+    path: string;
+    params: {
+        [key: string]: string;
+    };
+}
+export declare class MenuService extends StartableObservableService<MenuItem[]> {
+    protected settings: LocalSettingsService;
+    protected configService: ConfigService;
+    protected accountService: AccountService;
+    protected router: Router;
+    protected modalCtrl: ModalController;
+    protected alertController: AlertController;
+    protected navController: NavController;
+    protected translate: TranslateService;
+    protected environment: Environment;
+    readonly accountChanges: BehaviorSubject<Account>;
+    readonly onPinned: EventEmitter<MenuItem>;
+    private _staticItems;
+    private _detachedSubItems;
+    private _itemCounter;
+    private readonly _options;
+    private readonly _logPrefix;
+    private readonly _$opened;
+    private readonly _$splitPaneWhen;
+    private readonly _$enabled;
+    private readonly _$enableSubMenu;
+    constructor(settings: LocalSettingsService, configService: ConfigService, accountService: AccountService, router: Router, modalCtrl: ModalController, alertController: AlertController, navController: NavController, translate: TranslateService, environment: Environment, options?: MenuOptions, staticItems?: IMenuItem[]);
+    get opened(): Observable<boolean>;
+    get splitPaneWhen(): Observable<SplitPaneShowWhen>;
+    get enabled(): Observable<boolean>;
+    get subMenuEnabled(): boolean;
+    get subItems(): MenuItem[];
+    private get _staticSubItems();
+    enable(value: boolean): void;
+    enableSubMenu(value: boolean): void;
+    setSplitPaneShowWhen(value: SplitPaneShowWhen): void;
+    toggleSplitPaneWhen(): void;
+    fromObject(source: any, opts?: {
+        withChildren?: boolean;
+        computeId?: boolean;
+        fillParent?: boolean;
+        fillDefaultFromParent?: boolean;
+    }): MenuItem;
+    createSubMenu(source: Partial<IMenuItem>): MenuItem;
+    addSubMenuItems(sources: IMenuItem[], opts?: {
+        skipIfExists?: boolean;
+    }): Promise<MenuItem[]>;
+    addSubMenuItem(item: IMenuItem, opts?: {
+        skipIfExists?: boolean;
+    }): Promise<MenuItem>;
+    removeSubMenuItems(items: IMenuItem[]): Promise<MenuItem[]>;
+    removeSubMenuItem(item: IMenuItem): Promise<MenuItem>;
+    togglePinned(source: IMenuItem): void;
+    executeAction(event: Event, item: MenuItem): Promise<void>;
+    logout(): Promise<void>;
+    openAboutModal(): Promise<void>;
+    toggleExpandableItem(item: MenuItem): Promise<void>;
+    _markAsOpened(): void;
+    _markAsClosed(): void;
+    close(): Promise<void>;
+    open(): Promise<void>;
+    protected ngOnStart(): Promise<MenuItem[]>;
+    private _loadMenuItems;
+    private _addSubMenuItems;
+    private _addSubMenuItem;
+    private _computeNewId;
+    private _removeSubMenuItem;
+    private _detachSubMenuItems;
+    private _detachToParent;
+    private _findExistingItem;
+    private _findParent;
+    private _attachMenuToParent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuService, [null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MenuService>;
+}

package/src/app/core/menu/sub-menu-tab.directive.d.ts

@@ -0,0 +1,29 @@
+import { AfterViewInit, OnChanges, SimpleChanges } from '@angular/core';
+import { MatTab, MatTabGroup } from '@angular/material/tabs';
+import { Router } from '@angular/router';
+import { MenuService } from './menu.service';
+import { IconRef } from '../../shared/types';
+import * as i0 from "@angular/core";
+export declare class SubMenuTabDirective implements OnChanges, AfterViewInit {
+    private menuService;
+    private tabGroup;
+    private tab;
+    private router;
+    label: string;
+    disabled: boolean;
+    parentPath: string;
+    path: string;
+    subMenuTitle: string;
+    subMenuIcon: IconRef;
+    private _menuItem;
+    private readonly _enable;
+    constructor(menuService: MenuService, tabGroup: MatTabGroup, tab: MatTab, router: Router);
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _removeToMenu;
+    private _addToMenu;
+    private get menuItem();
+    private get title();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubMenuTabDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SubMenuTabDirective, "[appSubMenuTab]", never, { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "parentPath": { "alias": "parentPath"; "required": false; }; "path": { "alias": "path"; "required": false; }; "subMenuTitle": { "alias": "subMenuTitle"; "required": false; }; "subMenuIcon": { "alias": "subMenuIcon"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/core/menu/testing/menu-other.testing.d.ts

@@ -0,0 +1,15 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import { AlertController, NavController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { MenuService } from '../menu.service';
+import { MenuTestingPage } from './menu.testing';
+import * as i0 from "@angular/core";
+export declare class OtherMenuTestingPage extends MenuTestingPage {
+    constructor(route: ActivatedRoute, // Modal editor give 'null'
+    router: Router, navController: NavController, alertCtrl: AlertController, translate: TranslateService, menuService: MenuService);
+    initSubMenu(): Promise<void>;
+    protected getDefaultTitle(): string;
+    protected computeTitle(): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OtherMenuTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OtherMenuTestingPage, "app-testing-menu-other", never, {}, {}, never, never, false, never>;
+}