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

package/src/app/social/message/message.service.d.ts

@@ -0,0 +1,27 @@
+import { GraphqlService } from '../../core/graphql/graphql.service';
+import { ToastController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { BaseGraphqlService } from '../../core/services/base-graphql-service.class';
+import { Environment } from '../../../environments/environment.class';
+import { Message, MessageFilter } from './message.model';
+import { ShowToastOptions } from '../../shared/toast/toasts';
+import * as i0 from "@angular/core";
+export declare class MessageService extends BaseGraphqlService<Message, MessageFilter> {
+    protected graphql: GraphqlService;
+    protected translate: TranslateService;
+    protected toastController: ToastController;
+    protected environment: Environment;
+    constructor(graphql: GraphqlService, translate: TranslateService, toastController: ToastController, environment: Environment);
+    /**
+     * Send a message to recipient(s)
+     *
+     * @param entity
+     * @param opts
+     */
+    send(entity: Message, opts?: {
+        showToast?: boolean;
+    }): Promise<boolean>;
+    protected showToast(opts: ShowToastOptions): Promise<import("@ionic/core").OverlayEventDetail<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, [null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;
+}

package/src/app/social/social.errors.d.ts

@@ -0,0 +1,9 @@
+export declare const SocialErrorCodes: {
+    LOAD_USER_EVENTS_ERROR: number;
+    SAVE_USER_EVENT_ERROR: number;
+    COUNT_USER_EVENT_ERROR: number;
+    SEND_MESSAGE_ERROR: number;
+    SUBSCRIBE_USER_EVENTS_ERROR: number;
+    SUBSCRIBE_JOB_PROGRESSION_ERROR: number;
+    LOAD_JOB_PROGRESSIONS_ERROR: number;
+};

package/src/app/social/social.module.d.ts

@@ -0,0 +1,20 @@
+import { InjectionToken } from '@angular/core';
+import { JobProgressionOptions } from './job/progression/job-progression.icon';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../core/core.module";
+import * as i3 from "../shared/shared.module";
+import * as i4 from "./user-event/user-event.module";
+import * as i5 from "./job/job.module";
+import * as i6 from "./message/message.module";
+export interface SocialModuleOptions {
+    showUserEventNotification: boolean;
+    showJobProgression: boolean;
+    jobProgressionOptions: JobProgressionOptions;
+}
+export declare const SocialModuleOptionsToken: InjectionToken<SocialModuleOptions>;
+export declare class SocialModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SocialModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SocialModule, never, [typeof i1.CommonModule, typeof i2.CoreModule, typeof i3.SharedModule, typeof i4.UserEventModule, typeof i5.JobModule, typeof i6.MessageModule], [typeof i4.UserEventModule, typeof i5.JobModule, typeof i6.MessageModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SocialModule>;
+}

package/src/app/social/social.testing.module.d.ts

@@ -0,0 +1,13 @@
+import { TestingPage } from '../shared/testing/tests.page';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "@angular/router";
+import * as i4 from "./job/testing/job.testing.module";
+import * as i5 from "./user-event/testing/user-event.testing.module";
+export declare const SOCIAL_TESTING_PAGES: TestingPage[];
+export declare class SocialTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SocialTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SocialTestingModule, never, [typeof i1.CommonModule, typeof i2.TranslateModule, typeof i3.RouterModule, typeof i4.JobTestingModule, typeof i5.UserEventTestingModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SocialTestingModule>;
+}

package/src/app/social/user-event/notification/user-event-notification.icon.d.ts

@@ -0,0 +1,31 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { PopoverController } from '@ionic/angular';
+import { IUserEventService } from '../user-event.service';
+import { IUserEvent, IUserEventAction, IUserEventFilter } from '../user-event.model';
+import { AccountService } from '../../../core/services/account.service';
+import * as i0 from "@angular/core";
+export declare class UserEventNotificationIcon implements OnInit, OnDestroy {
+    userEventService: IUserEventService<IUserEvent<any>, IUserEventFilter<any>>;
+    protected accountService: AccountService;
+    protected popoverController: PopoverController;
+    private cd;
+    debug: boolean;
+    titleI18n: string;
+    disabled: boolean;
+    filter: any;
+    autoHide: boolean;
+    headerActions: IUserEventAction[];
+    footerActions: IUserEventAction[];
+    visible: boolean;
+    get countChanges(): Observable<number>;
+    private _logPrefix;
+    private _readEvent;
+    private _readEvents;
+    constructor(userEventService: IUserEventService<IUserEvent<any>, IUserEventFilter<any>>, accountService: AccountService, popoverController: PopoverController, cd: ChangeDetectorRef);
+    ngOnInit(): Promise<void>;
+    showList(event: Event): Promise<void>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventNotificationIcon, [{ optional: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventNotificationIcon, "app-user-event-notification-icon", never, { "debug": "debug"; "titleI18n": "titleI18n"; "disabled": "disabled"; "filter": "filter"; "autoHide": "autoHide"; "headerActions": "headerActions"; "footerActions": "footerActions"; }, {}, never, never, false>;
+}

package/src/app/social/user-event/notification/user-event-notification.list.d.ts

@@ -0,0 +1,71 @@
+import { ChangeDetectorRef, EventEmitter, InjectionToken, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { IUserEvent, IUserEventFilter, IUserEventAction } from '../user-event.model';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { IonContent, IonItem, PopoverController } from '@ionic/angular';
+import { IUserEventService } from '../user-event.service';
+import { LocalSettingsService } from '../../../core/services/local-settings.service';
+import { FetchMoreFn, LoadResult } from '../../../shared/services/entity-service.class';
+import { SortDirection } from '@angular/material/sort';
+import * as i0 from "@angular/core";
+export declare const APP_USER_EVENT_LIST_INFINITE_SCROLL_THRESHOLD: InjectionToken<string>;
+export interface UserEventNotificationListOptions<E extends IUserEvent<any> = IUserEvent<any>, F extends IUserEventFilter<any> = IUserEventFilter<any>> {
+    debug?: boolean;
+    titleI18n?: string;
+    readEvent?: EventEmitter<E>;
+    readEvents?: EventEmitter<E[]>;
+    filter?: Partial<F>;
+    headerActions?: IUserEventAction[];
+    footerActions?: IUserEventAction[];
+}
+export declare class UserEventNotificationList<E extends IUserEvent<any> = IUserEvent<any>, F extends IUserEventFilter<any> = IUserEventFilter<any>> implements OnInit, OnDestroy, UserEventNotificationListOptions<E, F> {
+    protected cd: ChangeDetectorRef;
+    protected popoverController: PopoverController;
+    protected settings: LocalSettingsService;
+    userEventService: IUserEventService<E, IUserEventFilter<any>>;
+    infiniteScrollThresholdFromToken: string;
+    debug: boolean;
+    mobile: boolean;
+    titleI18n: string;
+    sortBy: string;
+    sortDirection: SortDirection;
+    filter: Partial<F>;
+    enableInfiniteScroll: boolean;
+    infiniteScrollThreshold: string;
+    headerActions: IUserEventAction[];
+    footerActions: IUserEventAction[];
+    set pageSize(value: number);
+    get pageSize(): number;
+    readEvent: EventEmitter<E>;
+    readEvents: EventEmitter<E[]>;
+    ionContent: IonContent;
+    ionItems: QueryList<IonItem>;
+    get canFetchMore(): boolean;
+    fetchingMore: boolean;
+    $items: BehaviorSubject<E[]>;
+    $itemCount: BehaviorSubject<number>;
+    protected _subscriptions: Subscription;
+    protected _fetchMoreFn: FetchMoreFn<LoadResult<E>>;
+    protected _fetchMoreSubscription: Subscription;
+    protected _$pageSize: BehaviorSubject<number>;
+    protected _panelElement: HTMLElement;
+    constructor(cd: ChangeDetectorRef, popoverController: PopoverController, settings: LocalSettingsService, userEventService: IUserEventService<E, IUserEventFilter<any>>, infiniteScrollThresholdFromToken: string);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    click(event: Event, userEvent: E): void;
+    isDefaultAction(action: IUserEventAction): boolean;
+    markAsRead(event: Event, userEvent: E): void;
+    markAllAsRead(event: Event): void;
+    executeAction(event: Event, action: IUserEventAction, userEvent: IUserEvent<any>): Promise<void>;
+    dismiss(): void;
+    fetchMore(event?: CustomEvent & {
+        target?: EventTarget & {
+            complete?: () => void;
+        };
+    }): Promise<void>;
+    trackByFn(index: number, item: E): number;
+    protected initInfiniteScroll(threshold?: string): Promise<void>;
+    protected markForCheck(): void;
+    protected getPanelElement(): Promise<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventNotificationList<any, any>, [null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventNotificationList<any, any>, "app-user-event-notification-list", never, { "debug": "debug"; "mobile": "mobile"; "titleI18n": "titleI18n"; "sortBy": "sortBy"; "sortDirection": "sortDirection"; "filter": "filter"; "enableInfiniteScroll": "enableInfiniteScroll"; "infiniteScrollThreshold": "infiniteScrollThreshold"; "headerActions": "headerActions"; "footerActions": "footerActions"; "pageSize": "pageSize"; }, { "readEvent": "readEvent"; "readEvents": "readEvents"; }, never, never, false>;
+}

package/src/app/social/user-event/testing/user-event.testing.d.ts

@@ -0,0 +1,34 @@
+import { OnDestroy } from '@angular/core';
+import { Router } from '@angular/router';
+import { AlertController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { UserEventTestService } from './user-event.testing.service';
+import { UserEventNotificationIcon } from '../notification/user-event-notification.icon';
+import { UserEventTest } from './user-event.testing.model';
+import * as i0 from "@angular/core";
+export declare class UserEventTestingPage implements OnDestroy {
+    protected userEventService: UserEventTestService;
+    protected router: Router;
+    protected alertController: AlertController;
+    protected translateService: TranslateService;
+    private _timerSubscription;
+    notification: UserEventNotificationIcon;
+    get timerStarted(): boolean;
+    constructor(userEventService: UserEventTestService, router: Router, alertController: AlertController, translateService: TranslateService);
+    ngOnDestroy(): void;
+    protected customize(userEvent: UserEventTest): void;
+    addNotification(): void;
+    addError(): void;
+    addWarning(): void;
+    addDebug(): void;
+    addNotificationWithLink(): void;
+    addNotificationWithAction(): void;
+    addMany(count?: number): void;
+    startTimer(period?: number): void;
+    stopTimer(): void;
+    addRandom(value: number): void;
+    addNotificationWithDefaultAction(): void;
+    protected showMessage(text: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventTestingPage, "job-progression-testing", never, {}, {}, never, never, false>;
+}

package/src/app/social/user-event/testing/user-event.testing.model.d.ts

@@ -0,0 +1,44 @@
+import { Entity, EntityAsObjectOptions } from '../../../core/services/model/entity.model';
+import { Moment } from 'moment';
+import { IconRef } from '../../../shared/types';
+import { EventLevel, IUserEvent, IUserEventFilter, IUserEventAction } from '../user-event.model';
+import { EntityFilter } from '../../../core/services/model/filter.model';
+import { FilterFn } from '../../../shared/services/entity-service.class';
+import { StoreObject } from '@apollo/client/core';
+export declare class UserEventTest extends Entity<UserEventTest> implements IUserEvent<UserEventTest> {
+    static fromObject: (source: any, opts?: any) => UserEventTest;
+    type: string;
+    level: EventLevel;
+    issuer: string;
+    recipient: string;
+    updateDate: Moment;
+    creationDate: Moment;
+    readDate: Moment;
+    message: string | undefined;
+    content: string | any;
+    hash: string;
+    signature: string;
+    readSignature: string;
+    avatar?: string;
+    avatarIcon?: IconRef;
+    icon?: IconRef;
+    jobId?: number;
+    actions?: IUserEventAction[];
+    constructor();
+    asObject(opts?: EntityAsObjectOptions): any;
+    fromObject(source: any): void;
+}
+export declare class UserEventTestFilter extends EntityFilter<UserEventTestFilter, UserEventTest> implements IUserEventFilter<UserEventTest> {
+    static fromObject: (source: any, opts?: any) => UserEventTestFilter;
+    types: string[];
+    levels: EventLevel[];
+    issuers: string[];
+    recipients: string[];
+    startDate: Moment;
+    includedIds: number[];
+    excludeRead: boolean;
+    jobId: number;
+    fromObject(source: any, opts?: any): void;
+    protected buildFilter(): FilterFn<UserEventTest>[];
+    asObject(opts?: EntityAsObjectOptions): StoreObject;
+}

package/src/app/social/user-event/testing/user-event.testing.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./user-event.testing";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "../../../shared/shared.module";
+import * as i5 from "../user-event.module";
+export declare class UserEventTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UserEventTestingModule, [typeof i1.UserEventTestingPage], [typeof i2.CommonModule, typeof i3.TranslateModule, typeof i4.SharedModule, typeof i5.UserEventModule], [typeof i1.UserEventTestingPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UserEventTestingModule>;
+}

package/src/app/social/user-event/testing/user-event.testing.service.d.ts

@@ -0,0 +1,41 @@
+import { AbstractUserEventService, UserEventLoadOptions, UserEventWatchOptions } from '../user-event.service';
+import { Observable } from 'rxjs';
+import { GraphqlService } from '../../../core/graphql/graphql.service';
+import { AccountService } from '../../../core/services/account.service';
+import { NetworkService } from '../../../core/services/network.service';
+import { TranslateService } from '@ngx-translate/core';
+import { Environment } from '../../../../environments/environment.class';
+import { FetchPolicy } from '@apollo/client/core';
+import { EntityServiceLoadOptions, LoadResult } from '../../../shared/services/entity-service.class';
+import { SortDirection } from '@angular/material/sort';
+import { UserEventTest, UserEventTestFilter } from './user-event.testing.model';
+import * as i0 from "@angular/core";
+export declare class UserEventTestService extends AbstractUserEventService<UserEventTest, UserEventTestFilter> {
+    protected graphql: GraphqlService;
+    protected accountService: AccountService;
+    protected network: NetworkService;
+    protected translate: TranslateService;
+    protected environment: Environment;
+    private $userEvents;
+    private $newUserEvents;
+    constructor(graphql: GraphqlService, accountService: AccountService, network: NetworkService, translate: TranslateService, environment: Environment);
+    fromObject(source: any): UserEventTest;
+    add(entity: UserEventTest): Promise<UserEventTest>;
+    asFilter(filter: Partial<any>): any;
+    count(filter: any, options?: {
+        fetchPolicy?: FetchPolicy;
+    }): Promise<number>;
+    delete(entity: any): Promise<any>;
+    deleteAll(data: any[], opts?: any): Promise<any>;
+    listenAllChanges(filter: any, options?: UserEventWatchOptions & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<any[]>;
+    save(entity: any, options?: EntityServiceLoadOptions): Promise<any>;
+    saveAll(data: any[], opts?: any): Promise<any[]>;
+    protected defaultRecipient(): any;
+    watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<any>, opts?: UserEventWatchOptions): Observable<LoadResult<any>>;
+    loadAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<any>, opts?: UserEventLoadOptions): Promise<LoadResult<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserEventTestService>;
+}

package/src/app/social/user-event/user-event.model.d.ts

@@ -0,0 +1,45 @@
+import { Moment } from 'moment';
+import { Entity, IEntity } from '../../core/services/model/entity.model';
+import { IEntityFilter } from '../../core/services/model/filter.model';
+import { AppColors, IconRef } from '../../shared/types';
+export declare type EventLevel = 'ERROR' | 'WARNING' | 'INFO' | 'DEBUG';
+export interface IUserEvent<E extends Entity<E, ID>, ID = number, U = string, L = EventLevel> extends IEntity<E, ID> {
+    issuer: U;
+    recipient: U;
+    type: string;
+    level: L;
+    updateDate: Moment;
+    creationDate: Moment;
+    readDate?: Moment;
+    message?: string;
+    content?: string | any;
+    avatar?: string;
+    avatarIcon?: IconRef;
+    avatarJdenticon?: any;
+    icon?: IconRef;
+    jobId?: number;
+    actions?: IUserEventAction[];
+}
+export interface IUserEventFilter<E extends IUserEvent<E, ID, U, L>, ID = number, U = string, L = EventLevel> extends IEntityFilter<any, E> {
+    types: string[];
+    levels: L[];
+    issuers: U[];
+    recipients: U[];
+    startDate: Moment;
+    includedIds: ID[];
+    excludeRead: boolean;
+    jobId?: number;
+}
+export interface IUserEventAction {
+    name: string | any;
+    title?: string;
+    color?: AppColors;
+    iconRef?: IconRef;
+    default?: boolean;
+    executeAction: (event: IUserEvent<any>) => any | Promise<any>;
+}
+/**
+ * @deprecated use IUserEventAction instead
+ */
+export interface UserEventAction extends IUserEventAction {
+}

package/src/app/social/user-event/user-event.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./notification/user-event-notification.icon";
+import * as i2 from "./notification/user-event-notification.list";
+import * as i3 from "@angular/common";
+import * as i4 from "../../shared/shared.module";
+import * as i5 from "../../core/icon/icon.module";
+import * as i6 from "ngx-jdenticon";
+export declare class UserEventModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UserEventModule, [typeof i1.UserEventNotificationIcon, typeof i2.UserEventNotificationList], [typeof i3.CommonModule, typeof i4.SharedModule, typeof i5.AppIconModule, typeof i6.NgxJdenticonModule], [typeof i1.UserEventNotificationIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UserEventModule>;
+}

package/src/app/social/user-event/user-event.service.d.ts

@@ -0,0 +1,124 @@
+import { InjectionToken, OnDestroy } from '@angular/core';
+import { FetchPolicy } from '@apollo/client/core';
+import { AccountService } from '../../core/services/account.service';
+import { GraphqlService } from '../../core/graphql/graphql.service';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { IUserEvent, IUserEventFilter } from './user-event.model';
+import { SortDirection } from '@angular/material/sort';
+import { EntitiesServiceLoadOptions, EntitiesServiceWatchOptions, EntityServiceLoadOptions, IEntitiesService, LoadResult, Page } from '../../shared/services/entity-service.class';
+import { TranslateService } from '@ngx-translate/core';
+import { NetworkService } from '../../core/services/network.service';
+import { BaseGraphqlService, BaseGraphqlServiceOptions } from '../../core/services/base-graphql-service.class';
+import { Moment } from 'moment';
+import { IStartableService } from '../../shared/services/startable-service.class';
+import * as i0 from "@angular/core";
+export declare const APP_USER_EVENT_SERVICE: InjectionToken<IUserEventService<any, any, number, UserEventWatchOptions, UserEventLoadOptions>>;
+export declare interface UserEventLoadOptions extends EntitiesServiceLoadOptions {
+    withContent?: boolean;
+}
+export declare interface UserEventWatchOptions extends EntitiesServiceWatchOptions {
+    withContent?: boolean;
+}
+export interface IUserEventQueries {
+    loadAll: any;
+    loadAllWithContent: any;
+    count?: any;
+}
+export interface IUserEventMutations {
+    save: any;
+    markAsRead?: any;
+    deleteByIds: any;
+}
+export interface IUserEventSubscriptions {
+    listenAllChanges: any;
+    listenCountChanges?: any;
+}
+export interface IUserEventListener<E extends IUserEvent<E, ID>, ID = number> {
+    accept: (E: any) => boolean;
+    onReceived?: (E: any) => Promise<E> | E | undefined;
+    onRead?: (E: any) => Promise<void> | void;
+}
+export interface UserEventServiceOptions<Q extends IUserEventQueries = IUserEventQueries, M extends IUserEventMutations = IUserEventMutations, S extends IUserEventSubscriptions = IUserEventSubscriptions> extends BaseGraphqlServiceOptions {
+    queries: Q;
+    mutations?: Partial<M>;
+    subscriptions?: Partial<S>;
+}
+export interface IUserEventService<E extends IUserEvent<E, ID>, F extends IUserEventFilter<E, ID>, ID = number, WO extends UserEventWatchOptions = UserEventWatchOptions, LO extends UserEventLoadOptions = UserEventLoadOptions> extends IEntitiesService<E, F, WO>, IStartableService {
+    countSubject: Observable<number>;
+    add(entity: E): Promise<E>;
+    load(id: ID, opts?: LO): Promise<E>;
+    count(filter: Partial<F>, options?: {
+        fetchPolicy?: FetchPolicy;
+    }): Promise<number>;
+    listenCountChanges(filter: Partial<F>, options?: WO & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<number>;
+    listenAllChanges(filter: Partial<F>, options?: WO & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<E[]>;
+    save(entity: E, options?: EntityServiceLoadOptions): Promise<E>;
+    delete(entity: E): Promise<any>;
+    markAllAsRead(entities: E[]): any;
+    registerListener(listener: IUserEventListener<E, ID>): any;
+    resetCount(): any;
+}
+export declare abstract class AbstractUserEventService<E extends IUserEvent<E, ID, any>, F extends IUserEventFilter<E, ID, any>, ID = number, WO extends UserEventWatchOptions = UserEventWatchOptions, LO extends UserEventLoadOptions = UserEventLoadOptions, Q extends IUserEventQueries = IUserEventQueries, M extends IUserEventMutations = IUserEventMutations, S extends IUserEventSubscriptions = IUserEventSubscriptions> extends BaseGraphqlService<E, F, ID> implements IUserEventService<E, F, ID, WO, LO>, OnDestroy {
+    protected graphql: GraphqlService;
+    protected accountService: AccountService;
+    protected network: NetworkService;
+    protected translate: TranslateService;
+    protected options: UserEventServiceOptions<Q, M, S>;
+    protected readonly queries: Q;
+    protected readonly mutations: Partial<M>;
+    protected readonly subscriptions: Partial<S>;
+    protected readonly _countSubject: BehaviorSubject<number>;
+    protected resetCountDate: Moment;
+    protected listeners: IUserEventListener<E, ID>[];
+    private _subscriptions;
+    private _listenSubscription;
+    get countSubject(): Subject<number>;
+    protected constructor(graphql: GraphqlService, accountService: AccountService, network: NetworkService, translate: TranslateService, options: UserEventServiceOptions<Q, M, S>);
+    protected ngOnStart(): Promise<void>;
+    ngOnDestroy(): void;
+    abstract asFilter(filter: Partial<F>): F;
+    abstract fromObject(source: any): E;
+    watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<F>, options?: WO): Observable<LoadResult<E>>;
+    watchPage(page: Page, filter?: Partial<F>, opts?: WO): Observable<LoadResult<E>>;
+    loadPage(page: Page, filter?: Partial<F>, opts?: LO): Promise<LoadResult<E>>;
+    load(id: ID, opts?: LO): Promise<E>;
+    add(entity: E): Promise<E>;
+    count(filter: Partial<F>, options?: {
+        fetchPolicy?: FetchPolicy;
+    }): Promise<number>;
+    listenCountChanges(filter: Partial<F>, options?: WO & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<number>;
+    listenAllChanges(filter: Partial<F>, opts?: WO & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+        toEntity?: boolean;
+    }): Observable<E[]>;
+    delete(entity: E): Promise<any>;
+    deleteAll(entities: E[], opts?: any): Promise<any>;
+    save(entity: E, options?: EntityServiceLoadOptions): Promise<E>;
+    saveAll(entities: E[], opts?: any): Promise<E[]>;
+    markAllAsRead(entities: E[]): Promise<void>;
+    registerListener(listener: IUserEventListener<E, ID>): void;
+    resetCount(): void;
+    protected onLogin(): Promise<void>;
+    protected onLogout(): void;
+    protected startListenCountChanges(): void;
+    protected stopListenCountChanges(): void;
+    protected processUserEvent(source: any): Promise<E>;
+    protected defaultMarkAsRead(userEvents: E[]): Promise<void>;
+    protected defaultFilter(): F;
+    protected abstract defaultRecipient(): any;
+    protected fillDefaultProperties(entity: E): void;
+    protected unreadEvents(events: E[]): number;
+    protected copyIdAndUpdateDate(source: E, target: E): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractUserEventService<any, any, any, any, any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractUserEventService<any, any, any, any, any, any, any, any>, never, never, {}, {}, never, never, false>;
+}

package/src/environments/environment.class.d.ts

@@ -0,0 +1,57 @@
+import { FetchPolicy } from '@apollo/client/core';
+import { StorageConfig } from '@ionic/storage';
+import { InjectionToken } from '@angular/core';
+import { CacheConfig } from 'ionic-cache/lib/interfaces/cache-config.interface';
+import { LoggingServiceConfig } from '../app/shared/logging/logging-service.config';
+export declare const ENVIRONMENT: InjectionToken<Environment>;
+export declare class Environment {
+    name: string;
+    version: string;
+    production: boolean;
+    baseUrl: string;
+    sameUrlPeer?: boolean;
+    defaultPeer?: {
+        host: string;
+        port: number;
+        useSsl?: boolean;
+        path?: string;
+    } | undefined | null;
+    defaultPeers?: {
+        host: string;
+        port: number;
+        useSsl?: boolean;
+        path?: string;
+    }[];
+    peerMinVersion?: string;
+    checkAppVersionIntervalInSeconds?: number;
+    persistCache?: boolean;
+    offline?: boolean;
+    apolloFetchPolicy?: FetchPolicy;
+    defaultLocale: string;
+    defaultLatLongFormat?: 'DD' | 'DDMM' | 'DDMMSS';
+    defaultDepartmentId?: number;
+    defaultAppName?: string;
+    defaultAndroidInstallUrl?: string;
+    logging?: Partial<LoggingServiceConfig>;
+    cache?: Partial<CacheConfig>;
+    storage?: Partial<StorageConfig>;
+    storageSavePeriodMs?: number;
+    sourceUrl?: string;
+    reportIssueUrl?: string;
+    forumUrl?: string;
+    helpUrl?: string;
+    defaultAuthValues?: {
+        username?: string;
+        password?: string;
+        token?: string;
+    };
+    account?: {
+        showAccountButton?: boolean;
+        enableListenChanges?: boolean;
+        listenIntervalInSeconds?: number;
+    };
+    entityEditor?: {
+        enableListenChanges?: boolean;
+        listenIntervalInSeconds?: number;
+    };
+}

package/src/environments/environment.d.ts

@@ -0,0 +1,3 @@
+import { Environment } from './environment.class';
+import 'zone.js/plugins/zone-error';
+export declare const environment: Environment;

package/.editorconfig

@@ -1,24 +0,0 @@
-# EditorConfig helps developers define and maintain consistent coding styles between different editors and IDEs
-# editorconfig.org
-
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-max_line_length = 200
-
-# We recommend you to keep these unchanged
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.ts]
-indent_style = space
-indent_size = 2
-ij_typescript_use_double_quotes = false
-ij_typescript_force_quote_style = true
-
-[*.md]
-trim_trailing_whitespace = false