@sumaris-net/ngx-components 18.12.0 → 18.12.1

package/src/app/core/services/base-entity-service.class.d.ts

@@ -0,0 +1,135 @@
+import { Observable } from 'rxjs';
+import { ApolloCache, InternalRefetchQueriesInclude, MutationUpdaterFn, MutationUpdaterFunction, WatchQueryFetchPolicy } from '@apollo/client/core';
+import { SortDirection } from '@angular/material/sort';
+import { BaseGraphqlService } from './base-graphql-service.class';
+import { EntitiesServiceLoadOptions, EntitiesServiceWatchOptions, EntityServiceListenChangesOptions, IEntitiesService, IEntityService, LoadResult } from '../../shared/services/entity-service.class';
+import { GraphqlService } from '../graphql/graphql.service';
+import { PlatformService } from './platform.service';
+import { Entity, EntityAsObjectOptions } from './model/entity.model';
+import { FetchResult } from '@apollo/client/link/core';
+import { EntityFilter } from './model/filter.model';
+import { DocumentNode } from 'graphql';
+import * as i0 from "@angular/core";
+export type MutableWatchQueriesUpdatePolicy = 'update-cache' | 'refetch-queries';
+export interface BaseEntityGraphqlQueries {
+    load?: any;
+    loadAll: any;
+    loadAllWithTotal?: any;
+    countAll?: any;
+}
+export interface BaseEntityGraphqlMutations {
+    save?: any;
+    delete?: any;
+    saveAll?: any;
+    deleteAll?: any;
+}
+export interface BaseEntityGraphqlSubscriptions {
+    listenChanges?: any;
+}
+export interface BaseEntityServiceOptions<T extends Entity<any, ID>, ID = number, Q extends BaseEntityGraphqlQueries = BaseEntityGraphqlQueries, M extends BaseEntityGraphqlMutations = BaseEntityGraphqlMutations, S extends BaseEntityGraphqlSubscriptions = BaseEntityGraphqlSubscriptions> {
+    queries: Q;
+    mutations?: Partial<M>;
+    subscriptions?: Partial<S>;
+    equals?: (e1: T, e2: T) => boolean;
+    /**
+     * @deprecated Use 'equals' instead
+     */
+    equalsFn?: (e1: T, e2: T) => boolean;
+    isNew?: (e: T) => boolean;
+    /**
+     * @deprecated Use 'isNew' instead
+     */
+    isNewFn?: (e: T) => boolean;
+    defaultSortBy?: keyof T;
+    defaultSortDirection?: SortDirection;
+    watchQueriesUpdatePolicy?: MutableWatchQueriesUpdatePolicy;
+}
+export interface EntitySaveOptions<T = any, V = any> {
+    refetchQueries?: ((result: FetchResult<{
+        data: T;
+    }>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    awaitRefetchQueries?: boolean;
+    update?: MutationUpdaterFn<{
+        data: any;
+    }> | MutationUpdaterFunction<{
+        data: any;
+    }, V, any, ApolloCache<{
+        data: any;
+    }>>;
+}
+export declare abstract class BaseEntityService<T extends Entity<T, ID>, F extends EntityFilter<F, T, ID>, ID = number, WO extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions<T>, LO extends EntitiesServiceLoadOptions = EntitiesServiceLoadOptions<T>, Q extends BaseEntityGraphqlQueries = BaseEntityGraphqlQueries, M extends BaseEntityGraphqlMutations = BaseEntityGraphqlMutations, S extends BaseEntityGraphqlSubscriptions = BaseEntityGraphqlSubscriptions> extends BaseGraphqlService<T, F, ID> implements IEntitiesService<T, F, WO>, IEntityService<T, ID, LO> {
+    protected graphql: GraphqlService;
+    protected platform: PlatformService;
+    protected dataType: new () => T;
+    protected filterType: new () => F;
+    protected readonly _typename: string;
+    protected readonly _logTypeName: string;
+    protected readonly queries: Q;
+    protected readonly mutations: Partial<M>;
+    protected readonly subscriptions: Partial<S>;
+    protected readonly _equalsFn: (e1: T, e2: T) => boolean;
+    protected readonly _isNewFn: (e: T) => boolean;
+    protected readonly defaultSortBy: keyof T;
+    protected readonly defaultSortDirection: SortDirection;
+    protected readonly watchQueriesUpdatePolicy: MutableWatchQueriesUpdatePolicy;
+    get defaultFetchPolicy(): WatchQueryFetchPolicy;
+    protected constructor(graphql: GraphqlService, platform: PlatformService, dataType: new () => T, filterType: new () => F, options: BaseEntityServiceOptions<T, ID, Q, M, S>);
+    watch(id: number, opts?: WO): Observable<T>;
+    load(id: ID, opts?: LO): Promise<T>;
+    watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, dataFilter?: F, opts?: WO): Observable<LoadResult<T>>;
+    loadAll(offset: number, size: number, sortBy?: keyof T | string, sortDirection?: SortDirection, filter?: Partial<F>, opts?: LO & {
+        debug?: boolean;
+    }): Promise<LoadResult<T>>;
+    countAll(filter?: Partial<F>, opts?: LO): Promise<number>;
+    canUserWrite(data: T, opts?: any): boolean;
+    saveAll(entities: T[], opts?: EntitySaveOptions): Promise<T[]>;
+    /**
+     * Save a referential entity
+     *
+     * @param entity
+     * @param opts
+     */
+    save(entity: T, opts?: EntitySaveOptions): Promise<T>;
+    /**
+     * Delete referential entities
+     */
+    deleteAll(entities: T[], opts?: Partial<{
+        update: MutationUpdaterFn<any>;
+    }> | any): Promise<any>;
+    /**
+     * Delete a referential entity
+     */
+    delete(entity: T, opts?: EntitySaveOptions | any): Promise<any>;
+    listenChanges(id: ID, opts?: EntityServiceListenChangesOptions<T>): Observable<T>;
+    copyIdAndUpdateDate(source: T, target: T): void;
+    fromObject(source: any, opts?: {
+        toEntity?: boolean | ((source: any, opts?: any) => T);
+        [key: string]: any;
+    }): T;
+    asFilter(source: any): F;
+    equals(d1: T, d2: T): boolean;
+    isNew(data: T): boolean;
+    /**
+     * @deprecated Use equals() instead
+     */
+    equalsFn(d1: T, d2: T): boolean;
+    /**
+     * @deprecated Use isNew() instead
+     * @param data
+     */
+    isNewFn(data: T): boolean;
+    protected ngOnStart(): Promise<void>;
+    protected fillDefaultProperties(source: T): void;
+    protected fromObjects(sources: any[], opts?: {
+        toEntity?: boolean | ((source: any, opts?: any) => T);
+        [key: string]: any;
+    }): T[];
+    protected asObject(source: T, opts?: EntityAsObjectOptions): any;
+    protected getRefetchQueriesForMutation(opts?: EntitySaveOptions): ((result: FetchResult<{
+        data: any;
+    }>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    protected getLoadQueries(): DocumentNode[];
+    protected getLoadQueryNames(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseEntityService<any, any, any, any, any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseEntityService<any, any, any, any, any, any, any, any>, never, never, {}, {}, never, never, false, never>;
+}

package/src/app/core/services/base-graphql-service.class.d.ts

@@ -0,0 +1,77 @@
+import { GraphqlService, MutateQueryOptions, WatchQueryOptions } from '../graphql/graphql.service';
+import { Page } from '../../shared/services/entity-service.class';
+import { Observable } from 'rxjs';
+import { FetchResult } from '@apollo/client/link/core';
+import { ApolloCache, InternalRefetchQueriesInclude } from '@apollo/client/core';
+import { QueryRef } from 'apollo-angular';
+import { PureQueryOptions } from '@apollo/client/core/types';
+import { DocumentNode } from 'graphql';
+import { StartableService } from '../../shared/services/startable-service.class';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { EmptyObject } from '../graphql/graphql.utils';
+import * as i0 from "@angular/core";
+export interface QueryVariables<F = any> extends Partial<Page> {
+    filter?: F;
+    [key: string]: any;
+}
+export interface MutateQueryWithCacheUpdateOptions<T = any, V = EmptyObject> extends MutateQueryOptions<T, V> {
+    cacheInsert?: {
+        query: any;
+        fetchData: (variables: V, mutationResult: FetchResult<T>) => any;
+    }[];
+    cacheRemove?: {
+        query: any;
+        fetchIds: (variables: V) => number | number[];
+    }[];
+}
+export interface MutableWatchQueryOptions<D, T = any, V = EmptyObject> extends WatchQueryOptions<V> {
+    queryName: string;
+    arrayFieldName: keyof D;
+    totalFieldName?: keyof D;
+    insertFilterFn?: (data: T) => boolean;
+    sortFn?: (a: T, b: T) => number;
+}
+export interface MutableWatchQueryDescription<TData, TEntityClass = any, TVariables = EmptyObject> extends PureQueryOptions<TVariables, TData> {
+    id?: string;
+    query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    queryRef: QueryRef<TData, TVariables>;
+    variables: TVariables;
+    arrayFieldName: keyof TData;
+    totalFieldName?: keyof TData;
+    insertFilterFn?: (data: TEntityClass) => boolean;
+    sortFn?: (a: TEntityClass, b: TEntityClass) => number;
+    counter: number;
+}
+export interface FindMutableWatchQueriesOptions {
+    query?: DocumentNode;
+    queries?: DocumentNode[];
+    queryName?: string;
+    queryNames?: string[];
+}
+export declare class BaseGraphqlServiceOptions {
+    production?: boolean;
+}
+export declare abstract class BaseGraphqlService<T = any, F = any, ID = any, S = void> extends StartableService<S> {
+    protected graphql: GraphqlService;
+    protected _logPrefix: string;
+    protected _mutableWatchQueries: MutableWatchQueryDescription<any>[];
+    protected _mutableWatchQueriesMaxCount: number;
+    protected constructor(graphql: GraphqlService, options?: BaseGraphqlServiceOptions);
+    mutableWatchQuery<D, V = EmptyObject>(opts: MutableWatchQueryOptions<D, T, V>): Observable<D>;
+    insertIntoMutableCachedQueries(cache: ApolloCache<any>, opts: FindMutableWatchQueriesOptions & {
+        data: T[] | T;
+    }): void;
+    removeFromMutableCachedQueriesByIds(cache: ApolloCache<any>, opts: FindMutableWatchQueriesOptions & {
+        ids: ID | ID[];
+    }): number;
+    refetchMutableWatchQueries(opts: FindMutableWatchQueriesOptions & {
+        variables?: any;
+    }): Promise<void>;
+    protected computeMutableWatchQueryId<D, T, V = EmptyObject>(opts: MutableWatchQueryOptions<D, T, V>): string;
+    protected findMutableWatchQueries(opts: FindMutableWatchQueriesOptions): MutableWatchQueryDescription<any>[];
+    protected registerNewMutableWatchQuery(mutableQuery: MutableWatchQueryDescription<any>): void;
+    protected findRefetchQueries(opts: FindMutableWatchQueriesOptions): InternalRefetchQueriesInclude;
+    protected ngOnStart(): Promise<S>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseGraphqlService<any, any, any, any>, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseGraphqlService<any, any, any, any>, never, never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,7 @@
+export declare class Base58 {
+    private static alphabet;
+    private static alphabetMap;
+    private static getAlphabetMap;
+    static encode(buffer: Uint8Array): string;
+    static decode(string: string): Uint8Array;
+}

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

@@ -0,0 +1,46 @@
+import { FormFieldDefinition } from '../../../shared/form/field.model';
+export declare const CORE_CONFIG_OPTIONS: Readonly<{
+    LOGO: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    FAVICON: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    DEFAULT_LOCALE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    DEFAULT_LAT_LONG_FORMAT: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    /**
+     * @deprecated Use `ACCOUNT_LAT_LONG_FORMAT_ENABLE` instead
+     */
+    DEFAULT_LAT_LONG_FORMAT_ENABLED: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    REGISTRATION_ENABLE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    AUTH_TOKEN_TYPE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    AUTH_RESET_PASSWORD_ENABLE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    AUTH_API_TOKEN_ENABLED: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    AUTH_API_TOKEN_SCOPE_ENABLED: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    DEFAULT_AUTH_API_TOKEN_SCOPE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    GRAVATAR_ENABLE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    GRAVATAR_URL: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    TESTING: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    APP_MIN_VERSION: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    HELP_URL: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    FORUM_URL: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    REPORT_ISSUE_URL: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    PRIVACY_POLICY_URL: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    TERMS_OF_USE_URL: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    LOGO_LARGE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    MENU_ITEMS: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    HOME_PARTNERS_DEPARTMENTS: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    HOME_BACKGROUND_IMAGE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    COLOR_PRIMARY: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    COLOR_SECONDARY: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    COLOR_TERTIARY: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    COLOR_SUCCESS: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    COLOR_WARNING: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    COLOR_ACCENT: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    COLOR_DANGER: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    FORM_FIELD_BACKGROUND_COLOR: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    FORM_FIELD_FOCUS_BACKGROUND_COLOR: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    FORM_FIELD_DISABLED_BACKGROUND_COLOR: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    ANDROID_INSTALL_URL: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    IOS_INSTALL_URL: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    DESKTOP_INSTALL_URL: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    DB_TIMEZONE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    ACCOUNT_LAT_LONG_FORMAT_ENABLE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    ACCOUNT_READONLY: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+}>;

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

@@ -0,0 +1,63 @@
+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 { Environment } from '../../../environments/environment.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 ConfigFragments: {
+    config: import("apollo-angular").TypedDocumentNode<unknown, unknown>;
+};
+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: Environment;
+    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: Environment, defaultOptionsMap: FormFieldDefinitionMap);
+    protected ngOnStart(): Promise<Configuration>;
+    loadDefault(opts?: EntityServiceLoadOptions): Promise<Configuration>;
+    load(id: number, opts?: EntityServiceLoadOptions & {
+        query?: any;
+        variables?: any;
+    }): Promise<Configuration>;
+    canUserWrite(data: Configuration): boolean;
+    /**
+     * Save a configuration
+     *
+     * @param config
+     */
+    save(config: Configuration): Promise<Configuration>;
+    getCacheStatistics(): Promise<string>;
+    clearCache(opts?: {
+        cacheName?: string;
+    }): Promise<true>;
+    delete(data: Configuration): Promise<any>;
+    listenChanges(id: number): Observable<Configuration | undefined>;
+    get optionDefs(): FormFieldDefinition[];
+    protected copyIdAndUpdateDate(source: Configuration | undefined, target: Configuration): void;
+    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 { ScryptParams } 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: ScryptParams;
+    DEFAULT: ScryptParams;
+    SECURE: ScryptParams;
+    HARDEST: ScryptParams;
+    EXTREME: ScryptParams;
+};
+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?: ScryptParams): 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,65 @@
+import { FormErrors } from '../../shared/forms';
+export interface AppError {
+    code?: number;
+    message?: string;
+}
+export interface AppErrorWithDetails extends AppError {
+    details: AppError & {
+        errors?: FormErrors;
+    };
+}
+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;
+    INTERNAL_SERVER_ERROR: number;
+    AUTH_CHALLENGE_ERROR: number;
+    AUTH_SERVER_ERROR: number;
+    AUTH_SEND_RESET_PASSWORD_EMAIL_ERROR: number;
+    AUTH_RESET_PUBKEY_ERROR: number;
+    AUTH_UPDATE_PUBKEY_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,99 @@
+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 storage;
+    protected readonly environment: Environment;
+    private readonly defaultSettings;
+    onChange: Subject<LocalSettings>;
+    darkMode$: import("rxjs").Observable<boolean>;
+    private readonly _optionDefs;
+    private readonly _serializeAsString;
+    private _$persist;
+    get settings(): LocalSettings;
+    get locale(): string;
+    get latLongFormat(): LatLongPattern;
+    get usageMode(): UsageMode;
+    set usageMode(value: UsageMode);
+    get mobile(): boolean;
+    set mobile(value: boolean);
+    get pageHistory(): HistoryPageReference[];
+    get allowDarkMode(): boolean;
+    get isDarkMode(): boolean;
+    constructor(platform: Platform, translate: TranslateService, 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[];
+    getPropertyAsObjects(definition: FormFieldDefinition, defaultValue?: any[]): any[];
+    apply(settings: Partial<LocalSettings>, opts?: {
+        emitEvent?: boolean;
+        persistImmediate?: boolean;
+        sanitize?: 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<F = any>(featureName: string): OfflineFeature<F>;
+    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, opts?: {
+        replaceIfExists?: boolean;
+    }): void;
+    registerOptions(defs: FormFieldDefinition[]): void;
+    addToPageHistory(page: HistoryPageReference, opts?: AddToPageHistoryOptions, pageHistory?: HistoryPageReference[]): Promise<void>;
+    removePageHistory(path: string, opts?: {
+        emitEvent?: boolean;
+        persistImmediate?: boolean;
+    }, pageHistory?: HistoryPageReference[], // used for recursive call to children)
+    depth?: number): 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,56 @@
+import { LocalSettings } from './settings.model';
+import { Person, UserProfileLabel } from './person.model';
+import { Entity, EntityAsObjectOptions } from './entity.model';
+import { LatLongPattern } from '../../../shared/material/latlong/latlong.utils';
+import { UserToken } from './token.model';
+import { FormFieldDefinition } from '../../../shared/form/field.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 abstract class AccountUtils {
+    static accountToString: typeof accountToString;
+    static hasMinProfile(account: Account | null, userProfile: UserProfileLabel): boolean;
+    static hasExactProfile(account: Account | null, label: UserProfileLabel): boolean;
+    static hasProfileAndIsEnable(account: Account | null, userProfile: UserProfileLabel): boolean;
+}
+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;
+    /**
+     * Merges the given source object into the current instance.
+     *
+     * @param {S} source - The source object containing properties to merge.
+     * @param {Array<keyof S | string | number>} [includedProperties] - Optional array of property keys to be merged into the content map.
+     * @param {boolean} [resetContent] - Optional flag to reset existing content. False by default
+     * @return {boolean} - Returns true if any changes were made; otherwise, false.
+     */
+    merge<S = LocalSettings>(source: S, includedProperties: (keyof S | string | number)[], resetContent?: boolean): boolean;
+    /**
+     * Transform user settings into local settings
+     * @param opts
+     */
+    asLocalSettings(opts?: {
+        definitions?: FormFieldDefinition[];
+    }): 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 { PropertyMap } 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: PropertyMap;
+    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;