@sumaris-net/ngx-components 18.14.0 → 18.14.1

package/src/app/shared/validator/validators.d.ts

@@ -0,0 +1,139 @@
+import { AbstractControl, AsyncValidatorFn, UntypedFormControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { Moment, unitOfTime } from 'moment';
+import { Observable, Subscription } from 'rxjs';
+export declare class SharedValidators {
+    private static _DOUBLE_REGEXP_CACHE;
+    private static getDoubleRegexp;
+    static equals(otherControlName: string): ValidatorFn;
+    static readonly I18N_ERROR_KEYS: {
+        required: string;
+        min: string;
+        max: string;
+        minlength: string;
+        maxlength: string;
+        pubkey: string;
+        validDate: string;
+        dateIsAfter: string;
+        dateIsBefore: string;
+        dateRange: string;
+        dateMinDuration: string;
+        dateMaxDuration: string;
+        maxDecimals: string;
+        decimal: string;
+        integer: string;
+        precision: string;
+        email: string;
+        latitude: string;
+        longitude: string;
+        pattern: string;
+        unique: string;
+        entity: string;
+        invalid: string;
+        inconsistent: string;
+        equals: string;
+    };
+    static latitude(control: UntypedFormControl): ValidationErrors | null;
+    static longitude(control: UntypedFormControl): ValidationErrors | null;
+    static object(control: UntypedFormControl): ValidationErrors | null;
+    static entity(control: UntypedFormControl): ValidationErrors | null;
+    static entities(control: UntypedFormControl): ValidationErrors | null;
+    static empty(control: UntypedFormControl): ValidationErrors | null;
+    static pubkey(control: UntypedFormControl): ValidationErrors | null;
+    static integer(control: UntypedFormControl): ValidationErrors | null;
+    static decimal(opts?: {
+        maxDecimals?: number;
+    }): ValidatorFn;
+    /**
+     * Check precision. e.g. if precision=0.5 then value=0.6 is invalid, but 1.5 is valid
+     *
+     * @param precision
+     */
+    static precision(precision: number): ValidatorFn;
+    static validDateTime(requiredTime?: boolean): ValidatorFn;
+    static validDate: ValidatorFn;
+    static validDateAllowNoTime: ValidatorFn;
+    static dateIsAfter(previousValue: Moment, errorParam: string, granularity?: unitOfTime.StartOf): ValidatorFn;
+    static dateIsBefore(maxValue: Moment, errorParam: string, granularity?: unitOfTime.StartOf): ValidatorFn;
+    static dateRangeEnd(startDateFieldName: string, msg?: string): ValidatorFn;
+    static dateRangeStart(endDateFieldName: string, msg?: string): ValidatorFn;
+    static copyParentErrors(errorNames?: string[]): ValidatorFn;
+    static clearError(control: AbstractControl, errorCode: string): void;
+}
+export declare class SharedFormGroupValidators {
+    static dateRange(startDateField: string, endDateField: string, opts?: {
+        msg?: string;
+        fieldOnly?: boolean;
+        skipIfNoTime?: boolean;
+    } | string): ValidatorFn;
+    static dateMaxDuration(startDateField: string, endDateField: string, maxDuration: number, durationUnit?: moment.unitOfTime.Diff, opts?: {
+        skipIfNoTime?: boolean;
+    }): ValidatorFn;
+    static dateMinDuration(startDateField: string, endDateField: string, minDuration: number, durationUnit?: moment.unitOfTime.Diff): ValidatorFn;
+    static requiredIf(fieldName: string, anotherFieldToCheck: string | AbstractControl, opts?: {
+        fieldOnly?: boolean;
+        isEmpty?: (control: AbstractControl) => boolean;
+        predicate?: (control: AbstractControl) => boolean;
+    }): ValidatorFn;
+    static requiredIfTrue(fieldName: string, anotherFieldToCheck: string | AbstractControl, opts?: {
+        fieldOnly?: boolean;
+        isEmpty?: (control: AbstractControl) => boolean;
+    }): ValidatorFn;
+    static requiredIfEmpty(fieldName: string, anotherFieldToCheck: string, opts?: {
+        fieldOnly?: boolean;
+        isEmpty?: (control: AbstractControl) => boolean;
+    }): ValidatorFn;
+    static propagateIfDirty(fieldName: string, fieldNameToPropagate: string, valueToPropagate: any): ValidatorFn;
+    /**
+     * Same as compose, but keep only the first errors (instead of the union)
+     *
+     * @param validators
+     */
+    first(validators: (ValidatorFn | null | undefined)[]): ValidationErrors | null;
+}
+export declare class SharedFormArrayValidators {
+    /**
+     * Validate uniqueness of an entity in a FormArray
+     *
+     * @param controlName the name of the control in FormArray
+     */
+    static uniqueEntity(controlName: string): ValidatorFn;
+    static requiredArrayMinLength(minLength?: number): ValidatorFn;
+    static arrayMaxLength(maxLength?: number): ValidatorFn;
+    /**
+     * Validate the sum of control values in an FormArray not overflow the max value
+     *
+     * @param controlName the name of the control in FormArray
+     * @param max the maximum value
+     */
+    static validSumMaxValue(controlName: string, max: number): ValidatorFn;
+}
+export declare type ObservableValidatorFn = (control: AbstractControl) => Observable<ValidationErrors | null>;
+export declare type PromiseValidatorFn = (control: AbstractControl) => Promise<ValidationErrors | null>;
+export declare class SharedAsyncValidators {
+    private static DEBOUNCE_TIME_VALIDATOR_ID;
+    /**
+     * Add a debounce time to a validator.
+     *
+     * @param form
+     * @param validatorFn
+     * @param opts Use opts.stopSubject to stop the validator, before end
+     */
+    static debounceTime(validatorFn: ValidatorFn | AsyncValidatorFn, opts?: {
+        dispose?: Observable<any>;
+        debounceTime?: number;
+        markForCheck?: () => void;
+        debug?: boolean;
+    }): ObservableValidatorFn;
+    /**
+     * Add an async validator, that can be disposed by the returned subscription
+     *
+     * @param form
+     * @param validatorFn the validator or job to execute
+     * @param opts
+     */
+    static registerAsyncValidator(form: AbstractControl, validatorFn: ValidatorFn | AsyncValidatorFn, opts?: {
+        debounceTime?: number;
+        markForCheck?: () => void;
+        debug?: boolean;
+    }): Subscription;
+}

package/src/app/shared/version/versions.d.ts

@@ -0,0 +1,26 @@
+export declare class VersionUtils {
+    static compare: typeof compareVersionNumbers;
+    static isCompatible: typeof isVersionCompatible;
+    static isSame: typeof isSameVersion;
+}
+/**
+ * Compare two software version numbers (e.g. 1.7.1)
+ * Returns:
+ *
+ *  0 if they're identical
+ *  negative if v1 < v2
+ *  positive if v1 > v2
+ *  Nan if they in the wrong format
+ *
+ *  E.g.:
+ *
+ *  assert(version_number_compare("1.7.1", "1.6.10") > 0);
+ *  assert(version_number_compare("1.7.1", "1.7.10") < 0);
+ *
+ *  "Unit tests": http://jsfiddle.net/ripper234/Xv9WL/28/
+ *
+ *  Taken from http://stackoverflow.com/a/6832721/11236
+ */
+export declare function compareVersionNumbers(v1: any, v2: any): number;
+export declare function isVersionCompatible(minVersion: any, actualVersion: any): boolean;
+export declare function isSameVersion(v1: any, v2: any): boolean;

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

@@ -0,0 +1,4 @@
+import { FormFieldDefinition } from '../../shared/form/field.model';
+export declare const SOCIAL_CONFIG_OPTIONS: Readonly<{
+    ENABLE_NOTIFICATION_ICONS: FormFieldDefinition<string, import("../../shared/form/field.model").FormFieldType, any>;
+}>;

package/src/app/social/feed/discourse/discourse-feed.service.d.ts

@@ -0,0 +1,55 @@
+import DiscourseAPI from 'discourse2';
+import { JsonFeed } from '../feed.model';
+import { Observable } from 'rxjs';
+import { StartableService } from '../../../shared/services/startable-service.class';
+import { LocalSettingsService } from '../../../core/services/local-settings.service';
+import { Environment } from '../../../../environments/environment.class';
+import { LoadResult } from '../../../shared/services/entity-service.class';
+import { IFeedService } from '../feed.service';
+import * as i0 from "@angular/core";
+export interface DiscourseFeedServiceState {
+    locale: string;
+    feedUrls?: string[];
+}
+export declare class DiscourseFeedService extends StartableService<DiscourseFeedServiceState> implements IFeedService {
+    private settings;
+    protected environment: Environment;
+    private discourseApis;
+    private _logPrefix;
+    private _state;
+    private network;
+    locale$: Observable<string>;
+    feedUrls$: Observable<string[]>;
+    locale: string;
+    feedUrls: string[];
+    constructor(settings: LocalSettingsService, environment: Environment);
+    protected ngOnStart(): Promise<DiscourseFeedServiceState>;
+    watchAll(opts?: {
+        maxAgeInMonths?: number;
+        maxContentLength?: number;
+    }): Observable<LoadResult<JsonFeed>>;
+    getHomeUrl(feed?: JsonFeed): string;
+    getTagUrl(feed: JsonFeed, tag: string): string;
+    load(url: string, opts?: {
+        locale?: string;
+        maxAgeInMonths?: number;
+        maxContentLength?: number;
+        closeApis?: boolean;
+        depth?: number;
+    }): Promise<JsonFeed>;
+    loadAll(urls?: string[], opts?: {
+        locale?: string;
+        maxAgeInMonths?: number;
+        maxContentLength?: number;
+        closeApis?: boolean;
+        depth?: number;
+    }): Promise<LoadResult<JsonFeed>>;
+    protected getOrCreateDiscourseApi(url: string): DiscourseAPI;
+    protected closeApis(): void;
+    protected resolveFeedItems(json: JsonFeed, opts?: {
+        maxContentLength?: number;
+        depth?: number;
+    }): Promise<JsonFeed>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiscourseFeedService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DiscourseFeedService>;
+}

package/src/app/social/feed/discourse/discourse.model.d.ts

@@ -0,0 +1,7 @@
+import type { operations } from 'discourse2/esm/schema';
+export type DiscourseCategory = operations['listCategoryTopics']['responses']['200']['content']['application/json'];
+export type DiscourseCategoryTopic = DiscourseCategory['topic_list']['topics'][0];
+export type DiscourseTopic = operations['getTopic']['responses']['200']['content']['application/json'];
+export type DiscoursePost = operations['getTopic']['responses']['200']['content']['application/json']['post_stream']['posts'][0] & {
+    post_url?: string;
+};

package/src/app/social/feed/discourse/discourse.utils.d.ts

@@ -0,0 +1,44 @@
+import DiscourseAPI from 'discourse2';
+import { JsonFeed, JsonFeedItem, JsonFeedUtils } from '../feed.model';
+import { DiscourseCategory, DiscoursePost, DiscourseTopic } from './discourse.model';
+export declare abstract class DiscourseUtils {
+    static _logPrefix: string;
+    static removeJsonExtension: typeof JsonFeedUtils.removeJsonExtension;
+    static isDiscourseObject(json: any): json is DiscourseTopic | DiscourseCategory;
+    static isDiscourseTopic(json: any | Partial<DiscourseTopic>): json is DiscourseTopic;
+    static isDiscourseCategory(json: any | Partial<DiscourseCategory>): json is DiscourseCategory;
+    static getDiscourseBaseUrl(url: string): string;
+    static isDiscourseCategoryUrl(url: string): RegExpMatchArray;
+    static extractCategoryIdFromUrl(url: string): number;
+    static extractCategorySlugFromUrl(url: string): string;
+    static extractTopicIdFromUrl(url: string): number;
+    static getLanguageFromTitle(title: string): string;
+    static getFeedsByUrl(url: string, opts?: {
+        api?: DiscourseAPI;
+        locale?: string;
+        maxAgeInMonths?: number;
+        maxContentLength?: number;
+    }): Promise<JsonFeed[]>;
+    static getFeedsByCategoryUrl(url: string, opts?: {
+        api?: DiscourseAPI;
+        locale?: string;
+        maxAgeInMonths?: number;
+        maxContentLength?: number;
+    }): Promise<JsonFeed[]>;
+    static getFeedByTopicUrl(url: string, opts?: {
+        locale?: string;
+        maxAgeInMonths?: number;
+        maxContentLength?: number;
+        api?: DiscourseAPI;
+    }): Promise<JsonFeed>;
+    static filterRecentPosts(posts: DiscoursePost[], opts?: {
+        maxAgeInMonths?: number;
+    }): DiscoursePost[];
+    static toFeed(posts: DiscoursePost[], topic: DiscourseTopic, url: string, opts?: {
+        maxContentLength?: number;
+    }): JsonFeed;
+    static toFeedItem(post: DiscoursePost, topic: DiscourseTopic, url: string, opts?: {
+        maxContentLength?: number;
+    }): JsonFeedItem;
+    static cleanTitle(title: string): string;
+}

package/src/app/social/feed/feed.component.d.ts

@@ -0,0 +1,39 @@
+import { RxState } from '@rx-angular/state';
+import { TranslateService } from '@ngx-translate/core';
+import { Router } from '@angular/router';
+import { JsonFeed } from './feed.model';
+import { Observable } from 'rxjs';
+import { PlatformService } from '../../core/services/platform.service';
+import { Environment } from '../../../environments/environment.class';
+import { AppColors } from '../../shared/types';
+import { IFeedService } from './feed.service';
+import * as i0 from "@angular/core";
+export interface FeedState {
+    maxAgeInMonths: number;
+    maxContentLength: number;
+    feeds: JsonFeed[];
+    hasFeeds: boolean;
+}
+export declare class FeedsComponent<T extends JsonFeed = JsonFeed> {
+    protected environment: Environment;
+    feedService: IFeedService<T>;
+    protected _debug: boolean;
+    protected _state: RxState<FeedState>;
+    protected translate: TranslateService;
+    protected platform: PlatformService;
+    protected router: Router;
+    protected version: string;
+    feeds$: Observable<T[]>;
+    hasFeeds$: Observable<boolean>;
+    feeds: T[];
+    hasFeeds: boolean;
+    showHeader: boolean;
+    headerTextColor: AppColors;
+    constructor(environment: Environment, feedService: IFeedService<T>);
+    openFeedHome(feed?: T): Promise<void>;
+    openUrl(url: string): Promise<void>;
+    openTag(feed: T, tag: string): Promise<void>;
+    getTags(feedOrItem?: T | T['items'][0]): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeedsComponent<any>, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FeedsComponent<any>, "app-feeds", never, { "feeds": { "alias": "feeds"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "headerTextColor": { "alias": "headerTextColor"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/social/feed/feed.directive.d.ts

@@ -0,0 +1,32 @@
+import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { UrlTree } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class FeedDirective implements AfterViewInit, OnDestroy {
+    private element;
+    private _subscription;
+    private platform;
+    private locationStrategy;
+    private navController;
+    private router;
+    private route;
+    private _feedUrl;
+    private _baseUrl;
+    set feedUrl(value: string);
+    get feedUrl(): string;
+    constructor(element: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected listenClickEvents(nativeElement: HTMLElement): Subscription;
+    protected click(event: Event, containerElement: HTMLElement): Promise<boolean>;
+    scrollToAnchor(containerElement: HTMLElement, anchorId: string): void;
+    /**
+     * Transform a relative URL to its absolute representation according to current router state.
+     * @param url Relative URL path.
+     * @return Absolute URL based on the current route.
+     */
+    normalizeUrl(url: string): string;
+    getUrlTree(url: string): UrlTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FeedDirective, "feed,[feed]", never, { "feedUrl": { "alias": "feed"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,69 @@
+export interface JsonFeed {
+    version: string;
+    title: string;
+    home_page_url?: string;
+    feed_url?: string;
+    description?: string;
+    user_comment?: string;
+    next_url?: string;
+    icon?: string;
+    favicon?: string;
+    authors: JsonFeedAuthor[];
+    language?: string;
+    expired?: boolean;
+    items: JsonFeedItem[];
+    hubs?: {
+        type?: string;
+        url: string;
+    }[];
+    tag_template?: string;
+    /**
+     * @deprecated since version 1.1
+     */
+    author: JsonFeedAuthor;
+}
+export interface JsonFeedItem {
+    id: string;
+    url?: string;
+    external_url?: string;
+    title?: string;
+    content_html?: string;
+    content_text?: string;
+    summary?: string;
+    banner_image?: string;
+    date_published?: string;
+    date_modified?: string;
+    authors: JsonFeedAuthor[];
+    tags: string[];
+    language: string;
+    /**
+     * @deprecated since version 1.1
+     */
+    author: JsonFeedAuthor;
+    truncated: boolean;
+}
+export interface JsonFeedAuthor {
+    name?: string;
+    url?: string;
+    avatar?: string;
+}
+export declare class JsonFeedUtils {
+    static DEFAULT_MAX_POST_AGE_IN_MONTHS: number;
+    static VERSION_1: string;
+    static VERSION_1_1: string;
+    static ACCEPTED_VERSIONS: string[];
+    static removeJsonExtension(url: string): string;
+    static isJsonFeed(json: any): json is JsonFeed;
+    static isJsonFeedItem(json: any): json is JsonFeedItem;
+    static truncateFeedItemsHtml(feed: JsonFeed, opts?: {
+        maxContentLength?: number;
+    }): JsonFeed;
+    static truncateHtml(html: string, opts?: {
+        maxContentLength?: number;
+    }): string;
+    /**
+     * Migrate from old version 1.0 to 1.1
+     * @param feed
+     */
+    static migrateFeed(feed: JsonFeed): JsonFeed;
+}

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

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./feed.component";
+import * as i2 from "./feed.directive";
+import * as i3 from "../../shared/shared.module";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "@angular/common";
+export declare class FeedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FeedModule, [typeof i1.FeedsComponent, typeof i2.FeedDirective], [typeof i3.SharedModule, typeof i4.TranslateModule, typeof i5.NgOptimizedImage], [typeof i4.TranslateModule, typeof i1.FeedsComponent, typeof i2.FeedDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FeedModule>;
+}

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

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { LoadResult } from '../../shared/services/entity-service.class';
+import { JsonFeed } from './feed.model';
+import { InjectionToken } from '@angular/core';
+export declare const APP_FEED_SERVICE: InjectionToken<IFeedService<any>>;
+export interface IFeedService<T extends JsonFeed = JsonFeed> {
+    watchAll(opts?: {
+        maxAgeInMonths?: number;
+        maxContentLength?: number;
+    }): Observable<LoadResult<T>>;
+    getHomeUrl(feed?: T): string;
+    getTagUrl(feed: T, tag: string): string;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./progression/job-progression.icon";
+import * as i2 from "./progression/job-progression.list";
+import * as i3 from "./progression/job-progression.component";
+import * as i4 from "@angular/common";
+import * as i5 from "../../shared/shared.module";
+import * as i6 from "@ngx-translate/core";
+export declare class JobModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<JobModule, [typeof i1.JobProgressionIcon, typeof i2.JobProgressionList, typeof i3.JobProgressionComponent], [typeof i4.CommonModule, typeof i5.SharedModule, typeof i6.TranslateModule], [typeof i1.JobProgressionIcon, typeof i2.JobProgressionList, typeof i3.JobProgressionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<JobModule>;
+}

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

@@ -0,0 +1,23 @@
+import { OnInit } from '@angular/core';
+import { JobProgression } from './job-progression.model';
+import { RxState } from '@rx-angular/state';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface JobProgressionState {
+    name: string;
+    message: string;
+    value: number;
+    type: 'determinate' | 'indeterminate';
+}
+export declare class JobProgressionComponent extends RxState<JobProgressionState> implements OnInit {
+    showName: boolean;
+    jobProgression$: Observable<JobProgression>;
+    name$: Observable<string>;
+    message$: Observable<string>;
+    value$: Observable<number>;
+    type$: Observable<"determinate" | "indeterminate">;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JobProgressionComponent, "app-job-progression-component", never, { "showName": { "alias": "showName"; "required": false; }; "jobProgression$": { "alias": "jobProgression$"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,62 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { ThemePalette } from '@angular/material/core';
+import { IJobProgressionService } from './job-progression.service';
+import { JobProgression } from './job-progression.model';
+import { BehaviorSubject } from 'rxjs';
+import { PopoverController } from '@ionic/angular';
+import { IUserEventAction } from '../../user-event/user-event.model';
+import { ProgressSpinnerMode } from '@angular/material/progress-spinner';
+import { RxState } from '@rx-angular/state';
+import * as i0 from "@angular/core";
+export interface JobProgressionOptions {
+    autoHide: boolean;
+    autoHideDelay: number;
+    autoRemove: boolean;
+    autoRemoveDelay: number;
+}
+export interface JobProgressionIconState {
+    visible: boolean;
+    mode: ProgressSpinnerMode;
+    value: number;
+    jobProgressions: BehaviorSubject<JobProgression>[];
+    jobCount: number;
+}
+export declare class JobProgressionIcon extends RxState<JobProgressionIconState> implements OnInit, OnDestroy {
+    protected jobProgressionService: IJobProgressionService;
+    protected popoverController: PopoverController;
+    protected cd: ChangeDetectorRef;
+    private _listPopover;
+    private _subscriptions;
+    private _subscriptionsById;
+    private _logPrefix;
+    protected disabled: boolean;
+    protected color: ThemePalette;
+    protected jobProgressions$: import("rxjs").Observable<BehaviorSubject<JobProgression>[]>;
+    protected jobCount$: import("rxjs").Observable<number>;
+    protected visible$: import("rxjs").Observable<boolean>;
+    protected mode$: import("rxjs").Observable<ProgressSpinnerMode>;
+    protected value$: import("rxjs").Observable<number>;
+    protected autoHideDelay: number;
+    protected autoRemove: boolean;
+    protected autoRemoveDelay: number;
+    debug: boolean;
+    titleI18n: string;
+    options: JobProgressionOptions;
+    autoHide: boolean;
+    headerActions: IUserEventAction[];
+    jobFinished: EventEmitter<number>;
+    constructor(jobProgressionService: IJobProgressionService, popoverController: PopoverController, cd: ChangeDetectorRef);
+    get jobProgressions(): BehaviorSubject<JobProgression>[];
+    ngOnInit(): void;
+    protected startListenJob(id: number, job?: JobProgression): BehaviorSubject<JobProgression>;
+    protected stopListenJob(id: number, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected getProgression(id: number): BehaviorSubject<JobProgression> | undefined;
+    protected updateValue(): void;
+    showList(event: Event): Promise<void>;
+    protected markForCheck(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionIcon, [{ optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JobProgressionIcon, "app-job-progression-icon", never, { "debug": { "alias": "debug"; "required": false; }; "titleI18n": { "alias": "titleI18n"; "required": false; }; "options": { "alias": "options"; "required": false; }; "autoHide": { "alias": "autoHide"; "required": false; }; "headerActions": { "alias": "headerActions"; "required": false; }; }, { "jobFinished": "jobFinished"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,19 @@
+import { JobProgression } from './job-progression.model';
+import { IUserEventAction } from '../../user-event/user-event.model';
+import { PopoverController } from '@ionic/angular';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface JobProgressionListOptions {
+    titleI18n?: string;
+    headerActions?: IUserEventAction[];
+}
+export declare class JobProgressionList implements JobProgressionListOptions {
+    protected popoverController: PopoverController;
+    titleI18n: string;
+    headerActions: IUserEventAction[];
+    jobProgressions: Observable<Observable<JobProgression>[]>;
+    constructor(popoverController: PopoverController);
+    executeAction(event: Event, action: IUserEventAction): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JobProgressionList, "app-job-progression-list", never, { "titleI18n": { "alias": "titleI18n"; "required": false; }; "headerActions": { "alias": "headerActions"; "required": false; }; "jobProgressions": { "alias": "jobProgressions"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,10 @@
+import { Entity } from '../../../core/services/model/entity.model';
+export declare class JobProgression extends Entity<JobProgression> {
+    static fromObject: (source: any, opts?: any) => JobProgression;
+    name: string;
+    message: string;
+    current: number;
+    total: number;
+    constructor(id?: number);
+    fromObject(source: any): void;
+}

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

@@ -0,0 +1,33 @@
+import { InjectionToken } from '@angular/core';
+import { JobProgression } from './job-progression.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';
+import * as i0 from "@angular/core";
+export declare const APP_JOB_PROGRESSION_SERVICE: InjectionToken<IJobProgressionService>;
+export interface IJobProgressionService {
+    watchAll(): Observable<JobProgression[]>;
+    addJob(id: number, job?: JobProgression): any;
+    removeJob(id: number): any;
+    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;
+    private jobsSubject;
+    constructor(graphql: GraphqlService, environment: Environment);
+    watchAll(): Observable<JobProgression[]>;
+    addJob(id: number, job?: JobProgression): void;
+    removeJob(id: number): void;
+    listenChanges(id: number, options?: {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<JobProgression>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JobProgressionService>;
+}

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

@@ -0,0 +1,13 @@
+import { JobProgressionIcon, JobProgressionOptions } from '../progression/job-progression.icon';
+import { IJobProgressionService } from '../progression/job-progression.service';
+import * as i0 from "@angular/core";
+export declare class JobProgressionTestingPage {
+    protected jobProgressionService: IJobProgressionService;
+    jobProgressionIcon: JobProgressionIcon;
+    jobId: number;
+    options: JobProgressionOptions;
+    constructor(jobProgressionService: IJobProgressionService);
+    createJob(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JobProgressionTestingPage, "job-progression-testing", never, {}, {}, never, never, false, never>;
+}

package/src/app/social/job/testing/job-progression.testing.service.d.ts

@@ -0,0 +1,9 @@
+import { JobProgressionService } from '../progression/job-progression.service';
+import { Observable } from 'rxjs';
+import { JobProgression } from '../progression/job-progression.model';
+import * as i0 from "@angular/core";
+export declare class JobProgressionTestService extends JobProgressionService {
+    listenChanges(id: number): Observable<JobProgression>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JobProgressionTestService>;
+}

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

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./job-progression.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 "../job.module";
+export declare class JobTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<JobTestingModule, [typeof i1.JobProgressionTestingPage], [typeof i2.CommonModule, typeof i3.TranslateModule, typeof i4.SharedModule, typeof i5.JobModule], [typeof i1.JobProgressionTestingPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<JobTestingModule>;
+}