@sumaris-net/ngx-components 18.12.0 → 18.12.2

package/src/app/shared/material/test/test-component.d.ts

@@ -0,0 +1,75 @@
+import { OnDestroy } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, FormControl, FormGroup, NgControl } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/** @title Form field with custom telephone number input control. */
+export declare class FormFieldCustomControlExample {
+    readonly form: FormGroup<{
+        tel: FormControl<any>;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldCustomControlExample, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldCustomControlExample, "form-field-custom-control-example", never, {}, {}, never, never, true, never>;
+}
+/** Data structure for holding telephone number. */
+export declare class MyTel {
+    area: string;
+    exchange: string;
+    subscriber: string;
+    constructor(area: string, exchange: string, subscriber: string);
+}
+/** Custom `MatFormFieldControl` for telephone number input. */
+export declare class MyTelInput implements ControlValueAccessor, MatFormFieldControl<MyTel>, OnDestroy {
+    static nextId: number;
+    readonly areaInput: import("@angular/core").Signal<HTMLInputElement>;
+    readonly exchangeInput: import("@angular/core").Signal<HTMLInputElement>;
+    readonly subscriberInput: import("@angular/core").Signal<HTMLInputElement>;
+    ngControl: NgControl;
+    readonly parts: FormGroup<{
+        area: FormControl<string | null>;
+        exchange: FormControl<string | null>;
+        subscriber: FormControl<string | null>;
+    }>;
+    readonly stateChanges: Subject<void>;
+    readonly touched: import("@angular/core").WritableSignal<boolean>;
+    readonly controlType = "example-tel-input";
+    readonly id: string;
+    readonly _userAriaDescribedBy: import("@angular/core").InputSignal<string>;
+    readonly _placeholder: import("@angular/core").InputSignal<string>;
+    readonly _required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly _disabledByInput: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly _value: import("@angular/core").ModelSignal<MyTel>;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    protected readonly _formField: import("@angular/material/form-field").MatFormField;
+    private readonly _focused;
+    private readonly _disabledByCva;
+    private readonly _disabled;
+    private readonly _focusMonitor;
+    private readonly _elementRef;
+    get focused(): boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    get userAriaDescribedBy(): string;
+    get placeholder(): string;
+    get required(): boolean;
+    get disabled(): boolean;
+    get value(): MyTel | null;
+    get errorState(): boolean;
+    constructor();
+    ngOnDestroy(): void;
+    onFocusIn(): void;
+    onFocusOut(event: FocusEvent): void;
+    autoFocusNext(control: AbstractControl, nextElement?: HTMLInputElement): void;
+    autoFocusPrev(control: AbstractControl, prevElement: HTMLInputElement): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    writeValue(tel: MyTel | null): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    _handleInput(control: AbstractControl, nextElement?: HTMLInputElement): void;
+    private _updateValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MyTelInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MyTelInput, "example-tel-input", never, { "_userAriaDescribedBy": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "_placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "_required": { "alias": "required"; "required": false; "isSignal": true; }; "_disabledByInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "_value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "_value": "valueChange"; }, never, never, true, never>;
+}

package/src/app/shared/material/testing/common.test.d.ts

@@ -0,0 +1,25 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class MatCommonTestPage implements OnInit, OnDestroy {
+    protected formBuilder: UntypedFormBuilder;
+    protected cd: ChangeDetectorRef;
+    showLogPanel: boolean;
+    logContent: string;
+    form: UntypedFormGroup;
+    statusList: readonly import("../../../core/services/model/referential.model").IStatus[];
+    private subscription;
+    constructor(formBuilder: UntypedFormBuilder, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    loadData(): Promise<void>;
+    doSubmit(_: any): void;
+    log(message: string): void;
+    clearLogPanel(): void;
+    stringify: {
+        (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+        (value: any, replacer?: (string | number)[], space?: string | number): string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatCommonTestPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatCommonTestPage, "mat-common-test", never, {}, {}, never, never, false, never>;
+}

package/src/app/shared/material/text/testing/text-form.testing.d.ts

@@ -0,0 +1,19 @@
+import { AfterViewInit } from '@angular/core';
+import { UntypedFormBuilder, UntypedFormGroup, Validators } from '@angular/forms';
+import { TextForm } from '../text-form.component';
+import * as i0 from "@angular/core";
+export declare class TextFormTestingPage implements AfterViewInit {
+    protected formBuilder: UntypedFormBuilder;
+    standaloneTextForm1: TextForm;
+    standaloneTextForm2: TextForm;
+    form: UntypedFormGroup;
+    protected readonly Validators: typeof Validators;
+    stringify: {
+        (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+        (value: any, replacer?: (string | number)[], space?: string | number): string;
+    };
+    constructor(formBuilder: UntypedFormBuilder);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextFormTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextFormTestingPage, "text-form-testing", never, {}, {}, never, never, false, never>;
+}

package/src/app/shared/material/text/text-form.component.d.ts

@@ -0,0 +1,66 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, Injector, OnInit } from '@angular/core';
+import { ControlValueAccessor, FormGroupDirective, UntypedFormBuilder, UntypedFormControl, ValidatorFn } from '@angular/forms';
+import { CdkTextareaAutosize } from '@angular/cdk/text-field';
+import { AppForm } from '../../../core/form/form.class';
+import { AppFloatLabelType } from '../../form/field.model';
+import { MatFormFieldAppearance, SubscriptSizing } from '@angular/material/form-field';
+import * as i0 from "@angular/core";
+export declare class TextForm extends AppForm<{
+    text: string;
+}> implements OnInit, ControlValueAccessor {
+    protected injector: Injector;
+    protected cd: ChangeDetectorRef;
+    protected formBuilder: UntypedFormBuilder;
+    private formGroupDir;
+    showError: boolean;
+    placeholder: string;
+    multiline: boolean;
+    autoSize: boolean;
+    autoSizeMinRows: number;
+    autoSizeMaxRows: number;
+    maxLength: number;
+    autofocus: boolean;
+    validator: ValidatorFn;
+    standalone: boolean;
+    formControl: UntypedFormControl;
+    formControlName: string;
+    floatLabel: AppFloatLabelType;
+    appearance: MatFormFieldAppearance;
+    subscriptSizing: SubscriptSizing;
+    /**
+     * @deprecated Use autoSize instead
+     */
+    set autoHeight(value: boolean);
+    get autoHeight(): boolean;
+    textAreaChanges: EventEmitter<string>;
+    textArea: ElementRef;
+    textInput: ElementRef;
+    autosizeDirective: CdkTextareaAutosize;
+    textControl: UntypedFormControl;
+    private _onChangeCallback;
+    private _onTouchedCallback;
+    constructor(injector: Injector, cd: ChangeDetectorRef, formBuilder: UntypedFormBuilder, formGroupDir: FormGroupDirective);
+    ngOnInit(): void;
+    containerResize(): void;
+    focusInput(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    protected markForCheck(): void;
+    protected checkIfTouched(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    private textFormValueChanged;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextForm, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextForm, "app-text-form", never, { "showError": { "alias": "showError"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "multiline": { "alias": "multiline"; "required": false; }; "autoSize": { "alias": "autoSize"; "required": false; }; "autoSizeMinRows": { "alias": "autoSizeMinRows"; "required": false; }; "autoSizeMaxRows": { "alias": "autoSizeMaxRows"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "validator": { "alias": "validator"; "required": false; }; "standalone": { "alias": "standalone"; "required": false; }; "formControl": { "alias": "formControl"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "subscriptSizing": { "alias": "subscriptSizing"; "required": false; }; "autoHeight": { "alias": "autoHeight"; "required": false; }; }, { "textAreaChanges": "textAreaChanges"; }, never, ["[matError]"], false, never>;
+    static ngAcceptInputType_showError: unknown;
+    static ngAcceptInputType_multiline: unknown;
+    static ngAcceptInputType_autoSize: unknown;
+    static ngAcceptInputType_autoSizeMinRows: unknown;
+    static ngAcceptInputType_autoSizeMaxRows: unknown;
+    static ngAcceptInputType_maxLength: unknown;
+    static ngAcceptInputType_autofocus: unknown;
+    static ngAcceptInputType_standalone: unknown;
+    static ngAcceptInputType_autoHeight: unknown;
+}

package/src/app/shared/material/text/text-form.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./text-form.component";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "@angular/common";
+import * as i4 from "@ionic/angular";
+import * as i5 from "@angular/forms";
+import * as i6 from "../../pipes/pipes.module";
+import * as i7 from "@angular/material/core";
+import * as i8 from "@angular/material/form-field";
+import * as i9 from "@angular/material/input";
+import * as i10 from "../../directives/directives.module";
+export declare class SharedTextFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedTextFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedTextFormModule, [typeof i1.TextForm], [typeof i2.TranslateModule, typeof i3.CommonModule, typeof i4.IonicModule, typeof i5.ReactiveFormsModule, typeof i6.SharedPipesModule, typeof i7.MatCommonModule, typeof i8.MatFormFieldModule, typeof i9.MatInputModule, typeof i10.SharedDirectivesModule], [typeof i2.TranslateModule, typeof i1.TextForm]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SharedTextFormModule>;
+}

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

@@ -0,0 +1,9 @@
+export declare function isESModule<T>(value: any | T): value is {
+    default: T;
+};
+/**
+ * Workaround need for CommonJS library (eg. moment), because of packagr's issue - see https://github.com/ng-packagr/ng-packagr/issues/2215
+ *
+ * @param commonJSModule
+ */
+export declare function unwrapESModule<T = any>(commonJSModule: T | any): T;

package/src/app/shared/named-filter/named-filter-selector.component.d.ts

@@ -0,0 +1,62 @@
+import { ChangeDetectorRef, EventEmitter, Injector, OnInit } from '@angular/core';
+import { UntypedFormBuilder } from '@angular/forms';
+import { PopoverController, ToastController } from '@ionic/angular';
+import { AppForm } from '../../core/form/form.class';
+import { MatAutocompleteField } from '../material/autocomplete/material.autocomplete';
+import { MatAutocompleteFieldConfig } from '../material/autocomplete/material.autocomplete.config';
+import { INamedFilter, INamedFilterFilter, NamedFilter } from './named-filter.model';
+import { INamedFilterService, NamedFilterLoadOptions, NamedFilterWatchOptions } from './named-filter.service';
+import { MatFormFieldAppearance, SubscriptSizing } from '@angular/material/form-field';
+import * as i0 from "@angular/core";
+export type NamedFilterSelectorButtonsPosition = 'matSuffix' | 'after';
+export declare class NamedFilterSelector extends AppForm<{
+    namedFilter: any;
+}> implements OnInit {
+    protected injector: Injector;
+    protected formBuilder: UntypedFormBuilder;
+    protected cd: ChangeDetectorRef;
+    protected toastController: ToastController;
+    protected popoverController: PopoverController;
+    protected dataService: INamedFilterService<INamedFilter<any>, INamedFilterFilter<any, any>, NamedFilterWatchOptions, NamedFilterLoadOptions>;
+    protected readonly logPrefix = "[named-filter-selector]";
+    private _entityName;
+    private _deleteDisabled;
+    mobile: boolean;
+    set entityName(entityName: string);
+    get entityName(): string;
+    appearance: MatFormFieldAppearance;
+    subscriptSizing: SubscriptSizing;
+    filterContentProvider: () => any;
+    filterImportCallback: (namedFilter: NamedFilter) => Promise<NamedFilter>;
+    filterFormDirty: boolean;
+    showButtons: boolean;
+    exportFileNamePrefix: string;
+    autocompleteConfig: MatAutocompleteFieldConfig;
+    dropButtonTitle: string;
+    clearButtonTitle: string;
+    detectChangeOnSelectFilter: boolean;
+    buttonsPosition: NamedFilterSelectorButtonsPosition;
+    set disabled(_disabled: boolean);
+    get disabled(): boolean;
+    get isNew(): boolean;
+    get saveDisabled(): boolean;
+    get deleteDisabled(): boolean;
+    get dirty(): boolean;
+    filterSelected: EventEmitter<any>;
+    filterDeleted: EventEmitter<NamedFilter<NamedFilter<any>>>;
+    filterCleared: EventEmitter<void>;
+    autocompleteField: MatAutocompleteField;
+    constructor(injector: Injector, formBuilder: UntypedFormBuilder, cd: ChangeDetectorRef, toastController: ToastController, popoverController: PopoverController, dataService: INamedFilterService<INamedFilter<any>, INamedFilterFilter<any, any>, NamedFilterWatchOptions, NamedFilterLoadOptions>);
+    ngOnInit(): void;
+    getFilter(): any;
+    markForCheck(): void;
+    save(event: UIEvent): Promise<void>;
+    delete(event?: UIEvent): Promise<void>;
+    onMoreOptionsClick(event: Event): void;
+    export(event?: UIEvent): Promise<void>;
+    import(event: Event): Promise<void>;
+    protected onFilterChanges(value: NamedFilter | string): Promise<void>;
+    protected setControlValue(value: NamedFilter): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NamedFilterSelector, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NamedFilterSelector, "app-named-filter-selector", never, { "mobile": { "alias": "mobile"; "required": false; }; "entityName": { "alias": "entityName"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "subscriptSizing": { "alias": "subscriptSizing"; "required": false; }; "filterContentProvider": { "alias": "filterContentProvider"; "required": false; }; "filterImportCallback": { "alias": "filterImportCallback"; "required": false; }; "filterFormDirty": { "alias": "filterFormDirty"; "required": false; }; "showButtons": { "alias": "showButtons"; "required": false; }; "exportFileNamePrefix": { "alias": "exportFileNamePrefix"; "required": false; }; "autocompleteConfig": { "alias": "autocompleteConfig"; "required": false; }; "dropButtonTitle": { "alias": "dropButtonTitle"; "required": false; }; "clearButtonTitle": { "alias": "clearButtonTitle"; "required": false; }; "detectChangeOnSelectFilter": { "alias": "detectChangeOnSelectFilter"; "required": false; }; "buttonsPosition": { "alias": "buttonsPosition"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "filterSelected": "filterSelected"; "filterDeleted": "filterDeleted"; "filterCleared": "filterCleared"; }, never, never, false, never>;
+}

package/src/app/shared/named-filter/named-filter.model.d.ts

@@ -0,0 +1,32 @@
+import { Entity, IEntity } from '../../core/services/model/entity.model';
+import { EntityFilter, IEntityFilter } from '../../core/services/model/filter.model';
+export interface INamedFilter<T extends INamedFilter<T>> extends IEntity<T> {
+    name: string;
+    entityName: string;
+    content: any;
+    recorderPersonId: number;
+    recorderDepartmentId: number;
+}
+export declare class NamedFilter<T extends NamedFilter<any> = NamedFilter<any>> extends Entity<T> implements INamedFilter<T> {
+    static fromObject: (source: any, opts?: any) => NamedFilter;
+    name: string;
+    entityName: string;
+    content: any;
+    recorderPersonId: number;
+    recorderDepartmentId: number;
+    fromObject(source: any, opts?: any): void;
+}
+export interface INamedFilterFilter<F extends INamedFilterFilter<any, T>, T extends INamedFilter<T>> extends IEntityFilter<F, T> {
+    searchText: string;
+    entityName: string;
+    recorderPersonId: number;
+    recorderDepartmentId: number;
+}
+export declare class NamedFilterFilter<F extends NamedFilterFilter<any, T> = NamedFilterFilter<any, any>, T extends NamedFilter<any> = NamedFilter<any>> extends EntityFilter<F, T> implements INamedFilterFilter<F, T> {
+    static fromObject: (source: any, opts?: any) => NamedFilterFilter;
+    searchText: string;
+    entityName: string;
+    recorderPersonId: number;
+    recorderDepartmentId: number;
+    fromObject(source: any, opts?: any): void;
+}

package/src/app/shared/named-filter/named-filter.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./named-filter-selector.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@ionic/angular";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "../material/autocomplete/material.autocomplete.module";
+import * as i6 from "@angular/forms";
+import * as i7 from "../material/material.module";
+export declare class SharedNamedFilterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedNamedFilterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedNamedFilterModule, [typeof i1.NamedFilterSelector], [typeof i2.CommonModule, typeof i3.IonicModule, typeof i4.TranslateModule, typeof i5.SharedMatAutocompleteModule, typeof i6.ReactiveFormsModule, typeof i7.SharedMaterialModule], [typeof i1.NamedFilterSelector]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SharedNamedFilterModule>;
+}

package/src/app/shared/named-filter/named-filter.service.d.ts

@@ -0,0 +1,32 @@
+import { InjectionToken } from '@angular/core';
+import { EntitiesServiceLoadOptions, EntityServiceWatchOptions, IEntitiesService, IEntityService, LoadResult, SuggestService } from '../services/entity-service.class';
+import { GraphqlService } from '../../core/graphql/graphql.service';
+import { BaseEntityService, BaseEntityServiceOptions } from '../../core/services/base-entity-service.class';
+import { PlatformService } from '../../core/services/platform.service';
+import { AccountService } from '../../core/services/account.service';
+import { INamedFilter, INamedFilterFilter, NamedFilter, NamedFilterFilter } from './named-filter.model';
+import * as i0 from "@angular/core";
+export declare const APP_NAMED_FILTER_SERVICE: InjectionToken<INamedFilterService<any, any, any, any>>;
+export interface INamedFilterService<T extends INamedFilter<T>, F extends INamedFilterFilter<F, T>, WO extends NamedFilterWatchOptions, LO extends NamedFilterLoadOptions> extends IEntitiesService<T, F, WO>, IEntityService<T, number, LO>, SuggestService<T, F> {
+}
+export interface NamedFilterWatchOptions extends EntityServiceWatchOptions {
+    withContent?: boolean;
+}
+export interface NamedFilterLoadOptions extends EntitiesServiceLoadOptions {
+    withContent?: boolean;
+}
+export declare abstract class AbstractNamedFilterService<T extends NamedFilter<T>, F extends NamedFilterFilter<F, T>, WO extends NamedFilterWatchOptions = NamedFilterWatchOptions, LO extends NamedFilterLoadOptions = NamedFilterLoadOptions> extends BaseEntityService<T, F, number> implements INamedFilterService<T, F, WO, LO> {
+    protected graphql: GraphqlService;
+    protected platform: PlatformService;
+    protected account: AccountService;
+    protected dataType: new () => T;
+    protected filterType: new () => F;
+    protected options: BaseEntityServiceOptions<T, number>;
+    protected constructor(graphql: GraphqlService, platform: PlatformService, account: AccountService, dataType: new () => T, filterType: new () => F, options: BaseEntityServiceOptions<T, number>);
+    suggest(value: any, filter: Partial<F>): Promise<LoadResult<T>>;
+    asSuggestFilter(searchText: string, filter?: Partial<F>): F;
+    asFilter(source: any): F;
+    protected fillDefaultProperties(source: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractNamedFilterService<any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractNamedFilterService<any, any, any, any>, never, never, {}, {}, never, never, false, never>;
+}

package/src/app/shared/named-filter/testing/named-filter-selector.testing.d.ts

@@ -0,0 +1,34 @@
+import { ChangeDetectorRef, OnDestroy } from '@angular/core';
+import { UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import { MatAutocompleteFieldConfig } from '../../material/autocomplete/material.autocomplete.config';
+import { NamedFilter } from '../named-filter.model';
+import { LocalSettingsService } from '../../../core/services/local-settings.service';
+import * as i0 from "@angular/core";
+declare class DummyFilter {
+    filterA: string;
+    filterB: string;
+    filterC: string;
+}
+export declare class NamedFilterSelectorTestingPage implements OnDestroy {
+    protected cd: ChangeDetectorRef;
+    protected settings: LocalSettingsService;
+    private _subscription;
+    protected _filterForm: UntypedFormGroup;
+    protected mobile: boolean;
+    protected namedFilterContentProvider: () => object;
+    protected namedFilterAutocompleteConfig: MatAutocompleteFieldConfig;
+    set filterForm(value: UntypedFormGroup);
+    get filterForm(): UntypedFormGroup;
+    constructor(cd: ChangeDetectorRef, settings: LocalSettingsService, formBuilder: UntypedFormBuilder);
+    ngOnDestroy(): void;
+    setFilterForm(filterForm: UntypedFormGroup): void;
+    getFilterValue(): any;
+    protected markForCheck(): void;
+    protected filterImportCallback: (namedFilter: NamedFilter) => Promise<NamedFilter>;
+    setFilter(filter: Partial<DummyFilter>, opts?: {
+        emitEvent: boolean;
+    }): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NamedFilterSelectorTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NamedFilterSelectorTestingPage, "app-name-filter-selector-testing", never, { "filterForm": { "alias": "filterForm"; "required": false; }; }, {}, never, never, false, never>;
+}
+export {};

package/src/app/shared/named-filter/testing/named-filter.testing.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./named-filter-selector.testing";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/router";
+import * as i4 from "../../shared.module";
+export declare class NamedFilterSelectorTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NamedFilterSelectorTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NamedFilterSelectorTestingModule, [typeof i1.NamedFilterSelectorTestingPage], [typeof i2.CommonModule, typeof i3.RouterModule, typeof i4.SharedModule], [typeof i3.RouterModule, typeof i1.NamedFilterSelectorTestingPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NamedFilterSelectorTestingModule>;
+}

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

@@ -0,0 +1,30 @@
+import { Observable } from 'rxjs';
+import { Predicate } from '@angular/core';
+export declare interface FirstOptions {
+    timeout?: number;
+    stop?: Observable<any>;
+    stopError?: boolean | string | Error;
+}
+export declare interface WaitForOptions extends FirstOptions {
+    dueTime?: number;
+    checkPeriod?: number;
+}
+export declare function filterNotNil<T = any>(obs: Observable<T>): Observable<T>;
+export declare function filterTrue(obs: Observable<boolean>): Observable<boolean>;
+export declare function filterFalse(obs: Observable<boolean>, opts?: FirstOptions): Observable<boolean>;
+export declare function firstNotNil<T = any>(obs: Observable<T>, opts?: FirstOptions): Observable<T>;
+export declare function firstTrue<T = void>(obs: Observable<boolean>, opts?: FirstOptions, result?: T): Observable<T>;
+export declare function firstFalse<T = void>(obs: Observable<boolean>, opts?: FirstOptions, result?: T): Observable<T>;
+export declare function firstTruePromise(obs: Observable<boolean>, opts?: FirstOptions): Promise<void>;
+export declare function firstFalsePromise(obs: Observable<boolean>, opts?: FirstOptions): Promise<void>;
+export declare function firstNotNilPromise<T = any>(obs: Observable<T>, opts?: FirstOptions): Promise<T>;
+export declare function chainPromises<T = any>(defers: (() => Promise<any>)[]): Promise<T[]>;
+/**
+ * Wait form a predicate return true. This need to implement AppFormUtils.waitWhilePending(), AppFormUtils.waitIdle()
+ *
+ * @param predicate
+ * @param opts
+ */
+export declare function waitFor(predicate: Predicate<void>, opts?: WaitForOptions): Promise<void>;
+export declare function waitForTrue(observable: Observable<boolean>, opts?: WaitForOptions): Promise<void>;
+export declare function waitForFalse(observable: Observable<boolean>, opts?: WaitForOptions): Promise<void>;

package/src/app/shared/pipes/arrays.pipe.d.ts

@@ -0,0 +1,82 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NotEmptyArrayPipe implements PipeTransform {
+    transform<T = any>(val: unknown | T[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotEmptyArrayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NotEmptyArrayPipe, "isNotEmptyArray", false>;
+}
+export declare class EmptyArrayPipe implements PipeTransform {
+    transform<T = any>(val: unknown | T[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyArrayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EmptyArrayPipe, "isEmptyArray", false>;
+}
+export declare class ArrayLengthPipe implements PipeTransform {
+    transform<T = any>(val: unknown | T[], args?: {
+        greaterThan?: number;
+        equals?: number;
+        lessThan?: number;
+    }): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayLengthPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayLengthPipe, "isArrayLength", false>;
+}
+export declare class ArrayFirstPipe implements PipeTransform {
+    transform<T = any>(val: unknown | T[]): T | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayFirstPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayFirstPipe, "arrayFirst", false>;
+}
+export declare class ArrayLastPipe implements PipeTransform {
+    transform<T = any>(val: unknown | T[]): T | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayLastPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayLastPipe, "arrayLast", false>;
+}
+export declare class ArrayPluckPipe implements PipeTransform {
+    /**
+     *
+     * @param val
+     * @param opts property to get, or options
+     */
+    transform<T = any>(val: unknown | T[], opts: string | string[] | {
+        property: string | string[];
+        omitNil?: boolean;
+    }): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayPluckPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayPluckPipe, "arrayPluck", false>;
+}
+export declare class ArrayIncludesPipe implements PipeTransform {
+    transform<T = any>(val: unknown | T[], searchElement: T, fromIndex?: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayIncludesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayIncludesPipe, "arrayIncludes", false>;
+}
+export declare class ArrayFilterPipe implements PipeTransform {
+    transform<T = any>(val: unknown | T[], filterFn: (T: any) => boolean): T[] | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayFilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayFilterPipe, "arrayFilter", false>;
+}
+export declare class ArraySortPipe implements PipeTransform {
+    transform<T = any>(val: unknown | T[], sortFn: (a: T, b: T) => number): T[] | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArraySortPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArraySortPipe, "arraySort", false>;
+}
+export declare class ArrayFindByPropertyPipe implements PipeTransform {
+    transform<T = any>(items: unknown | T[], property: string | Array<string | number>, findValue: any): T | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayFindByPropertyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayFindByPropertyPipe, "arrayFindByProperty", false>;
+}
+export declare class ArrayJoinPipe implements PipeTransform {
+    transform<T = any>(val: unknown | T[], separator: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayJoinPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayJoinPipe, "arrayJoin", false>;
+}
+export declare class ArrayDistinctPipe implements PipeTransform {
+    transform<T = any>(val: unknown | T[], opts?: string | {
+        property: string;
+        omitNil?: boolean;
+    }): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayDistinctPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayDistinctPipe, "arrayDistinct", false>;
+}
+export declare class SplitArrayInChunksPipe implements PipeTransform {
+    transform<T = any>(value: T[], chunkSize: number): T[][];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SplitArrayInChunksPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SplitArrayInChunksPipe, "splitArrayInChunks", false>;
+}

package/src/app/shared/pipes/badge.pipes.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class BadgeNumberPipe implements PipeTransform {
+    transform(val: number, max?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BadgeNumberPipe, "badgeNumber", false>;
+}

package/src/app/shared/pipes/colors.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { AppColors } from '../types';
+import { ThemePalette } from '@angular/material/core';
+import * as i0 from "@angular/core";
+export declare class MatColorPipe implements PipeTransform {
+    transform(color: AppColors): ThemePalette | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatColorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MatColorPipe, "matColor", false>;
+}

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

@@ -0,0 +1,25 @@
+import { PipeTransform } from '@angular/core';
+import { Moment } from 'moment';
+import { DateAdapter } from '@angular/material/core';
+import { TranslateService } from '@ngx-translate/core';
+import { unitOfTime } from 'moment/moment';
+import * as i0 from "@angular/core";
+export declare class DateDiffDurationPipe implements PipeTransform {
+    private dateAdapter;
+    protected dayUnit: string;
+    constructor(dateAdapter: DateAdapter<Moment>, translate: TranslateService);
+    transform(value: {
+        startValue: string | Moment;
+        endValue: string | Moment;
+    }, opts?: {
+        seconds?: boolean;
+        unit?: unitOfTime.Base;
+    }): string | Promise<string>;
+    format(startDate: Moment, endDate: Moment, opts: {
+        seconds?: boolean;
+        unit?: unitOfTime.Base;
+    }): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateDiffDurationPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateDiffDurationPipe, "dateDiffDuration", false>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateDiffDurationPipe>;
+}

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

@@ -0,0 +1,35 @@
+import { OnDestroy, PipeTransform } from '@angular/core';
+import { Moment } from 'moment';
+import { TranslateService } from '@ngx-translate/core';
+import { MomentDateAdapter } from '@angular/material-moment-adapter';
+import * as i0 from "@angular/core";
+declare abstract class AbstractDateFormat {
+    protected dateAdapter: MomentDateAdapter;
+    protected translate: TranslateService;
+    private datePattern;
+    private dateTimePattern;
+    private dateTimeSecondsPattern;
+    protected constructor(dateAdapter: MomentDateAdapter, translate: TranslateService);
+    transform(value: string | Moment | Date, args?: {
+        pattern?: string;
+        time?: boolean;
+        seconds?: boolean;
+    }): string;
+    protected _updateTranslations(translations: any): void;
+    protected _getTranslationValue(translations: any, key: string, defaultValue: string): string;
+}
+export declare class DateFormatPipe extends AbstractDateFormat implements PipeTransform {
+    constructor(dateAdapter: MomentDateAdapter, translate: TranslateService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateFormatPipe, "dateFormat", false>;
+}
+export declare class DateFormatService extends AbstractDateFormat implements OnDestroy {
+    private _subscription;
+    constructor(dateAdapter: MomentDateAdapter, translate: TranslateService);
+    ngOnDestroy(): void;
+    format(date: Moment, pattern: any): string;
+    parse(value: string, parseFormat: any): Moment;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateFormatService>;
+}
+export {};

package/src/app/shared/pipes/date-from-now.pipe.d.ts

@@ -0,0 +1,12 @@
+import { PipeTransform } from '@angular/core';
+import { Moment } from 'moment';
+import { MomentDateAdapter } from '@angular/material-moment-adapter';
+import * as i0 from "@angular/core";
+export declare class DateFromNowPipe implements PipeTransform {
+    private dateAdapter;
+    constructor(dateAdapter: MomentDateAdapter);
+    transform(value: string | Moment, args?: any): string | Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFromNowPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateFromNowPipe, "dateFromNow", false>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateFromNowPipe>;
+}

package/src/app/shared/pipes/dates.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import { Moment } from 'moment';
+import * as i0 from "@angular/core";
+export declare class IsValidDatePipe implements PipeTransform {
+    transform(value: string | Moment, opts?: {
+        requiredTime?: boolean;
+    }): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsValidDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsValidDatePipe, "isValidDate", false>;
+}