@sumaris-net/ngx-components 18.14.0 → 18.14.1

package/src/app/core/services/validator/account.validator.d.ts

@@ -0,0 +1,24 @@
+import { UntypedFormBuilder } from '@angular/forms';
+import { Account } from '../model/account.model';
+import { AccountService } from '../account.service';
+import { UserSettingsValidatorService } from './user-settings.validator';
+import { PersonValidatorOptions, PersonValidatorService } from '../../../admin/services/validator/person.validator';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+export interface AccountValidatorOptions extends PersonValidatorOptions {
+    withSettings?: boolean;
+    withTokens?: boolean;
+}
+export declare class AccountValidatorService<T extends Account = Account, O extends AccountValidatorOptions = AccountValidatorOptions> extends PersonValidatorService<T, O> {
+    protected formBuilder: UntypedFormBuilder;
+    protected translate: TranslateService;
+    protected accountService: AccountService;
+    protected userSettingsValidatorService: UserSettingsValidatorService;
+    constructor(formBuilder: UntypedFormBuilder, translate: TranslateService, accountService: AccountService, userSettingsValidatorService: UserSettingsValidatorService);
+    getFormGroupConfig(data?: T, opts?: O): {
+        [key: string]: any[];
+    };
+    protected fillDefaultOptions(opts?: O): O;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountValidatorService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccountValidatorService<any, any>>;
+}

package/src/app/core/services/validator/base.validator.class.d.ts

@@ -0,0 +1,21 @@
+import { ValidatorService } from '@e-is/ngx-material-table';
+import { AbstractControl, UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import { IValidatorService } from '../../../shared/services/validator-service.class';
+import { TranslateService } from '@ngx-translate/core';
+import { FormErrors } from '../../../shared/forms';
+import * as i0 from "@angular/core";
+export declare abstract class AppValidatorService<T = any, O = any> extends ValidatorService implements IValidatorService<T> {
+    protected formBuilder: UntypedFormBuilder;
+    protected translate?: TranslateService;
+    protected constructor(formBuilder: UntypedFormBuilder, translate?: TranslateService);
+    getRowValidator(): UntypedFormGroup;
+    getFormGroup(data?: T, opts?: O): UntypedFormGroup;
+    getFormGroupConfig(data?: T, opts?: O): {
+        [key: string]: any[];
+    };
+    getI18nFormErrors(control: AbstractControl): string[];
+    getI18nErrors(errors: FormErrors): string[];
+    protected getI18nError(errorKey: string, errorContent?: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppValidatorService<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppValidatorService<any, any>, never, never, {}, {}, never, never, false, never>;
+}

package/src/app/core/services/validator/local-settings.validator.d.ts

@@ -0,0 +1,18 @@
+import { AbstractControl, UntypedFormBuilder, UntypedFormGroup, ValidationErrors } from '@angular/forms';
+import { LocalSettings } from '../model/settings.model';
+import { NetworkService } from '../network.service';
+import { AppValidatorService } from './base.validator.class';
+import { PropertyValidator } from '../../form/properties/property.validator';
+import { FormFieldDefinition } from '../../../shared/form/field.model';
+import * as i0 from "@angular/core";
+export declare class LocalSettingsValidatorService extends AppValidatorService<LocalSettings> {
+    private propertyValidator;
+    private networkService;
+    constructor(formBuilder: UntypedFormBuilder, propertyValidator: PropertyValidator, networkService: NetworkService);
+    getFormGroup(data?: LocalSettings, opts?: {
+        definitions?: FormFieldDefinition[];
+    }): UntypedFormGroup;
+    protected peerAlive(peerUrlControl: AbstractControl): Promise<ValidationErrors | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalSettingsValidatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalSettingsValidatorService>;
+}

package/src/app/core/services/validator/user-settings.validator.d.ts

@@ -0,0 +1,10 @@
+import { UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import { AppValidatorService } from './base.validator.class';
+import { UserSettings } from '../model/account.model';
+import * as i0 from "@angular/core";
+export declare class UserSettingsValidatorService extends AppValidatorService<UserSettings> {
+    constructor(formBuilder: UntypedFormBuilder);
+    getFormGroup(data?: UserSettings): UntypedFormGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserSettingsValidatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserSettingsValidatorService>;
+}

package/src/app/core/services/validator/user-token.validator.d.ts

@@ -0,0 +1,13 @@
+import { UntypedFormBuilder, UntypedFormControl, UntypedFormGroup, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { AppValidatorService } from './base.validator.class';
+import { UserToken } from '../model/token.model';
+import * as i0 from "@angular/core";
+export declare class UserTokenValidatorService extends AppValidatorService<UserToken> {
+    constructor(formBuilder: UntypedFormBuilder);
+    getFormGroup(data?: UserToken): UntypedFormGroup;
+    updateFormGroup(formGroup: UntypedFormGroup, existingNames: string[]): void;
+    static notAlreadyExists(existingNames: string[]): ValidatorFn;
+    static notEmptyArray(control: UntypedFormControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserTokenValidatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserTokenValidatorService>;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./settings.page";
+import * as i2 from "../../shared/shared.module";
+import * as i3 from "../form/buttons/form-buttons-bar.module";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "../form/properties/properties.module";
+import * as i6 from "@rx-angular/template/push";
+export declare class AppSettingsPageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppSettingsPageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppSettingsPageModule, [typeof i1.SettingsPage], [typeof i2.SharedModule, typeof i3.AppFormButtonsBarModule, typeof i4.TranslateModule, typeof i5.AppPropertiesFormModule, typeof i6.RxPush], [typeof i4.TranslateModule, typeof i1.SettingsPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppSettingsPageModule>;
+}

package/src/app/core/settings/settings.page.d.ts

@@ -0,0 +1,88 @@
+import { ChangeDetectorRef, InjectionToken, Injector, OnDestroy, OnInit } from '@angular/core';
+import { AccountService } from '../services/account.service';
+import { LocaleConfig, LocalSettings, UsageMode } from '../services/model/settings.model';
+import { UntypedFormArray, UntypedFormBuilder } from '@angular/forms';
+import { AppForm } from '../form/form.class';
+import { CanLeave } from '../form/form.utils';
+import { TranslateService } from '@ngx-translate/core';
+import { LocalSettingsValidatorService } from '../services/validator/local-settings.validator';
+import { PlatformService } from '../services/platform.service';
+import { NetworkService } from '../services/network.service';
+import { LocalSettingsService } from '../services/local-settings.service';
+import { FormFieldDefinition } from '../../shared/form/field.model';
+import { AlertController, NavController } from '@ionic/angular';
+import { ISelectPeerModalOptions } from '../peer/select-peer.modal';
+import { IMenuItem } from '../menu/menu.model';
+import { AppPropertiesForm } from '../form/properties/properties.form';
+import * as i0 from "@angular/core";
+export declare const APP_SETTINGS_MENU_ITEMS: InjectionToken<IMenuItem[]>;
+export declare class SettingsPage extends AppForm<LocalSettings> implements OnInit, OnDestroy, CanLeave {
+    protected platform: PlatformService;
+    protected navController: NavController;
+    protected validatorService: LocalSettingsValidatorService;
+    protected alertCtrl: AlertController;
+    protected translate: TranslateService;
+    protected formBuilder: UntypedFormBuilder;
+    protected accountService: AccountService;
+    protected settings: LocalSettingsService;
+    protected cd: ChangeDetectorRef;
+    network: NetworkService;
+    locales: LocaleConfig[];
+    private data;
+    protected mobile: boolean;
+    protected isAdmin: boolean;
+    protected saving: boolean;
+    protected usageModes: UsageMode[];
+    protected menuItems: IMenuItem[];
+    protected showOptionKeys: boolean;
+    protected propertyDefinitions: FormFieldDefinition[];
+    protected latLongFormats: string[];
+    get accountInheritance(): boolean;
+    get isLogin(): boolean;
+    get propertiesFormArray(): UntypedFormArray;
+    get darkMode(): boolean;
+    set darkMode(value: boolean);
+    propertiesForm: AppPropertiesForm;
+    constructor(injector: Injector, platform: PlatformService, navController: NavController, validatorService: LocalSettingsValidatorService, alertCtrl: AlertController, translate: TranslateService, formBuilder: UntypedFormBuilder, accountService: AccountService, settings: LocalSettingsService, cd: ChangeDetectorRef, network: NetworkService, locales: LocaleConfig[], menuItems?: IMenuItem[]);
+    ngOnInit(): Promise<void>;
+    protected loadPropertyDefinitions(): void;
+    load(): Promise<void>;
+    updateView(data: LocalSettings): Promise<void>;
+    save(event?: Event, options?: any): Promise<boolean>;
+    setAccountInheritance(enable: boolean, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    showSelectPeerModal(opts?: Partial<ISelectPeerModalOptions>): Promise<void>;
+    protected setForceOffline(value: boolean): void;
+    cancel(event?: Event): Promise<void>;
+    close(_?: Event): Promise<boolean>;
+    clearCache(event?: Event): Promise<void>;
+    executeAction(event: Event, item: IMenuItem): Promise<void>;
+    getValue(): Promise<LocalSettings>;
+    markAsLoading(): void;
+    markAsLoaded(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    get loading(): boolean;
+    get loaded(): boolean;
+    enable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    disable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsPristine(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    handleRefresh(event: BeforeUnloadEvent): void;
+    protected openAccountPage(): Promise<boolean>;
+    protected toggleDarkMode(enable?: boolean): Promise<void>;
+    protected toggleShowOptionKeys(): void;
+    protected devToggleDebug(): void;
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsPage, [null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsPage, "page-settings", never, {}, {}, never, never, false, never>;
+}

package/src/app/core/table/async-table.class.d.ts

@@ -0,0 +1,395 @@
+import { AfterViewInit, ChangeDetectorRef, EventEmitter, Injector, OnDestroy, OnInit } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort, MatSortable, SortDirection } from '@angular/material/sort';
+import { MatTable } from '@angular/material/table';
+import { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';
+import { SelectionModel } from '@angular/cdk/collections';
+import { IEntity } from '../services/model/entity.model';
+import { AlertController, ModalController, NavController, ToastController } from '@ionic/angular';
+import { ActivatedRoute, Router } from '@angular/router';
+import { ColumnItem } from './table-select-columns.component';
+import { Location } from '@angular/common';
+import { CanSave, IAppForm } from '../form/form.utils';
+import { LocalSettingsService } from '../services/local-settings.service';
+import { TranslateService } from '@ngx-translate/core';
+import { MatAutocompleteConfigHolder, MatAutocompleteFieldAddOptions, MatAutocompleteFieldConfig } from '../../shared/material/autocomplete/material.autocomplete.config';
+import { CompletableEvent } from '../../shared/events';
+import { WaitForOptions } from '../../shared/observables';
+import { ShowToastOptions } from '../../shared/toast/toasts';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { LoadResult } from '../../shared/services/entity-service.class';
+import { FormErrorTranslateOptions, FormErrorTranslator, IFormPathTranslator } from '../../shared/validator/form-error-adapter.class';
+import { SaveActionType } from './table.model';
+import { AsyncTableElement } from '@e-is/ngx-material-table';
+import { EntitiesAsyncTableDataSource } from './entities-async-table-datasource.class';
+import * as i0 from "@angular/core";
+export declare abstract class AppAsyncTable<T extends IEntity<T, ID>, F = any, ID = number> implements OnInit, OnDestroy, AfterViewInit, IAppForm, CanSave, IFormPathTranslator {
+    protected columns: string[];
+    protected _dataSource?: EntitiesAsyncTableDataSource<T, F, ID>;
+    private _filter?;
+    private _initialized;
+    private _openingRow;
+    private _subscription;
+    private _dataSourceLoadingSubscription;
+    private _cellValueChangesDefs;
+    protected _enabled: boolean;
+    protected _autocompleteConfigHolder: MatAutocompleteConfigHolder;
+    protected allowRowDetail: boolean;
+    protected readonly cd: ChangeDetectorRef;
+    protected route: ActivatedRoute;
+    protected router: Router;
+    protected navController: NavController;
+    protected location: Location;
+    protected settings: LocalSettingsService;
+    protected translate: TranslateService;
+    protected modalCtrl: ModalController;
+    protected alertCtrl: AlertController;
+    protected toastController: ToastController;
+    protected previouslyEditedRowId: number;
+    protected formErrorAdapter: FormErrorTranslator;
+    protected readonly destroySubject: Subject<void>;
+    excludesColumns: string[];
+    displayedColumns: string[];
+    totalRowCount: number | null;
+    visibleRowCount: number;
+    errorTranslateOptions: FormErrorTranslateOptions;
+    readonly readySubject: BehaviorSubject<boolean>;
+    readonly loadingSubject: BehaviorSubject<boolean>;
+    readonly savingSubject: BehaviorSubject<boolean>;
+    readonly touchedSubject: BehaviorSubject<boolean>;
+    readonly dirtySubject: BehaviorSubject<boolean>;
+    readonly errorSubject: BehaviorSubject<string>;
+    get error(): string;
+    set error(error: string);
+    selection: SelectionModel<AsyncTableElement<T>>;
+    permanentSelection: SelectionModel<T>;
+    permanentSelectionChangedPrevented: boolean;
+    autocompleteFields: {
+        [key: string]: MatAutocompleteFieldConfig;
+    };
+    readonly mobile: boolean;
+    settingsId: string;
+    debug: boolean;
+    i18nColumnPrefix: string;
+    i18nColumnSuffix: string;
+    autoLoad: boolean;
+    readOnly: boolean;
+    inlineEdition: boolean;
+    focusFirstColumn: boolean;
+    confirmBeforeDelete: boolean;
+    confirmBeforeCancel: boolean;
+    undoableDeletion: boolean;
+    saveBeforeDelete: boolean;
+    keepEditedRowOnSave: boolean;
+    saveBeforeSort: boolean;
+    saveBeforeFilter: boolean;
+    propagateRowError: boolean;
+    permanentSelectionAllowed: boolean;
+    openRowThrottleTime: number;
+    defaultSortBy: string;
+    defaultSortDirection: SortDirection;
+    defaultPageSize: number;
+    defaultPageSizeOptions: number[];
+    focusColumn: string;
+    get firstUserColumn(): string;
+    get lastUserColumn(): string;
+    set dataSource(value: EntitiesAsyncTableDataSource<T, F, ID>);
+    get dataSource(): EntitiesAsyncTableDataSource<T, F, ID>;
+    set filter(value: F);
+    get filter(): F;
+    get empty(): boolean;
+    get selectedEntities(): T[];
+    onRefresh: EventEmitter<any>;
+    onClickRow: EventEmitter<AsyncTableElement<T>>;
+    onOpenRow: EventEmitter<AsyncTableElement<T>>;
+    onNewRow: EventEmitter<any>;
+    onStartEditingRow: EventEmitter<AsyncTableElement<T>>;
+    onConfirmEditCreateRow: EventEmitter<AsyncTableElement<T>>;
+    onCancelOrDeleteRow: EventEmitter<AsyncTableElement<T>>;
+    onBeforeDeleteRows: EventEmitter<import("../../shared/events").PromiseEvent<boolean, {
+        rows: AsyncTableElement<T>[];
+    }>>;
+    onBeforeCancelRows: EventEmitter<import("../../shared/events").PromiseEvent<boolean, {
+        rows: AsyncTableElement<T>[];
+    }>>;
+    onBeforeSave: EventEmitter<import("../../shared/events").PromiseEvent<{
+        confirmed: boolean;
+        save: boolean;
+    }, {
+        action: SaveActionType;
+        valid: boolean;
+    }>>;
+    onAfterDeletedRows: EventEmitter<AsyncTableElement<T>[]>;
+    onSort: EventEmitter<any>;
+    onDirty: EventEmitter<boolean>;
+    onError: EventEmitter<string>;
+    get dirty(): boolean;
+    get valid(): boolean;
+    get invalid(): boolean;
+    get pending(): boolean;
+    get touched(): boolean;
+    get untouched(): boolean;
+    disable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    enable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    get enabled(): boolean;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    markAsDirty(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsPristine(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsUntouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): Promise<void>;
+    /**
+     * @deprecated prefer to use markAllAsTouched()
+     * @param opts
+     */
+    markAsTouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAllAsTouched(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsSaving(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsSaved(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsLoading(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsLoaded(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsReady(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    get loading(): boolean;
+    get loaded(): boolean;
+    enableSort(): void;
+    disableSort(): void;
+    set pageSize(value: number);
+    get pageSize(): number;
+    get pageOffset(): number;
+    get sortActive(): string;
+    set sortActive(sortBy: string);
+    get sortDirection(): SortDirection;
+    set sortDirection(value: SortDirection);
+    private _paginator;
+    set paginator(value: MatPaginator);
+    get paginator(): MatPaginator;
+    get destroyed(): boolean;
+    table: MatTable<T>;
+    childPaginator: MatPaginator;
+    sort: MatSort;
+    protected constructor(injector: Injector, columns: string[], _dataSource?: EntitiesAsyncTableDataSource<T, F, ID>, _filter?: F);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    updateView(res: LoadResult<T> | undefined, opts?: {
+        emitEvent?: boolean;
+    }): Promise<void>;
+    setDatasource(datasource: EntitiesAsyncTableDataSource<T, F, ID>): void;
+    resetDataSource(): void;
+    addColumnDef(column: CdkColumnDef): void;
+    removeColumnDef(column: CdkColumnDef): void;
+    setFilter(filter: F, opts?: {
+        emitEvent?: boolean;
+        permanentSelectionChangedPrevented?: boolean;
+    }): Promise<void>;
+    confirmAndAdd(event?: Event, row?: AsyncTableElement<T>): Promise<boolean>;
+    confirmAndBackward(event?: Event, row?: AsyncTableElement<T>): Promise<boolean>;
+    confirmAndForward(event?: Event, row?: AsyncTableElement<T>): Promise<boolean>;
+    /**
+     * Confirm the creation of the given row, or if not specified the currently edited row
+     *
+     * @param event
+     * @param row
+     */
+    confirmEditCreate(event?: Event, row?: AsyncTableElement<T>): Promise<boolean>;
+    cancelOrDelete(event: Event, row: AsyncTableElement<T>, opts?: {
+        interactive?: boolean;
+        keepEditing?: boolean;
+    }): Promise<void>;
+    addRow(event?: Event, insertAt?: number, opts?: {
+        focusColumn?: string;
+        editing?: boolean;
+    }): Promise<boolean>;
+    save(opts?: {
+        keepEditing?: boolean;
+    }): Promise<boolean>;
+    cancel(event?: Event, opts?: {
+        interactive?: boolean;
+    }): Promise<void>;
+    duplicateRow(event?: Event, row?: AsyncTableElement<T>, opts?: {
+        includedProperties?: string[];
+        excludedProperties?: string[];
+    }): Promise<boolean>;
+    /** Whether the number of selected elements matches the total number of rows. */
+    isAllSelected(): boolean;
+    /** Selects all rows if they are not all selected; otherwise clear selection. */
+    masterToggle(): Promise<void>;
+    deleteSelection(event: Event, opts?: {
+        interactive?: boolean;
+    }): Promise<number>;
+    /**
+     *
+     * @param event
+     * @param row
+     * @param opts Use interactive=false to avoid user interaction (e.g. user confirmation)
+     *  And to force deletion even if table is busy
+     */
+    deleteRow(event: Event | null, row: AsyncTableElement<T>, opts?: {
+        interactive?: boolean;
+    }): Promise<boolean>;
+    /**
+     *
+     * @param event
+     * @param rows
+     * @param opts Use interactive=false to avoid user interaction (e.g. user confirmation)
+     *    And to force deletion even if table is busy
+     */
+    deleteRows(event: Event | null, rows: AsyncTableElement<T>[], opts?: {
+        interactive?: boolean;
+    }): Promise<number>;
+    selectRowById(id: number): Promise<boolean>;
+    /**
+     * Try to select row by data. Will use equals() to find same row's data
+     *
+     * @param data
+     */
+    selectRowByData(data: T): Promise<boolean>;
+    toggleSelectRow(event: Event | undefined, row: AsyncTableElement<T>): void;
+    clickRow(event: Event | undefined, row: AsyncTableElement<T>): Promise<boolean>;
+    moveRow(id: number, direction: number): Promise<void>;
+    ready(opts?: WaitForOptions): Promise<void>;
+    waitIdle(opts?: WaitForOptions): Promise<void>;
+    openSelectColumnsModal(event?: Event): Promise<any>;
+    trackByFn(index: number, row: AsyncTableElement<T>): any;
+    doRefresh(event?: CompletableEvent): void;
+    getCurrentColumns(): ColumnItem[];
+    escapeEditingRow(event?: Event, row?: AsyncTableElement<T>): Promise<void>;
+    translateFormPath(path: string): string;
+    protected editRow(event: Event | undefined, row: AsyncTableElement<T>, opts?: {
+        focusColumn?: string;
+    }): Promise<boolean>;
+    /**
+     * Try to select row, by row.id, or by data. WIll use EntityUtils.equals()
+     *
+     * @param id
+     * @param data
+     * @protected
+     */
+    protected selectRowByIdOrData(id: number, data?: T): Promise<boolean>;
+    /**
+     * return the selected row if unique in selection
+     */
+    protected get singleSelectedRow(): AsyncTableElement<T>;
+    protected canDeleteRows(rows: AsyncTableElement<T>[], opts?: {
+        interactive?: boolean;
+    }): Promise<boolean>;
+    protected canCancelRows(rows?: AsyncTableElement<T>[], opts?: {
+        interactive?: boolean;
+    }): Promise<boolean>;
+    protected saveBeforeAction(saveAction: SaveActionType): Promise<boolean>;
+    /**
+     * Open a row detail view. By default, will to open row detail page.
+     * Can be overridden by subclasses, BUT prefer to subscribe on onOpenRow
+     *
+     * @param id
+     * @param row
+     * @protected
+     */
+    protected openRow(id: ID, row: AsyncTableElement<T>): Promise<boolean>;
+    protected openNewRowDetail(event?: any): Promise<boolean>;
+    protected getRequiredColumns(): string[];
+    protected getUserColumns(): string[];
+    protected getSortedColumn(): MatSortable;
+    protected getPageSize(): number;
+    protected getDisplayColumns(): string[];
+    /**
+     * Recompute display columns
+     *
+     * @protected
+     */
+    protected updateColumns(): void;
+    protected registerSubscription(sub: Subscription): void;
+    protected unregisterSubscription(sub: Subscription): void;
+    protected registerAutocompleteField<E = any, EF = any>(fieldName: string, options?: MatAutocompleteFieldAddOptions<E, EF>): MatAutocompleteFieldConfig<E, EF>;
+    protected getI18nColumnName(columnName: string): string;
+    protected generateTableId(): string;
+    protected addRowToTable(insertAt?: number, opts?: {
+        focusColumn?: string;
+        editing?: boolean;
+        emitEvent?: boolean;
+    }): Promise<AsyncTableElement<T> | undefined>;
+    protected registerCellValueChanges(name: string, formPath?: string, emitInitialValue?: boolean): Observable<any>;
+    protected setShowColumn(columnName: string, show: boolean, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected getShowColumn(columnName: string): boolean;
+    protected startsWithUpperCase(input: string, search: string): boolean;
+    protected markForCheck(): void;
+    protected detectChanges(): void;
+    protected askDeleteConfirmation(event?: Event, rows?: AsyncTableElement<T>[]): Promise<boolean>;
+    protected askCancelConfirmation(event?: Event, rows?: AsyncTableElement<T>[]): Promise<boolean>;
+    protected askRestoreConfirmation(event?: Event): Promise<boolean>;
+    protected showToast(opts: ShowToastOptions): Promise<import("@ionic/core").OverlayEventDetail<any>>;
+    protected resetError(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected getRowError(row?: AsyncTableElement<T>, opts?: FormErrorTranslateOptions): string;
+    protected setError(value: string, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * Compare data equality (default by id, using EntityUtils.equals())
+     * Can be overridden to add additional properties to compare
+     *
+     * @param d1
+     * @param d2
+     * @protected
+     */
+    protected equals(d1: T, d2: T): boolean;
+    protected markRowAsDirty(row?: AsyncTableElement<T>, opts?: {
+        onlySelf?: boolean;
+        emitEVent?: boolean;
+    }): void;
+    protected getPageSettings<T = any>(propertyName?: string): T;
+    protected savePageSettings(value: any, propertyName?: string): Promise<void>;
+    protected emitRefresh(value?: any): void;
+    /**
+     * Initialize the permanent selection model
+     *
+     * @protected
+     */
+    protected initPermanentSelection(): void;
+    private listenSortAndPaginationEvents;
+    private editRowById;
+    private setLoading;
+    private deleteNewRow;
+    private deleteExistingRow;
+    private cancelExistingRow;
+    private checkIfRowPristine;
+    private checkIfPristine;
+    private applyFilter;
+    private listenDatasourceLoading;
+    private startCellValueChanges;
+    private stopCellValueChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppAsyncTable<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppAsyncTable<any, any, any>, never, never, { "settingsId": { "alias": "settingsId"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; "i18nColumnPrefix": { "alias": "i18nColumnPrefix"; "required": false; }; "i18nColumnSuffix": { "alias": "i18nColumnSuffix"; "required": false; }; "autoLoad": { "alias": "autoLoad"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "inlineEdition": { "alias": "inlineEdition"; "required": false; }; "focusFirstColumn": { "alias": "focusFirstColumn"; "required": false; }; "confirmBeforeDelete": { "alias": "confirmBeforeDelete"; "required": false; }; "confirmBeforeCancel": { "alias": "confirmBeforeCancel"; "required": false; }; "undoableDeletion": { "alias": "undoableDeletion"; "required": false; }; "saveBeforeDelete": { "alias": "saveBeforeDelete"; "required": false; }; "keepEditedRowOnSave": { "alias": "keepEditedRowOnSave"; "required": false; }; "saveBeforeSort": { "alias": "saveBeforeSort"; "required": false; }; "saveBeforeFilter": { "alias": "saveBeforeFilter"; "required": false; }; "propagateRowError": { "alias": "propagateRowError"; "required": false; }; "permanentSelectionAllowed": { "alias": "permanentSelectionAllowed"; "required": false; }; "openRowThrottleTime": { "alias": "openRowThrottleTime"; "required": false; }; "defaultSortBy": { "alias": "defaultSortBy"; "required": false; }; "defaultSortDirection": { "alias": "defaultSortDirection"; "required": false; }; "defaultPageSize": { "alias": "defaultPageSize"; "required": false; }; "defaultPageSizeOptions": { "alias": "defaultPageSizeOptions"; "required": false; }; "focusColumn": { "alias": "focusColumn"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "paginator": { "alias": "paginator"; "required": false; }; }, { "onRefresh": "onRefresh"; "onClickRow": "onClickRow"; "onOpenRow": "onOpenRow"; "onNewRow": "onNewRow"; "onStartEditingRow": "onStartEditingRow"; "onConfirmEditCreateRow": "onConfirmEditCreateRow"; "onCancelOrDeleteRow": "onCancelOrDeleteRow"; "onBeforeDeleteRows": "onBeforeDeleteRows"; "onBeforeCancelRows": "onBeforeCancelRows"; "onBeforeSave": "onBeforeSave"; "onAfterDeletedRows": "onAfterDeletedRows"; "onSort": "onSort"; "onDirty": "onDirty"; "onError": "onError"; }, never, never, false, never>;
+}

package/src/app/core/table/column/actions-column.component.d.ts

@@ -0,0 +1,62 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { AsyncTableElement, TableElement } from '@e-is/ngx-material-table';
+import { MatColumnDef, MatTable } from '@angular/material/table';
+import { MatMenuTrigger } from '@angular/material/menu';
+import * as i0 from "@angular/core";
+export declare class ActionsColumnComponent<T extends TableElement<any> | AsyncTableElement<any> = TableElement<any>> implements OnInit, OnDestroy {
+    private table;
+    private cd;
+    columnDef: MatColumnDef;
+    matMenuTrigger: MatMenuTrigger;
+    matColumnDef: string;
+    style: 'table' | 'mat-table';
+    stickyEnd: boolean;
+    canCancel: boolean;
+    canConfirm: boolean;
+    canDelete: boolean;
+    canBackward: boolean;
+    canForward: boolean;
+    canConfirmAndAdd: boolean;
+    dirtyIcon: boolean | string;
+    optionsTitle: string;
+    classList: string;
+    cellTemplateStart: TemplateRef<{
+        $implicit: T;
+    }>;
+    cellTemplate: TemplateRef<{
+        $implicit: T;
+    }>;
+    optionsClick: EventEmitter<Event>;
+    cancelOrDeleteClick: EventEmitter<{
+        event: Event;
+        row: T;
+    }>;
+    confirmEditCreateClick: EventEmitter<{
+        event: Event;
+        row: T;
+    }>;
+    confirmAndAddClick: EventEmitter<{
+        event: Event;
+        row: T;
+    }>;
+    backward: EventEmitter<{
+        event: Event;
+        row: T;
+    }>;
+    forward: EventEmitter<{
+        event: Event;
+        row: T;
+    }>;
+    constructor(table: MatTable<any>, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsColumnComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionsColumnComponent<any>, "app-actions-column", never, { "matColumnDef": { "alias": "matColumnDef"; "required": false; }; "style": { "alias": "style"; "required": false; }; "stickyEnd": { "alias": "stickyEnd"; "required": false; }; "canCancel": { "alias": "canCancel"; "required": false; }; "canConfirm": { "alias": "canConfirm"; "required": false; }; "canDelete": { "alias": "canDelete"; "required": false; }; "canBackward": { "alias": "canBackward"; "required": false; }; "canForward": { "alias": "canForward"; "required": false; }; "canConfirmAndAdd": { "alias": "canConfirmAndAdd"; "required": false; }; "dirtyIcon": { "alias": "dirtyIcon"; "required": false; }; "optionsTitle": { "alias": "optionsTitle"; "required": false; }; "classList": { "alias": "class"; "required": false; }; "cellTemplateStart": { "alias": "cellTemplateStart"; "required": false; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; }; }, { "optionsClick": "optionsClick"; "cancelOrDeleteClick": "cancelOrDeleteClick"; "confirmEditCreateClick": "confirmEditCreateClick"; "confirmAndAddClick": "confirmAndAddClick"; "backward": "backward"; "forward": "forward"; }, never, ["[matHeader]", "[matFooter]", "[matHeader]", "[matFooter]"], false, never>;
+    static ngAcceptInputType_stickyEnd: unknown;
+    static ngAcceptInputType_canCancel: unknown;
+    static ngAcceptInputType_canConfirm: unknown;
+    static ngAcceptInputType_canDelete: unknown;
+    static ngAcceptInputType_canBackward: unknown;
+    static ngAcceptInputType_canForward: unknown;
+    static ngAcceptInputType_canConfirmAndAdd: unknown;
+}