@sumaris-net/ngx-components 18.14.0 → 18.14.1

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

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

@@ -0,0 +1,51 @@
+import { AfterViewInit, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { MenuService } from '../menu.service';
+import { ActivatedRoute, Router } from '@angular/router';
+import { AlertController, NavController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { Subject } from 'rxjs';
+import { MatTabGroup } from '@angular/material/tabs';
+import { AppTabEditor } from '../../form/entity/tab-editor.class';
+import * as i0 from "@angular/core";
+export declare class MenuTestingPage extends AppTabEditor implements OnInit, OnDestroy, AfterViewInit {
+    protected menuService: MenuService;
+    protected logPrefix: string;
+    protected childPath: string;
+    protected thirdTabTitle: string;
+    protected parentPath: string;
+    protected path: string;
+    protected showOtherLinks: boolean;
+    protected showThirdTab: boolean;
+    protected $title: Subject<string>;
+    protected $secondTabTitle: Subject<string>;
+    protected _subSelectedTabIndex: number;
+    subTabCount: number;
+    set subSelectedTabIndex(value: number);
+    get subSelectedTabIndex(): number;
+    readonly subSelectedTabIndexChange: EventEmitter<number>;
+    subTabGroup: MatTabGroup;
+    protected set title(value: string);
+    protected set secondTabTitle(value: string);
+    constructor(route: ActivatedRoute, // Modal editor give 'null'
+    router: Router, navController: NavController, alertCtrl: AlertController, translate: TranslateService, menuService: MenuService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    load(id?: number, options?: any): Promise<void>;
+    get isNewData(): boolean;
+    reload(): Promise<void>;
+    save(event: Event | undefined, options: any): Promise<boolean>;
+    changeTitle(event?: UIEvent): void;
+    changeSecondTabTitle(event?: UIEvent): void;
+    addSubMenuItem(event?: UIEvent): void;
+    addOutsideRouteSubMenuItem(event?: UIEvent, pinned?: boolean): void;
+    protected enableMenu(value: boolean): void;
+    protected toggleSplitPaneWhen(): void;
+    protected initSubMenu(): Promise<void>;
+    protected getFirstInvalidTabIndex(): number;
+    protected getDefaultTitle(): string;
+    protected computeTitle(): Promise<string>;
+    setSubSelectedTabIndex(value: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuTestingPage, "app-testing-menu", never, { "subSelectedTabIndex": { "alias": "subSelectedTabIndex"; "required": false; }; }, { "subSelectedTabIndexChange": "subSelectedTabIndexChange"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./menu.testing";
+import * as i2 from "./menu-other.testing";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/router";
+import * as i5 from "../menu.module";
+import * as i6 from "../../../shared/shared.module";
+export declare class MenuTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MenuTestingModule, [typeof i1.MenuTestingPage, typeof i2.OtherMenuTestingPage], [typeof i3.CommonModule, typeof i4.RouterModule, typeof i5.AppMenuModule, typeof i6.SharedModule], [typeof i4.RouterModule, typeof i1.MenuTestingPage, typeof i2.OtherMenuTestingPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MenuTestingModule>;
+}

package/src/app/core/offline/update-offline-mode-card.component.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AppUpdateOfflineModeCard implements OnDestroy {
+    progressionMessage: string;
+    progressionValue: number;
+    onUpdateClick: EventEmitter<Event>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppUpdateOfflineModeCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppUpdateOfflineModeCard, "app-update-offline-mode-card", never, { "progressionMessage": { "alias": "progressionMessage"; "required": false; }; "progressionValue": { "alias": "progressionValue"; "required": false; }; }, { "onUpdateClick": "onUpdateClick"; }, never, never, false, never>;
+}

package/src/app/core/offline/update-offline-mode-card.module.d.ts

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

package/src/app/core/peer/select-peer.modal.d.ts

@@ -0,0 +1,101 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy } from '@angular/core';
+import { IonSearchbar, ModalController, PopoverController } from '@ionic/angular';
+import { Peer } from '../services/model/peer.model';
+import { HttpClient } from '@angular/common/http';
+import { Environment } from '../../../environments/environment.class';
+import { TextPopoverOptions } from '../form/text-popover/text-popover.component';
+import { TranslateService } from '@ngx-translate/core';
+import { ILoggingService } from '../../shared/logging/logger.model';
+import { RxState } from '@rx-angular/state';
+import { NodeFeature } from '../services/model/node-feature.model';
+import * as i0 from "@angular/core";
+export interface ISelectPeerModalOptions {
+    canCancel: boolean;
+    allowSelectDownPeer: boolean;
+    onRefresh: EventEmitter<Event>;
+    showSetManuallyButton: boolean;
+    selectedPeer?: string;
+    title?: string;
+    defaultPeers: Peer[];
+    showSearchBar?: boolean;
+}
+export interface ISelectPeerModalState {
+    defaultPeers: Peer[];
+    peers: Peer[];
+    filteredPeers: Peer[];
+    filteredPeersByFeatures: Peer[];
+    filteredPeerCount: number;
+    filteredFeaturesCount: number;
+    searchText: string;
+    selectedTabIndex: number;
+}
+export declare class SelectPeerModal extends RxState<ISelectPeerModalState> implements OnDestroy, ISelectPeerModalOptions {
+    private modalCtrl;
+    private popoverController;
+    private translate;
+    private http;
+    private cd;
+    protected environment: Environment;
+    protected loggingService?: ILoggingService;
+    private _subscription;
+    private readonly _logger;
+    protected defaultPeers$: import("rxjs").Observable<Peer[]>;
+    protected peers$: import("rxjs").Observable<Peer[]>;
+    protected filteredPeers$: import("rxjs").Observable<Peer[]>;
+    protected filteredPeersByFeatures$: import("rxjs").Observable<Peer[]>;
+    protected filteredPeerCount$: import("rxjs").Observable<number>;
+    protected filteredFeaturesCount$: import("rxjs").Observable<number>;
+    protected loading: boolean;
+    protected mobile: boolean;
+    protected peerMinVersion: string;
+    protected peerDefaultPrefix: string;
+    protected enableSelectPeerByFeature: boolean;
+    protected collapsedPeers: {
+        [key: string]: boolean;
+    };
+    set peers(value: Peer[]);
+    get peers(): Peer[];
+    set searchText(value: string);
+    get searchText(): string;
+    set filteredPeers(value: Peer[]);
+    get filteredPeers(): Peer[];
+    set selectedTabIndex(value: number);
+    get selectedTabIndex(): number;
+    selectedPeer: string;
+    title: string;
+    canCancel: boolean;
+    allowSelectDownPeer: boolean;
+    showSetManuallyButton: boolean;
+    showSearchBar: boolean;
+    tabGroupAnimationDuration: '200ms';
+    onRefresh: EventEmitter<Event>;
+    set defaultPeers(value: Peer[]);
+    searchbar: IonSearchbar;
+    constructor(modalCtrl: ModalController, popoverController: PopoverController, translate: TranslateService, http: HttpClient, cd: ChangeDetectorRef, environment: Environment, loggingService?: ILoggingService);
+    cancel(): void;
+    ngOnDestroy(): void;
+    selectPeer(peer: Peer): void;
+    toggleSearchBar(): Promise<void>;
+    togglePeerFeatures(peerUrl: string): void;
+    /**
+     *  Check the min pod version, defined by the app
+     *
+     * @param peer
+     */
+    isCompatible(peer: Peer): boolean;
+    refresh(event: Event): void;
+    clickSetManually(event?: Event): Promise<void>;
+    protected clearLogo(peer: Peer | NodeFeature): void;
+    refreshPeers(peers: Peer[]): Promise<void>;
+    protected refreshPeer(peer: Peer): Promise<Peer>;
+    protected openPeerUrlPopover(event: Event, opts?: Partial<TextPopoverOptions>): Promise<any>;
+    protected updateFilteredPeer(event: any): void;
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectPeerModal, [null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectPeerModal, "select-peer-modal", never, { "selectedTabIndex": { "alias": "selectedTabIndex"; "required": false; }; "selectedPeer": { "alias": "selectedPeer"; "required": false; }; "title": { "alias": "title"; "required": false; }; "canCancel": { "alias": "canCancel"; "required": false; }; "allowSelectDownPeer": { "alias": "allowSelectDownPeer"; "required": false; }; "showSetManuallyButton": { "alias": "showSetManuallyButton"; "required": false; }; "showSearchBar": { "alias": "showSearchBar"; "required": false; }; "tabGroupAnimationDuration": { "alias": "tabGroupAnimationDuration"; "required": false; }; "onRefresh": { "alias": "onRefresh"; "required": false; }; "defaultPeers": { "alias": "defaultPeers"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_selectedTabIndex: unknown;
+    static ngAcceptInputType_canCancel: unknown;
+    static ngAcceptInputType_allowSelectDownPeer: unknown;
+    static ngAcceptInputType_showSetManuallyButton: unknown;
+    static ngAcceptInputType_showSearchBar: unknown;
+}

package/src/app/core/peer/select-peer.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./select-peer.modal";
+import * as i2 from "../../shared/shared.module";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "../form/text-popover/text-popover.module";
+import * as i5 from "../services/pipes/pipes.module";
+import * as i6 from "@angular/forms";
+export declare class AppSelectPeerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppSelectPeerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppSelectPeerModule, [typeof i1.SelectPeerModal], [typeof i2.SharedModule, typeof i3.TranslateModule, typeof i4.AppTextPopoverModule, typeof i5.CorePipesModule, typeof i6.FormsModule], [typeof i3.TranslateModule, typeof i1.SelectPeerModal]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppSelectPeerModule>;
+}

package/src/app/core/register/register-confirm.page.d.ts

@@ -0,0 +1,24 @@
+import { OnDestroy } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { ActivatedRoute } from '@angular/router';
+import { AccountService } from '../services/account.service';
+import { ConfigService } from '../services/config.service';
+import { PlatformService } from '../services/platform.service';
+import * as i0 from "@angular/core";
+export declare class RegisterConfirmPage implements OnDestroy {
+    private platform;
+    private accountService;
+    private activatedRoute;
+    private configService;
+    subscriptions: Subscription[];
+    isLogin: boolean;
+    loading: boolean;
+    error: string;
+    email: string;
+    contentStyle: {};
+    constructor(platform: PlatformService, accountService: AccountService, activatedRoute: ActivatedRoute, configService: ConfigService);
+    ngOnDestroy(): void;
+    doConfirm(email: string, code: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterConfirmPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegisterConfirmPage, "app-register-confirm-page", never, {}, {}, never, never, false, never>;
+}

package/src/app/core/register/register.form.d.ts

@@ -0,0 +1,49 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { AsyncValidatorFn, UntypedFormBuilder, UntypedFormGroup, ValidatorFn } from '@angular/forms';
+import { AccountService, RegisterData } from '../services/account.service';
+import { referentialToString } from '../services/model/referential.model';
+import { Subscription } from 'rxjs';
+import { AccountValidatorService } from '../services/validator/account.validator';
+import { FormFieldDefinition } from '../../shared/form/field.model';
+import { LocalSettingsService } from '../services/local-settings.service';
+import { Environment } from '../../../environments/environment.class';
+import { MatAutocompleteConfigHolder } from '../../shared/material/autocomplete/material.autocomplete.config';
+import * as i0 from "@angular/core";
+export declare class RegisterForm implements OnInit {
+    private accountService;
+    private accountValidatorService;
+    formBuilder: UntypedFormBuilder;
+    protected environment: Environment;
+    protected settings?: LocalSettingsService;
+    protected debug: boolean;
+    autocompleteHelper: MatAutocompleteConfigHolder;
+    additionalFields: FormFieldDefinition[];
+    form: UntypedFormGroup;
+    forms: UntypedFormGroup[];
+    subscriptions: Subscription[];
+    error: string;
+    sending: boolean;
+    showPwd: boolean;
+    showConfirmPwd: boolean;
+    private stepper;
+    onCancel: EventEmitter<any>;
+    onSubmit: EventEmitter<RegisterData>;
+    constructor(accountService: AccountService, accountValidatorService: AccountValidatorService, formBuilder: UntypedFormBuilder, environment: Environment, settings?: LocalSettingsService);
+    ngOnInit(): void;
+    get value(): RegisterData;
+    get valid(): boolean;
+    isEnd(): boolean;
+    isBeginning(): boolean;
+    slidePrev(): void;
+    slideNext(event?: Event): void;
+    equalsValidator(otherControlName: string): ValidatorFn;
+    emailAvailability(accountService: AccountService): AsyncValidatorFn;
+    cancel(): void;
+    doSubmit(event?: any): void;
+    referentialToString: typeof referentialToString;
+    markAsTouched(): void;
+    disable(): void;
+    enable(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterForm, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegisterForm, "app-register-form", never, {}, { "onCancel": "onCancel"; "onSubmit": "onSubmit"; }, never, never, false, never>;
+}

package/src/app/core/register/register.modal.d.ts

@@ -0,0 +1,14 @@
+import { ModalController } from '@ionic/angular';
+import { AccountService } from '../services/account.service';
+import * as i0 from "@angular/core";
+export declare class RegisterModal {
+    private accountService;
+    viewCtrl: ModalController;
+    sending: boolean;
+    private form;
+    constructor(accountService: AccountService, viewCtrl: ModalController);
+    cancel(): void;
+    doSubmit(event?: any): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegisterModal, "app-register-modal", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./register.form";
+import * as i2 from "./register.modal";
+import * as i3 from "./register-confirm.page";
+import * as i4 from "../../shared/shared.module";
+import * as i5 from "@angular/router";
+import * as i6 from "@ngx-translate/core";
+export declare class AppRegisterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppRegisterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppRegisterModule, [typeof i1.RegisterForm, typeof i2.RegisterModal, typeof i3.RegisterConfirmPage], [typeof i4.SharedModule, typeof i5.RouterModule, typeof i6.TranslateModule], [typeof i6.TranslateModule, typeof i1.RegisterForm, typeof i2.RegisterModal, typeof i3.RegisterConfirmPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppRegisterModule>;
+}

package/src/app/core/services/account.service.d.ts

@@ -0,0 +1,207 @@
+import { InjectionToken } from '@angular/core';
+import { Keypair } from './crypto.service';
+import { Department } from './model/department.model';
+import { Account, UserSettings } from './model/account.model';
+import { Person, UserProfileLabel } from './model/person.model';
+import { LocalSettings, UsageMode } from './model/settings.model';
+import { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';
+import { FetchPolicy } from '@apollo/client/core';
+import { Storage } from '@ionic/storage-angular';
+import { BaseGraphqlService } from './base-graphql-service.class';
+import { GraphqlService } from '../graphql/graphql.service';
+import { LocalSettingsService } from './local-settings.service';
+import { FormFieldDefinition, FormFieldDefinitionMap } from '../../shared/form/field.model';
+import { NetworkService } from './network.service';
+import { AuthTokenType } from './network.types';
+import { FileService } from '../../shared/file/file.service';
+import { Referential } from './model/referential.model';
+import { Environment } from '../../../environments/environment.class';
+import { ShowToastOptions } from '../../shared/toast/toasts';
+import { OverlayEventDetail } from '@ionic/core';
+import { ToastController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { TokenScope, UserToken } from './model/token.model';
+import * as i0 from "@angular/core";
+export declare interface AccountDetails {
+    loaded: boolean;
+    keypair: Keypair;
+    authToken: string;
+    authBasic?: string;
+    pubkey: string;
+    person: Person;
+    department: Department;
+    mainProfile: string;
+}
+export interface AuthData {
+    username: string;
+    password: string;
+    offline?: boolean;
+}
+export interface RegisterData extends AuthData {
+    account: Account;
+}
+export interface ChangePasswordData {
+    password: string;
+    confirmPassword: string;
+    email: string;
+}
+export interface UserSettingsOptions {
+    options: FormFieldDefinitionMap;
+    remoteLocalSettingsKeys?: (keyof LocalSettings | string)[];
+}
+export declare const APP_USER_SETTINGS_OPTIONS: InjectionToken<UserSettingsOptions>;
+export declare const APP_USER_TOKEN_SCOPES: InjectionToken<TokenScope[]>;
+export declare interface IsEmailExistsVariables {
+    email: string;
+    hash: string;
+}
+interface IAuthChallenge {
+    pubkey: string;
+    challenge: string;
+    signature: string;
+}
+export interface AccountWatchOptions {
+    intervalInSeconds?: number;
+}
+export declare class AccountService extends BaseGraphqlService<Account, any, number, Account> {
+    protected network: NetworkService;
+    protected graphql: GraphqlService;
+    protected settings: LocalSettingsService;
+    protected storage: Storage;
+    protected file: FileService;
+    private translate;
+    private toastController;
+    protected environment: Environment;
+    onLogin: Subject<Account>;
+    onWillLogout: Subject<Account>;
+    onLogout: Subject<void>;
+    onChange: Subject<Account>;
+    onAuthTokenChange: BehaviorSubject<string>;
+    onAuthBasicChange: BehaviorSubject<string>;
+    private _listenChangesSubscription;
+    private readonly _enableListenChanges;
+    private readonly _listenIntervalInSeconds;
+    private _cache;
+    private readonly _optionDefs;
+    private readonly _remoteLocalSettingsKeys;
+    private _$additionalFields;
+    private _tokenType$;
+    private _apiTokenEnabled;
+    get account(): Account;
+    get person(): Person;
+    get department(): Department;
+    get tokenType(): AuthTokenType;
+    set tokenType(value: AuthTokenType);
+    get apiTokenEnabled(): boolean;
+    set apiTokenEnabled(value: boolean);
+    constructor(network: NetworkService, graphql: GraphqlService, settings: LocalSettingsService, storage: Storage, file: FileService, translate: TranslateService, toastController: ToastController, environment: Environment, options: UserSettingsOptions);
+    ngOnStart(): Promise<Account>;
+    protected ngOnStop(): Promise<void>;
+    isLogin(): boolean;
+    isAuth(): boolean;
+    hasMinProfile(userProfile: UserProfileLabel): boolean;
+    hasExactProfile(label: UserProfileLabel): boolean;
+    hasProfileAndIsEnable(userProfile: UserProfileLabel): boolean;
+    isAdmin(): boolean;
+    isSupervisor(): boolean;
+    isUser(): boolean;
+    /**
+     * @deprecated
+     * @param mode
+     */
+    isUsageMode(mode: UsageMode): boolean;
+    isOnlyGuest(): boolean;
+    /**
+     *
+     * @param recorderDepartment
+     * @deprecated use ProgramRefService.canUserWriteEntity() instead
+     */
+    canUserWriteDataForDepartment(recorderDepartment: Referential | any): boolean;
+    register(data: RegisterData): Promise<Account>;
+    authenticate(data?: AuthData): Promise<void>;
+    login(data: AuthData): Promise<Account>;
+    reload(opts?: {
+        showToast?: boolean;
+    }): Promise<Account>;
+    /**
+     * Create or update an user account, to the remote storage
+     *
+     * @param account
+     */
+    save(account: Account): Promise<Account>;
+    logout(): Promise<void>;
+    /**
+     * Load a account
+     *
+     * @param opts
+     */
+    load(opts?: {
+        offline?: boolean;
+        fetchPolicy?: FetchPolicy;
+        query?: any;
+    }): Promise<Account | undefined>;
+    generateToken(flags: number): Promise<string | undefined>;
+    /**
+     * Check if email is available for new account registration.
+     * Throw an error if not available
+     *
+     * @param email
+     */
+    checkEmailAvailable(email: string): Promise<void>;
+    /**
+     * Check if email is exists in server.
+     *
+     * @param email
+     */
+    isEmailExists(email: string): Promise<boolean>;
+    sendConfirmationEmail(email: string, locale?: string): Promise<boolean>;
+    confirmEmail(email: string, code: string): Promise<boolean>;
+    sendResetPasswordEmail(username: string, locale?: string): Promise<boolean>;
+    updatePubkey(data: AuthData): Promise<boolean>;
+    resetPubkey(data: AuthData, token: string): Promise<boolean>;
+    listenChanges(opts?: AccountWatchOptions): Subscription;
+    get additionalFields(): FormFieldDefinition[];
+    get $additionalFields(): Observable<FormFieldDefinition[]>;
+    getAdditionalField(key: string): FormFieldDefinition | undefined;
+    registerAdditionalField(field: FormFieldDefinition): void;
+    get optionDefs(): FormFieldDefinition[];
+    registerOption(def: FormFieldDefinition): void;
+    registerOptions(defs: FormFieldDefinition[]): void;
+    protected resetData(): void;
+    protected loadData(opts?: {
+        offline?: boolean;
+        fetchPolicy?: FetchPolicy;
+    }): Promise<Account>;
+    protected listenSettings(): Promise<void>;
+    protected restoreLocally(): Promise<Account | undefined>;
+    /**
+     * Save account into the local storage
+     */
+    protected saveLocally(): Promise<void>;
+    saveLocalSettingsRemotely(source: LocalSettings): Promise<void>;
+    /**
+     * Create or update an user account
+     *
+     * @param account
+     * @param keyPair
+     */
+    protected saveRemotely(account: Account, keyPair?: Keypair): Promise<Account>;
+    /**
+     * Create or update user settings
+     *
+     * @param settings
+     */
+    protected saveSettingsRemotely(settings: UserSettings): Promise<void>;
+    protected authenticateAndGetToken(token?: string, counter?: number): Promise<string>;
+    protected getAuthChallenge(): Promise<IAuthChallenge>;
+    protected startListenRemoteChanges(opts?: AccountWatchOptions): Subscription;
+    protected stopListenRemoteChanges(): void;
+    protected watchChanges(opts?: AccountWatchOptions): Observable<Account>;
+    protected copyIdAndUpdateDate(source: Account | undefined, target: Account): void;
+    protected copyIdAndUpdateDateSettings(source: UserSettings | undefined, target: UserSettings): void;
+    protected copyIdAndUpdateDateToken(sources: UserToken[] | undefined, targets: UserToken[]): void;
+    protected showToast<T = any>(opts: ShowToastOptions): Promise<OverlayEventDetail<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountService, [null, null, null, null, null, { optional: true; }, { optional: true; }, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccountService>;
+}
+export {};