@sumaris-net/ngx-components 1.21.8 → 1.22.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sumaris-net/ngx-components",
   "description": "SUMARiS Angular components",
-  "version": "1.21.8",
+  "version": "1.22.1",
   "author": "contact@e-is.pro",
   "license": "AGPL-3.0",
   "readmeFilename": "README.md",

package/public_api.d.ts

@@ -165,10 +165,17 @@ export * from './src/app/core/menu/menu.service';
 export { EntityClass, EntityClasses } from './src/app/core/services/model/entity.decorators';
 export * from './src/app/social/social.module';
 export * from './src/app/social/social.errors';
+export * from './src/app/social/user-event/user-event.module';
 export * from './src/app/social/user-event/user-event.model';
 export * from './src/app/social/user-event/user-event.fragments';
 export * from './src/app/social/user-event/user-event.service';
 export * from './src/app/social/user-event/user-events.table';
+export * from './src/app/social/user-event/notification/user-event-notification.component';
+export * from './src/app/social/job/job.module';
+export * from './src/app/social/job/job.model';
+export * from './src/app/social/job/job.service';
+export * from './src/app/social/job/progression/job-progression.component';
+export * from './src/app/social/message/message.module';
 export * from './src/app/social/message/message.model';
 export * from './src/app/social/message/message.service';
 export * from './src/app/social/message/message.form';

package/src/app/core/icon/icon.component.d.ts

@@ -1,10 +1,10 @@
-import { IconRef } from '../../shared/types';
-import { PredefinedColors } from '@ionic/core';
-import { ThemePalette } from '@angular/material/core';
+import { AppColors, IconRef } from '../../shared/types';
 export declare class AppIconComponent {
     icon: string;
     matIcon: string;
     matSvgIcon: string;
-    color: PredefinedColors | ThemePalette;
+    color: AppColors;
+    height: number;
+    width: number;
     set ref(value: IconRef);
 }

package/src/app/core/icon/icon.module.d.ts

@@ -0,0 +1,2 @@
+export declare class AppIconModule {
+}

package/src/app/core/menu/menu.component.d.ts

@@ -9,8 +9,9 @@ import { ConfigService } from '../services/config.service';
 import { HammerSwipeEvent } from '../../shared/gesture/hammer.utils';
 import { PlatformService } from '../services/platform.service';
 import { MenuService, SplitPaneShowWhen } from './menu.service';
-import { MenuItem } from './menu.model';
+import { MenuConfig, MenuItem } from './menu.model';
 export declare const APP_MENU_ITEMS: InjectionToken<MenuItem[]>;
+export declare const APP_MENU_CONFIG: InjectionToken<MenuConfig>;
 export declare class MenuComponent implements OnInit {
     protected platformService: PlatformService;
     protected accountService: AccountService;
@@ -37,11 +38,12 @@ export declare class MenuComponent implements OnInit {
     menuId: string;
     side: string;
     contentId: string;
-    logo: String;
-    appName: String;
-    appVersion: String;
+    logo: string;
+    appName: string;
+    appVersion: string;
+    showNotification: boolean;
     splitPane: IonSplitPane;
-    constructor(platformService: PlatformService, accountService: AccountService, router: Router, menu: MenuController, modalCtrl: ModalController, alertController: AlertController, translate: TranslateService, configService: ConfigService, cd: ChangeDetectorRef, menuService: MenuService, environment: any, items: MenuItem[]);
+    constructor(platformService: PlatformService, accountService: AccountService, router: Router, menu: MenuController, modalCtrl: ModalController, alertController: AlertController, translate: TranslateService, configService: ConfigService, cd: ChangeDetectorRef, menuService: MenuService, environment: any, config: MenuConfig, items: MenuItem[]);
     ngOnInit(): Promise<void>;
     onLogin(account: Account): Promise<void>;
     onLogout(skipRedirect?: boolean): Promise<void>;

package/src/app/core/menu/menu.model.d.ts

@@ -24,3 +24,6 @@ export declare class MenuItems {
         logPrefix?: string;
     }): boolean;
 }
+export declare class MenuConfig {
+    showNotification?: boolean;
+}

package/src/app/shared/material/badge/badge-icon.test.d.ts

@@ -5,5 +5,5 @@ export declare class MatBadgeIconTestPage {
     $icon: BehaviorSubject<string>;
     $size: BehaviorSubject<MatBadgeSize>;
     $fill: BehaviorSubject<MatBadgeFill>;
-    $color: BehaviorSubject<"primary" | "accent" | "warn" | "light" | "tertiary" | "secondary" | "success" | "warning" | "danger" | "medium" | "dark">;
+    $color: BehaviorSubject<"primary" | "secondary" | "tertiary" | "success" | "warning" | "danger" | "light" | "medium" | "dark" | "accent" | "warn">;
 }

package/src/app/shared/pipes/date-diff-duration.pipe.d.ts

@@ -10,6 +10,10 @@ export declare class DateDiffDurationPipe implements PipeTransform {
     transform(value: {
         startValue: string | Moment;
         endValue: string | Moment;
-    }, args?: any): string | Promise<string>;
-    format(startDate: Moment, endDate: Moment): string;
+    }, args?: {
+        seconds?: boolean;
+    }): string | Promise<string>;
+    format(startDate: Moment, endDate: Moment, args: {
+        seconds?: boolean;
+    }): string;
 }

package/src/app/shared/types.d.ts

@@ -1,3 +1,5 @@
+import { ThemePalette } from '@angular/material/core';
+import { PredefinedColors } from '@ionic/core';
 export declare type KeyType = string | number;
 export declare type KeyValueType<T> = {
     [key in KeyType]: T;
@@ -15,8 +17,10 @@ export declare interface ObjectMapEntry<O = any> {
 export declare type PropertiesMap = ObjectMap<string>;
 export declare type Property = ObjectMapEntry<string>;
 export declare type PropertiesArray = Property[];
+export declare type AppColors = PredefinedColors | ThemePalette | string;
 export declare interface IconRef {
     icon?: string;
     matIcon?: string;
     matSvgIcon?: string;
+    color?: AppColors;
 }

package/src/app/social/job/job.model.d.ts

@@ -0,0 +1,33 @@
+import { Moment } from 'moment';
+import { Entity } from '../../core/services/model/entity.model';
+export declare type JobStatus = 'PENDING' | 'RUNNING' | 'SUCCESS' | 'ERROR' | 'FAILED' | 'WARNING' | 'CANCELLED';
+export interface IJob {
+    id: number;
+    name: string;
+    type: string;
+    status: JobStatus;
+    startDate: Moment;
+    endDate: Moment;
+    configuration: string;
+    report: string;
+}
+export declare class Job implements IJob {
+    id: number;
+    name: string;
+    type: string;
+    status: JobStatus;
+    startDate: Moment;
+    endDate: Moment;
+    configuration: string;
+    report: string;
+}
+export declare class JobProgression extends Entity<JobProgression> {
+    static fromObject: (source: any, opts?: any) => JobProgression;
+    id: number;
+    name: string;
+    message: string;
+    current: number;
+    total: number;
+    constructor(id?: number);
+    fromObject(source: any): void;
+}

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

@@ -0,0 +1,2 @@
+export declare class JobModule {
+}

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

@@ -0,0 +1,23 @@
+import { InjectionToken } from '@angular/core';
+import { JobProgression } from './job.model';
+import { BaseGraphqlService } from '../../core/services/base-graphql-service.class';
+import { GraphqlService } from '../../core/graphql/graphql.service';
+import { Environment } from '../../../environments/environment.class';
+import { Observable } from 'rxjs';
+import { FetchPolicy } from '@apollo/client/core';
+export declare const JobProgressionServiceToken: InjectionToken<JobProgressionService>;
+export interface IJobProgressionService {
+    listenChanges(id: number, options?: {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<JobProgression>;
+}
+export declare class JobProgressionService extends BaseGraphqlService<JobProgression> implements IJobProgressionService {
+    protected graphql: GraphqlService;
+    protected environment: Environment;
+    constructor(graphql: GraphqlService, environment: Environment);
+    listenChanges(id: number, options?: {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<JobProgression>;
+}

package/src/app/social/job/progression/job-progression.component.d.ts

@@ -0,0 +1,44 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { ThemePalette } from '@angular/material/core';
+import { ProgressSpinnerMode } from '@angular/material/progress-spinner';
+import { IJobProgressionService } from '../job.service';
+import { JobProgression } from '../job.model';
+import { PopoverController } from '@ionic/angular';
+export interface JobProgressionOptions {
+    autoHide: boolean;
+    autoHideDelay: number;
+    autoRemove: boolean;
+    autoRemoveDelay: number;
+}
+export declare class JobProgressionComponent implements OnInit, OnDestroy {
+    protected jobProgressionService: IJobProgressionService;
+    protected popoverController: PopoverController;
+    protected cd: ChangeDetectorRef;
+    debug: boolean;
+    titleI18n: string;
+    options: JobProgressionOptions;
+    jobFinished: EventEmitter<number>;
+    visible: boolean;
+    disabled: boolean;
+    color: ThemePalette;
+    mode: ProgressSpinnerMode;
+    value: number;
+    jobProgressions: JobProgression[];
+    protected autoHide: boolean;
+    protected autoHideDelay: number;
+    protected autoRemove: boolean;
+    protected autoRemoveDelay: number;
+    private _listPopover;
+    private _subscriptions;
+    private _subscriptionsById;
+    private _logPrefix;
+    constructor(jobProgressionService: IJobProgressionService, popoverController: PopoverController, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    addJob(id: number): void;
+    removeJob(id: number): void;
+    getProgression(id: number): JobProgression | undefined;
+    updateValue(): void;
+    showList(event: UIEvent): Promise<void>;
+    protected markForCheck(): void;
+    ngOnDestroy(): void;
+}

package/src/app/social/job/progression/job-progression.list.d.ts

@@ -0,0 +1,12 @@
+import { OnInit } from '@angular/core';
+import { JobProgression } from '../job.model';
+export interface JobProgressionListOptions {
+    titleI18n?: string;
+    jobProgressions?: JobProgression[];
+}
+export declare class JobProgressionList implements OnInit, JobProgressionListOptions {
+    titleI18n: string;
+    jobProgressions: JobProgression[];
+    constructor();
+    ngOnInit(): void;
+}

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

@@ -0,0 +1,2 @@
+export declare class MessageModule {
+}

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

@@ -1,5 +1,8 @@
 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;
 };

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

@@ -1,2 +1,10 @@
+import { InjectionToken } from '@angular/core';
+import { JobProgressionOptions } from './job/progression/job-progression.component';
+export interface SocialModuleOptions {
+    showUserEventNotification: boolean;
+    showJobProgression: boolean;
+    jobProgressionOptions: JobProgressionOptions;
+}
+export declare const SocialModuleOptionsToken: InjectionToken<SocialModuleOptions>;
 export declare class SocialModule {
 }

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

@@ -0,0 +1,22 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { PopoverController } from '@ionic/angular';
+import { IUserEventService } from '../user-event.service';
+import { IUserEvent, IUserEventFilter } from '../user-event.model';
+import { AccountService } from '../../../core/services/account.service';
+export declare class UserEventNotificationComponent implements OnInit, OnDestroy {
+    userEventService: IUserEventService<IUserEvent<any>, IUserEventFilter<any>>;
+    protected accountService: AccountService;
+    protected popoverController: PopoverController;
+    debug: boolean;
+    titleI18n: string;
+    disabled: boolean;
+    get count(): Observable<number>;
+    private _logPrefix;
+    private _readEvent;
+    private _readEvents;
+    constructor(userEventService: IUserEventService<IUserEvent<any>, IUserEventFilter<any>>, accountService: AccountService, popoverController: PopoverController);
+    ngOnInit(): Promise<void>;
+    showList(event: UIEvent): Promise<void>;
+    ngOnDestroy(): void;
+}

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

@@ -0,0 +1,30 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { IUserEvent, IUserEventFilter, UserEventAction } from '../user-event.model';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { PopoverController } from '@ionic/angular';
+import { IUserEventService } from '../user-event.service';
+export interface UserEventNotificationListOptions {
+    debug?: boolean;
+    titleI18n?: string;
+    readEvent?: EventEmitter<IUserEvent<any>>;
+    readEvents?: EventEmitter<IUserEvent<any>[]>;
+}
+export declare class UserEventNotificationList implements OnInit, OnDestroy, UserEventNotificationListOptions {
+    protected cd: ChangeDetectorRef;
+    protected popoverController: PopoverController;
+    userEventService: IUserEventService<IUserEvent<any>, IUserEventFilter<any>>;
+    debug: boolean;
+    titleI18n: string;
+    readEvent: EventEmitter<IUserEvent<any>>;
+    readEvents: EventEmitter<IUserEvent<any>[]>;
+    userEvents: BehaviorSubject<IUserEvent<any, string, import("../user-event.model").EventLevel>[]>;
+    protected subscriptions: Subscription;
+    constructor(cd: ChangeDetectorRef, popoverController: PopoverController, userEventService: IUserEventService<IUserEvent<any>, IUserEventFilter<any>>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    read(event: UIEvent, userEvent: IUserEvent<any>): void;
+    readAll(event: UIEvent): void;
+    executeAction(action: UserEventAction, userEvent: IUserEvent<any>): void;
+    dismiss(): void;
+    protected markForCheck(): void;
+}

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

@@ -0,0 +1,35 @@
+import { AbstractUserEventService, UserEventWatchOptions } from '../user-event.service';
+import { IUserEvent, UserEvent, UserEventFilter } from '../user-event.model';
+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';
+export declare class UserEventTestService extends AbstractUserEventService<UserEvent, UserEventFilter> {
+    protected graphql: GraphqlService;
+    protected accountService: AccountService;
+    protected network: NetworkService;
+    protected translate: TranslateService;
+    protected environment: Environment;
+    private userEvents;
+    constructor(graphql: GraphqlService, accountService: AccountService, network: NetworkService, translate: TranslateService, environment: Environment);
+    fromObject(source: any): UserEvent;
+    add(entity: IUserEvent<any>): void;
+    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>;
+    listenChanges(filter: any, options?: UserEventWatchOptions & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<any[]>;
+    save(entity: any, options?: EntityServiceLoadOptions): Promise<any>;
+    saveAll(data: any[], opts?: any): Promise<any[]>;
+    watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<any>, options?: UserEventWatchOptions): Observable<LoadResult<any>>;
+}

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

@@ -1,29 +1,73 @@
 import { Moment } from 'moment';
 import { Entity, EntityAsObjectOptions, IEntity } from '../../core/services/model/entity.model';
-import { PredefinedColors } from '@ionic/core';
+import { EntityFilter, IEntityFilter } from '../../core/services/model/filter.model';
+import { FilterFn } from '../../shared/services/entity-service.class';
+import { AppColors, IconRef } from '../../shared/types';
 export declare const UserEventTypes: {
     DEBUG_DATA: string;
     INBOX_MESSAGE: string;
 };
-export declare class UserEvent extends Entity<UserEvent> {
+export declare type EventLevel = 'ERROR' | 'WARNING' | 'INFO' | 'DEBUG';
+export interface IUserEvent<E extends Entity<E>, U = string, L = EventLevel> extends IEntity<E> {
+    issuer: U;
+    recipient: U;
+    type: string;
+    level: L;
+    updateDate: Moment;
+    creationDate: Moment;
+    readDate?: Moment;
+    message?: string;
+    content?: string | any;
+    avatar?: string;
+    avatarIcon?: IconRef;
+    icon?: IconRef;
+    actions?: UserEventAction[];
+}
+export declare class UserEvent extends Entity<UserEvent> implements IUserEvent<UserEvent> {
     static fromObject: (source: any, opts?: any) => UserEvent;
-    eventType: string;
+    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;
+    actions?: UserEventAction[];
     constructor();
     asObject(opts?: EntityAsObjectOptions): any;
     fromObject(source: any): void;
 }
-export interface UserEventAction<T extends IEntity<T>> {
+export interface IUserEventFilter<E extends IUserEvent<E, U, L>, U = string, L = EventLevel> extends IEntityFilter<any, E> {
+    types: string[];
+    levels: L[];
+    issuers: U[];
+    recipients: U[];
+    startDate: Moment;
+    excludeRead: boolean;
+}
+export declare class UserEventFilter extends EntityFilter<UserEventFilter, UserEvent> implements IUserEventFilter<UserEvent> {
+    static fromObject: (source: any, opts?: any) => UserEventFilter;
+    types: string[];
+    levels: EventLevel[];
+    issuers: string[];
+    recipients: string[];
+    startDate: Moment;
+    excludeRead: boolean;
+    fromObject(source: any, opts?: any): void;
+    protected buildFilter(): FilterFn<UserEvent>[];
+}
+export interface UserEventAction {
     name: string | any;
     title?: string;
-    icon?: string;
-    matIcon?: string;
-    color?: PredefinedColors;
-    executeAction: (event: UserEvent, context?: T) => any | Promise<any>;
+    color?: AppColors;
+    iconRef?: IconRef;
+    executeAction: (event: IUserEvent<any>) => any | Promise<any>;
 }

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

@@ -0,0 +1,2 @@
+export declare class UserEventModule {
+}

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

@@ -1,9 +1,11 @@
+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 { Observable } from 'rxjs';
-import { UserEvent, UserEventAction } from './user-event.model';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { IUserEvent, IUserEventFilter, UserEvent, UserEventFilter } from './user-event.model';
 import { SortDirection } from '@angular/material/sort';
-import { EntitiesServiceWatchOptions, EntityServiceLoadOptions, FilterFn, IEntitiesService, LoadResult, Page } from '../../shared/services/entity-service.class';
+import { EntitiesServiceWatchOptions, EntityServiceLoadOptions, IEntitiesService, LoadResult, Page } from '../../shared/services/entity-service.class';
 import { ShowToastOptions } from '../../shared/toast/toasts';
 import { OverlayEventDetail } from '@ionic/core';
 import { ToastController } from '@ionic/angular';
@@ -11,64 +13,112 @@ import { TranslateService } from '@ngx-translate/core';
 import { NetworkService } from '../../core/services/network.service';
 import { BaseGraphqlService } from '../../core/services/base-graphql-service.class';
 import { Environment } from '../../../environments/environment.class';
-import { EntityFilter } from '../../core/services/model/filter.model';
-export declare class UserEventFilter extends EntityFilter<UserEventFilter, UserEvent> {
-    static fromObject: (source: any, opts?: any) => UserEventFilter;
-    issuer: string;
-    recipient: string;
-    fromObject(source: any, opts?: any): void;
-    protected buildFilter(): FilterFn<UserEvent>[];
-}
+import { Moment } from 'moment';
+import { IStartableService } from '../../shared/services/startable-service.class';
+export declare const UserEventServiceToken: InjectionToken<IUserEventService<any, any, UserEventWatchOptions>>;
 export declare interface UserEventWatchOptions extends EntitiesServiceWatchOptions {
     withContent?: boolean;
 }
-export interface UserEventActionDefinition extends UserEventAction<any> {
-    __typename: string;
+export interface IUserEventQueries {
+    loadAll: any;
+    loadAllWithContent: any;
+    count?: any;
+}
+export interface IUserEventMutations {
+    save: any;
+    markAsRead?: any;
+    deleteByIds: any;
+}
+export interface IUserEventSubscriptions {
+    listenChanges: any;
+    listenCountChanges?: any;
+}
+export interface IUserEventListener<E extends IUserEvent<E>> {
+    accept: (E: any) => boolean;
+    onReceived?: (E: any) => E | undefined;
+    onRead?: (E: any) => Promise<void> | void;
+}
+export interface IUserEventService<E extends IUserEvent<E>, F extends IUserEventFilter<E>, WO extends UserEventWatchOptions = UserEventWatchOptions> extends IEntitiesService<E, F, WO>, IStartableService {
+    userEventCount: Observable<number>;
+    add(entity: E): any;
+    count(filter: Partial<F>, options?: {
+        fetchPolicy?: FetchPolicy;
+    }): Promise<number>;
+    listenCountChanges(filter: Partial<F>, options?: WO & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<number>;
+    listenChanges(filter: Partial<F>, options?: WO & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<E[]>;
+    save(entity: E, options?: EntityServiceLoadOptions): Promise<E>;
+    delete(entity: E): Promise<any>;
+    markAsRead(entities: E[]): any;
+    registerListener(listener: IUserEventListener<E>): any;
+    resetCount(): any;
+}
+export declare abstract class AbstractUserEventService<E extends IUserEvent<E, any>, F extends IUserEventFilter<E, any>, WO extends UserEventWatchOptions = UserEventWatchOptions> extends BaseGraphqlService<E, F> implements IUserEventService<E, F, WO>, OnDestroy {
+    protected graphql: GraphqlService;
+    protected accountService: AccountService;
+    protected network: NetworkService;
+    protected translate: TranslateService;
+    protected queries: IUserEventQueries;
+    protected mutations: IUserEventMutations;
+    protected subscriptions: IUserEventSubscriptions;
+    protected environment: Environment;
+    protected count$: BehaviorSubject<number>;
+    protected resetCountDate: Moment;
+    protected listeners: IUserEventListener<E>[];
+    private _subscriptions;
+    private _listenSubscription;
+    get userEventCount(): Observable<number>;
+    protected constructor(graphql: GraphqlService, accountService: AccountService, network: NetworkService, translate: TranslateService, queries: IUserEventQueries, mutations: IUserEventMutations, subscriptions: IUserEventSubscriptions, environment: Environment);
+    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>, options?: WO): Observable<LoadResult<E>>;
+    add(entity: E): void;
+    count(filter: Partial<F>, options?: {
+        fetchPolicy?: FetchPolicy;
+    }): Promise<number>;
+    listenCountChanges(filter: Partial<F>, options?: WO & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<number>;
+    listenChanges(filter: Partial<F>, options?: WO & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): 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[]>;
+    markAsRead(entities: E[]): Promise<void>;
+    registerListener(listener: IUserEventListener<E>): void;
+    resetCount(): void;
+    protected onLogin(): Promise<void>;
+    protected onLogout(): void;
+    protected startListenCountChanges(): void;
+    protected stopListenCountChanges(): void;
+    protected processUserEvent(source: any, that?: AbstractUserEventService<E, F>): E;
+    protected defaultMarkAsRead(userEvents: E[]): Promise<void>;
+    protected defaultFilter(): F;
+    protected defaultRecipient(): any;
+    protected fillDefaultProperties(entity: E): void;
+    protected unreadEvents(events: E[]): number;
+    protected copyIdAndUpdateDate(source: E, target: E): void;
 }
-export declare class UserEventService extends BaseGraphqlService<UserEvent, UserEventFilter> implements IEntitiesService<UserEvent, UserEventFilter, UserEventWatchOptions> {
+export declare class UserEventService extends AbstractUserEventService<UserEvent, UserEventFilter> {
     protected graphql: GraphqlService;
     protected accountService: AccountService;
     protected network: NetworkService;
     protected translate: TranslateService;
     protected toastController: ToastController;
     protected environment: Environment;
-    private _userEventActions;
     constructor(graphql: GraphqlService, accountService: AccountService, network: NetworkService, translate: TranslateService, toastController: ToastController, environment: Environment);
-    /**
-     *
-     * @param offset
-     * @param size
-     * @param sortBy
-     * @param sortDirection
-     * @param filter
-     * @param options
-     * @deprecated use watchPage() instead
-     */
-    watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: UserEventFilter, options?: UserEventWatchOptions): Observable<LoadResult<UserEvent>>;
-    watchPage(page: Page, filter?: Partial<UserEventFilter>, options?: UserEventWatchOptions): Observable<LoadResult<UserEvent>>;
-    saveAll(data: UserEvent[], options?: any): Promise<UserEvent[]>;
-    /**
-     * Save a userEvent entity
-     *
-     * @param entity
-     */
-    save(entity: UserEvent, options?: EntityServiceLoadOptions): Promise<UserEvent>;
-    /**
-     * Save many trips
-     *
-     * @param entities
-     * @param opts
-     */
-    deleteAll(entities: UserEvent[], opts?: {
-        trash?: boolean;
-    }): Promise<any>;
-    /**
-     * Delete userEvent entities
-     */
-    delete(data: UserEvent): Promise<any>;
-    listenChanges(id: number, options?: any): Observable<UserEvent | undefined>;
-    registerAction(definition: UserEventActionDefinition): void;
-    getActionsByTypename(typename: string): UserEventAction<any>[];
     showToastErrorWithContext(opts: {
         error?: any;
         message?: string;
@@ -76,8 +126,8 @@ export declare class UserEventService extends BaseGraphqlService<UserEvent, User
     }): Promise<void>;
     sendDataForDebug(data: any): Promise<UserEvent>;
     asFilter(filter: Partial<UserEventFilter>): UserEventFilter;
+    fromObject(source: any): UserEvent;
     protected convertObjectToString(data: any): string;
     protected showToast<T = any>(opts: ShowToastOptions): Promise<OverlayEventDetail<T>>;
     protected fillDefaultProperties(entity: UserEvent): void;
-    protected copyIdAndUpdateDate(source: UserEvent, target: UserEvent): void;
 }