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

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

@@ -0,0 +1,53 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy } from '@angular/core';
+import { ModalController, PopoverController } from '@ionic/angular';
+import { Peer } from '../services/model/peer.model';
+import { Observable, Subject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { TextPopoverOptions } from '../form/text-popover/text-popover.component';
+import { TranslateService } from '@ngx-translate/core';
+import { ILoggingService } from '../../shared/logging/logger.model';
+import * as i0 from "@angular/core";
+export interface ISelectPeerModalOptions {
+    canCancel: boolean;
+    allowSelectDownPeer: boolean;
+    onRefresh: EventEmitter<Event>;
+    showSetManuallyButton: boolean;
+}
+export declare class SelectPeerModal implements OnDestroy, ISelectPeerModalOptions {
+    private modalCtrl;
+    private popoverController;
+    private translate;
+    private http;
+    private cd;
+    protected environment: any;
+    protected loggingService?: ILoggingService;
+    private _subscription;
+    private readonly _logger;
+    loading: boolean;
+    mobile: boolean;
+    $peers: Subject<Peer[]>;
+    peerMinVersion: any;
+    canCancel: boolean;
+    allowSelectDownPeer: boolean;
+    onRefresh: EventEmitter<Event>;
+    showSetManuallyButton: boolean;
+    constructor(modalCtrl: ModalController, popoverController: PopoverController, translate: TranslateService, http: HttpClient, cd: ChangeDetectorRef, environment: any, loggingService?: ILoggingService);
+    set peers(peers: Observable<Peer[]>);
+    cancel(): void;
+    ngOnDestroy(): void;
+    selectPeer(peer: Peer): void;
+    /**
+     *  Check the min pod version, defined by the app
+     *
+     * @param peer
+     */
+    isCompatible(peer: Peer): boolean;
+    refresh(event: any): void;
+    clickSetManually(event?: Event): Promise<void>;
+    refreshPeers(peers: Peer[]): Promise<void>;
+    protected refreshPeer(peer: Peer): Promise<Peer>;
+    protected openPeerUrlPopover(event: Event, opts?: Partial<TextPopoverOptions>): Promise<any>;
+    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, { "canCancel": "canCancel"; "allowSelectDownPeer": "allowSelectDownPeer"; "onRefresh": "onRefresh"; "showSetManuallyButton": "showSetManuallyButton"; }, {}, never, never, false>;
+}

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

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./select-peer.modal";
+import * as i2 from "../../shared/shared.module";
+import * as i3 from "@angular/common/http";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "../form/text-popover/text-popover.module";
+export declare class AppSelectPeerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppSelectPeerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppSelectPeerModule, [typeof i1.SelectPeerModal], [typeof i2.SharedModule, typeof i3.HttpClientModule, typeof i4.TranslateModule, typeof i5.AppTextPopoverModule], [typeof i4.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>;
+}

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

@@ -0,0 +1,48 @@
+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 { 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: any;
+    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: any, 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>;
+}

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

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,191 @@
+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 { 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 UserSettingsOptions {
+    options: FormFieldDefinitionMap;
+}
+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: any;
+    onLogin: 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 _$additionalFields;
+    private _tokenType$;
+    get account(): Account;
+    get person(): Person;
+    get department(): Department;
+    get tokenType(): AuthTokenType;
+    set tokenType(value: AuthTokenType);
+    constructor(network: NetworkService, graphql: GraphqlService, settings: LocalSettingsService, storage: Storage, file: FileService, translate: TranslateService, toastController: ToastController, environment: any, 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.canUserWriteDataForDepartment() 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;
+    }): 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>;
+    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 {};

package/src/app/core/services/auth-guard.service.d.ts

@@ -0,0 +1,17 @@
+import { ActivatedRouteSnapshot, CanActivate, Router, RouterStateSnapshot, UrlTree } from '@angular/router';
+import { Observable } from 'rxjs';
+import { ModalController } from '@ionic/angular';
+import { AccountService } from './account.service';
+import * as i0 from "@angular/core";
+export declare class AuthGuardService implements CanActivate {
+    private accountService;
+    private modalCtrl;
+    private router;
+    protected environment: any;
+    private readonly _debug;
+    constructor(accountService: AccountService, modalCtrl: ModalController, router: Router, environment: any);
+    canActivate(next: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | Promise<boolean | UrlTree> | boolean | UrlTree;
+    login(next?: ActivatedRouteSnapshot): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthGuardService>;
+}

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

@@ -0,0 +1,104 @@
+import { Observable } from 'rxjs';
+import { InternalRefetchQueriesInclude, MutationUpdaterFn } 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 declare 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>;
+    equalsFn?: (e1: T, e2: T) => boolean;
+    isNewFn?: (e: T) => boolean;
+    defaultSortBy?: keyof T;
+    defaultSortDirection?: SortDirection;
+    watchQueriesUpdatePolicy?: MutableWatchQueriesUpdatePolicy;
+}
+export interface EntitySaveOptions {
+    refetchQueries?: ((result: FetchResult<{
+        data: any;
+    }>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+    awaitRefetchQueries?: boolean;
+    update?: MutationUpdaterFn<{
+        data: any;
+    }>;
+}
+export declare abstract class BaseEntityService<T extends Entity<T, ID>, F extends EntityFilter<F, T, ID>, ID = number, WO extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions, LO extends EntitiesServiceLoadOptions = EntitiesServiceLoadOptions, 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;
+    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, filter?: F, opts?: WO): Observable<LoadResult<T>>;
+    loadAll(offset: number, size: number, sortBy?: 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): Observable<T>;
+    copyIdAndUpdateDate(source: T, target: T): void;
+    fromObject(source: any): T;
+    asFilter(source: any): F;
+    protected ngOnStart(): Promise<void>;
+    protected fillDefaultProperties(source: T): void;
+    protected asObject(entity: 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>;
+}

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

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,29 @@
+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>;
+    REGISTRATION_ENABLE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    AUTH_TOKEN_TYPE: 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>;
+    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>;
+    ANDROID_INSTALL_URL: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    DB_TIMEZONE: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+    ACCOUNT_READONLY: FormFieldDefinition<string, import("../../../shared/form/field.model").FormFieldType, any>;
+}>;