@sumaris-net/ngx-components 2.6.4-alpha5 → 2.6.4-alpha6

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

@@ -0,0 +1,60 @@
+import { InjectionToken } from '@angular/core';
+import { Configuration } from './model/config.model';
+import { Storage } from '@ionic/storage-angular';
+import { Observable } from 'rxjs';
+import { GraphqlService } from '../graphql/graphql.service';
+import { FormFieldDefinition, FormFieldDefinitionMap } from '../../shared/form/field.model';
+import { FileService } from '../../shared/file/file.service';
+import { NetworkService } from './network.service';
+import { Platform, ToastController } from '@ionic/angular';
+import { ShowToastOptions } from '../../shared/toast/toasts';
+import { TranslateService } from '@ngx-translate/core';
+import { EntityServiceLoadOptions, IEntityService } from '../../shared/services/entity-service.class';
+import { BaseGraphqlService } from './base-graphql-service.class';
+import { IStartableService } from '../../shared/services/startable-service.class';
+import { AccountService } from './account.service';
+import * as i0 from "@angular/core";
+export declare const Fragments: {
+    config: import("graphql/language/ast").DocumentNode;
+};
+export declare const APP_CONFIG_OPTIONS: InjectionToken<FormFieldDefinitionMap>;
+export declare class ConfigService extends BaseGraphqlService<Configuration, any, number, Configuration> implements IEntityService<Configuration>, IStartableService<Configuration> {
+    protected platform: Platform;
+    protected graphql: GraphqlService;
+    protected storage: Storage;
+    protected network: NetworkService;
+    protected file: FileService;
+    protected toastController: ToastController;
+    protected translate: TranslateService;
+    protected accountService: AccountService;
+    protected environment: any;
+    private _optionDefs;
+    private $data;
+    get config(): Observable<Configuration>;
+    constructor(platform: Platform, graphql: GraphqlService, storage: Storage, network: NetworkService, file: FileService, toastController: ToastController, translate: TranslateService, accountService: AccountService, environment: any, defaultOptionsMap: FormFieldDefinitionMap);
+    protected ngOnStart(): Promise<Configuration>;
+    loadDefault(opts?: EntityServiceLoadOptions): Promise<Configuration>;
+    load(id: number, opts?: EntityServiceLoadOptions & {
+        query?: any;
+    }): Promise<Configuration>;
+    canUserWrite(data: Configuration, opts?: any): boolean;
+    /**
+     * Save a configuration
+     *
+     * @param config
+     */
+    save(config: Configuration): Promise<Configuration>;
+    getCacheStatistics(): Promise<string>;
+    clearCache(opts?: {
+        cacheName?: string;
+    }): Promise<true>;
+    delete(data: Configuration, options?: any): Promise<any>;
+    listenChanges(id: number, options?: any): Observable<Configuration | undefined>;
+    get optionDefs(): FormFieldDefinition[];
+    private loadOrRestoreLocally;
+    private restoreLocally;
+    private storeLocally;
+    protected showToast(opts: ShowToastOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, [null, null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
+}

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

@@ -0,0 +1,44 @@
+import { Params } from '@polkadot/util-crypto/scrypt/types';
+import { Keypair } from '@polkadot/util-crypto/types';
+import * as i0 from "@angular/core";
+export declare const ED25519_SEED_LENGTH = 32;
+export declare const SCRYPT_PARAMS: {
+    SIMPLE: Params;
+    DEFAULT: Params;
+    SECURE: Params;
+    HARDEST: Params;
+    EXTREME: Params;
+};
+export { Keypair };
+export declare class CryptoService {
+    private static _ready;
+    private static get started();
+    private static ready;
+    /**
+     * Generate a sign keypair, using scrypt, from a salt and a password
+     *
+     * @param salt
+     * @param password
+     * @param scryptParams
+     */
+    static scryptKeypair(salt: string, password: string, scryptParams?: Params): Promise<Keypair>;
+    /**
+     * Sign a message, from a key pair
+     */
+    static sign(message: string, keypair: Keypair): Promise<string>;
+    /**
+     * Sign a message, from a key pair
+     */
+    static verify(message: string, signature: string, publicKey: string): Promise<boolean>;
+    /**
+     * Hash (using SHA256) a message, as Hex
+     */
+    static sha256(message: string): string;
+    /**
+     * Hash (using SHA512) a message, as Hex
+     */
+    static sha512(message: string): string;
+    static encodeBase64(message: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CryptoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CryptoService>;
+}

package/src/app/core/services/errors.d.ts

@@ -0,0 +1,51 @@
+export declare interface ServiceError {
+    code: number;
+    message: string;
+    reject?: (err: any) => void;
+}
+export declare const ErrorCodes: {
+    UNKNOWN_ERROR: number;
+    LOAD_ACCOUNT_ERROR: number;
+    BAD_PASSWORD: number;
+    UNKNOWN_ACCOUNT_EMAIL: number;
+    EMAIL_ALREADY_REGISTERED: number;
+    UNREACHABLE_NETWORK_ERROR: number;
+    UNKNOWN_NETWORK_ERROR: number;
+    SENT_CONFIRMATION_EMAIL_FAILED: number;
+    CONFIRM_EMAIL_FAILED: number;
+    SAVE_ACCOUNT_ERROR: number;
+    ACCOUNT_NOT_EXISTS: number;
+    SAVE_SETTINGS_ERROR: number;
+    SUBSCRIBE_ACCOUNT_ERROR: number;
+    ENTITY_STORAGE_MIGRATION_FAILED: number;
+    LOAD_DATA_ERROR: number;
+    SAVE_DATA_ERROR: number;
+    DELETE_DATA_ERROR: number;
+    SUBSCRIBE_DATA_ERROR: number;
+    LOAD_PERSONS_ERROR: number;
+    DATA_NOT_FOUND_ERROR: number;
+    TABLE_INVALID_ROW_ERROR: number;
+    TABLE_READ_ONLY: number;
+    UNAUTHORIZED: number;
+    AUTH_CHALLENGE_ERROR: number;
+    AUTH_SERVER_ERROR: number;
+    LOAD_CONFIG_ERROR: number;
+    SAVE_CONFIG_ERROR: number;
+    LOAD_TRASH_ENTITY_ERROR: number;
+    DELETE_TRASH_ENTITY_ERROR: number;
+};
+export declare const ServerErrorCodes: {
+    BAD_REQUEST: number;
+    UNAUTHORIZED: number;
+    FORBIDDEN: number;
+    NOT_FOUND: number;
+    INTERNAL_SERVER_ERROR: number;
+    DATA_LOCKED: number;
+    BAD_UPDATE_DATE: number;
+    DENY_DELETION: number;
+    DATA_NOT_UNIQUE: number;
+    INVALID_EMAIL_CONFIRMATION: number;
+    INVALID_QUERY_VARIABLES: number;
+    ACCOUNT_ALREADY_EXISTS: number;
+    BAD_APP_VERSION: number;
+};

package/src/app/core/services/local-settings.service.d.ts

@@ -0,0 +1,90 @@
+import { InjectionToken } from '@angular/core';
+import { LocalSettings, OfflineFeature, UsageMode } from './model/settings.model';
+import { TranslateService } from '@ngx-translate/core';
+import { Storage } from '@ionic/storage-angular';
+import { Subject } from 'rxjs';
+import { Platform } from '@ionic/angular';
+import { FormFieldDefinition, FormFieldDefinitionMap } from '../../shared/form/field.model';
+import { Moment } from 'moment';
+import { LatLongPattern } from '../../shared/material/latlong/latlong.utils';
+import { Environment } from '../../../environments/environment.class';
+import { HistoryPageReference } from './model/history.model';
+import { StartableService } from '../../shared/services/startable-service.class';
+import * as i0 from "@angular/core";
+export declare const SETTINGS_STORAGE_KEY = "settings";
+export declare const SETTINGS_TRANSIENT_PROPERTIES: string[];
+export interface LocalSettingsOptions {
+    serializeAsString?: boolean;
+    options: FormFieldDefinitionMap;
+}
+export declare interface AddToPageHistoryOptions {
+    removePathQueryParams?: boolean;
+    removeTitleSmallTag?: boolean;
+    emitEvent?: boolean;
+}
+export declare const APP_LOCAL_SETTINGS: InjectionToken<Partial<LocalSettings>>;
+export declare const APP_LOCAL_SETTINGS_OPTIONS: InjectionToken<LocalSettingsOptions>;
+export declare class LocalSettingsService extends StartableService<LocalSettings> {
+    private translate;
+    private platform;
+    private storage;
+    protected readonly environment: Environment;
+    private readonly defaultSettings;
+    onChange: Subject<LocalSettings>;
+    private readonly _optionDefs;
+    private readonly _serializeAsString;
+    private _$persist;
+    get settings(): LocalSettings;
+    get locale(): string;
+    get latLongFormat(): LatLongPattern;
+    get usageMode(): UsageMode;
+    get mobile(): boolean;
+    set mobile(value: boolean);
+    get pageHistory(): HistoryPageReference[];
+    constructor(translate: TranslateService, platform: Platform, storage: Storage, environment: Environment, defaultSettings: LocalSettings, options: LocalSettingsOptions);
+    ngOnStart(): Promise<LocalSettings>;
+    isUsageMode(mode: UsageMode): boolean;
+    isOnFieldMode(value?: UsageMode): boolean;
+    restoreLocally(): Promise<LocalSettings | undefined>;
+    setProperty<T = string>(keyOrDef: string | FormFieldDefinition, value: T, opts?: {
+        emitEvent?: boolean;
+        immediate?: boolean;
+    }): void;
+    getProperty(keyOrDef: string | FormFieldDefinition, defaultValue?: any): any;
+    getPropertyAsBoolean(definition: FormFieldDefinition, defaultValue?: boolean): boolean;
+    getPropertyAsInt(definition: FormFieldDefinition, defaultValue?: number): number;
+    getPropertyAsNumbers(definition: FormFieldDefinition, defaultValue?: number[]): number[];
+    getPropertyAsStrings(definition: FormFieldDefinition, defaultValue?: string[]): string[];
+    apply(settings: Partial<LocalSettings>, opts?: {
+        emitEvent?: boolean;
+        persistImmediate?: boolean;
+    }): Promise<void>;
+    applyProperty(key: keyof LocalSettings, value: any, opts?: {
+        emitEvent?: boolean;
+        persistImmediate?: boolean;
+    }): Promise<void>;
+    getPageSettings<T = any>(pageId: string, propertyName?: string): T;
+    savePageSetting(pageId: string, value: any, propertyName?: string): Promise<void>;
+    getOfflineFeature(featureName: string): OfflineFeature;
+    getOfflineFeatureLastSyncDate(featureName: string): Moment;
+    hasOfflineFeature(featureName?: string): boolean;
+    saveOfflineFeature(feature: OfflineFeature): void;
+    markOfflineFeatureAsSync(featureName: string): void;
+    removeOfflineFeatures(): void;
+    getFieldDisplayAttributes(fieldName: string, defaultAttributes?: string[]): string[];
+    getPageFieldDefaultValue(pageId: string, fieldName: string): any;
+    get optionDefs(): FormFieldDefinition[];
+    registerOption(def: FormFieldDefinition): void;
+    registerOptions(defs: FormFieldDefinition[]): void;
+    addToPageHistory(page: HistoryPageReference, opts?: AddToPageHistoryOptions, pageHistory?: HistoryPageReference[]): Promise<void>;
+    removePageHistory(path: string, opts?: {
+        emitEvent?: boolean;
+    }, pageHistory?: HistoryPageReference[]): any;
+    clearPageHistory(): Promise<void>;
+    protected ngOnStop(): Promise<void>;
+    private resetData;
+    private persistLocally;
+    private fillPageHistoryDefaults;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalSettingsService, [null, null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalSettingsService>;
+}

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

@@ -0,0 +1,35 @@
+import { LocalSettings } from './settings.model';
+import { Person } from './person.model';
+import { Entity, EntityAsObjectOptions } from './entity.model';
+import { LatLongPattern } from '../../../shared/material/latlong/latlong.utils';
+import { UserToken } from './token.model';
+/**
+ * A user account
+ */
+export declare class Account extends Person<Account> {
+    static fromObject: (source: any, opts?: any) => Account;
+    settings: UserSettings;
+    tokens: UserToken[];
+    constructor();
+    asObject(opts?: EntityAsObjectOptions): any;
+    fromObject(source: any): void;
+    /**
+     * Convert into a Person. This will fill __typename with a right value, for data cache
+     */
+    asPerson(): Person;
+    get displayName(): string;
+}
+export declare class UserSettings extends Entity<UserSettings> {
+    static SETTINGS_PROPERTIES: string[];
+    static fromObject: (source: any, opts?: any) => UserSettings;
+    locale: string;
+    latLongFormat: LatLongPattern;
+    content: any;
+    nonce: string;
+    constructor();
+    asObject(opts?: EntityAsObjectOptions): any;
+    fromObject(source: any, opts?: any): void;
+    merge<S = LocalSettings>(source: S, includesProperties: (keyof S)[]): boolean;
+    asLocalSettings(): Partial<LocalSettings>;
+}
+export declare function accountToString(data: Account): string;

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

@@ -0,0 +1,36 @@
+import { Moment } from 'moment';
+import { FormFieldDefinition } from '../../../shared/form/field.model';
+import { Entity, EntityAsObjectOptions, IEntity } from './entity.model';
+import { Department } from './department.model';
+import { PropertiesMap } from '../../../shared/types';
+export declare class Software<T extends Software<any> = Software<any>> extends Entity<T, number> implements IEntity<T, number> {
+    static fromObject: (source: any, opts?: any) => Software;
+    label: string;
+    name: string;
+    description: string;
+    comments: string;
+    creationDate: Date | Moment;
+    statusId: number;
+    properties: PropertiesMap;
+    constructor(__typename?: string);
+    asObject(options?: EntityAsObjectOptions): any;
+    fromObject(source: any): void;
+}
+export declare class Configuration extends Software<Configuration> {
+    static fromObject: (source: any, opts?: any) => Configuration;
+    smallLogo: string;
+    largeLogo: string;
+    backgroundImages: string[];
+    partners: Department[];
+    constructor();
+    clone(): Configuration;
+    copy(target: Configuration): Configuration;
+    asObject(options?: EntityAsObjectOptions): any;
+    fromObject(source: any): void;
+    getPropertyAsBoolean(definition: FormFieldDefinition): boolean;
+    getPropertyAsInt(definition: FormFieldDefinition): number;
+    getPropertyAsNumbers(definition: FormFieldDefinition): number[];
+    getPropertyAsStrings(definition: FormFieldDefinition): string[];
+    getProperty<T = string>(definition: FormFieldDefinition): T;
+    hasProperty<T = string>(definition: FormFieldDefinition): boolean;
+}

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

@@ -0,0 +1,11 @@
+import { BaseReferential } from './referential.model';
+export declare class Department extends BaseReferential<Department> {
+    static ENTITY_NAME: string;
+    static fromObject: (source: any, opts?: any) => Department;
+    logo: string;
+    siteUrl: string;
+    constructor();
+    fromObject(source: any): void;
+}
+export declare function departmentToString(obj: Department): string;
+export declare function departmentsToString(data: Department[], separator?: string): string;

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

@@ -0,0 +1,17 @@
+import { Entity } from './entity.model';
+declare type Constructor = new (...args: any[]) => any;
+export declare class EntityClasses {
+    static CLASSES_BY_NAME: Map<string, Constructor>;
+    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>(constructor: T) => T;
+export {};

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

@@ -0,0 +1,89 @@
+import { Moment } from 'moment';
+import { getPropertyByPath } from '../../../shared/functions';
+import { FilterFn } from '../../../shared/services/entity-service.class';
+import { ObjectMap, ObjectMapEntry, PropertiesArray, PropertiesMap } from '../../../shared/types';
+import { StoreObject } from '@apollo/client/core';
+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): any;
+    asObject(opts?: AO): any;
+    fromObject(source: any, opts?: FO): any;
+}
+export declare interface ITreeItemEntity<T extends IEntity<T, ID>, ID = number> {
+    parentId: ID;
+    parent: T;
+    children: T[];
+}
+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(source?: PropertiesArray): PropertiesMap;
+    static copyIdAndUpdateDate<T extends Entity<any, any, any>>(source: T, target: T): void;
+    static fillLocalIds<T extends IEntity<T>>(items: T[], sequenceFactory: (firstEntity: T, incrementSize: number) => Promise<number>): Promise<void>;
+    static cleanIdAndUpdateDate<T extends IEntity<T>>(source: T): void;
+    static cleanIdsAndUpdateDates<T extends IEntity<T>>(items: T[]): void;
+    static sort<T extends IEntity<T> | any>(data: T[], sortBy?: string, sortDirection?: string): T[];
+    static sortComparator<T extends IEntity<T> | any>(sortBy?: string, sortDirection?: string): (a: T, b: T) => number;
+    static compare<T extends IEntity<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>(data: T[], searchAttribute: string, searchText: string): T[];
+    static searchTextFilter<T extends IEntity<T> | 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<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): T[];
+    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 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;
+}

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

@@ -0,0 +1,43 @@
+import { Entity, EntityAsObjectOptions, IEntity } from './entity.model';
+import { FilterFn } from '../../../shared/services/entity-service.class';
+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> {
+    filterName: string;
+    filterType: string;
+    filterRecorderPersonId: number;
+    filterRecorderDepartmentId: number;
+    asPodObject(): any;
+    asFilterFn(): FilterFn<T>;
+    isEmpty(): boolean;
+    countNotEmptyCriteria(): number;
+}
+export declare abstract class EntityFilter<F extends EntityFilter<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> {
+    filterName: string;
+    filterType: string;
+    filterRecorderPersonId: number;
+    filterRecorderDepartmentId: number;
+    /**
+     * 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>>(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/peer.model.d.ts

@@ -0,0 +1,29 @@
+import { Cloneable, Entity, EntityAsObjectOptions } from './entity.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;
+    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;
+    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,31 @@
+import { Moment } from 'moment';
+import { ReferentialAsObjectOptions } from './referential.model';
+import { Entity } from './entity.model';
+import { Department } from './department.model';
+export declare 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;
+}
+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): string;
+    static personsToString(data: Person[], separator?: string): string;
+}

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

@@ -0,0 +1,77 @@
+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[]): string | undefined;
+export declare function referentialsToString(values: Referential[], properties?: string[], separator?: 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;
+    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> {
+    properties?: {
+        [key: string]: any;
+    };
+    static fromObject: (source: any, opts?: any) => Referential;
+    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;
+}
+export interface ReferentialAsObjectOptions extends EntityAsObjectOptions {
+    keepEntityName?: boolean;
+    keepIcon?: 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;
+    label: string;
+    name: string;
+    description: string;
+    statusId: number;
+    levelId: number;
+    entityName: string;
+    icon?: IconRef;
+    constructor();
+    asObject(opts?: O): any;
+    fromObject(source: any, opts?: FO): void;
+}