@ecodev/natural 63.9.1 → 64.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecodev/natural",
-  "version": "63.9.1",
+  "version": "64.0.0",
   "license": "MIT",
   "repository": "github:Ecodev/natural",
   "sideEffects": false,
@@ -23,14 +23,14 @@
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@angular/cdk": "^19.2.0",
-    "@angular/common": "^19.2.0",
-    "@angular/core": "^19.2.0",
-    "@angular/forms": "^19.2.0",
-    "@angular/localize": "^19.2.0",
-    "@angular/material": "^19.2.0",
-    "@angular/platform-browser": "^19.2.0",
-    "@angular/router": "^19.2.0",
+    "@angular/cdk": "^20.3.0",
+    "@angular/common": "^20.3.0",
+    "@angular/core": "^20.3.0",
+    "@angular/forms": "^20.3.0",
+    "@angular/localize": "^20.3.0",
+    "@angular/material": "^20.3.0",
+    "@angular/platform-browser": "^20.3.0",
+    "@angular/router": "^20.3.0",
     "apollo-angular": "^10.0.0",
     "es-toolkit": "^1.39.7",
     "rxjs": "^7.8.2"

package/src/lib/modules/sidenav/_sidenav.theme.scss

@@ -10,7 +10,7 @@
             border-right: none;
         }
 
-        mat-sidenav[ng-reflect-mode='side'] {
+        mat-sidenav.modeSide {
             .mat-drawer-inner-container {
                 display: flex;
                 flex-direction: column;

package/vanilla/index.d.ts

@@ -1,5 +1,420 @@
+import { BehaviorSubject, Observable, OperatorFunction } from 'rxjs';
+import { Apollo, MutationResult } from 'apollo-angular';
+import { WatchQueryFetchPolicy, FetchResult } from '@apollo/client/core';
+import { ValidatorFn, AsyncValidatorFn, AbstractControl, UntypedFormGroup } from '@angular/forms';
+import { DocumentNode } from 'graphql';
+import * as i0 from '@angular/core';
+import { HttpInterceptorFn } from '@angular/common/http';
+
+type QueryVariables = {
+    filter?: any | null;
+    pagination?: PaginationInput | null;
+    sorting?: Sorting[] | null;
+};
+type PaginationInput = {
+    offset?: number | null;
+    pageIndex?: number | null;
+    pageSize?: number | null;
+};
+type Sorting = {
+    field: any;
+    order?: SortingOrder | null;
+    nullAsHighest?: boolean | null;
+    emptyStringAsHighest?: boolean | null;
+};
+declare enum SortingOrder {
+    ASC = "ASC",
+    DESC = "DESC"
+}
 /**
- * Generated bundle index. Do not edit.
+ * Filter manager stores a set of channels that contain a variable object and exposes an observable "variables" that updates with the result
+ * of all channels merged together.
+ *
+ * A channel is supposed to be used by a given aspect of the GUI (pagination, sorting, search, others ?).
+ *
+ * ```ts
+ * const fm = new QueryVariablesManager();
+ * fm.merge('componentA-variables', {a : [1, 2, 3]});
+ * ```
+ *
+ * Variables attributes is a BehaviorSubject. That mean it's not mandatory to subscribe, we can just call getValue or value attributes on
+ * it :
+ *
+ * ```ts
+ * console.log(fm.variables.value); // {a : [1, 2, 3]}
+ * ```
+ *
+ * Set new variables for 'componentA-variables':
+ *
+ * ```ts
+ * fm.merge('componentA-variables', {a : [1, 2]});
+ * console.log(fm.variables.value); // {a : [1, 2, 3]}
+ * ```
+ *
+ * Set new variables for new channel:
+ *
+ * ```ts
+ * fm.merge('componentB-variables', {a : [3, 4]});
+ * console.log(fm.variables.value); // {a : [1, 2, 3, 4]}
+ * ```
  */
-/// <amd-module name="@ecodev/natural/vanilla" />
-export * from './public-api';
+declare class NaturalQueryVariablesManager<T extends QueryVariables = QueryVariables> {
+    readonly variables: BehaviorSubject<T | undefined>;
+    private readonly channels;
+    constructor(queryVariablesManager?: NaturalQueryVariablesManager<T>);
+    /**
+     * Set or override all the variables that may exist in the given channel
+     */
+    set(channelName: string, variables: Partial<T> | null | undefined): void;
+    /**
+     * Return a deep clone of the variables for the given channel name.
+     *
+     * Avoid returning the same reference to prevent an attribute change, then another channel update that would
+     * used this changed attribute without having explicitly asked QueryVariablesManager to update it.
+     */
+    get(channelName: string): Partial<T> | undefined;
+    /**
+     * Merge variable into a channel, overriding arrays in same channel / key
+     */
+    merge(channelName: string, newVariables: Partial<T>): void;
+    /**
+     * Apply default values to a channel
+     * Note : lodash defaults only defines values on destinations keys that are undefined
+     */
+    defaults(channelName: string, newVariables: Partial<T>): void;
+    private getChannelsCopy;
+    /**
+     * Merge channels in a single object
+     * Arrays are concatenated
+     * Filter groups are combined smartly (see mergeGroupList)
+     */
+    private updateVariables;
+    /**
+     * Cross merge two filters
+     * Only accepts groups with same groupLogic (ignores the first one, because there is no groupLogic in this one)
+     * @throws In case two non-empty lists of groups are given and at one of them mix groupLogic value, throws an error
+     */
+    private mergeGroupList;
+}
+
+type PaginatedData<T> = {
+    readonly items: readonly T[];
+    readonly offset?: number | null;
+    readonly pageSize: number;
+    readonly pageIndex: number;
+    readonly length: number;
+};
+
+/**
+ * Debounce subscriptions to update mutations, with the possibility to cancel one, flush one, or flush all of them.
+ *
+ * `modelService` is also used to separate objects by their types. So User with ID 1 is not confused with Product with ID 1.
+ *
+ * `id` must be the ID of the object that will be updated.
+ */
+declare class NaturalDebounceService {
+    /**
+     * Stores the debounced update function
+     */
+    private readonly allDebouncedUpdateCache;
+    /**
+     * Debounce the `modelService.updateNow()` mutation for a short time. If called multiple times with the same
+     * modelService and id, it will postpone the subscription to the mutation.
+     *
+     * All input variables for the same object (same service and ID) will be cumulated over time. So it is possible
+     * to update `field1`, then `field2`, and they will be batched into a single XHR including `field1` and `field2`.
+     *
+     * But it will always keep the same debouncing timeline.
+     */
+    debounce<T extends UntypedModelService>(modelService: UntypedModelService, id: string, object: Parameters<T['updateNow']>[0]): ReturnType<T['updateNow']>;
+    cancelOne(modelService: UntypedModelService, id: string): void;
+    /**
+     * Immediately execute the pending update, if any.
+     *
+     * It should typically be called before resolving the object, to mutate it before re-fetching it from server.
+     *
+     * The returned observable will complete when the update completes, even if it errors.
+     */
+    flushOne(modelService: UntypedModelService, id: string): Observable<void>;
+    /**
+     * Immediately execute all pending updates.
+     *
+     * It should typically be called before login out.
+     *
+     * The returned observable will complete when all updates complete, even if some of them error.
+     */
+    flush(): Observable<void>;
+    private internalFlush;
+    /**
+     * Count of pending updates
+     */
+    get count(): number;
+    private getMap;
+    private delete;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalDebounceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalDebounceService>;
+}
+
+type FormValidators = Record<string, ValidatorFn[]>;
+type FormAsyncValidators = Record<string, AsyncValidatorFn[]>;
+type VariablesWithInput = {
+    input: Literal;
+};
+type FormControls = Record<string, AbstractControl>;
+type WithId<T> = {
+    id: string;
+} & T;
+declare abstract class NaturalAbstractModelService<Tone, Vone extends {
+    id: string;
+}, Tall extends PaginatedData<Literal>, Vall extends QueryVariables, Tcreate, Vcreate extends VariablesWithInput, Tupdate, Vupdate extends {
+    id: string;
+    input: Literal;
+}, Tdelete, Vdelete extends {
+    ids: string[];
+}> {
+    protected readonly name: string;
+    protected readonly oneQuery: DocumentNode | null;
+    protected readonly allQuery: DocumentNode | null;
+    protected readonly createMutation: DocumentNode | null;
+    protected readonly updateMutation: DocumentNode | null;
+    protected readonly deleteMutation: DocumentNode | null;
+    private readonly createName;
+    private readonly updateName;
+    private readonly deleteName;
+    /**
+     * Store the creation mutations that are pending
+     */
+    private readonly creatingCache;
+    protected readonly apollo: Apollo;
+    protected readonly naturalDebounceService: NaturalDebounceService;
+    private readonly plural;
+    /**
+     *
+     * @param name service and single object query name (eg. userForFront or user).
+     * @param oneQuery GraphQL query to fetch a single object from ID (eg. userForCrudQuery).
+     * @param allQuery GraphQL query to fetch a filtered list of objects (eg. usersForCrudQuery).
+     * @param createMutation GraphQL mutation to create an object.
+     * @param updateMutation GraphQL mutation to update an object.
+     * @param deleteMutation GraphQL mutation to delete a list of objects.
+     * @param plural list query name (eg. usersForFront or users).
+     * @param createName create object mutation name (eg. createUser).
+     * @param updateName update object mutation name (eg. updateUser).
+     * @param deleteName delete object mutation name (eg. deleteUsers).
+     */
+    constructor(name: string, oneQuery: DocumentNode | null, allQuery: DocumentNode | null, createMutation: DocumentNode | null, updateMutation: DocumentNode | null, deleteMutation: DocumentNode | null, plural?: string | null, createName?: string | null, updateName?: string | null, deleteName?: string | null);
+    /**
+     * List of individual fields validators
+     */
+    getFormValidators(model?: Literal): FormValidators;
+    /**
+     * List of individual async fields validators
+     */
+    getFormAsyncValidators(model?: Literal): FormAsyncValidators;
+    /**
+     * List of grouped fields validators (like password + confirm password)
+     */
+    getFormGroupValidators(model?: Literal): ValidatorFn[];
+    /**
+     * List of async group fields validators (like unique constraint on multiple columns)
+     */
+    getFormGroupAsyncValidators(model?: Literal): AsyncValidatorFn[];
+    getFormConfig(model: Literal): FormControls;
+    /**
+     * Create the final FormGroup for the object, including all validators
+     *
+     * This method should **not** be overridden, but instead `getFormConfig`,
+     * `getFormGroupValidators`, `getFormGroupAsyncValidators` might be.
+     */
+    getFormGroup(model: Literal): UntypedFormGroup;
+    /**
+     * Get a single object
+     *
+     * If available it will emit object from cache immediately, then it
+     * will **always** fetch from network and then the observable will be completed.
+     *
+     * You must subscribe to start getting results (and fetch from network).
+     */
+    getOne(id: string): Observable<Tone>;
+    /**
+     * Watch a single object
+     *
+     * If available it will emit object from cache immediately, then it
+     * will **always** fetch from network, and then keep watching the cache forever.
+     *
+     * You must subscribe to start getting results (and fetch from network).
+     *
+     * You **MUST** unsubscribe.
+     */
+    watchOne(id: string, fetchPolicy?: WatchQueryFetchPolicy): Observable<Tone>;
+    private prepareOneQuery;
+    /**
+     * Get a collection of objects
+     *
+     * It will **always** fetch from network and then the observable will be completed.
+     * No cache is ever used, so it's slow but correct.
+     */
+    getAll(queryVariablesManager: NaturalQueryVariablesManager<Vall>): Observable<Tall>;
+    /**
+     * Get a collection of objects
+     *
+     * Every time the observable variables change, and they are not undefined,
+     * it will return result from cache, then it will **always** fetch from network,
+     * and then keep watching the cache forever.
+     *
+     * You must subscribe to start getting results (and fetch from network).
+     *
+     * You **MUST** unsubscribe.
+     */
+    watchAll(queryVariablesManager: NaturalQueryVariablesManager<Vall>, fetchPolicy?: WatchQueryFetchPolicy): Observable<Tall>;
+    /**
+     * This functions allow to quickly create or update objects.
+     *
+     * Manages a "creation is pending" status, and update when creation is ready.
+     * Uses regular update/updateNow and create methods.
+     * Used mainly when editing multiple objects in same controller (like in editable arrays)
+     */
+    createOrUpdate(object: Vcreate['input'] | WithId<Vupdate['input']>, now?: boolean): Observable<Tcreate | Tupdate>;
+    /**
+     * Create an object in DB and then refetch the list of objects
+     */
+    create(object: Vcreate['input']): Observable<Tcreate>;
+    /**
+     * Update an object, after a short debounce
+     */
+    update(object: WithId<Vupdate['input']>): Observable<Tupdate>;
+    /**
+     * Update an object immediately when subscribing
+     */
+    updateNow(object: WithId<Vupdate['input']>): Observable<Tupdate>;
+    /**
+     * Delete objects and then refetch the list of objects
+     */
+    delete(objects: {
+        id: string;
+    }[]): Observable<Tdelete>;
+    /**
+     * If the id is provided, resolves an observable model. The observable model will only be emitted after we are sure
+     * that Apollo cache is fresh and warm. Then the component can subscribe to the observable model to get the model
+     * immediately from Apollo cache and any subsequents future mutations that may happen to Apollo cache.
+     *
+     * Without id, returns default values, in order to show a creation form.
+     */
+    resolve(id: string | undefined): Observable<Observable<Tone | Vcreate['input']>>;
+    /**
+     * Return an object that match the GraphQL input type.
+     * It creates an object with manually filled data and add uncompleted data (like required attributes that can be empty strings)
+     */
+    getInput(object: Literal, forCreation: boolean): Vcreate['input'] | Vupdate['input'];
+    /**
+     * Return the number of objects matching the query. It may never complete.
+     *
+     * This is used for the unique validator
+     */
+    count(queryVariablesManager: NaturalQueryVariablesManager<Vall>): Observable<number>;
+    /**
+     * Return empty object with some default values from server perspective
+     *
+     * This is typically useful when showing a form for creation
+     */
+    getDefaultForServer(): Vcreate['input'];
+    /**
+     * You probably **should not** use this.
+     *
+     * If you are trying to *call* this method, instead you probably want to call `getDefaultForServer()` to get default
+     * values for a model, or `getFormConfig()` to get a configured form that includes extra form fields.
+     *
+     * If you are trying to *override* this method, instead you probably want to override `getDefaultForServer()`.
+     *
+     * The only and **very rare** reason to override this method is if the client needs extra form fields that cannot be
+     * accepted by the server (not part of `XXXInput` type) and that are strictly for the client form needs. In that case,
+     * then you can return default values for those extra form fields, and the form returned by `getFormConfig()` will
+     * include those extra fields.
+     */
+    protected getFormExtraFieldDefaultValues(): Literal;
+    /**
+     * This is used to extract only the array of fetched objects out of the entire fetched data
+     */
+    protected mapAll(): OperatorFunction<FetchResult<unknown>, Tall>;
+    /**
+     * This is used to extract only the created object out of the entire fetched data
+     */
+    protected mapCreation(result: MutationResult<unknown>): Tcreate;
+    /**
+     * This is used to extract only the updated object out of the entire fetched data
+     */
+    protected mapUpdate(result: MutationResult<unknown>): Tupdate;
+    /**
+     * This is used to extract only flag when deleting an object
+     */
+    protected mapDelete(result: MutationResult<unknown>): Tdelete;
+    /**
+     * Returns additional variables to be used when getting a single object
+     *
+     * This is typically a site or state ID, and is needed to get appropriate access rights
+     */
+    protected getPartialVariablesForOne(): Observable<Partial<Vone>>;
+    /**
+     * Returns additional variables to be used when getting multiple objects
+     *
+     * This is typically a site or state ID, but it could be something else to further filter the query
+     */
+    getPartialVariablesForAll(): Observable<Partial<Vall>>;
+    /**
+     * Returns additional variables to be used when creating an object
+     *
+     * This is typically a site or state ID
+     */
+    protected getPartialVariablesForCreation(object: Literal): Partial<Vcreate>;
+    /**
+     * Returns additional variables to be used when updating an object
+     *
+     * This is typically a site or state ID
+     */
+    protected getPartialVariablesForUpdate(object: Literal): Partial<Vupdate>;
+    /**
+     * Return additional variables to be used when deleting an object
+     *
+     * This is typically a site or state ID
+     */
+    protected getPartialVariablesForDelete(objects: Literal[]): Partial<Vdelete>;
+    /**
+     * Throw exception to prevent executing queries with invalid variables
+     */
+    protected throwIfObservable(value: unknown): void;
+    /**
+     * Merge given ID with additional partial variables if there is any
+     */
+    private getVariablesForOne;
+    /**
+     * Throw exception to prevent executing null queries
+     */
+    private throwIfNotQuery;
+}
+
+/**
+ * An object literal with any keys and values
+ */
+type Literal = Record<string, any>;
+/**
+ * This should be avoided if possible, and instead use a more precise type with some constraints on it to ensure that the model
+ * service is able to fulfill its requirements.
+ */
+type UntypedModelService = NaturalAbstractModelService<any, any, any, any, any, any, any, any, any, any>;
+
+/**
+ * Sign all HTTP POST requests that are GraphQL queries against `/graphql` endpoint with a custom signature.
+ *
+ * The server will validate the signature before executing the GraphQL query.
+ */
+declare function graphqlQuerySigner(key: string): HttpInterceptorFn;
+
+/**
+ * Format a date and time in a way that will preserve the local time zone.
+ * This allows the server side to know the day (without time) that was selected on client side.
+ *
+ * So something like: "2021-09-23T17:57:16+09:00"
+ */
+declare function formatIsoDateTime(date: Date): string;
+
+export { NaturalAbstractModelService, NaturalQueryVariablesManager, formatIsoDateTime, graphqlQuerySigner };
+export type { FormValidators, Literal };

package/lib/classes/abstract-detail.d.ts

@@ -1,108 +0,0 @@
-import { OnInit } from '@angular/core';
-import { UntypedFormGroup } from '@angular/forms';
-import { ActivatedRoute, type NavigationExtras, Router } from '@angular/router';
-import { NaturalAlertService } from '../modules/alert/alert.service';
-import { NaturalAbstractPanel } from '../modules/panels/abstract-panel';
-import { NaturalAbstractModelService } from '../services/abstract-model.service';
-import { ExtractResolve, ExtractTcreate, ExtractTone, ExtractTupdate, Literal } from '../types/types';
-import { Observable } from 'rxjs';
-import { PaginatedData } from './data-source';
-import { QueryVariables } from './query-variable-manager';
-import * as i0 from "@angular/core";
-/**
- * `Data` contains in `model` either the model fetched from DB or default values (without ID). And besides `model`,
- * any other extra keys defined by Extra.
- */
-type Data<TService, Extra> = {
-    model: {
-        id?: string;
-    } & ExtractResolve<TService>;
-} & Extra;
-export declare class NaturalAbstractDetail<TService extends NaturalAbstractModelService<{
-    id: string;
-}, any, PaginatedData<Literal>, QueryVariables, any, any, any, any, unknown, any>, ExtraResolve extends Literal = Record<never, never>> extends NaturalAbstractPanel implements OnInit {
-    #private;
-    protected readonly key: string;
-    readonly service: TService;
-    /**
-     * Data retrieved by the server via route resolvers.
-     *
-     * The key `model` is special. It is readonly and represents the model being updated
-     * as it exists on server. The value is kept up to date when Apollo mutates it on server.
-     *
-     * The only time when `model` is not readonly is during creation. Only then can we modify the model values directly.
-     *
-     * Other keys, if present, are whatever is returned from route resolvers as-is.
-     */
-    data: Data<TService, ExtraResolve>;
-    /**
-     * Form that manages the data from the controller
-     */
-    form: UntypedFormGroup;
-    /**
-     * Show / hides the bottom fab button (mostly to hide it when we are on other tabs where semantic of button can conflict with ...
-     * semantic of data on other tab, like relations that list other objects)
-     */
-    showFabButton: boolean;
-    protected readonly alertService: NaturalAlertService;
-    protected readonly router: Router;
-    protected readonly route: ActivatedRoute;
-    private readonly _dialogData;
-    /**
-     * Once set, this must not change anymore, especially not right after the creation mutation,
-     * so the form does not switch from creation mode to update mode without an actual reload of
-     * model from DB (by navigating to update page).
-     */
-    private _isUpdatePage;
-    private readonly changes;
-    constructor(key: string, service: TService);
-    /**
-     * You probably should not override this method. Instead, consider overriding `initForm()`.
-     */
-    ngOnInit(): void;
-    changeTab(index: number): void;
-    /**
-     * Returns whether `data.model` was fetched from DB, so we are on an update page, or if it is a new object
-     * with (only) default values, so we are on a creation page.
-     *
-     * This should be used instead of checking `data.model.id` directly, in order to type guard and get proper typing
-     */
-    protected isUpdatePage(): this is {
-        data: {
-            model: ExtractTone<TService>;
-        };
-    };
-    /**
-     * Update the object on the server with the values from the form fields that were modified since
-     * the initialization, or since the previous successful update.
-     *
-     * Form fields that are never modified are **not** sent to the server, unless if you specify `submitAllFields`.
-     */
-    update(now?: boolean, submitAllFields?: boolean): void;
-    create(redirect?: boolean): void;
-    /**
-     * `confirmer` can be used to open a custom dialog, or anything else, to confirm the deletion, instead of the standard dialog
-     */
-    delete(redirectionRoute?: unknown[] | {
-        commands: unknown[];
-        extras: NavigationExtras;
-    }, confirmer?: Observable<boolean | undefined>): void;
-    protected postUpdate(model: ExtractTupdate<TService>): void;
-    /**
-     * Returns an observable that will be subscribed to immediately and the
-     * redirect navigation will only happen after the observable completes.
-     */
-    protected postCreate(model: ExtractTcreate<TService>): Observable<unknown>;
-    protected preDelete(model: ExtractTone<TService>): void;
-    /**
-     * Initialize the form whenever it is needed.
-     *
-     * You should override this method, and not `ngOnInit()` if you need to customize the form. Because this will
-     * correctly be called more than one time per component instance if needed, when the route changes. But `ngOnInit()`
-     * will incorrectly be called exactly 1 time per component instance, even if the object changes via route navigation.
-     */
-    protected initForm(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalAbstractDetail<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalAbstractDetail<any, any>, never, never, {}, {}, never, never, true, never>;
-}
-export {};

package/lib/classes/abstract-editable-list.d.ts

@@ -1,70 +0,0 @@
-import { AbstractControl, UntypedFormArray, UntypedFormGroup } from '@angular/forms';
-import { MatTableDataSource } from '@angular/material/table';
-import { NaturalAbstractModelService } from '../services/abstract-model.service';
-import { NaturalQueryVariablesManager, QueryVariables } from './query-variable-manager';
-import { ExtractTallOne, ExtractVall, Literal } from '../types/types';
-import { PaginatedData } from './data-source';
-import * as i0 from "@angular/core";
-/**
- * This class helps managing non-paginated rows of items that can be edited in-place, typically in a <mat-table>.
- * But it does **not** mutate anything to persist the edits on the server. It is up to the consuming component to implement
- * custom mutation mechanism.
- *
- * To access data of this component from a parent component, use:
- *
- * ```ts
- * private readonly cmp = viewChildren(ComponentType);
- *
- * this.cmp.getItems();
- * ```
- *
- * To add empty line, call:
- *
- * ```
- * this.cmp.addEmpty();
- * ```
- *
- * @dynamic
- */
-export declare class NaturalAbstractEditableList<TService extends NaturalAbstractModelService<any, any, PaginatedData<Literal>, QueryVariables, any, any, any, any, any, any>, T extends Literal = ExtractTallOne<TService>> {
-    protected readonly service: TService;
-    readonly form: UntypedFormGroup;
-    readonly formArray: UntypedFormArray;
-    readonly variablesManager: NaturalQueryVariablesManager<ExtractVall<TService>>;
-    readonly dataSource: MatTableDataSource<AbstractControl<any, any>, import("@angular/material/paginator").MatPaginator>;
-    constructor(service: TService);
-    /**
-     * Set the list of items (overwriting what may have existed)
-     */
-    setItems(items: readonly T[]): void;
-    /**
-     * Add given items to the list
-     * Reproduces the model data loading the same way as it would be on a detail page (via AbstractDetail controller) but without resolving
-     */
-    addItems(items: readonly T[]): void;
-    removeAt(index: number): void;
-    /**
-     * Add empty item at the end of the list
-     */
-    addEmpty(): void;
-    /**
-     * Return a list of models without any treatment.
-     *
-     * To mutate models, it would be required to map them using :
-     *  - AbstractModelService.getInput()
-     *  - AbstractModelService.getPartialVariablesForCreation()
-     *  - AbstractModelService.getPartialVariablesForUpdate()
-     *  - some other required treatment.
-     *
-     * TODO return type is incorrect and should be closer to `Partial<T>[]` or an even looser type, because we don't really know what fields exists in the form. When we fix this, we should also remove type coercing in unit tests.
-     */
-    getItems(): T[];
-    /**
-     * Force the form validation.
-     *
-     * The valid state can then be read via `this.form.valid`
-     */
-    validateForm(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalAbstractEditableList<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalAbstractEditableList<any, any>, never, never, {}, {}, never, never, true, never>;
-}