@sumaris-net/ngx-components 18.12.0 → 18.12.2

package/src/app/core/services/model/entity.decorators.d.ts

@@ -0,0 +1,17 @@
+import { Entity } from './entity.model';
+declare type Constructor<T = any> = new (...args: any[]) => T;
+export declare class EntityClasses {
+    static CLASSES_BY_NAME: Map<string, Constructor<any>>;
+    static register(typename: string, entityClass: Constructor): void;
+    static get<T extends Entity<T>>(entityName: string): Constructor;
+    static fromObject<T extends Entity<T>>(value: any, opts?: {
+        [key: string]: any;
+        typename?: string;
+        entityName?: string;
+    }): T;
+}
+export declare function EntityClass(opts: {
+    typename: string;
+    fromObjectReuseStrategy?: 'default' | 'clone';
+}): <T extends Constructor<any>>(constructor: T) => T;
+export {};

package/src/app/core/services/model/entity.model.d.ts

@@ -0,0 +1,133 @@
+import { Moment } from 'moment';
+import { getPropertyByPath } from '../../../shared/functions';
+import { FilterFn, KeyValueType, ObjectMap, ObjectMapEntry } from '../../../shared/types';
+import { StoreObject } from '@apollo/client/core';
+import { TreeItemEntityUtils } from './tree-item-entity.model';
+import { SortDirection } from '@angular/material/sort';
+import { AppPropertiesUtils } from '../../form/properties/properties.utils';
+export declare interface Cloneable<T> {
+    clone(): T;
+}
+export declare function entityToString(obj: Entity<any> | any, properties?: string[]): string | undefined;
+export interface EntityAsObjectOptions {
+    minify?: boolean;
+    keepTypename?: boolean;
+    keepLocalId?: boolean;
+}
+export interface IEntity<T, ID = number, AO extends EntityAsObjectOptions = EntityAsObjectOptions, FO = any> extends Cloneable<T> {
+    id: ID;
+    updateDate: Moment;
+    __typename: string;
+    equals(other: T): boolean;
+    clone(opts?: AO & FO): T;
+    copy(target: T, opts?: AO & FO): void;
+    asObject(opts?: AO): any;
+    fromObject(source: any, opts?: FO): void;
+}
+export declare type OmitFunctions<T extends IEntity<T, any>> = {
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+};
+export declare abstract class Entity<T extends Entity<T, ID, AO, FO>, ID = number, AO extends EntityAsObjectOptions = EntityAsObjectOptions, FO = any> implements IEntity<T, ID, AO, FO> {
+    static TYPENAME: string;
+    id: ID;
+    updateDate: Moment;
+    __typename: string;
+    constructor(__typename?: string);
+    clone(opts?: AO & FO): T;
+    copy(target: T, opts?: AO & FO): void;
+    asObject(opts?: AO): StoreObject;
+    fromObject(source: any, opts?: FO): void;
+    equals(other: T): boolean;
+}
+/**
+ * @deprecated use standard instanceof instead
+ * @param obj
+ * @param constructor
+ */
+export declare function isInstanceOf<T>(obj: any, constructor: new (...args: any[]) => T): obj is T;
+export declare abstract class EntityUtils {
+    static isEntity<T extends IEntity<any>>(obj: T | any): obj is T;
+    static isNotEmpty<T extends IEntity<any> | any>(obj: T, checkedAttribute?: keyof T): boolean;
+    static isEmpty<T extends IEntity<any> | any>(obj: T, checkedAttribute?: keyof T): boolean;
+    static equals<T extends IEntity<any> | any>(o1: T, o2: T, checkAttribute?: keyof T): boolean;
+    static getPropertyByPath: typeof getPropertyByPath;
+    static getArrayAsMap<T = any>(source?: ObjectMapEntry<T>[]): ObjectMap<T>;
+    static getMapAsArray<T = any>(source?: ObjectMap<T>): ObjectMapEntry<T>[];
+    static getPropertyArrayAsObject: typeof AppPropertiesUtils.arrayAsObject;
+    static copyIdAndUpdateDate<T extends Entity<any, any, any>>(source: T, target: T): void;
+    static fillLocalIds<T extends IEntity<T, any>>(items: T[], sequenceFactory: (firstEntity: T, incrementSize: number) => Promise<number>): Promise<void>;
+    static cleanIdAndUpdateDate<T extends IEntity<T, any>>(source: T, defaultValue?: any): void;
+    static cleanIdsAndUpdateDates<T extends IEntity<T, any>>(items: T[], defaultValue?: any): void;
+    static sort<T extends IEntity<T, any> | any>(data: T[], sortBy?: keyof T | string, sortDirection?: SortDirection): T[];
+    static sortComparator<T extends IEntity<T, any> | any>(sortBy?: keyof T | string, sortDirection?: SortDirection): (a: T, b: T) => number;
+    static compare<T extends IEntity<T, any>>(value1: T, value2: T, direction: 1 | -1, checkAttribute?: keyof T): number;
+    static compareValue<T>(value1: T, value2: T, direction: 1 | -1): number;
+    static filter<T extends IEntity<T, any> | any>(data: T[], searchAttribute: string, searchText: string): T[];
+    static searchTextFilter<T extends IEntity<T, any> | any>(searchAttribute: string | string[], searchText: string): FilterFn<T>;
+    /**
+     * Transform a batch entity tree into a array list. This method keep links parent/children.
+     *
+     * Method used to find batch without id (e.g. before local storage)
+     *
+     * @param source
+     */
+    static treeToArray: typeof TreeItemEntityUtils.treeToArray;
+    static listOfTreeToArray: typeof TreeItemEntityUtils.listOfTreeToArray;
+    /**
+     * Fill parent attribute, of all children found in the tree
+     *
+     * @param source
+     */
+    static treeFillParent: typeof TreeItemEntityUtils.treeFillParent;
+    static isLocal(entity: IEntity<any, any> | Entity<any, any>): boolean;
+    static isRemote(entity: IEntity<any, any> | Entity<any, any>): boolean;
+    static isLocalId(id: number): boolean;
+    static isRemoteId(id: number): boolean;
+    static getId<T extends IEntity<T, ID> = IEntity<any, any>, ID = any>(entity: T): ID;
+    static hasId<T extends IEntity<any, any> = IEntity<any, any>>(entity: T): boolean;
+    static hasNilId<T extends IEntity<any, any> = IEntity<any, any>>(entity: T): boolean;
+    /**
+     * Splits an array of entities into a key-value map using an entity ID as the key.
+     *
+     * @param {Array<T>} entities - The array of entities to be split by their ID.
+     * @return {KeyValueType<T>} A key-value map with entity IDs as keys and entities as values.
+     */
+    static splitById<T extends IEntity<T, ID>, ID = any>(entities: T[]): KeyValueType<T>;
+    /**
+     * Collects the IDs from an array of entities and returns them as an array.
+     *
+     * @param {T[]} entities - An array of entities from which to collect IDs.
+     * @return {ID[]} An array of IDs collected from the entities.
+     */
+    static collectIds<T extends IEntity<T, ID>, ID = any>(entities: T[]): ID[];
+    /**
+     * @deprecated Use collectIds() instead - will be remove in next major release
+     */
+    static collectById<T extends IEntity<T, ID>, ID = any>(entities: T[]): ID[];
+    static arrayDistinctFilterFn<E extends IEntity<any, any>>(item: E, index: number, values: E[]): boolean;
+    static findById<E extends IEntity<any, ID> = IEntity<any, any>, ID = number>(items: E[], id: ID): E | undefined;
+    static fromObject<E extends IEntity<any, any>>(source: any, dataType: new () => E): E;
+    /**
+     * Recursively converts any object, entity, or array to a plain JavaScript object.
+     * This method handles entities by calling their asObject() method, processes arrays recursively,
+     * and provides protection against circular references.
+     *
+     * @param {any} source - The source object, entity, array, or primitive value to convert
+     * @param {any} [opts] - Optional configuration object passed to entity asObject() methods
+     * @param {WeakSet} [visited=new WeakSet()] - Internal parameter for circular reference detection
+     * @returns {any} A plain JavaScript object representation of the source
+     *
+     * @example
+     * // Convert a simple entity
+     * const plainObject = EntityUtils.asObject(myEntity);
+     *
+     * @example
+     * // Convert an array of entities
+     * const plainArray = EntityUtils.asObject([entity1, entity2]);
+     *
+     * @example
+     * // Convert with options
+     * const result = EntityUtils.asObject(myEntity, { minify: true });
+     */
+    static asObject(source: any, opts?: any, visited?: WeakSet<object>): any;
+}

package/src/app/core/services/model/filter.model.d.ts

@@ -0,0 +1,37 @@
+import { Entity, EntityAsObjectOptions, IEntity } from './entity.model';
+import { FilterFn } from '../../../shared/types';
+export interface IEntityFilter<F extends IEntityFilter<F, T, ID, AO, FO>, T extends IEntity<T, any>, ID = number, AO extends EntityAsObjectOptions = EntityAsObjectOptions, FO = any> extends IEntity<F, ID, AO, FO> {
+    asPodObject(): any;
+    asFilterFn(): FilterFn<T>;
+    isEmpty(): boolean;
+    countNotEmptyCriteria(): number;
+}
+export declare abstract class EntityFilter<F extends IEntityFilter<F, T, ID, AO, FO>, T extends IEntity<T, any>, ID = number, AO extends EntityAsObjectOptions = EntityAsObjectOptions, FO = any> extends Entity<F, ID, AO, FO> implements IEntityFilter<F, T, ID, AO, FO> {
+    /**
+     * Compose some filter functions: all should return true
+     *
+     * @param filterFns
+     */
+    static composeFilters<T extends IEntity<T, any>>(filterFns: FilterFn<T>[]): FilterFn<T>;
+    static compose<F extends EntityFilter<F, T>, T extends IEntity<T, any>>(filters: F[]): FilterFn<T>;
+    /**
+     * Compose some filter functions: all should return true
+     *
+     * @param filterFns
+     */
+    static composeFns<T extends IEntity<T, any>>(filterFns: FilterFn<T>[]): FilterFn<T>;
+    constructor(__typename?: string);
+    /**
+     * Clean a filter, before sending to the pod (e.g convert dates, remove internal properties, etc.)
+     */
+    asPodObject(): any;
+    isEmpty(): boolean;
+    countNotEmptyCriteria(): number;
+    asFilterFn(): FilterFn<T>;
+    protected buildFilter(): FilterFn<T>[];
+    protected isCriteriaNotEmpty(key: string, value: any): boolean;
+}
+export declare abstract class EntityFilterUtils {
+    static isEntityFilter<F extends EntityFilter<F, any>>(obj: Partial<F>): obj is F;
+    static fromObject<F>(source: any, filterType: new () => F): F;
+}

package/src/app/core/services/model/history.model.d.ts

@@ -0,0 +1,20 @@
+import { Moment } from 'moment';
+export declare interface SynchronizationHistory {
+    name: string;
+    filter?: any;
+    execDate: string;
+    execDurationMs: number;
+    lastUpdateDate?: string;
+    children?: SynchronizationHistory[];
+}
+export interface HistoryPageReference {
+    title: string;
+    subtitle?: string;
+    path: string;
+    time?: Moment | string;
+    icon?: string;
+    matIcon?: string;
+    children?: HistoryPageReference[];
+    offline?: boolean;
+    onlinePeer?: string;
+}

package/src/app/core/services/model/model.enum.d.ts

@@ -0,0 +1,7 @@
+export declare const StatusIds: {
+    DISABLE: number;
+    ENABLE: number;
+    TEMPORARY: number;
+    DELETED: number;
+    ALL: number;
+};

package/src/app/core/services/model/node-feature.model.d.ts

@@ -0,0 +1,14 @@
+import { Moment } from 'moment/moment';
+import { Cloneable, Entity, EntityAsObjectOptions } from './entity.model';
+export declare class NodeFeature extends Entity<NodeFeature> implements Cloneable<NodeFeature> {
+    static fromObject: (source: any, opts?: any) => NodeFeature;
+    label: string;
+    name: string;
+    description: string;
+    logo: string;
+    creationDate: Moment;
+    statusId: number;
+    validityStatusId: number;
+    asObject(options?: EntityAsObjectOptions): any;
+    fromObject(source: any): void;
+}

package/src/app/core/services/model/peer.model.d.ts

@@ -0,0 +1,35 @@
+import { Cloneable, Entity, EntityAsObjectOptions } from './entity.model';
+import { NodeFeature } from './node-feature.model';
+export declare class Peer extends Entity<Peer> implements Cloneable<Peer> {
+    static fromObject: (source: any, opts?: any) => Peer;
+    static parseUrl(peerUrl: string): Peer;
+    static path(peer: Peer, ...paths: string[]): string;
+    static equals(p1: Peer, p2: Peer): boolean;
+    static countAllFeatures(peers: Peer[]): number;
+    dns: string;
+    ipv4: string;
+    ipv6: string;
+    port: number;
+    useSsl: boolean;
+    pubkey: string;
+    path?: string;
+    favicon: string;
+    status: 'UP' | 'DOWN';
+    softwareName: string;
+    softwareVersion: string;
+    label: string;
+    name: string;
+    registrationUri?: string;
+    registrationManager?: string;
+    features?: NodeFeature[];
+    constructor();
+    asObject(options?: EntityAsObjectOptions): any;
+    fromObject(source: any): void;
+    equals(other: Peer): boolean;
+    /**
+     * Return the peer URL (without trailing slash)
+     */
+    get url(): string;
+    get hostAndPort(): string;
+    get reachable(): boolean;
+}

package/src/app/core/services/model/person.model.d.ts

@@ -0,0 +1,37 @@
+import { Moment } from 'moment';
+import { ReferentialAsObjectOptions } from './referential.model';
+import { Entity } from './entity.model';
+import { Department } from './department.model';
+export type UserProfileLabel = 'ADMIN' | 'USER' | 'SUPERVISOR' | 'GUEST';
+export declare const PRIORITIZED_AUTHORITIES: Readonly<UserProfileLabel[]>;
+export declare class Person<T extends Person<any> = Person<any>> extends Entity<T, number, ReferentialAsObjectOptions> {
+    static fromObject: (source: any, opts?: any) => Person;
+    firstName: string;
+    lastName: string;
+    email: string;
+    pubkey: string;
+    avatar: string;
+    creationDate: Date | Moment;
+    statusId: number;
+    department: Department;
+    username: string;
+    usernameExtranet: string;
+    profiles: string[];
+    mainProfile: string;
+    constructor(__typename?: string);
+    asObject(opts?: ReferentialAsObjectOptions): any;
+    fromObject(source: any): void;
+    equals(other: T): boolean;
+}
+export declare class PersonUtils {
+    static getMainProfile(profiles?: string[]): UserProfileLabel;
+    static getMainProfileIndex(profiles?: string[]): number;
+    static hasUpperOrEqualsProfile(actualProfiles: string[], expectedProfile: UserProfileLabel): boolean;
+    static personToString(obj: Person, opts?: {
+        withDepartment?: boolean;
+    }): string;
+    static personsToString(data: Person[], separator?: string, opts?: {
+        withDepartment?: boolean;
+    }): string;
+    static roleToProfile(role: string, defaultProfile?: UserProfileLabel): UserProfileLabel;
+}

package/src/app/core/services/model/referential.model.d.ts

@@ -0,0 +1,84 @@
+import { Moment } from 'moment';
+import { Entity, EntityAsObjectOptions, IEntity } from './entity.model';
+import { IconRef } from '../../../shared/types';
+export declare function referentialToString(obj: Referential | any, properties?: string[], separator?: string): string | undefined;
+export declare function referentialsToString(values: Referential[], properties?: string[], valueSeparator?: string, propertySeparator?: string): string;
+export declare interface IStatus {
+    id: number;
+    icon?: string;
+    label: string;
+}
+export declare const StatusList: Readonly<IStatus[]>;
+export declare const StatusById: Readonly<import("../../../shared/types").KeyValueType<IStatus>>;
+export declare interface IReferentialRef<T extends IEntity<T, ID> = IEntity<any, any>, ID = number> extends IEntity<T, ID> {
+    label: string;
+    name: string;
+    description?: string;
+    levelId?: number;
+    statusId: number;
+    entityName: string;
+    icon?: IconRef;
+}
+export declare abstract class BaseReferential<T extends BaseReferential<T, ID, AO>, ID = number, AO extends ReferentialAsObjectOptions = ReferentialAsObjectOptions, FO = any> extends Entity<T, ID, AO, FO> implements IReferentialRef<T, ID> {
+    label: string;
+    name: string;
+    description: string;
+    comments: string;
+    creationDate: Date | Moment;
+    statusId: number;
+    validityStatusId: number;
+    levelId: number;
+    parentId: number;
+    entityName: string;
+    icon?: IconRef;
+    protected constructor(__typename?: string);
+    asObject(opts?: AO): any;
+    fromObject(source: any, opts?: FO): void;
+    equals(other: T): boolean;
+}
+export declare class Referential<T extends Referential<T, any> = Referential<any>, ID = number> extends BaseReferential<T, ID> {
+    static fromObject: (source: any, opts?: any) => Referential;
+    properties?: {
+        [key: string]: any;
+    };
+    constructor();
+    fromObject(source: any, opts?: any): void;
+    asObject(opts?: ReferentialAsObjectOptions): any;
+}
+export declare class ReferentialUtils {
+    static fromObject(source: any, opts?: any): Referential;
+    static isNotEmpty<T extends IReferentialRef<T>>(obj: T | any): boolean;
+    static isEmpty<T extends IReferentialRef<T>>(obj: T | any): boolean;
+    static equals<T extends IReferentialRef<T>>(o1: T | any, o2: T | any): boolean;
+    static isNotDisabled<T extends IReferentialRef<T>>(obj: T | any): boolean;
+}
+export interface ReferentialAsObjectOptions extends EntityAsObjectOptions {
+    keepEntityName?: boolean;
+    keepIcon?: boolean;
+    keepProperties?: boolean;
+}
+/**
+ * Used to store an entity locally
+ */
+export declare const MINIFY_ENTITY_FOR_LOCAL_STORAGE: ReferentialAsObjectOptions;
+/**
+ * Used to send an entity to a pod
+ */
+export declare const MINIFY_ENTITY_FOR_POD: ReferentialAsObjectOptions;
+export declare class ReferentialRef<T extends ReferentialRef<any, ID> = ReferentialRef<any, any>, ID = number, O extends ReferentialAsObjectOptions = ReferentialAsObjectOptions, FO = any> extends Entity<T, ID, O, FO> implements IReferentialRef<T, ID> {
+    static fromObject: (source: any, opts?: any) => ReferentialRef;
+    static clone(source: any): ReferentialRef;
+    label: string;
+    name: string;
+    description: string;
+    statusId: number;
+    levelId: number;
+    entityName: string;
+    icon?: IconRef;
+    properties?: {
+        [key: string]: any;
+    };
+    constructor();
+    asObject(opts?: O): any;
+    fromObject(source: any, opts?: FO): void;
+}

package/src/app/core/services/model/settings.model.d.ts

@@ -0,0 +1,29 @@
+import { Property, PropertyMap } from '../../../shared/types';
+import { InjectionToken } from '@angular/core';
+import { HistoryPageReference } from './history.model';
+export type UsageMode = 'DESK' | 'FIELD';
+export declare function isOnFieldMode(value: UsageMode): value is 'FIELD';
+export declare interface LocaleConfig extends Property {
+    country?: string;
+}
+export declare const APP_LOCALES: InjectionToken<LocaleConfig[]>;
+export declare interface OfflineFeature<F = any> {
+    name: string;
+    lastSyncDate?: string;
+    filter?: F;
+}
+export declare interface LocalSettings {
+    pages?: any;
+    peerUrl?: string;
+    latLongFormat: 'DDMMSS' | 'DDMM' | 'DD';
+    accountInheritance?: boolean;
+    locale: string;
+    usageMode?: UsageMode;
+    mobile?: boolean;
+    properties?: PropertyMap | Property[];
+    pageHistory?: HistoryPageReference[];
+    offlineFeatures?: (string | OfflineFeature)[];
+    pageHistoryMaxSize: number;
+    darkMode?: boolean;
+    autoDarkMode?: boolean;
+}

package/src/app/core/services/model/token.model.d.ts

@@ -0,0 +1,22 @@
+import { Entity, EntityAsObjectOptions } from './entity.model';
+import { Moment } from 'moment/moment';
+export declare class TokenScope {
+    id: string;
+    flag: number;
+    name: string;
+}
+export declare class UserToken extends Entity<UserToken> {
+    static fromObject: (source: any, opts?: any) => UserToken;
+    static equals(t1: UserToken, t2: UserToken): boolean;
+    pubkey: string;
+    token: string;
+    name: string;
+    flags: number;
+    scopes: TokenScope[];
+    expirationDate: Moment;
+    lastUsedDate: Moment;
+    creationDate: Moment;
+    constructor();
+    asObject(opts?: EntityAsObjectOptions): any;
+    fromObject(source: any, opts?: any): void;
+}

package/src/app/core/services/model/tree-item-entity.model.d.ts

@@ -0,0 +1,53 @@
+import { IEntity } from './entity.model';
+import { EntityFilter } from './filter.model';
+import { FilterFn } from '../../../shared/types';
+export declare interface ITreeItemEntity<T extends IEntity<T, ID>, ID = number> {
+    parentId: ID;
+    parent: T;
+    children: T[];
+}
+export declare class TreeItemEntityUtils {
+    static forward<T extends ITreeItemEntity<any>, ID = number>(node: T, filterFn?: FilterFn<T>, loopCount?: number): T;
+    static backward<T extends ITreeItemEntity<any>, ID = number>(node: T, filterFn?: FilterFn<T>, loopCount?: number): T;
+    static first<T extends ITreeItemEntity<any>>(node: T, filterFn?: FilterFn<T>): T;
+    static lastLeaf<T extends ITreeItemEntity<any>>(node: T, filterFn?: FilterFn<T>): T;
+    static findByFilter<T extends ITreeItemEntity<T> & IEntity<T>>(node: T, filter: EntityFilter<any, T>): T[];
+    /**
+     * Delete matches batches
+     *
+     * @param node
+     * @param filter
+     */
+    static deleteByFilter<T extends ITreeItemEntity<T> & IEntity<T>>(node: T, filter: EntityFilter<any, T>): T[];
+    static filterRecursively<T extends ITreeItemEntity<any>>(node: T, filterFn: (n: T) => boolean): T[];
+    static deleteRecursively<T extends ITreeItemEntity<any>>(node: T, filterFn: (n: T) => boolean): T[];
+    /**
+     * Visit each node, from root to leaf
+     *
+     * @param node
+     * @param action
+     */
+    static visit<T extends ITreeItemEntity<any>>(node: T, action: (item: T) => void): void;
+    /**
+     * Visit each node, from leaf to root
+     *
+     * @param node
+     * @param action
+     */
+    static visitInverse<T extends ITreeItemEntity<any>>(node: T, action: (T: any) => void): void;
+    /**
+     * Transform a batch entity tree into a array list. This method keep links parent/children.
+     *
+     * Method used to find batch without id (e.g. before local storage)
+     *
+     * @param source
+     */
+    static treeToArray<T extends ITreeItemEntity<any>>(source: T): T[];
+    static listOfTreeToArray<T extends ITreeItemEntity<any>>(sources: T[]): T[];
+    /**
+     * Fill parent attribute, of all children found in the tree
+     *
+     * @param source
+     */
+    static treeFillParent<T extends ITreeItemEntity<any>>(source: T): any;
+}

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

@@ -0,0 +1,159 @@
+import { EventEmitter } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Storage } from '@ionic/storage-angular';
+import { Peer } from './model/peer.model';
+import { ModalController, Platform, ToastController } from '@ionic/angular';
+import { ISelectPeerModalOptions } from '../peer/select-peer.modal';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { ConnectionType } from '@capacitor/network';
+import { LocalSettingsService } from './local-settings.service';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { CacheService } from 'ionic-cache';
+import { ShowToastOptions } from '../../shared/toast/toasts';
+import { OverlayEventDetail } from '@ionic/core';
+import { AppManifest, NodeInfo } from './network.utils';
+import { Environment } from '../../../environments/environment.class';
+import { StartableObservableService } from '../../shared/services/startable-observable-service.class';
+import { NetworkEventType } from './network.types';
+import { ILoggingService } from '../../shared/logging/logger.model';
+import * as i0 from "@angular/core";
+export declare const PEER_URL_REGEXP: RegExp;
+export declare const NETWORK_DEFAULT_CONNECTION_TIMEOUT = 10000;
+export declare class NetworkService extends StartableObservableService<Peer, Peer> {
+    private _document;
+    private modalCtrl;
+    private storage;
+    private settings;
+    private cache;
+    private http;
+    protected environment: Environment;
+    private loggingService;
+    private translate;
+    private toastController;
+    onPeerChanges: import("rxjs").Observable<string>;
+    onNetworkStatusChanges: BehaviorSubject<ConnectionType>;
+    onResetNetworkCache: EventEmitter<any>;
+    private readonly _mobile;
+    private readonly _logger;
+    private _timerSubscription;
+    private readonly _timerRefreshPeriod;
+    private readonly _timerRefreshCondition;
+    private _deviceConnectionType;
+    private _forceOffline;
+    private readonly _connectionTimeout;
+    private _listeners;
+    get online(): boolean;
+    get offline(): boolean;
+    get forceOffline(): boolean;
+    get connectionType(): ConnectionType;
+    get peer(): Peer;
+    set peer(peer: Peer);
+    get connectionTimeout(): number;
+    constructor(_document: any, platform: Platform, modalCtrl: ModalController, storage: Storage, settings: LocalSettingsService, cache: CacheService, http: HttpClient, environment: Environment, loggingService: ILoggingService, translate: TranslateService, toastController: ToastController);
+    /**
+     * Register to network event
+     *
+     * @param eventType
+     * @param callback
+     */
+    on<T = any>(eventType: NetworkEventType, callback: (data?: T) => Promise<any>): Subscription;
+    tryOnline(opts?: {
+        showOfflineToast?: boolean;
+        showOnlineToast?: boolean;
+        showLoadingToast?: boolean;
+        afterRetryDelay?: number;
+        afterRetryPromise?: () => Promise<any>;
+    }): Promise<boolean>;
+    showOfflineToast(opts?: {
+        message?: string;
+        showCloseButton?: boolean;
+        showRetryButton?: boolean;
+        showRetrySuccessToast?: boolean;
+        showRetryLoadingToast?: boolean;
+        onRetrySuccess?: () => void;
+    }): Promise<boolean>;
+    /**
+     * Check if the peer is alive
+     *
+     * @param peer
+     */
+    checkPeerAlive(peer?: string | Peer): Promise<NodeInfo>;
+    /**
+     * Checks whether a peer is compatible based on its software version and the required minimum version.
+     * Optionally displays a toast notification if the peer is not compatible.
+     *
+     * @param {NodeInfo} peerInfo - Information about the peer, including its software version.
+     * @param {Object} [opts] - Additional options for the compatibility check.
+     * @param {boolean} [opts.showToast] - Whether to show a toast notification if the peer is not compatible. Defaults to true.
+     * @return {Promise<boolean>} - A promise that resolves to `true` if the peer is compatible, otherwise `false`.
+     */
+    checkPeerCompatible(peerInfo: NodeInfo, opts?: {
+        showToast?: boolean;
+    }): Promise<boolean>;
+    getNodeInfo(peer?: string | Peer, opts?: {
+        nocache?: boolean;
+        timeout?: number;
+    }): Promise<NodeInfo>;
+    getAppManifest(peer?: string | Peer, opts?: {
+        nocache?: boolean;
+    }): Promise<AppManifest | undefined>;
+    getAppVersion(peer?: string | Peer, opts?: {
+        nocache: boolean;
+    }): Promise<string | undefined>;
+    computePeerPath(peer: string | Peer | undefined, path: string): string | undefined;
+    /**
+     * Allow to force offline mode
+     */
+    setForceOffline(value?: boolean, opts?: {
+        showToast?: boolean;
+    }): void;
+    showSelectPeerModal(opts?: Partial<ISelectPeerModalOptions>): Promise<Peer | undefined>;
+    clearCache(opts?: {
+        emitEvent?: boolean;
+    }): Promise<void>;
+    protected ngOnStart(peer?: Peer): Promise<Peer>;
+    protected ngOnAfterStart(peer: Peer): Promise<void>;
+    protected ngOnStop(): void;
+    /**
+     * Try to restore peer from the local storage
+     */
+    protected restoreLocally(): Promise<Peer | undefined>;
+    /**
+     * Stop to network state
+     *
+     * @protected
+     */
+    protected stopRefreshTimer(): void;
+    /**
+     * Refresh the network state
+     *
+     * @protected
+     */
+    protected startRefreshTimer(): void;
+    protected getText(path: string, opts?: {
+        headers?: HttpHeaders | {
+            [header: string]: string | string[];
+        };
+        responseType?: 'text';
+        nocache?: boolean;
+    }): Promise<string>;
+    protected get<T>(path: string, opts?: {
+        headers?: HttpHeaders | {
+            [header: string]: string | string[];
+        };
+        responseType?: 'json';
+        nocache?: boolean;
+        timeout?: number;
+    }): Promise<T>;
+    protected getUri(path: string): string;
+    protected onDeviceConnectionChanged(connectionType?: ConnectionType): void;
+    /**
+     * Get default peers, from environment
+     */
+    protected getDefaultPeers(): Promise<Peer[]>;
+    protected showToast<T = any>(opts: ShowToastOptions): Promise<OverlayEventDetail<T>>;
+    protected addListener<T = any>(name: NetworkEventType, callback: (data?: T) => Promise<void>): Subscription;
+    protected emit<T = any>(name: NetworkEventType, data?: T): Promise<void[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkService, [null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NetworkService>;
+}

package/src/app/core/services/network.types.d.ts

@@ -0,0 +1,4 @@
+import { ConnectionType } from '@capacitor/network';
+export type AuthTokenType = 'token' | 'basic' | 'basic-and-token';
+export declare type NetworkEventType = 'start' | 'peerChanged' | 'statusChanged' | 'resetCache' | 'beforeTryOnlineFinish';
+export { ConnectionType };