@sumaris-net/ngx-components 18.14.0 → 18.14.1

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

@@ -0,0 +1,36 @@
+import { ChangeDetectorRef, Injector, OnInit } from '@angular/core';
+import { UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import { Message } from './message.model';
+import { AppForm } from '../../core/form/form.class';
+import { Person } from '../../core/services/model/person.model';
+import { SuggestFn } from '../../shared/services/entity-service.class';
+import { PersonFilter } from '../../admin/services/filter/person.filter';
+import * as i0 from "@angular/core";
+export declare class MessageForm extends AppForm<Message> implements OnInit {
+    private formBuilder;
+    private readonly cd;
+    readonly mobile: boolean;
+    suggestFn: SuggestFn<Person, PersonFilter>;
+    subjectMinLength: number;
+    subjectMaxLength: number;
+    bodyMaxLength: number;
+    bodyAutoHeight: boolean;
+    canSelectType: boolean;
+    canRecipientFilter: boolean;
+    recipientFilterCount: number;
+    types: readonly {
+        id: string;
+        icon: string;
+        label: string;
+    }[];
+    constructor(injector: Injector, formBuilder: UntypedFormBuilder, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    isSamePerson(o1: Person, o2: Person): boolean;
+    protected updateFormGroup(formGroup: UntypedFormGroup, opts?: {
+        type?: string;
+        recipientRequired?: boolean;
+    }): void;
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageForm, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageForm, "app-message-form", never, { "suggestFn": { "alias": "suggestFn"; "required": false; }; "subjectMinLength": { "alias": "subjectMinLength"; "required": false; }; "subjectMaxLength": { "alias": "subjectMaxLength"; "required": false; }; "bodyMaxLength": { "alias": "bodyMaxLength"; "required": false; }; "bodyAutoHeight": { "alias": "bodyAutoHeight"; "required": false; }; "canSelectType": { "alias": "canSelectType"; "required": false; }; "canRecipientFilter": { "alias": "canRecipientFilter"; "required": false; }; "recipientFilterCount": { "alias": "recipientFilterCount"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,43 @@
+import { AfterViewInit, ChangeDetectorRef, OnInit } from '@angular/core';
+import { ModalController } from '@ionic/angular';
+import { Message } from './message.model';
+import { Person } from '../../core/services/model/person.model';
+import { SuggestFn } from '../../shared/services/entity-service.class';
+import { PersonFilter } from '../../admin/services/filter/person.filter';
+import { LocalSettingsService } from '../../core/services/local-settings.service';
+import { AccountService } from '../../core/services/account.service';
+import * as i0 from "@angular/core";
+export interface MessageModalOptions {
+    suggestFn: SuggestFn<Person, PersonFilter>;
+    data?: Message;
+    canSelectType?: boolean;
+    canRecipientFilter?: boolean;
+    recipientFilterCount?: number;
+}
+export declare class MessageModal implements OnInit, AfterViewInit, MessageModalOptions {
+    protected settings: LocalSettingsService;
+    protected viewCtrl: ModalController;
+    protected accountService: AccountService;
+    protected cd: ChangeDetectorRef;
+    readonly mobile: boolean;
+    suggestFn: SuggestFn<Person, PersonFilter>;
+    data: Message;
+    canSelectType: boolean;
+    canRecipientFilter: boolean;
+    recipientFilterCount: number;
+    private form;
+    constructor(settings: LocalSettingsService, viewCtrl: ModalController, accountService: AccountService, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    cancel(): void;
+    doSubmit(): Promise<any>;
+    protected markForCheck(): void;
+    protected markAsLoading(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected markAsLoaded(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageModal, "app-message-modal", never, { "suggestFn": { "alias": "suggestFn"; "required": false; }; "data": { "alias": "data"; "required": false; }; "canSelectType": { "alias": "canSelectType"; "required": false; }; "canRecipientFilter": { "alias": "canRecipientFilter"; "required": false; }; "recipientFilterCount": { "alias": "recipientFilterCount"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,33 @@
+import { Entity, EntityAsObjectOptions } from '../../core/services/model/entity.model';
+import { StoreObject } from '@apollo/client/core';
+import { EntityFilter } from '../../core/services/model/filter.model';
+import { Person } from '../../core/services/model/person.model';
+import { PersonFilter } from '../../admin/services/filter/person.filter';
+import { FilterFn } from '../../shared/types';
+export declare const MessageTypes: {
+    INBOX_MESSAGE: string;
+    EMAIL: string;
+    FEED: string;
+};
+export declare const MessageTypeList: readonly {
+    id: string;
+    icon: string;
+    label: string;
+}[];
+export declare class Message extends Entity<Message> {
+    static fromObject: (source: any, opts?: any) => Message;
+    type: string;
+    issuer: Person;
+    recipients: Person[];
+    recipientFilter: PersonFilter;
+    subject: string;
+    body: string;
+    constructor();
+    fromObject(source: any, opts?: any): void;
+    asObject(opts?: EntityAsObjectOptions): StoreObject;
+}
+export declare class MessageFilter extends EntityFilter<MessageFilter, Message> {
+    static fromObject: (source: any, opts?: any) => MessageFilter;
+    fromObject(source: any, opts?: any): void;
+    protected buildFilter(): FilterFn<Message>[];
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./message.modal";
+import * as i2 from "./message.form";
+import * as i3 from "@angular/common";
+import * as i4 from "../../core/core.module";
+import * as i5 from "../../shared/shared.module";
+import * as i6 from "@angular/material/chips";
+export declare class MessageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MessageModule, [typeof i1.MessageModal, typeof i2.MessageForm], [typeof i3.CommonModule, typeof i4.CoreModule, typeof i5.SharedModule, typeof i6.MatChipsModule], [typeof i1.MessageModal]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MessageModule>;
+}

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

@@ -0,0 +1,32 @@
+import { GraphqlService } from '../../core/graphql/graphql.service';
+import { ModalController, 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 { MessageModalOptions } from './message.modal';
+import * as i0 from "@angular/core";
+export declare class MessageService extends BaseGraphqlService<Message, MessageFilter> {
+    protected graphql: GraphqlService;
+    protected translate: TranslateService;
+    protected modalCtrl: ModalController;
+    protected toastController: ToastController;
+    protected environment: Environment;
+    constructor(graphql: GraphqlService, translate: TranslateService, modalCtrl: ModalController, toastController: ToastController, environment: Environment);
+    /**
+     * Send a message to recipient(s)
+     *
+     * @param entity
+     * @param opts
+     */
+    send(entity: Message, opts?: {
+        showToast?: boolean;
+    }): Promise<boolean>;
+    openComposeModal(options: MessageModalOptions & {
+        showToast?: boolean;
+    }): Promise<any>;
+    protected showToast(opts: ShowToastOptions): Promise<import("@ionic/core").OverlayEventDetail<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, [null, 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,46 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ModalController, PopoverController } from '@ionic/angular';
+import { IUserEventService } from '../user-event.service';
+import { UserEventNotificationListOptions } from './user-event-notification.list';
+import { IUserEvent, IUserEventAction, IUserEventFilter } from '../user-event.model';
+import { AccountService } from '../../../core/services/account.service';
+import { AppColors } from '../../../shared/types';
+import { LocalSettingsService } from '../../../core/services/local-settings.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;
+    protected modalController: ModalController;
+    protected settings: LocalSettingsService;
+    private cd;
+    private _logPrefix;
+    private _readEvent;
+    private _readEvents;
+    protected visible: boolean;
+    protected readonly count$: Observable<number>;
+    titleI18n: string;
+    disabled: boolean;
+    filter: any;
+    autoHide: boolean;
+    headerActions: IUserEventAction[];
+    footerActions: IUserEventAction[];
+    style: 'mat-button' | 'ion-button';
+    color: AppColors;
+    unreadColor: AppColors;
+    fill: 'clear' | 'outline' | 'solid';
+    mobile: boolean;
+    listStyle: 'popover' | 'modal';
+    debug: boolean;
+    onShowList: EventEmitter<Event>;
+    constructor(userEventService: IUserEventService<IUserEvent<any>, IUserEventFilter<any>>, accountService: AccountService, popoverController: PopoverController, modalController: ModalController, settings: LocalSettingsService, cd: ChangeDetectorRef);
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): void;
+    showList(event?: Event, options?: UserEventNotificationListOptions & {
+        style: 'modal' | 'popover';
+    }): Promise<void>;
+    protected setVisible(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventNotificationIcon, [{ optional: true; }, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventNotificationIcon, "app-user-event-notification-icon", never, { "titleI18n": { "alias": "titleI18n"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "autoHide": { "alias": "autoHide"; "required": false; }; "headerActions": { "alias": "headerActions"; "required": false; }; "footerActions": { "alias": "footerActions"; "required": false; }; "style": { "alias": "style"; "required": false; }; "color": { "alias": "color"; "required": false; }; "unreadColor": { "alias": "unreadColor"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "listStyle": { "alias": "listStyle"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; }, { "onShowList": "showList"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,75 @@
+import { ChangeDetectorRef, EventEmitter, InjectionToken, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { IUserEvent, IUserEventAction, IUserEventFilter } from '../user-event.model';
+import { BehaviorSubject, Observable, 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;
+    protected fetchingMore: boolean;
+    protected $items: BehaviorSubject<E[]>;
+    protected _subscriptions: Subscription;
+    protected _fetchMoreFn: FetchMoreFn<LoadResult<E>>;
+    protected _fetchMoreSubscription: Subscription;
+    protected _$pageSize: BehaviorSubject<number>;
+    protected _panelElement: HTMLElement;
+    titleI18n: string;
+    sortBy: string;
+    sortDirection: SortDirection;
+    filter: Partial<F>;
+    enableInfiniteScroll: boolean;
+    infiniteScrollThreshold: string;
+    headerActions: IUserEventAction[];
+    footerActions: IUserEventAction[];
+    showHeader: boolean;
+    showFooter: boolean;
+    mobile: boolean;
+    debug: boolean;
+    set pageSize(value: number);
+    $itemCount: BehaviorSubject<number>;
+    get pageSize(): number;
+    get hasItem$(): Observable<boolean>;
+    get itemCount$(): Observable<number>;
+    readEvent: EventEmitter<E>;
+    readEvents: EventEmitter<E[]>;
+    dismiss: EventEmitter<Event>;
+    ionContent: IonContent;
+    ionItems: QueryList<IonItem>;
+    get canFetchMore(): boolean;
+    constructor(cd: ChangeDetectorRef, popoverController: PopoverController, settings: LocalSettingsService, userEventService: IUserEventService<E, IUserEventFilter<any>>, infiniteScrollThresholdFromToken: string);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    click(event: Event, userEvent: E): Promise<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>;
+    close(): void;
+    fetchMore(event?: CustomEvent & {
+        target?: EventTarget & {
+            complete?: () => void;
+        };
+    }): Promise<void>;
+    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, { "titleI18n": { "alias": "titleI18n"; "required": false; }; "sortBy": { "alias": "sortBy"; "required": false; }; "sortDirection": { "alias": "sortDirection"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "enableInfiniteScroll": { "alias": "enableInfiniteScroll"; "required": false; }; "infiniteScrollThreshold": { "alias": "infiniteScrollThreshold"; "required": false; }; "headerActions": { "alias": "headerActions"; "required": false; }; "footerActions": { "alias": "footerActions"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; }, { "readEvent": "readEvent"; "readEvents": "readEvents"; "dismiss": "dismiss"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,36 @@
+import { ChangeDetectorRef, OnInit } from '@angular/core';
+import { IUserEvent, IUserEventAction, IUserEventFilter } from '../user-event.model';
+import { ModalController } from '@ionic/angular';
+import { SortDirection } from '@angular/material/sort';
+import { UserEventNotificationList, UserEventNotificationListOptions } from './user-event-notification.list';
+import { IUserEventService } from '../user-event.service';
+import { LocalSettingsService } from '../../../core/services/local-settings.service';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface UserEventNotificationModalOptions<E extends IUserEvent<any> = IUserEvent<any>, F extends IUserEventFilter<any> = IUserEventFilter<any>> extends UserEventNotificationListOptions<E, F> {
+}
+export declare class UserEventNotificationModal<E extends IUserEvent<any> = IUserEvent<any>, F extends IUserEventFilter<any> = IUserEventFilter<any>> implements UserEventNotificationModalOptions<E, F>, OnInit {
+    protected cd: ChangeDetectorRef;
+    protected settings: LocalSettingsService;
+    protected modalController: ModalController;
+    userEventService: IUserEventService<E, IUserEventFilter<any>>;
+    protected itemCount$: Observable<number>;
+    titleI18n: string;
+    sortBy: string;
+    sortDirection: SortDirection;
+    filter: Partial<F>;
+    enableInfiniteScroll: boolean;
+    infiniteScrollThreshold: string;
+    headerActions: IUserEventAction[];
+    footerActions: IUserEventAction[];
+    pageSize: number;
+    mobile: boolean;
+    debug: boolean;
+    list: UserEventNotificationList<E, F>;
+    constructor(cd: ChangeDetectorRef, settings: LocalSettingsService, modalController: ModalController, userEventService: IUserEventService<E, IUserEventFilter<any>>);
+    ngOnInit(): void;
+    protected close(): void;
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventNotificationModal<any, any>, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventNotificationModal<any, any>, "app-user-event-notification-modal", never, { "titleI18n": { "alias": "titleI18n"; "required": false; }; "sortBy": { "alias": "sortBy"; "required": false; }; "sortDirection": { "alias": "sortDirection"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "enableInfiniteScroll": { "alias": "enableInfiniteScroll"; "required": false; }; "infiniteScrollThreshold": { "alias": "infiniteScrollThreshold"; "required": false; }; "headerActions": { "alias": "headerActions"; "required": false; }; "footerActions": { "alias": "footerActions"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,44 @@
+import { OnDestroy } from '@angular/core';
+import { IUserEventAction } from '../user-event.model';
+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 { LocalSettingsService } from '../../../core/services/local-settings.service';
+import * as i0 from "@angular/core";
+export declare class UserEventTestingPage implements OnDestroy {
+    protected userEventService: UserEventTestService;
+    protected router: Router;
+    protected alertController: AlertController;
+    protected settings: LocalSettingsService;
+    protected translateService: TranslateService;
+    private _timerSubscription;
+    protected mobile: boolean;
+    protected popoverHeaderActions: IUserEventAction[];
+    protected modalHeaderActions: IUserEventAction[];
+    protected footerActions: IUserEventAction[];
+    notification: UserEventNotificationIcon;
+    get timerStarted(): boolean;
+    constructor(userEventService: UserEventTestService, router: Router, alertController: AlertController, settings: LocalSettingsService, 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>;
+    protected showNotificationModal(): void;
+    protected openSettings(): void;
+    protected replaceLastEvent(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventTestingPage, "job-progression-testing", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,42 @@
+import { Entity, EntityAsObjectOptions } from '../../../core/services/model/entity.model';
+import { Moment } from 'moment';
+import { FilterFn, IconRef } from '../../../shared/types';
+import { EventLevel, IUserEvent, IUserEventAction, IUserEventFilter } from '../user-event.model';
+import { EntityFilter } from '../../../core/services/model/filter.model';
+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;
+    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,42 @@
+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 { LoadResult } from '../../../shared/services/entity-service.class';
+import { SortDirection } from '@angular/material/sort';
+import { UserEventTest, UserEventTestFilter } from './user-event.testing.model';
+import { EntitySaveOptions } from '../../../core/services/base-entity-service.class';
+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>;
+    replaceLast(entity: UserEventTest): Promise<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>;
+    listenAllChanges(filter: any, options?: UserEventLoadOptions<UserEventTest> & {
+        interval?: number;
+    }): Observable<any[]>;
+    save(entity: any, options?: EntitySaveOptions<UserEventTest>): 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<UserEventTest>): Observable<LoadResult<any>>;
+    loadAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<any>, opts?: UserEventLoadOptions<UserEventTest>): 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,44 @@
+import { Moment } from 'moment';
+import { IEntity } from '../../core/services/model/entity.model';
+import { IEntityFilter } from '../../core/services/model/filter.model';
+import { AppColors, IconRef } from '../../shared/types';
+export type EventLevel = 'ERROR' | 'WARNING' | 'INFO' | 'DEBUG';
+export interface IUserEvent<E extends IEntity<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 type UserEventAction = IUserEventAction;

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

@@ -0,0 +1,14 @@
+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 "./notification/user-event-notification.modal";
+import * as i4 from "@angular/common";
+import * as i5 from "../../shared/shared.module";
+import * as i6 from "../../core/icon/icon.module";
+import * as i7 from "../../shared/rx-state/rx-state.module";
+import * as i8 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.UserEventNotificationModal], [typeof i4.CommonModule, typeof i5.SharedModule, typeof i6.AppIconModule, typeof i7.RxStateModule, typeof i8.NgxJdenticonModule], [typeof i1.UserEventNotificationIcon, typeof i3.UserEventNotificationModal]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UserEventModule>;
+}