@ecodev/natural 63.9.1 → 64.0.0

package/index.d.ts

@@ -1,5 +1,4266 @@
+import * as i0 from '@angular/core';
+import { Injector, InjectionToken, DestroyRef, OnInit, Type, OnChanges, SimpleChanges, AfterViewInit, PipeTransform, Provider, EnvironmentProviders, OnDestroy, EmbeddedViewRef, ComponentRef, StaticProvider, TemplateRef, DoCheck, ErrorHandler, ApplicationConfig } from '@angular/core';
+import { ValidatorFn, AsyncValidatorFn, AbstractControl, UntypedFormGroup, UntypedFormArray, ValidationErrors, FormControl, FormGroup, FormGroupDirective, NgForm, ControlValueAccessor, NgControl } from '@angular/forms';
+import * as _angular_router from '@angular/router';
+import { ActivatedRoute, ResolveData, UrlSegment, Router, NavigationExtras, RouterLink, Data as Data$1, NavigationEnd, UrlMatcher, Params, QueryParamsHandling, UrlTree } from '@angular/router';
+import { MatSnackBarRef, SimpleSnackBar } from '@angular/material/snack-bar';
+import * as rxjs from 'rxjs';
+import { Observable, Subject, BehaviorSubject, OperatorFunction, ObservedValueOf, MonoTypeOperatorFunction } from 'rxjs';
+import { ComponentType, BasePortalOutlet, CdkPortalOutlet, TemplatePortal, ComponentPortal } from '@angular/cdk/portal';
+import { DataSource, SelectionModel } from '@angular/cdk/collections';
+import { Apollo, MutationResult } from 'apollo-angular';
+import { WatchQueryFetchPolicy, FetchResult, ApolloLink } from '@apollo/client/core';
+import { DocumentNode, GraphQLFormattedError } from 'graphql';
+import * as _angular_material_paginator from '@angular/material/paginator';
+import { PageEvent } from '@angular/material/paginator';
+import { MatTableDataSource } from '@angular/material/table';
+import { Sort } from '@angular/material/sort';
+import { HttpLink, HttpBatchLink, Options } from 'apollo-angular/http';
+import { ReadonlyDeep } from 'type-fest';
+import { HttpInterceptorFn } from '@angular/common/http';
+import { NativeDateAdapter, ThemePalette, ErrorStateMatcher } from '@angular/material/core';
+import { MatSelectionList } from '@angular/material/list';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { MatTreeFlattener, MatTreeFlatDataSource } from '@angular/material/tree';
+import { MatDialogConfig, MatDialogRef } from '@angular/material/dialog';
+import { MatAutocompleteTrigger } from '@angular/material/autocomplete';
+import { MatSidenav, MatDrawerMode } from '@angular/material/sidenav';
+import { MatButtonAppearance } from '@angular/material/button';
+
+declare class NaturalAlertService {
+    private readonly dialog;
+    private readonly snackBar;
+    /**
+     * Show an informative message in a snack bar
+     */
+    info(message: string, duration?: number | null): MatSnackBarRef<SimpleSnackBar>;
+    /**
+     * Show an error in a snack bar
+     */
+    error(message: string, duration?: number | null, action?: string): MatSnackBarRef<SimpleSnackBar>;
+    /**
+     * Show a simple confirmation dialog and returns true if user confirmed it
+     */
+    confirm(title: string, message: string, confirmText: string, cancelText?: string): Observable<boolean | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalAlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalAlertService>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * TODO: implement route update when closing dialog with escape
+ * @dynamic
  */
-/// <amd-module name="@ecodev/natural" />
-export * from './public-api';
+declare class NaturalPanelsService {
+    private readonly router;
+    private readonly dialog;
+    private readonly injector;
+    private hooksConfig;
+    private readonly panelWidth;
+    /**
+     * Because of this static property Panels are **not** compatible with SSR.
+     * And we cannot make it non-static, because `UrlMatcher` cannot be injected.
+     */
+    private static _opened;
+    static get opened(): boolean;
+    /**
+     * Stream that emits when all open dialog have finished closing
+     */
+    readonly afterAllClosed: Subject<void>;
+    /**
+     * Cache for panels counter. Works more like an ID.
+     * Is used to give an unique identifier to multiple similar panels configurations
+     */
+    private counter;
+    /**
+     * Class applied to dialog overlay related with panels
+     * If change, change CSS too
+     */
+    private panelClass;
+    /**
+     * Cache for panels setup before navigation change.
+     * Used to detect panels openings/closings and adapt for new configuration
+     */
+    private oldFullConfig;
+    /**
+     * Cache for subscription stop
+     */
+    private routeSub?;
+    /**
+     * Cache for subscription stop
+     */
+    private navSub?;
+    /**
+     * Horizontal gaps between panels
+     */
+    private panelsOffsetH;
+    /**
+     * Vertical gaps between panels
+     */
+    private panelsOffsetV;
+    /**
+     * Cache of previous screen size
+     * Used to change panels stack orientation on small screens
+     */
+    private isVertical;
+    constructor();
+    /**
+     * Notify the service to start listening to route changes to open panels
+     *
+     * @internal
+     */
+    start(route: ActivatedRoute): void;
+    /**
+     * Uses given configuration to add at the end of current url
+     */
+    private appendConfigToCurrentUrl;
+    /**
+     * Notify the service that all panels were closed
+     *
+     * @internal
+     */
+    stop(): void;
+    /**
+     * Go to panel matching given component. Causes an url change.
+     *
+     * @internal
+     */
+    goToPanelByComponent(component: NaturalAbstractPanel): void;
+    /**
+     * Go to panel matching given component. Causes an url change.
+     */
+    goToPenultimatePanel(): void;
+    /**
+     * Calls the new url that only includes the segments from the panels we want to stay open
+     */
+    private goToPanelByIndex;
+    /**
+     * Selecting a panel is equivalent to close all those that are in front of him
+     * @param index of panel in stack. The most behind (the first one) is 0.
+     */
+    private selectPanelByIndex;
+    /**
+     * Open new panels if url has changed with new segments
+     */
+    private updatePanels;
+    /**
+     * Resolve all services, then open panels
+     */
+    private openPanels;
+    private getResolvedData;
+    private openPanel;
+    /**
+     * Return panel position (index) by searching matching component
+     */
+    private getPanelIndex;
+    /**
+     * Whether the given panel is currently the top, visible, panel. If there are no panels opened at all, then any panel given is considered top, visible, panel.
+     */
+    isTopPanel(component: NaturalAbstractPanel): boolean;
+    /**
+     * Repositions panels from start until given index
+     */
+    private updateComponentsPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalPanelsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalPanelsService>;
+}
+
+type PaginatedData<T> = {
+    readonly items: readonly T[];
+    readonly offset?: number | null;
+    readonly pageSize: number;
+    readonly pageIndex: number;
+    readonly length: number;
+};
+/**
+ * A NaturalDataSource will connect immediately, in order to know as soon as possible if
+ * we need to show a template at all (as seen in my-ichtus)
+ *
+ * It also allow some extra data manipulation
+ */
+declare class NaturalDataSource<T extends PaginatedData<Literal> = PaginatedData<Literal>> extends DataSource<T['items'][0]> {
+    private readonly ngUnsubscribe;
+    private readonly internalData;
+    constructor(value: Observable<T> | T);
+    get internalDataObservable(): Observable<T | null>;
+    /**
+     * Array of data that should be rendered by the table, where each object represents one row.
+     */
+    get data(): T | null;
+    set data(data: T | null);
+    connect(): Observable<T['items']>;
+    disconnect(): void;
+    push(item: T['items'][0]): void;
+    pop(): T['items'][0] | undefined;
+    remove(item: T['items'][0]): void;
+}
+
+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"
+}
+/**
+ * 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]}
+ * ```
+ */
+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;
+}
+
+/**
+ * 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>;
+/**
+ * An object with either a name or a fullName (or maybe both)
+ */
+type NameOrFullName = {
+    id: string;
+    name: string;
+    fullName?: string;
+} | {
+    id: string;
+    name?: string;
+    fullName: string;
+};
+/**
+ * Extract the Tone type from a NaturalAbstractModelService
+ */
+type ExtractTone<P> = P extends NaturalAbstractModelService<infer Tone, any, any, any, any, any, any, any, any, any> ? Tone : never;
+/**
+ * Extract the Vone type from a NaturalAbstractModelService
+ */
+type ExtractVone<P> = P extends NaturalAbstractModelService<any, infer Vone, any, any, any, any, any, any, any, any> ? Vone extends {
+    id: string;
+} ? Vone : never : never;
+/**
+ * Extract the Tall type from a NaturalAbstractModelService
+ */
+type ExtractTall<P> = P extends NaturalAbstractModelService<any, any, infer Tall, any, any, any, any, any, any, any> ? Tall extends PaginatedData<Literal> ? Tall : never : never;
+/**
+ * Extract the TallOne type for a single item coming from a list of items from a NaturalAbstractModelService
+ */
+type ExtractTallOne<P> = P extends NaturalAbstractModelService<any, any, PaginatedData<infer TallOne extends Literal>, any, any, any, any, any, any, any> ? TallOne extends Literal ? TallOne : never : never;
+/**
+ * Extract the Vall type from a NaturalAbstractModelService
+ */
+type ExtractVall<P> = P extends NaturalAbstractModelService<any, any, any, infer Vall, any, any, any, any, any, any> ? Vall extends QueryVariables ? Vall : never : never;
+/**
+ * Extract the Tcreate type from a NaturalAbstractModelService
+ */
+type ExtractTcreate<P> = P extends NaturalAbstractModelService<any, any, any, any, infer Tcreate, any, any, any, any, any> ? Tcreate : never;
+/**
+ * Extract the Vcreate type from a NaturalAbstractModelService
+ */
+type ExtractVcreate<P> = P extends NaturalAbstractModelService<any, any, any, any, any, infer Vcreate, any, any, any, any> ? Vcreate extends VariablesWithInput ? Vcreate : never : never;
+/**
+ * Extract the Tupdate type from a NaturalAbstractModelService
+ */
+type ExtractTupdate<P> = P extends NaturalAbstractModelService<any, any, any, any, any, any, infer Tupdate, any, any, any> ? Tupdate : never;
+/**
+ * Extract the Vupdate type from a NaturalAbstractModelService
+ */
+type ExtractVupdate<P> = P extends NaturalAbstractModelService<any, any, any, any, any, any, any, infer Vupdate, any, any> ? Vupdate extends {
+    id: string;
+    input: Literal;
+} ? Vupdate : never : never;
+/**
+ * Extract the Tdelete type from a NaturalAbstractModelService
+ */
+type ExtractTdelete<P> = P extends NaturalAbstractModelService<any, any, any, any, any, any, any, any, infer Tdelete, any> ? Tdelete : never;
+/**
+ * Extract the Vdelete type from a NaturalAbstractModelService
+ */
+type ExtractVdelete<P> = P extends NaturalAbstractModelService<any, any, any, any, any, any, any, any, any, infer Vdelete> ? Vdelete extends {
+    ids: string[];
+} ? Vdelete : never : never;
+/**
+ * Extract the resolve type from a NaturalAbstractModelService
+ */
+type ExtractResolve<P> = P extends NaturalAbstractModelService<any, any, any, any, any, any, any, any, any, any> ? ObservedValueOf<ObservedValueOf<ReturnType<P['resolve']>>> : never;
+/**
+ * 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>;
+/**
+ * Returns the resolved data type, as available in components, from the given resolvers
+ *
+ * Eg:
+ *
+ * ```ts
+ * const actionResolvers = {
+ *     model: resolveAction,
+ *     statuses: () => inject(NaturalEnumService).get('Status'),
+ * } as const;
+ *
+ * // In action.component.ts
+ * const data: ResolvedData<typeof actionResolvers>;
+ * data.statuses.forEach(...);
+ * ```
+ */
+type ResolvedData<T extends ResolveData> = {
+    readonly [KeyType in keyof Pick<T, keyof T>]: ObservedValueOf<ReturnType<Pick<T, keyof T>[KeyType]>>;
+};
+
+type LinkableObject = {
+    id: string;
+    __typename: string;
+};
+declare class NaturalLinkMutationService {
+    private readonly apollo;
+    /**
+     * Receives the list of available mutations
+     */
+    private allMutations?;
+    /**
+     * Link two objects together
+     */
+    link(obj1: LinkableObject, obj2: LinkableObject, otherName?: string | null, variables?: Literal): Observable<FetchResult<{
+        id: string;
+    }>>;
+    /**
+     * Link many objects
+     */
+    linkMany(obj1: LinkableObject, objects: LinkableObject[], otherName?: string | null, variables?: Literal): Observable<FetchResult<{
+        id: string;
+    }>[]>;
+    /**
+     * Unlink two objects
+     */
+    unlink(obj1: LinkableObject, obj2: LinkableObject, otherName?: string | null): Observable<FetchResult<{
+        id: string;
+    }>>;
+    /**
+     * Return the list of all available mutation names
+     */
+    private getAllMutationNames;
+    /**
+     * Generate mutation using patterns and replacing variables
+     */
+    private getMutation;
+    /**
+     * Execute mutation
+     */
+    private execute;
+    /**
+     * Build the actual mutation string
+     */
+    private buildTemplate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalLinkMutationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalLinkMutationService>;
+}
+
+/**
+ * Kind of snapshot of the instance of a panel activated route
+ */
+type NaturalPanelsRouteConfig = {
+    segments: UrlSegment[];
+    path: string;
+};
+/**
+ * Config required to manage url and instantiate component correctly
+ */
+type NaturalPanelConfig = {
+    component: ComponentType<NaturalAbstractPanel>;
+    injector: Injector | null;
+    resolve: NaturalPanelResolves;
+    params: Literal;
+    rule: NaturalPanelsRouterRule;
+    route: NaturalPanelsRouteConfig;
+};
+/**
+ * Data provided to instantiated components in context of a panel/dialog
+ */
+type NaturalPanelData = {
+    config: NaturalPanelConfig;
+    data: Literal;
+    /**
+     * Related objects that should be linked to the object shown in the panel after its creation
+     */
+    linkableObjects: LinkableObject[];
+};
+/**
+ * Similar to Angular functional resolver interface, but simpler for our panels' needs
+ */
+type NaturalPanelResolve<T> = (route: NaturalPanelConfig) => Observable<T>;
+type NaturalPanelResolves = Record<string, NaturalPanelResolve<unknown>>;
+/**
+ * Configuration for a route
+ */
+type NaturalPanelsRouterRule = {
+    path: string;
+    component: ComponentType<NaturalAbstractPanel>;
+    resolve?: NaturalPanelResolves;
+};
+type NaturalPanelsBeforeOpenPanel = {
+    itemData: NaturalPanelData;
+    panelConfig: NaturalPanelConfig;
+    fullPanelsConfig: NaturalPanelConfig[];
+    resolvedResult: any;
+};
+type NaturalPanelsHooksConfig = {
+    beforeOpenPanel?: (injector: Injector, naturalPanelsBeforeOpenPanel: NaturalPanelsBeforeOpenPanel) => NaturalPanelData;
+};
+type NaturalPanelsRoutesConfig = NaturalPanelsRouterRule[];
+declare const PanelsHooksConfig: InjectionToken<NaturalPanelsHooksConfig>;
+
+declare class NaturalAbstractPanel {
+    protected readonly destroyRef: DestroyRef;
+    /**
+     * The data property is the container where the resolved content is stored
+     * When loading a component from a panel opening (dialog), receives the data provided by the service
+     */
+    data: any;
+    /**
+     * Bind isFrontPanel style class on root component
+     */
+    isFrontPanel: boolean;
+    /**
+     * Bind isPanel style class on root component
+     */
+    isPanel: boolean;
+    /**
+     * Merging of data provided by the very root component (that is in a route context) and inherited data through panels
+     * TODO: provide type with available attributes
+     */
+    panelData?: NaturalPanelData;
+    panelService?: NaturalPanelsService;
+    /**
+     * Bind click on panels, to allow the selection of those who are behind
+     */
+    clickPanel(): void;
+    /**
+     * Called when panel opens and component is loaded
+     * Runs before ngOnInit()
+     */
+    initPanel(panelData: NaturalPanelData): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalAbstractPanel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalAbstractPanel, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * `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;
+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>;
+}
+
+/**
+ * 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
+ */
+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, any>, _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>;
+}
+
+type AvailableColumn = {
+    /**
+     * This must be the column ID as defined in `matColumnDef`
+     *
+     * Implementation details:
+     *
+     * Unfortunately, we cannot use a `Record<AvailableColumn>` where keys would implicitly be unique and would replace
+     * this ID property, because only ES2020 guarantee the order of object keys, and we must still support ES2015 for
+     * iPhone 6. So, instead of `Record<AvailableColumn>`, we use `AvailableColumn[]` for now. But this could be
+     * revisited once we drop support of ES2015.
+     *
+     * @see https://stackoverflow.com/questions/30076219/does-es6-introduce-a-well-defined-order-of-enumeration-for-object-properties
+     */
+    id: string;
+    /**
+     * Localized label of column for human
+     */
+    label: string;
+    /**
+     * Initial checked state, defaults to `true`.
+     */
+    checked?: boolean;
+    /**
+     * Initial visibility state, defaults to `false`.
+     *
+     * A column that is hidden will not appear in the list of choice,
+     * but it will be included in the result of selected columns.
+     */
+    hidden?: boolean;
+};
+/**
+ * A button that will be shown as an icon on desktop, or as a menu entry on mobile
+ */
+type Button = {
+    /**
+     * On desktop will be shown as tooltip, or as menu entry on mobile
+     */
+    label: string;
+    /**
+     * The icon name to be used on desktop
+     */
+    icon: string;
+    /**
+     * Whether to show the button at all. Defaults to `true`.
+     */
+    show?: boolean;
+    /**
+     * Whether the button is disabled. Defaults to `false`.
+     */
+    disabled?: boolean;
+    /**
+     * A checked button will have a highlight color as an icon, or a check mark as menu entry. Defaults to `false`.
+     */
+    checked?: boolean;
+    /**
+     * The callback to call when button was clicked.
+     */
+    click?: (button: Button, event: Event) => void;
+    /**
+     * Rarely used, only for OKpilot where we want to show proper URL, but click is actually intercepted to show dialog
+     */
+    href?: string;
+    /**
+     * A non-empty list of sub-buttons (only 2 levels is supported).
+     */
+    buttons?: SubButton[];
+};
+/**
+ * A sub-button that will (always) be shown as a sub-menu entry
+ */
+type SubButton = {
+    /**
+     * Label for menu entry
+     */
+    label: string;
+    /**
+     * Whether the button is disabled. Defaults to `false`.
+     */
+    disabled?: boolean;
+    /**
+     * The callback to call when button was clicked.
+     */
+    click: (subButton: SubButton, event: Event) => void;
+};
+
+type Filter = {
+    groups?: FilterGroup[] | null;
+};
+type FilterGroup = {
+    groupLogic?: LogicalOperator | null;
+    conditionsLogic?: LogicalOperator | null;
+    joins?: FilterGroupJoin | null;
+    conditions?: FilterGroupCondition[] | null;
+};
+type FilterGroupJoin = Record<string, JoinOn>;
+type JoinOn = {
+    type?: JoinType | null;
+    joins?: FilterGroupJoin | null;
+    conditions?: FilterGroupCondition[] | null;
+};
+declare enum LogicalOperator {
+    AND = "AND",
+    OR = "OR"
+}
+declare enum JoinType {
+    innerJoin = "innerJoin",
+    leftJoin = "leftJoin"
+}
+type FilterGroupCondition = Record<string, FilterGroupConditionField>;
+type FilterGroupConditionField = {
+    between?: BetweenOperator | null;
+    equal?: EqualOperator | null;
+    greater?: GreaterOperator | null;
+    greaterOrEqual?: GreaterOrEqualOperator | null;
+    in?: InOperator | null;
+    less?: LessOperator | null;
+    lessOrEqual?: LessOrEqualOperator | null;
+    like?: LikeOperator | null;
+    null?: NullOperator | null;
+    have?: HaveOperator | null;
+    empty?: EmptyOperator | null;
+    [key: string]: Literal | undefined | null;
+};
+type Scalar = number | string | boolean;
+type HaveOperator = {
+    values: string[];
+    not?: boolean | null;
+};
+type EmptyOperator = {
+    not?: boolean | null;
+};
+type BetweenOperator = {
+    from: Scalar;
+    to: Scalar;
+    not?: boolean | null;
+};
+type EqualOperator = {
+    value: Scalar;
+    not?: boolean | null;
+};
+type GreaterOperator = {
+    value: Scalar;
+    not?: boolean | null;
+};
+type GreaterOrEqualOperator = {
+    value: Scalar;
+    not?: boolean | null;
+};
+type InOperator = {
+    values: Scalar[];
+    not?: boolean | null;
+};
+type LessOperator = {
+    value: Scalar;
+    not?: boolean | null;
+};
+type LessOrEqualOperator = {
+    value: Scalar;
+    not?: boolean | null;
+};
+type LikeOperator = {
+    value: Scalar;
+    not?: boolean | null;
+};
+type NullOperator = {
+    not?: boolean | null;
+};
+
+type DropdownComponent = {
+    /**
+     * Observable of current value as string
+     */
+    readonly renderedValue: BehaviorSubject<string>;
+    /**
+     * Get condition, including rich object types
+     */
+    getCondition(): FilterGroupConditionField;
+    /**
+     * Returns true if dropdown value is valid
+     */
+    isValid(): boolean;
+    /**
+     * Returns true if the dropdown value has change
+     */
+    isDirty(): boolean;
+};
+
+/**
+ * Type for a search selection
+ */
+type NaturalSearchSelection = {
+    field: string;
+    /**
+     * This is required if the facet also have a `name`.
+     *
+     * See BasicFacet.name
+     */
+    name?: string;
+    condition: FilterGroupConditionField;
+};
+/**
+ * Groups are a list of values, that should be interpreted with AND condition
+ */
+type GroupSelections = NaturalSearchSelection[];
+/**
+ * List of groups, that should be interpreted with OR condition
+ * Final input / output format
+ */
+type NaturalSearchSelections = GroupSelections[];
+/**
+ * Consolidated type for a selection and it's matching facet
+ * Used internally for dropdown
+ */
+type DropdownResult = {
+    condition: FilterGroupConditionField;
+    facet?: Facet;
+};
+
+type BasicFacet = {
+    /**
+     * The label to be used in the GUI
+     */
+    display: string;
+    /**
+     * The field this facet should apply to.
+     *
+     * In most cases it should be the property name of the model. Something like:
+     *
+     * - name
+     * - description
+     * - artist.name
+     */
+    field: string;
+    /**
+     * This is required only if there are duplicated `field` in all facets.
+     *
+     * If `name` exists it will be used as an alternative identifier for facet, instead of `field`, to match
+     * a selection with its facet (in `getFacetFromSelection()`). So a selection must be given with the `name`,
+     * instead of `field`. And it will also be present in the URL. But it will never appear in the GraphQL selection.
+     *
+     * https://github.com/Ecodev/natural-search/issues/16
+     */
+    name?: string;
+    /**
+     * A function to transform the selection before it is applied onto the filter.
+     *
+     * This would typically be useful to do unit conversion so the GUI has some user
+     * friendly values, but the API works with a "low-level" unit.
+     */
+    transform?: (s: NaturalSearchSelection) => NaturalSearchSelection;
+};
+/**
+ * Facet that is only a flag (set or unset)
+ */
+type FlagFacet<Condition> = {
+    /**
+     * The value to be returned when the flag is set
+     */
+    condition: Condition;
+    /**
+     * If true the value is set when the flag does NOT exist and the
+     * value is unset when the flag exists.
+     *
+     * Defaults to `false`.
+     */
+    inversed?: boolean;
+} & BasicFacet;
+/**
+ * Facet that uses a component in a dropdown
+ */
+type DropdownFacet<C> = {
+    component: Type<DropdownComponent>;
+    /**
+     * Show a button into the dropdown container to validate value. Gives alternative to "click out" and incoming "tab/esc" key.
+     */
+    showValidateButton?: boolean;
+    /**
+     * Anything that could be useful for the dropdown component
+     */
+    configuration?: C;
+} & BasicFacet;
+/**
+ * A facet
+ */
+type Facet = DropdownFacet<any> | FlagFacet<any>;
+/**
+ * Exhaustive list of facets
+ */
+type NaturalSearchFacets = Facet[];
+
+/**
+ * Validator for persisted values retrieved from NaturalPersistenceService. If returns false, the persisted value
+ * will be ignored, and instead `null` will be returned.
+ *
+ * `storageKey` is only given if the value is coming from session storage (and not from URL).
+ */
+type PersistenceValidator = (key: string, storageKey: string | null, value: unknown) => boolean;
+declare const NATURAL_PERSISTENCE_VALIDATOR: InjectionToken<PersistenceValidator>;
+declare class NaturalPersistenceService {
+    private readonly router;
+    private readonly sessionStorage;
+    private readonly isValid;
+    /**
+     * Persist in url and local storage the given value with the given key.
+     * When stored in storage, we need more "key" to identify the controller.
+     */
+    persist(key: string, value: unknown, route: ActivatedRoute, storageKey: string, navigationExtras?: NavigationExtras): Promise<boolean>;
+    /**
+     * Return object with persisted data in url or in session storage
+     * Url has priority over session storage because of url sharing. When url is provided, session storage is ignored.
+     * Url and storage are synced when arriving in a component :
+     *  - When loading with url parameters, storage is updated to stay synced
+     *  - When loading without url, but with storage data, the url is updated
+     */
+    get(key: string, route: ActivatedRoute, storageKey: string): any | null;
+    /**
+     * Get given key from the url parameters
+     */
+    getFromUrl(key: string, route: ActivatedRoute): any | null;
+    /**
+     * Add/override given pair key-value in the url
+     * Always JSON.stringify() the given value
+     * If the value is falsey, the pair key-value is removed from the url.
+     */
+    persistInUrl(key: string, value: unknown, route: ActivatedRoute, navigationExtras?: NavigationExtras): Promise<boolean>;
+    getFromStorage(key: string, storageKey: string): any | null;
+    /**
+     * Store value in session storage.
+     * If value is falsy, the entry is removed
+     */
+    persistInStorage(key: string, value: unknown, storageKey: string): void;
+    private getStorageKey;
+    private isFalseyValue;
+    private deserialize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalPersistenceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalPersistenceService>;
+}
+
+type BreadcrumbItem = {
+    id: string;
+    name: string;
+} & Literal;
+type NavigableItem<T> = {
+    item: T;
+    hasNavigation: boolean;
+};
+/**
+ * This class helps managing a list of paginated items that can be filtered,
+ * selected, and then bulk actions can be performed on selection.
+ *
+ * @dynamic
+ */
+declare class NaturalAbstractNavigableList<TService extends NaturalAbstractModelService<any, any, PaginatedData<{
+    id: string;
+}>, QueryVariables, any, any, any, any, any, any>> extends NaturalAbstractList<TService, PaginatedData<NavigableItem<ExtractTall<TService>['items'][0]>>> implements OnInit {
+    /**
+     * Name of filter for child items to access ancestor item
+     */
+    readonly ancestorRelationName: i0.InputSignal<string>;
+    private oldAncertorId;
+    breadcrumbs: BreadcrumbItem[];
+    constructor(service: TService);
+    ngOnInit(): void;
+    protected getDataObservable(): Observable<PaginatedData<NavigableItem<ExtractTallOne<TService>>>>;
+    protected translateSearchAndRefreshList(naturalSearchSelections: NaturalSearchSelections): void;
+    clearSearch(resetPagination?: boolean): void;
+    search(naturalSearchSelections: NaturalSearchSelections, navigationExtras?: NavigationExtras, resetPagination?: boolean): void;
+    /**
+     * Return an array for router link usage
+     */
+    getChildLink(ancestor: {
+        id: string;
+    } | null): RouterLink['routerLink'];
+    /**
+     * Depth is limited by queries
+     * @param item with an ancestor relation (must match ancestorRelationName attribute)
+     */
+    protected getBreadcrumb(item: BreadcrumbItem): BreadcrumbItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalAbstractNavigableList<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalAbstractNavigableList<any>, never, never, { "ancestorRelationName": { "alias": "ancestorRelationName"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type MaybeNavigable = Literal | NavigableItem<Literal>;
+/**
+ * This class helps managing a list of paginated items that can be filtered,
+ * selected, and then bulk actions can be performed on selection.
+ *
+ * Components inheriting from this class can be used as standalone with input attributes.
+ *
+ * Usage :
+ *
+ * ```html
+ * <natural-my-listing [forcedVariables]="{filter:...}" [selectedColumns]="['col1']" [persistSearch]="false">
+ * ```
+ */
+declare class NaturalAbstractList<TService extends NaturalAbstractModelService<any, any, PaginatedData<Literal>, QueryVariables, any, any, any, any, any, any>, Tall extends PaginatedData<MaybeNavigable> = ExtractTall<TService>> extends NaturalAbstractPanel implements OnInit {
+    readonly service: TService;
+    /**
+     * Whether search should be loaded from url/storage and persisted in it too.
+     */
+    persistSearch: boolean;
+    /**
+     * List of columns that are available to the end-user to select from, via `<natural-columns-picker>`
+     */
+    availableColumns: AvailableColumn[];
+    /**
+     * Columns list after interaction with `<natural-columns-picker>`
+     */
+    columnsForTable: string[];
+    /**
+     * The default column selection that automatically happened after `<natural-columns-picker>` initialization
+     */
+    private defaultSelectedColumns;
+    /**
+     * Visible (checked) columns
+     *
+     * Instead of using this, you should consider correctly configuring `AvailableColumn.checked`.
+     */
+    selectedColumns?: string[];
+    /**
+     * Source of the list
+     */
+    dataSource: NaturalDataSource<Tall> | undefined;
+    /**
+     * Selection for bulk actions
+     */
+    readonly selection: SelectionModel<ExtractTall<TService>["items"][0]>;
+    /**
+     * Next executed action from bulk menu
+     */
+    bulkActionSelected: string | null;
+    /**
+     * Centralisation of query variables
+     */
+    variablesManager: NaturalQueryVariablesManager<ExtractVall<TService>>;
+    /**
+     * Configuration for natural-search facets
+     */
+    naturalSearchFacets: NaturalSearchFacets;
+    /**
+     * Result of a search (can be provided as input for initialisation)
+     */
+    naturalSearchSelections: NaturalSearchSelections;
+    /**
+     * Data attribute provided by activated route snapshot
+     */
+    routeData?: Data$1;
+    /**
+     * List of page sizes
+     */
+    readonly pageSizeOptions: number[];
+    /**
+     * Initial pagination setup
+     */
+    protected defaultPagination: Required<PaginationInput>;
+    /**
+     * Initial sorting
+     */
+    protected defaultSorting?: Sorting[];
+    protected readonly router: Router;
+    protected readonly route: ActivatedRoute;
+    protected readonly alertService: NaturalAlertService;
+    protected readonly persistenceService: NaturalPersistenceService;
+    constructor(service: TService);
+    /**
+     * Variables that are always forced on a list, in addition to whatever the end-user might select
+     */
+    set forcedVariables(variables: QueryVariables | null | undefined);
+    /**
+     * If change, check DocumentsComponent that overrides this function without calling super.ngOnInit().
+     */
+    ngOnInit(): void;
+    protected handleHistoryNavigation(): void;
+    /**
+     * Persist search and then launch whatever is required to refresh the list
+     */
+    search(naturalSearchSelections: NaturalSearchSelections, navigationExtras?: NavigationExtras, resetPagination?: boolean): void;
+    /**
+     * Change sorting variables for query and persist the new value in url and local storage
+     * The default value is not persisted
+     * @param sortingEvents List of material sorting events
+     */
+    sorting(sortingEvents: (Sort & Partial<Pick<Sorting, 'nullAsHighest' | 'emptyStringAsHighest'>>)[]): void;
+    /**
+     * Return current pagination, either the user defined one, or the default one
+     */
+    protected getPagination(): PaginationInput;
+    /**
+     * Change pagination variables for query and persist in url and local storage the new value
+     * The default value not persisted
+     *
+     * @param event Natural or Paginator PageEvent
+     * @param defer Promise (usually a route promise) that defers the redirection from this call to prevent route navigation collision
+     * @param navigationExtras Angular router navigation options. Is relevant only if persistSearch is true
+     */
+    pagination(event: PaginationInput | PageEvent, defer?: Promise<unknown>, navigationExtras?: NavigationExtras): void;
+    protected persistPagination(pagination: PaginationInput | null, defer?: Promise<unknown>, navigationExtras?: NavigationExtras): void;
+    /**
+     * Selects all rows if they are not all selected; otherwise clear selection
+     */
+    masterToggle(): void;
+    /**
+     * Whether the number of selected elements matches the total number of rows
+     */
+    isAllSelected(): boolean;
+    /**
+     * Called when a bulk action is selected
+     */
+    bulkAction(): void;
+    /**
+     * In non-panel context, header is always visible.
+     * In panel context, header is hidden when no results.
+     */
+    showHeader(): boolean;
+    /**
+     * Search is visible in most cases, but hidden on a panel
+     */
+    showSearch(): boolean;
+    /**
+     * Table should be shown only when there is data
+     */
+    showTable(): boolean;
+    /**
+     * No results is shown when there is no items, but only in non-panel context only.
+     * In panels we want discrete mode, there is no search and no "no-results"
+     */
+    showNoResults(): boolean;
+    /**
+     * Initialize from route.
+     *
+     * Uses data provided by router such as:
+     *
+     * - `route.data.forcedVariables`
+     * - `route.data.availableColumns`
+     * - `route.data.selectedColumns`
+     */
+    protected initFromRoute(): void;
+    protected getDataObservable(): Observable<Tall>;
+    protected initFromPersisted(): void;
+    protected translateSearchAndRefreshList(naturalSearchSelections: NaturalSearchSelections, ignoreEmptyFilter?: boolean): void;
+    /**
+     * Return current url excluding last route parameters;
+     */
+    protected getStorageKey(): string;
+    protected bulkdDeleteConfirmation(): Observable<boolean | undefined>;
+    /**
+     * Delete multiple items at once
+     */
+    protected bulkDelete(): Observable<void>;
+    private applyForcedVariables;
+    selectColumns(columns: string[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalAbstractList<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalAbstractList<any, any>, never, never, { "persistSearch": { "alias": "persistSearch"; "required": false; }; "availableColumns": { "alias": "availableColumns"; "required": false; }; "selectedColumns": { "alias": "selectedColumns"; "required": false; }; "forcedVariables": { "alias": "forcedVariables"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Detect if the given variables have a file to be uploaded or not, and
+ * also convert date to be serialized with their timezone.
+ */
+declare function hasFilesAndProcessDate(variables: unknown): boolean;
+/**
+ * Create an Apollo link that supports batched queries and file uploads.
+ *
+ * File uploads and mutations are never batched.
+ */
+declare function createHttpLink(httpLink: HttpLink, httpBatchLink: HttpBatchLink, options: Options): ApolloLink;
+
+/**
+ * Behave like setTimeout(), but with a mandatory cancel mechanism.
+ *
+ * This is typically useful to replace setTimeout() in components where the callback
+ * would crash if executed after the component destruction. That can easily happen
+ * when the user navigates quickly between pages.
+ *
+ * Typical usage in a component would be:
+ *
+ * ```ts
+ * cancellableTimeout(inject(DestroyRef)).subscribe(myCallback);
+ * ```
+ *
+ * or
+ *
+ * ```ts
+ * cancellableTimeout(this.ngUnsubscribe).subscribe(myCallback);
+ * ```
+ *
+ * Instead of the more error-prone:
+ *
+ * ```ts
+ * public foo(): void {
+ *     this.timeout = setTimeout(myCallBack);
+ * }
+ *
+ * public ngOnDestroy(): void {
+ *     if (this.timeout) {
+ *         clearTimeout(this.timeout);
+ *         this.timeout = null;
+ *      }
+ * }
+ * ```
+ */
+declare function cancellableTimeout(canceller: Observable<unknown> | DestroyRef, milliSeconds?: number): Observable<void>;
+/**
+ * For debugging purpose only, will dump in console everything that happen to
+ * the observable
+ */
+declare function debug<T>(debugName: string): MonoTypeOperatorFunction<T>;
+
+/**
+ * Very basic formatting to get only date, without time and ignoring entirely the timezone
+ *
+ * So something like: "2021-09-23"
+ */
+declare function formatIsoDate(date: null): null;
+declare function formatIsoDate(date: Date): string;
+declare function formatIsoDate(date: Date | null): string | null;
+/**
+ * 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;
+/**
+ * Relations to full objects are converted to their IDs only.
+ *
+ * So {user: {id: 123}} becomes {user: 123}
+ */
+declare function relationsToIds(object: Literal): Literal;
+/**
+ * Returns the plural form of the given name
+ *
+ * This is **not** necessarily valid english grammar. Its only purpose is for internal usage, not for humans.
+ *
+ * This **MUST** be kept in sync with `\Ecodev\Felix\Api\Plural:make()`.
+ *
+ * This is a bit performance-sensitive, so we should keep it fast and only cover cases that we actually need.
+ */
+declare function makePlural(name: string): string;
+/**
+ * Returns the string with the first letter as capital
+ */
+declare function upperCaseFirstLetter(term: string): string;
+/**
+ * Replace all attributes of first object with the ones provided by the second, but keeps the reference
+ */
+declare function replaceObjectKeepingReference(obj: Literal | null, newObj: Literal | null): void;
+/**
+ * Get contrasted color for text in the slider thumb
+ * @param hexBgColor string in hexadecimals representing the background color
+ */
+declare function getForegroundColor(hexBgColor: string): 'black' | 'white';
+/**
+ * Convert RGB color to hexadecimal color
+ *
+ * ```ts
+ * rgbToHex('rgb(255, 00, 255)'); // '#FF00FF'
+ * ```
+ */
+declare function rgbToHex(rgb: string): string;
+/**
+ * Deep clone given values except for `File` that will be referencing the original value
+ */
+declare function cloneDeepButSkipFile<T>(value: T): T;
+declare function isFile(value: unknown): boolean;
+/**
+ * During lodash.mergeWith, overrides arrays
+ */
+declare function mergeOverrideArray(destValue: unknown, source: unknown): unknown;
+/**
+ * Copy text to clipboard.
+ * Accepts line breaks `\n` as textarea do.
+ */
+declare function copyToClipboard(document: Document, text: string): void;
+declare function deepFreeze<T extends Literal>(o: T): ReadonlyDeep<T>;
+/**
+ * Return a valid PaginationInput from whatever is available from data. Invalid properties/types will be dropped.
+ */
+declare function validatePagination(data: unknown): PaginationInput | null;
+/**
+ * Return a valid Sortings from whatever is available from data. Invalid properties/types will be dropped.
+ */
+declare function validateSorting(data: unknown): Sorting[] | null;
+/**
+ * Return valid columns from whatever is available from data. Invalid properties/types will be dropped.
+ */
+declare function validateColumns(data: unknown): string[] | null;
+declare function onHistoryEvent(router: Router): Observable<NavigationEnd>;
+
+/**
+ * Returns an async validator function that checks that the form control value is unique
+ */
+declare function unique(fieldName: string, excludedId: string | null | undefined, modelService: UntypedModelService): AsyncValidatorFn;
+/**
+ * Returns an async validator function that checks that the form control value is available
+ *
+ * Similar to `unique` validator, but allows to use a custom query for when the client does
+ * not have permissions for `modelService.count()`.
+ */
+declare function available(getAvailableQuery: (value: string, excludedId: string | null) => Observable<boolean>, excludedId?: string | null): AsyncValidatorFn;
+/**
+ * Return all errors recursively for the given Form or control
+ */
+declare function collectErrors(control: AbstractControl<unknown>): ValidationErrors | null;
+/**
+ * Force validation of all form controls recursively.
+ *
+ * Recursively mark descending form tree as dirty and touched in order to show all invalid fields on demand.
+ * Typically used when creating a new object and user clicked on create button but several fields were not
+ * touched and are invalid.
+ */
+declare function validateAllFormControls(control: AbstractControl<unknown>): void;
+/**
+ * Emits exactly 0 or 1 time:
+ *
+ * - if the form is VALID, emits immediately
+ * - if the form is PENDING emits if it changes from PENDING to VALID
+ * - any other cases will **never** emit
+ */
+declare function ifValid(control: AbstractControl): Observable<'VALID'>;
+/**
+ * Validate an email address according to RFC, and also that it is publicly deliverable (not "root@localhost" or "root@127.0.0.1")
+ *
+ * This is meant to replace **all** usages of Angular too permissive `Validators.email`
+ */
+declare function deliverableEmail(control: AbstractControl): ValidationErrors | null;
+/**
+ * Naive URL validator for "normal" web links, that is a bit too permissive
+ *
+ * It enforces:
+ *
+ *     - http/https protocol
+ *     - one domain
+ *     - one tld
+ *
+ * It allows:
+ *
+ *     - any number of subdomains
+ *     - any parameters
+ *     - any fragments
+ *     - any characters for any parts (does not conform to rfc1738)
+ */
+declare const urlValidator: ValidatorFn;
+/**
+ * Validates that the value is an integer (non-float)
+ */
+declare function integer(control: AbstractControl): ValidationErrors | null;
+/**
+ * Validate that the value is a decimal number with up to `scale` digits
+ *
+ * The error contains the expected scale, so that the error message can explain
+ * it to the end-user.
+ */
+declare function decimal(scale: number): ValidatorFn;
+/**
+ * Validate that the value is an amount of money, meaning a number with at most 2 decimals
+ */
+declare function money(control: AbstractControl): ValidationErrors | null;
+
+type ProgressBar = {
+    start: () => void;
+    complete: () => void;
+};
+/**
+ * Intercept HTTP request from Angular to show them as activity
+ */
+declare const activityInterceptor: HttpInterceptorFn;
+/**
+ * Singleton to track pending XHR and XHR errors in the whole application.
+ *
+ * You must:
+ *
+ * - start the tracking by calling `setProgressRef()`
+ * - provide the HTTP interceptor `activityInterceptor`
+ *
+ * The tracking will be entirely disabled for SSR.
+ */
+declare class NetworkActivityService {
+    private progress;
+    private readonly isBrowser;
+    /**
+     * Count pending requests
+     */
+    private pending;
+    private readonly writableErrors;
+    /**
+     * GraphQL errors that happened recently
+     */
+    readonly errors: i0.Signal<GraphQLFormattedError[]>;
+    setProgressRef(progressBar: ProgressBar): void;
+    /**
+     * Notify an XHR started
+     */
+    increase(): void;
+    /**
+     * Notify an XHR ended (even if unsuccessful)
+     */
+    decrease(): void;
+    /**
+     * Add new GraphQL errors
+     */
+    addErrors(errors: readonly GraphQLFormattedError[]): void;
+    /**
+     * Clear all GraphQL errors
+     */
+    clearErrors(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkActivityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NetworkActivityService>;
+}
+
+/**
+ * Array of valid top-level-domains
+ * IanaVersion 2020033100
+ *
+ * This should ideally be kept in sync with \Laminas\Validator\Hostname
+ *
+ * See ftp://data.iana.org/TLD/tlds-alpha-by-domain.txt  List of all TLDs by domain
+ * See http://www.iana.org/domains/root/db/ Official list of supported TLDs
+ */
+declare const validTlds: readonly string[];
+
+type IEnum = {
+    value: string;
+    name: string;
+};
+declare class NaturalEnumService {
+    private readonly apollo;
+    /**
+     * Return a list of observable enumerables considering the given name
+     */
+    get(name: string): Observable<IEnum[]>;
+    /**
+     * Returns the enum user-friendly name, instead of its value.
+     */
+    getValueName(value: string, enumName: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalEnumService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalEnumService>;
+}
+
+declare class NaturalSwissParsingDateAdapter extends NativeDateAdapter {
+    /**
+     * Parse commonly accepted swiss format, such as:
+     *
+     * - 24.12.2018
+     * - 1.4.18
+     * - 2018-12-24
+     */
+    parse(value: unknown): Date | null;
+    private createDateIfValid;
+    getFirstDayOfWeek(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSwissParsingDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalSwissParsingDateAdapter>;
+}
+
+type NaturalConfirmData = {
+    title: string;
+    message: string;
+    confirmText: string;
+    cancelText: string;
+};
+declare class NaturalConfirmComponent {
+    readonly data: NaturalConfirmData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalConfirmComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class NaturalColumnsPickerComponent implements OnChanges {
+    private readonly destroyRef;
+    private readonly breakpointObserver;
+    private _selections?;
+    private _availableColumns;
+    readonly buttons: i0.InputSignal<readonly Readonly<Button>[] | null>;
+    /**
+     * Set all the columns that are available.
+     */
+    set availableColumns(columns: readonly Readonly<AvailableColumn>[] | undefined);
+    /**
+     * Set the columns that we would like to select but might be unavailable.
+     *
+     * If a column is unavailable it will be ignored silently. To know what columns were actually applied
+     * you should use `selectionChange`.
+     *
+     * It is often set once on component initialization, but it can also be set again later in the lifespan of the component.
+     */
+    set selections(columns: string[] | undefined);
+    /**
+     * Emit a list of valid and selected column keys whenever the selection changes
+     */
+    readonly selectionChange: i0.OutputEmitterRef<string[]>;
+    /**
+     * Displayed options in the dropdown menu
+     */
+    displayedColumns: Required<AvailableColumn>[];
+    readonly isMobile: rxjs.Observable<boolean>;
+    private initColumns;
+    updateColumns(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    defaultTrue(value: boolean | undefined): boolean;
+    color(button: Button): ThemePalette | null;
+    useCheckbox(button: Button): boolean;
+    needMargin(button?: Button | null): string;
+    someVisibleButtons(): boolean;
+    protected menuItemClicked($event: MouseEvent, column: Required<AvailableColumn>): void;
+    protected checkboxClicked($event: MouseEvent, column: Required<AvailableColumn>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalColumnsPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalColumnsPickerComponent, "natural-columns-picker", never, { "buttons": { "alias": "buttons"; "required": false; "isSignal": true; }; "availableColumns": { "alias": "availableColumns"; "required": false; }; "selections": { "alias": "selections"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+/**
+ * Usage :
+ *
+ * ```html
+ * <mat-tab-group [naturalLinkableTab]="!isPanel">
+ *     <mat-tab label="Tab 1">Tab 1</mat-tab> // First tab doesn't need id. This keeps url clean on default one
+ *     <mat-tab label="Tab 2" id="second-tab">Tab 2</mat-tab>
+ *     ...
+ * </mat-tab-group>
+ * ```
+ */
+declare class NaturalLinkableTabDirective implements AfterViewInit {
+    private readonly destroyRef;
+    private readonly component;
+    private readonly route;
+    private readonly router;
+    /**
+     * If false, disables the persistent navigation
+     */
+    readonly naturalLinkableTab: i0.InputSignal<boolean | "">;
+    private isLoadingRouteConfig;
+    constructor();
+    ngAfterViewInit(): void;
+    private getTabIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalLinkableTabDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalLinkableTabDirective, "mat-tab-group[naturalLinkableTab]", never, { "naturalLinkableTab": { "alias": "naturalLinkableTab"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Returns the string with the first letter as capital
+ */
+declare class NaturalCapitalizePipe implements PipeTransform {
+    transform(value: string | null): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalCapitalizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NaturalCapitalizePipe, "capitalize", true>;
+}
+
+declare class NaturalEllipsisPipe implements PipeTransform {
+    transform(value: string, limit: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalEllipsisPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NaturalEllipsisPipe, "ellipsis", true>;
+}
+
+/**
+ * A pipe to output an enum user-friendly name, instead of its value.
+ *
+ * Usage would be: {{ element.priority | enum: 'Priority' | async }}
+ */
+declare class NaturalEnumPipe implements PipeTransform {
+    private readonly enumService;
+    transform(value: any, enumName: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalEnumPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NaturalEnumPipe, "enum", true>;
+}
+
+/**
+ * Returns a string to approximately describe the date.
+ *
+ * Eg:
+ *
+ * - "il y a quelques minutes"
+ * - "dans 3 jours"
+ * - "dans 3 ans"
+ */
+declare class NaturalTimeAgoPipe implements PipeTransform {
+    fakedNow: number | null;
+    private getNow;
+    transform(date: Date | string | null | undefined): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalTimeAgoPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NaturalTimeAgoPipe, "timeAgo", true>;
+}
+
+declare const SESSION_STORAGE: InjectionToken<NaturalStorage>;
+declare const LOCAL_STORAGE: InjectionToken<NaturalStorage>;
+/**
+ * Normal `Storage` type, but without array access
+ */
+type NaturalStorage = Pick<Storage, 'length' | 'clear' | 'getItem' | 'key' | 'removeItem' | 'setItem'>;
+/**
+ * Memory storage to keep store volatile things in memory
+ *
+ * Should be used to shim sessionStorage when running on server or in our tests
+ */
+declare class NaturalMemoryStorage implements NaturalStorage {
+    private readonly data;
+    get length(): number;
+    clear(): void;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
+    removeItem(key: string): void;
+    setItem(key: string, value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalMemoryStorage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalMemoryStorage>;
+}
+declare function sessionStorageFactory(): NaturalStorage;
+/**
+ * Standard `sessionStorage` provider that is compatible with SSR.
+ *
+ * In SSR environment, or when `sessionStorage` is not available, will return a `NaturalMemoryStorage`
+ */
+declare const sessionStorageProvider: Provider;
+/**
+ * Provide in-memory session storage to be used only in tests or SSR
+ */
+declare const memorySessionStorageProvider: Provider;
+declare function localStorageFactory(): NaturalStorage;
+/**
+ * Standard `localStorage` provider that is compatible with SSR.
+ *
+ * In SSR environment, or when `localStorage` is not available, will return a `NaturalMemoryStorage`
+ */
+declare const localStorageProvider: Provider;
+/**
+ * Provide in-memory local storage to be used only in tests or SSR
+ */
+declare const memoryLocalStorageProvider: Provider;
+
+declare class NaturalSrcDensityDirective {
+    private readonly elementRef;
+    /**
+     * Automatically apply image selection based on screen density.
+     *
+     * The given URL **MUST** be the normal density URL. And it **MUST** include
+     * the size as last path segment. That size will automatically be changed
+     * for other screen densities. That means that the server **MUST** be able to
+     * serve an image of the given size.
+     *
+     * Usage:
+     *
+     * ```html
+     * <img naturalSrcDensity="/api/image/123/200" />
+     * ```
+     *
+     * Will generate something like:
+     *
+     * ```html
+     * <img
+     *     src="/api/image/123/200"
+     *     srcset="/api/image/123/200, /api/image/123/300 1.5x, /api/image/123/400 2x, /api/image/123/600 3x, /api/image/123/800 4x"
+     * />
+     * ```
+     *
+     * See https://web.dev/codelab-density-descriptors/
+     */
+    readonly naturalSrcDensity: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSrcDensityDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalSrcDensityDirective, "img[naturalSrcDensity]", never, { "naturalSrcDensity": { "alias": "naturalSrcDensity"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NaturalBackgroundDensityDirective {
+    private readonly elementRef;
+    /**
+     * Automatically apply background image selection based on screen density.
+     *
+     * The given URL **MUST** be the normal density URL. And it **MUST** include
+     * the size as last path segment. That size will automatically be changed
+     * for other screen densities. That means that the server **MUST** be able to
+     * serve an image of the given size.
+     *
+     * If the given URL starts with `url(`, or is not ending with a number, then
+     * it will be set as-is, without any processing. This allows using url data,
+     * such as `url(data:image/png;base64,aabbcc)`.
+     *
+     * Usage:
+     *
+     * ```html
+     * <div naturalBackgroundDensity="/api/image/123/200"></div>
+     * <div naturalBackgroundDensity="/non-responsive.jpg"></div>
+     * <div naturalBackgroundDensity="url(data:image/png;base64,aabbcc)"></div>
+     * ```
+     *
+     * Will generate something like:
+     *
+     * ```html
+     * <div style="background-image: image-set(url("/api/image/123/200") 1x, url("/api/image/123/300") 1.5x, url("/api/image/123/400") 2x, url("/api/image/123/600") 3x, url("/api/image/123/800") 4x);"></div>
+     * <div style="background-image: url("/non-responsive.jpg");"></div>
+     * <div style="background-image: url(data:image/png;base64,aabbcc)"></div>
+     * ```
+     *
+     * See https://developer.mozilla.org/en-US/docs/Web/CSS/image/image-set
+     */
+    readonly naturalBackgroundDensity: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalBackgroundDensityDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalBackgroundDensityDirective, "[naturalBackgroundDensity]", never, { "naturalBackgroundDensity": { "alias": "naturalBackgroundDensity"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NaturalSeo = NaturalSeoBasic | NaturalSeoCallback | NaturalSeoResolve;
+/**
+ * Typically used for "static" pages where there is not a single resolved object. So
+ * all pages such as "About", or list of objects (list of risks, etc.).
+ *
+ * This should be the most common used variant.
+ */
+type NaturalSeoBasic = Robots & {
+    /**
+     * The page title, that will be concatenated with application name
+     */
+    title: string;
+    /**
+     * If given will be used as page description, otherwise fallback on default value
+     */
+    description?: string;
+    /**
+     * List of parameters included in the canonical tag's url
+     */
+    canonicalQueryParamsWhitelist?: string[];
+};
+/**
+ * Typically used for a "dynamic" page where a single object is resolved. So a detail page, such
+ * as the detail of a risk and so on.
+ */
+type NaturalSeoResolve = Robots & {
+    /**
+     * The key `model` will be used in the resolved data to find the resolved object. The fullName
+     * or name of the object will be used for page title, and the object description, if any,
+     * will be used for page description.
+     */
+    resolve: true;
+};
+/**
+ * Rarely used for a page that has very specific needs and need to build title and description in a custom way.
+ * The callback back will be given the resolved data, and it is up to the callback to find whatever it needs.
+ */
+type NaturalSeoCallback = (routeData: Data$1) => NaturalSeoBasic | Observable<NaturalSeoBasic>;
+/**
+ * Typically used to type the routing data received in the component, eg:
+ *
+ * ```ts
+ * class MyComponent extends NaturalAbstractDetail<MyService, NaturalSeoResolveData> {}
+ * ```
+ */
+type NaturalSeoResolveData = {
+    seo: NaturalSeoBasic;
+};
+type Robots = {
+    /**
+     * If given will be used as robots meta tag, otherwise fallback on default value
+     */
+    robots?: string;
+};
+type NaturalSeoConfigPlain = {
+    /**
+     * The name of the application that will always appear in the page title
+     */
+    readonly applicationName: string;
+    /**
+     * Default value for description meta that is used for pages without value
+     */
+    readonly defaultDescription?: string;
+    /**
+     * Default value for robots meta that is used for pages without value
+     */
+    readonly defaultRobots?: string;
+    /**
+     * If given, the callback will be called for each route and must return a string that will
+     * be inserted between the page title and the application name.
+     *
+     * It should be used to complete the title with info that are often, but not necessarily always,
+     * available throughout the entire application. Typically used for the site/state in OKpilot.
+     */
+    readonly extraPart?: (routeData: Data$1) => string;
+    /**
+     * Used to generate alternative tags
+     * <link rel="alternate" hreflang="en" href="https://www.example.com/en/page">
+     */
+    readonly languages?: readonly string[];
+};
+type NaturalSeoConfig = NaturalSeoConfigPlain | Observable<NaturalSeoConfigPlain>;
+declare const NATURAL_SEO_CONFIG: InjectionToken<NaturalSeoConfig>;
+/**
+ * This service is responsible to keep up to date the page title and page description according
+ * to what is configured in routing or default values.
+ *
+ * It **must** be injected in the root module of the application to have effects in all modules. And it
+ * must be provided a configuration.
+ *
+ * The full title has the following structure:
+ *
+ *     dialog title - page title - extra part - app name
+ *
+ * `dialog title` only exists if a `NaturalDialogTriggerComponent` is currently open, and that some SEO is
+ * configured for it in the routing.
+ */
+declare class NaturalSeoService {
+    private readonly router;
+    private readonly titleService;
+    private readonly metaTagService;
+    private readonly document;
+    private locale;
+    private routeData?;
+    private config;
+    constructor();
+    /**
+     * Update the SEO with given info. The extra part and app name will be appended automatically.
+     *
+     * In most cases, this should not be used. And instead, the SEO should be configured in the routing,
+     * possibly with the callback variant for some dynamism.
+     *
+     * But in rare cases, only the Component is able to build a proper page title, after it gathered everything it
+     * needed. For those cases, the Component can inject this service and update the SEO directly.
+     */
+    update(seo: NaturalSeoBasic): void;
+    private updateAlternates;
+    private getUrlParts;
+    /**
+     * Add language between domain and uri https://example.com/fr/folder/page
+     */
+    private getUrl;
+    private addLanguageSegment;
+    private join;
+    private updateTag;
+    private updateLinkTag;
+    /**
+     * Returns selector to use in querySelector to get the given link
+     */
+    private parseSelector;
+    /**
+     * Returns the data from the most deep/specific activated route
+     */
+    private getRouteData;
+    /**
+     * Returns the data from the `NaturalDialogTriggerComponent` if one is open
+     */
+    private getDialogRouteData;
+    private toBasic;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSeoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalSeoService>;
+}
+
+/**
+ * Configure and starts `NaturalSeoService`
+ */
+declare function provideSeo(config: NaturalSeoConfig): (EnvironmentProviders | Provider)[];
+
+declare class NaturalDetailHeaderComponent {
+    /**
+     * Base URL used to build links, defaults to '/'
+     */
+    readonly currentBaseUrl: i0.InputSignal<string | undefined>;
+    /**
+     * Must be set to get proper links when used in panels
+     */
+    readonly isPanel: i0.InputSignal<boolean>;
+    /**
+     * If given will show icon before title
+     */
+    icon: string;
+    /**
+     * Title shown if model has no name, or empty name.
+     *
+     * Typically should be the human name for the object type, eg: 'Product'
+     */
+    label: string;
+    /**
+     * Label of the root of the breadcrumb, defaults to the value of `label`.
+     *
+     * Typically should be the plural form of the object type, eg: 'Products'
+     */
+    rootLabel: string;
+    /**
+     * Title shown if model has no id.
+     *
+     * Typically should be similar to 'New product'.
+     */
+    readonly newLabel: i0.InputSignal<string>;
+    model: Literal;
+    readonly breadcrumbs: i0.InputSignal<NameOrFullName[]>;
+    readonly listRoute: i0.InputSignal<any[]>;
+    readonly listFragment: i0.InputSignal<string | undefined>;
+    readonly link: i0.InputSignal<((id: string) => any[]) | undefined>;
+    getRootLink(): string[];
+    getLink(id: string): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalDetailHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalDetailHeaderComponent, "natural-detail-header", never, { "currentBaseUrl": { "alias": "currentBaseUrl"; "required": false; "isSignal": true; }; "isPanel": { "alias": "isPanel"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; }; "label": { "alias": "label"; "required": false; }; "rootLabel": { "alias": "rootLabel"; "required": false; }; "newLabel": { "alias": "newLabel"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": true; }; "breadcrumbs": { "alias": "breadcrumbs"; "required": false; "isSignal": true; }; "listRoute": { "alias": "listRoute"; "required": false; "isSignal": true; }; "listFragment": { "alias": "listFragment"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type PossibleComparableOpertorKeys = keyof Pick<FilterGroupConditionField, 'less' | 'lessOrEqual' | 'equal' | 'greaterOrEqual' | 'greater'>;
+type PossibleComparableOperator = {
+    key: PossibleComparableOpertorKeys;
+    label: string;
+};
+declare const possibleComparableOperators: readonly PossibleComparableOperator[];
+type PossibleDiscreteOperatorKeys = 'is' | 'isnot' | 'any' | 'none';
+type PossibleDiscreteOperator = {
+    key: PossibleDiscreteOperatorKeys;
+    label: string;
+};
+
+type TypeSelectItem = Scalar | {
+    id: Scalar;
+    name: Scalar;
+} | {
+    value: Scalar;
+    name: Scalar;
+};
+type TypeSelectConfiguration = {
+    items: TypeSelectItem[] | Observable<TypeSelectItem[]>;
+    multiple?: boolean;
+    /**
+     * If true (default) a selectbox allows to choose an operator. Otherwise, the selectbox is hidden and the operator will always be `is`.
+     */
+    operators?: boolean;
+};
+declare class TypeSelectComponent implements DropdownComponent, AfterViewInit {
+    private readonly destroyRef;
+    readonly renderedValue: BehaviorSubject<string>;
+    readonly list: i0.Signal<MatSelectionList | undefined>;
+    requireValueCtrl: boolean;
+    readonly operators: readonly PossibleDiscreteOperator[];
+    readonly operatorCtrl: FormControl<PossibleDiscreteOperatorKeys>;
+    readonly valueCtrl: FormControl<any>;
+    readonly form: FormGroup<{
+        operator: FormControl<PossibleDiscreteOperatorKeys>;
+        value: FormControl<any>;
+    }>;
+    items: TypeSelectItem[];
+    readonly configuration: Required<TypeSelectConfiguration>;
+    private readonly defaults;
+    constructor();
+    ngAfterViewInit(): void;
+    getId(item: TypeSelectItem): Scalar;
+    getDisplay(item: TypeSelectItem): Scalar;
+    getCondition(): FilterGroupConditionField;
+    isValid(): boolean;
+    isDirty(): boolean;
+    private initValidators;
+    private isMultiple;
+    private getItemById;
+    private reloadCondition;
+    /**
+     * Reload the value from API (`operatorCtrl` should not be touched)
+     */
+    private reloadValue;
+    private getRenderedValue;
+    private conditionToOperatorKey;
+    private operatorKeyToCondition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeSelectComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class AbstractAssociationSelectComponent<C> implements DropdownComponent {
+    readonly configuration: C;
+    readonly renderedValue: BehaviorSubject<string>;
+    requireValueCtrl: boolean;
+    readonly operators: readonly PossibleDiscreteOperator[];
+    readonly operatorCtrl: FormControl<PossibleDiscreteOperatorKeys>;
+    readonly valueCtrl: FormControl<any>;
+    readonly form: FormGroup<{
+        operator: FormControl<PossibleDiscreteOperatorKeys>;
+        value: FormControl<any>;
+    }>;
+    constructor();
+    /**
+     * Reload the value from API (`operatorCtrl` should not be touched)
+     */
+    protected abstract reloadValue(condition: FilterGroupConditionField): Observable<unknown>;
+    protected abstract renderValueWithoutOperator(): string;
+    abstract getCondition(): FilterGroupConditionField;
+    isValid(): boolean;
+    isDirty(): boolean;
+    private initValidators;
+    private reloadCondition;
+    protected getRenderedValue(): string;
+    protected conditionToOperatorKey(condition: FilterGroupConditionField): PossibleDiscreteOperatorKeys;
+    protected operatorKeyToCondition(key: PossibleDiscreteOperatorKeys, values: string[]): FilterGroupConditionField;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractAssociationSelectComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractAssociationSelectComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+type TypeSelectNaturalConfiguration<TService extends UntypedModelService> = {
+    service: TService;
+    placeholder: string;
+    filter?: ExtractVall<TService>['filter'];
+    pageSize?: number;
+};
+declare class TypeNaturalSelectComponent<TService extends UntypedModelService> extends AbstractAssociationSelectComponent<TypeSelectNaturalConfiguration<TService>> {
+    getCondition(): FilterGroupConditionField;
+    protected reloadValue(condition: FilterGroupConditionField): Observable<ExtractTone<TService>>;
+    protected renderValueWithoutOperator(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeNaturalSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeNaturalSelectComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type NaturalDropdownContainerData = {
+    showValidateButton: boolean;
+};
+declare class NaturalDropdownContainerComponent extends BasePortalOutlet implements OnDestroy {
+    private readonly elementRef;
+    private readonly focusTrapFactory;
+    readonly data: NaturalDropdownContainerData;
+    readonly portalOutlet: i0.Signal<CdkPortalOutlet>;
+    readonly closed: Subject<void>;
+    /** Current state of the panel animation. */
+    protected panelAnimationState: 'void' | 'enter';
+    private focusTrap;
+    private elementFocusedBeforeDialogWasOpened;
+    ngOnDestroy(): void;
+    close(): void;
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    /** Callback that is invoked when the panel animation completes. */
+    protected onAnimationDone(state: string): void;
+    private trapFocus;
+    /** Restores focus to the element that was focused before the dialog opened. */
+    private restoreFocus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalDropdownContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalDropdownContainerComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class NaturalDropdownRef {
+    private readonly dropdownContainer;
+    readonly componentInstance: DropdownComponent;
+    readonly closed: Subject<DropdownResult | undefined>;
+    constructor(dropdownContainer: NaturalDropdownContainerComponent, component: ComponentType<DropdownComponent>, customProviders: StaticProvider[], parentInjector: Injector, containerRef: ComponentRef<NaturalDropdownContainerComponent>);
+    close(result?: DropdownResult): void;
+}
+
+/**
+ * Show an error message if the control has a value and an error, even if control is not dirty and not touched.
+ */
+declare class InvalidWithValueStateMatcher$1 implements ErrorStateMatcher {
+    isErrorState(control: FormControl | null): boolean;
+}
+declare class TypeTextComponent implements DropdownComponent {
+    protected dropdownRef: NaturalDropdownRef;
+    readonly renderedValue: BehaviorSubject<string>;
+    readonly formCtrl: FormControl<string>;
+    readonly matcher: InvalidWithValueStateMatcher$1;
+    constructor();
+    getCondition(): FilterGroupConditionField;
+    isValid(): boolean;
+    isDirty(): boolean;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeTextComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type TypeNumberConfiguration = {
+    min?: number | null;
+    max?: number | null;
+    step?: number | null;
+};
+declare class TypeNumberComponent implements DropdownComponent {
+    protected dropdownRef: NaturalDropdownRef;
+    readonly renderedValue: BehaviorSubject<string>;
+    readonly configuration: Required<TypeNumberConfiguration>;
+    readonly operatorCtrl: FormControl<"equal" | "greater" | "greaterOrEqual" | "less" | "lessOrEqual">;
+    readonly valueCtrl: FormControl<any>;
+    readonly matcher: InvalidWithValueStateMatcher$1;
+    readonly form: FormGroup<{
+        operator: FormControl<"equal" | "greater" | "greaterOrEqual" | "less" | "lessOrEqual">;
+        value: FormControl<any>;
+    }>;
+    readonly operators: readonly PossibleComparableOperator[];
+    private readonly defaults;
+    constructor();
+    getCondition(): FilterGroupConditionField;
+    isValid(): boolean;
+    isDirty(): boolean;
+    close(): void;
+    private initValidators;
+    private reloadCondition;
+    private getRenderedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeNumberComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeNumberComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type NaturalHierarchicConfiguration<T extends UntypedModelService = UntypedModelService> = {
+    /**
+     * An AbstractModelService to be used to fetch items
+     */
+    service: Type<T>;
+    /**
+     * A list of FilterConditionField name to filter items
+     *
+     * Those will be used directly to build filter to fetch items, so they must be
+     * valid API FilterConditionField names for the given service.
+     *
+     * Eg: given the QuestionService, possible names would be:
+     *
+     * - "chapter" to filter by the question's chapter
+     * - "parent" to filter by the question's parent question
+     */
+    parentsRelationNames?: string[];
+    /**
+     * A list of FilterConditionField name to declare hierarchy
+     *
+     * Those must be the `parentsRelationNames` name, that correspond to this service,
+     * of all children services.
+     *
+     * Eg: given the QuestionService, possible names would be:
+     *
+     * - "questions" coming from ChapterService
+     * - "questions" coming from QuestionService
+     */
+    childrenRelationNames?: string[];
+    /**
+     * Additional filters applied in the query sent by getList function
+     */
+    filter?: QueryVariables['filter'];
+    /**
+     * Key of the returned literal container models by config / service
+     */
+    selectableAtKey?: string;
+    /**
+     * Displayed icon for items retrieved for that config
+     */
+    icon?: string;
+    /**
+     * Callback function that returns boolean. If true the item is selectable, if false, it's not.
+     * If missing, item is selectable.
+     */
+    isSelectableCallback?: (item: any) => boolean;
+    /**
+     * Functions that receives a model and returns a string for display value
+     *
+     * If missing, fallback on global `NaturalHierarchicSelectorComponent.displayWith`
+     */
+    displayWith?: (item: any) => string;
+};
+
+type HierarchicModel = {
+    __typename: string;
+} & NameOrFullName;
+declare class HierarchicModelNode {
+    readonly model: HierarchicModel;
+    readonly config: NaturalHierarchicConfiguration;
+    readonly childrenChange: BehaviorSubject<HierarchicModelNode[]>;
+    constructor(model: HierarchicModel, config: NaturalHierarchicConfiguration);
+    get children(): HierarchicModelNode[];
+}
+
+declare class HierarchicFlatNode {
+    readonly node: HierarchicModelNode;
+    readonly name: string;
+    readonly level: number;
+    expandable: boolean;
+    readonly selectable: boolean;
+    deselectable: boolean;
+    loading: boolean;
+    constructor(node: HierarchicModelNode, name: string, level?: number, expandable?: boolean, selectable?: boolean, deselectable?: boolean);
+}
+
+type HierarchicFilterConfiguration$1<T = Literal> = {
+    service: NaturalHierarchicConfiguration['service'];
+    filter: T;
+};
+type HierarchicFiltersConfiguration$1<T = Literal> = HierarchicFilterConfiguration$1<T>[];
+
+type OrganizedModelSelection = Record<string, any[]>;
+declare class NaturalHierarchicSelectorService {
+    private readonly injector;
+    /**
+     * Stores the global result of the tree
+     * This observable contains Node.
+     * When it's updated, the TreeController and TreeFlattener process the new array to generate the flat tree.
+     */
+    readonly dataChange: BehaviorSubject<HierarchicModelNode[]>;
+    /**
+     * Configuration for relations and selection constraints
+     *
+     * The list should be sorted in the order of the hierarchic (list first parent rules, then child rules)
+     */
+    private configuration;
+    /**
+     * Init component by saving the complete configuration, and then retrieving root elements.
+     * Updates **another** observable (this.dataChange) when data is retrieved.
+     */
+    init(config: NaturalHierarchicConfiguration[], contextFilter?: HierarchicFiltersConfiguration$1 | null, searchVariables?: QueryVariables | null): Observable<unknown>;
+    /**
+     * Get list of children, considering given FlatNode id as a parent.
+     * Mark loading status individually on nodes.
+     */
+    loadChildren(flatNode: HierarchicFlatNode, contextFilter?: HierarchicFiltersConfiguration$1 | null): void;
+    search(searchVariables: QueryVariables, contextFilter?: HierarchicFiltersConfiguration$1 | null): void;
+    /**
+     * Retrieve elements from the server
+     * Get root elements if node is null, or child elements if node is given
+     */
+    private getList;
+    countItems(node: HierarchicFlatNode, contextFilters?: HierarchicFiltersConfiguration$1 | null): void;
+    private getContextualizedConfigs;
+    /**
+     * Return models matching given FlatNodes
+     * Returns a Literal of models grouped by their configuration attribute "selectableAtKey"
+     */
+    toOrganizedSelection(nodes: HierarchicModelNode[]): OrganizedModelSelection;
+    /**
+     * Transforms an OrganizedModelSelection into a list of ModelNodes
+     */
+    fromOrganizedSelection(organizedModelSelection: OrganizedModelSelection): HierarchicModelNode[];
+    /**
+     * Checks that each configuration.selectableAtKey attribute is unique
+     */
+    private validateConfiguration;
+    /**
+     * Return configurations setup in the list after the given one
+     */
+    private getNextConfigs;
+    /**
+     * Builds queryVariables filter for children query
+     */
+    private getServiceFilter;
+    /**
+     * Return a context filter applicable to the service for given config
+     *
+     * @param config Applicable config
+     * @param contextFilters List of context filters
+     */
+    private getFilterByService;
+    /**
+     * Search in configurations.selectableAtKey attribute to find given key and return the configuration
+     */
+    private getConfigurationBySelectableKey;
+    private getOrCreateModelNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalHierarchicSelectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalHierarchicSelectorService>;
+}
+
+type HierarchicFilterConfiguration<T = Literal> = {
+    service: NaturalHierarchicConfiguration['service'];
+    filter: T;
+};
+type HierarchicFiltersConfiguration<T = Literal> = HierarchicFilterConfiguration<T>[];
+type TypeHierarchicSelectorConfiguration = {
+    key: string;
+    service: UntypedModelService;
+    config: NaturalHierarchicConfiguration[];
+    filters?: HierarchicFiltersConfiguration;
+};
+declare class TypeHierarchicSelectorComponent extends AbstractAssociationSelectComponent<TypeHierarchicSelectorConfiguration> {
+    getCondition(): FilterGroupConditionField;
+    protected reloadValue(condition: FilterGroupConditionField): Observable<unknown | null>;
+    protected renderValueWithoutOperator(): string;
+    selectionChange(selection: OrganizedModelSelection): void;
+    /**
+     * We need to keep `null` in our valueCtrl so the required validator works properly, so
+     * filter here
+     */
+    private noEmptySelection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeHierarchicSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeHierarchicSelectorComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type TypeDateConfiguration<D = Date> = {
+    min?: D | null;
+    max?: D | null;
+};
+declare class TypeDateComponent<D = any> implements DropdownComponent {
+    private dateAdapter;
+    private dateFormats;
+    readonly renderedValue: BehaviorSubject<string>;
+    readonly configuration: Required<TypeDateConfiguration<D>>;
+    readonly operatorCtrl: FormControl<"equal" | "greater" | "greaterOrEqual" | "less" | "lessOrEqual">;
+    readonly valueCtrl: FormControl<D | null>;
+    readonly todayCtrl: FormControl<boolean | null>;
+    readonly operators: readonly PossibleComparableOperator[];
+    readonly form: FormGroup<{
+        operator: FormControl<"equal" | "greater" | "greaterOrEqual" | "less" | "lessOrEqual">;
+        value: FormControl<D | null>;
+        today: FormControl<boolean | null>;
+    }>;
+    private readonly defaults;
+    constructor();
+    getCondition(): FilterGroupConditionField;
+    isValid(): boolean;
+    isDirty(): boolean;
+    private reloadCondition;
+    private setTodayOrDate;
+    private initValidators;
+    private getDayAfter;
+    private getRenderedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeDateComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeDateComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type TypeDateRangeConfiguration<D = any> = {
+    min?: D | null;
+    max?: D | null;
+};
+declare class InvalidWithValueStateMatcher implements ErrorStateMatcher {
+    isErrorState(control: FormControl<unknown> | null, form: FormGroupDirective | NgForm | null): boolean;
+}
+/**
+ * Date range with mandatory bounding dates.
+ *
+ * If you need optional bounding date, then use `TypeDateComponent` instead.
+ */
+declare class TypeDateRangeComponent<D = any> implements DropdownComponent {
+    private dateAdapter;
+    private dateFormats;
+    readonly renderedValue: BehaviorSubject<string>;
+    readonly configuration: Required<TypeDateRangeConfiguration<D>>;
+    readonly matcher: InvalidWithValueStateMatcher;
+    readonly fromCtrl: FormControl<D | null>;
+    readonly toCtrl: FormControl<D | null>;
+    readonly form: FormGroup<{
+        from: FormControl<D | null>;
+        to: FormControl<D | null>;
+    }>;
+    private readonly defaults;
+    constructor();
+    getCondition(): FilterGroupConditionField;
+    isValid(): boolean;
+    isDirty(): boolean;
+    private reloadCondition;
+    private initValidators;
+    render(value: D | null): string;
+    private getRenderedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeDateRangeComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeDateRangeComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type NaturalDropdownData<C = any> = {
+    condition: FilterGroupConditionField | null;
+    configuration: C;
+    title?: string;
+};
+declare const NATURAL_DROPDOWN_DATA: InjectionToken<NaturalDropdownData<any>>;
+
+type TypeOption = {
+    display: string;
+    condition: Literal;
+};
+type TypeOptionsConfiguration = {
+    options: TypeOption[];
+};
+declare class TypeOptionsComponent implements DropdownComponent {
+    readonly data: NaturalDropdownData<TypeOptionsConfiguration>;
+    readonly renderedValue: BehaviorSubject<string>;
+    readonly formControl: FormControl<TypeOption>;
+    readonly configuration: Required<TypeOptionsConfiguration>;
+    private readonly defaults;
+    protected readonly dropdownRef: NaturalDropdownRef;
+    constructor(data: NaturalDropdownData<TypeOptionsConfiguration>);
+    getCondition(): FilterGroupConditionField;
+    isValid(): boolean;
+    isDirty(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeOptionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeOptionsComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type TypeBooleanConfiguration = {
+    displayWhenActive: string;
+    displayWhenInactive: string;
+};
+declare class TypeBooleanComponent extends TypeOptionsComponent implements DropdownComponent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeBooleanComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeBooleanComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type FileModel = {
+    __typename?: 'File' | 'AccountingDocument' | 'Image';
+    id?: string;
+    file?: File;
+    mime?: string;
+    src?: string;
+};
+
+declare class NaturalFileService {
+    private readonly document;
+    /**
+     * Allow to subscribe to selected files in the entire application. So a
+     * child component is able to receive a file that was dropped on a parent
+     * component.
+     *
+     * Typically useful to drop a file on the entire screen, instead of a precise
+     * component.
+     */
+    readonly filesChanged: Subject<FileSelection>;
+    getDownloadLink(model: FileModel | null): null | string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalFileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalFileService>;
+}
+
+type InvalidFile = {
+    file: File;
+    error: string;
+};
+type FileSelection = {
+    /**
+     * The list of files that have been selected.
+     */
+    valid: File[];
+    /**
+     * The list of files that have been selected but are invalid according to validators.
+     */
+    invalid: InvalidFile[];
+};
+/**
+ * A master base set of logic intended to support file select/drag/drop operations
+ *
+ * In most cases you probably want click-to-select and drag-to-select, so you should use:
+ *
+ *     <div naturalFileDrop [selectable]="true"></div>
+ *
+ * @dynamic
+ */
+declare abstract class NaturalAbstractFile implements OnInit, OnDestroy, OnChanges {
+    private fileElement?;
+    /**
+     * Whether we should accept a single file or multiple files
+     */
+    readonly multiple: i0.InputSignal<boolean>;
+    /**
+     * Comma-separated list of unique file type specifiers. Like the native element,
+     * it can be a mix of mime-type and file extensions.
+     *
+     * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#accept
+     */
+    readonly accept: i0.InputSignal<string>;
+    /**
+     * Maximum file size in bytes. 0 means no validation at all.
+     */
+    readonly maxSize: i0.InputSignal<number>;
+    /**
+     * Disable the file selection entirely
+     */
+    readonly fileSelectionDisabled: i0.InputSignal<boolean>;
+    /**
+     * Whether the user can click on the element to select something
+     *
+     * This has only effect during initialization. Subsequent changes will have
+     * no effect.
+     */
+    readonly selectable: i0.InputSignal<boolean>;
+    /**
+     * If true, the file selection will be broadcast through `NaturalFileService.filesChanged`.
+     *
+     * It is useful to set this to false if there are two uploads on a page with different purposes,
+     * and the second upload should not be confused with the first one.
+     */
+    broadcast: boolean;
+    private readonly fileChange$;
+    /**
+     * The single valid file that has been selected.
+     *
+     * It is for convenience of use, and will only emit if there is at least one
+     * valid file. See `filesChange` for a more complete output.
+     */
+    readonly fileChange: i0.OutputRef<File>;
+    private readonly filesChange$;
+    /**
+     * The list of files that have been selected.
+     */
+    readonly filesChange: i0.OutputRef<FileSelection>;
+    private readonly element;
+    protected readonly naturalFileService: NaturalFileService;
+    private readonly document;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getFileElement;
+    private enableSelecting;
+    protected handleFiles(files: File[]): void;
+    /**
+     * Called when input has files
+     */
+    private changeFn;
+    private clickHandler;
+    private beforeSelect;
+    onChange(event: Event): void;
+    private validate;
+    protected hasObservers(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalAbstractFile, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalAbstractFile, never, never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "fileSelectionDisabled": { "alias": "fileSelectionDisabled"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "broadcast": { "alias": "broadcast"; "required": false; }; }, { "fileChange": "fileChange"; "filesChange": "filesChange"; }, never, never, true, never>;
+}
+
+/**
+ * This directive has all options to select files, and adds support for drag'n'drop.
+ *
+ * It will add the CSS class `natural-file-over` on the component when a file is
+ * dragged over. It is up to the component to have some specific styling by using
+ * this class.
+ *
+ * In most cases you probably also want click-to-select, so you should use:
+ *
+ * ```html
+ * <div naturalFileDrop [selectable]="true"></div>
+ * ```
+ */
+declare class NaturalFileDropDirective extends NaturalAbstractFile implements OnInit {
+    private readonly destroyRef;
+    fileOverClass: boolean;
+    /**
+     * Emits whenever files are being dragged over
+     */
+    readonly fileOver: i0.OutputEmitterRef<boolean>;
+    private readonly rawFileOver;
+    ngOnInit(): void;
+    onDrop(event: DragEvent): void;
+    onDragOver(event: DragEvent): void;
+    private closeDrags;
+    onDragLeave(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalFileDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalFileDropDirective, ":not([naturalFileSelect])[naturalFileDrop]", never, {}, { "fileOver": "fileOver"; }, never, never, true, never>;
+}
+
+/**
+ * This directive has all options to select files, except drag'n'drop.
+ */
+declare class NaturalFileSelectDirective extends NaturalAbstractFile {
+    /**
+     * Whether the user can click on the element to select something
+     *
+     * Override parent to enable it by default
+     */
+    readonly selectable: i0.InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalFileSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalFileSelectDirective, ":not([naturalFileDrop])[naturalFileSelect]", never, { "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NaturalFileComponent implements OnInit, OnChanges {
+    private readonly naturalFileService;
+    private readonly alertService;
+    private readonly document;
+    readonly height: i0.InputSignal<number>;
+    readonly iconHeight: i0.Signal<number>;
+    readonly fontSize: i0.Signal<number>;
+    readonly action: i0.InputSignal<"download" | "upload" | null>;
+    readonly backgroundSize: i0.InputSignal<string>;
+    /**
+     * Comma-separated list of unique file type specifiers. Like the native element,
+     * it can be a mix of mime-type and file extensions.
+     *
+     * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#accept
+     */
+    readonly accept: i0.InputSignal<string>;
+    /**
+     * If given, it will be called when a new file is selected. The callback should typically upload the file
+     * to the server and link the newly uploaded file to the existing related object.
+     *
+     * The callback **must** be able to run even if the calling component has been destroyed. That means in most
+     * cases you **must** `bind()` the callback explicitly, like so:
+     *
+     * ```html
+     * <natural-file [uploader]="myCallback.bind(this)" />
+     * ```
+     *
+     * Also, you probably **should** set a `[formCtrl]` so that the form is updated automatically, instead of doing
+     * it manually within the callback.
+     */
+    readonly uploader: i0.InputSignal<((file: File) => Observable<FileModel>) | undefined>;
+    model: FileModel | null;
+    /**
+     * If provided, its value will get updated when the model changes.
+     * But its value is never read, so if you want to set a value use `[model]` instead.
+     */
+    readonly formCtrl: i0.InputSignal<AbstractControl<any, any, any> | null | undefined>;
+    /**
+     * This **must not** be used to mutate the server, because it is very likely it will never be called if the
+     * human navigates away from the page before the upload is finished. Instead, you should use `[uploader]`.
+     */
+    readonly modelChange: i0.OutputEmitterRef<FileModel>;
+    imagePreview: string;
+    filePreview: string | null;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    upload(file: File): void;
+    getDownloadLink(): null | string;
+    private updateImage;
+    private getBase64;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalFileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalFileComponent, "natural-file", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; "action": { "alias": "action"; "required": false; "isSignal": true; }; "backgroundSize": { "alias": "backgroundSize"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "uploader": { "alias": "uploader"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": false; }; "formCtrl": { "alias": "formCtrl"; "required": false; "isSignal": true; }; }, { "modelChange": "modelChange"; }, never, never, true, never>;
+}
+
+declare class NaturalFixedButtonComponent {
+    readonly icon: i0.InputSignal<string>;
+    readonly link: i0.InputSignal<string | readonly any[] | _angular_router.UrlTree | null | undefined>;
+    readonly color: i0.InputSignal<ThemePalette>;
+    readonly disabled: i0.InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalFixedButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalFixedButtonComponent, "natural-fixed-button", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type Model = {
+    id?: string;
+    permissions?: {
+        delete: boolean;
+    };
+};
+declare class NaturalFixedButtonDetailComponent {
+    private canChange;
+    isCreation: boolean;
+    get model(): Model;
+    set model(value: Model);
+    private _model;
+    form: FormGroup;
+    readonly create: i0.OutputEmitterRef<void>;
+    readonly delete: i0.OutputEmitterRef<void>;
+    constructor();
+    clickCreate(): void;
+    clickDelete(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalFixedButtonDetailComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalFixedButtonDetailComponent, "natural-fixed-button-detail", never, { "model": { "alias": "model"; "required": true; }; "form": { "alias": "form"; "required": true; }; }, { "create": "create"; "delete": "delete"; }, never, never, true, never>;
+}
+
+declare class NaturalHierarchicSelectorComponent implements OnInit, OnChanges {
+    private readonly destroyRef;
+    private readonly hierarchicSelectorService;
+    /**
+     * Function that receives a model and returns a string for display value
+     */
+    readonly displayWith: i0.InputSignal<((item: any) => string) | undefined>;
+    /**
+     * Config for items and relations arrangement
+     */
+    readonly config: i0.InputSignal<NaturalHierarchicConfiguration[]>;
+    /**
+     * If multiple or single item selection
+     */
+    readonly multiple: i0.InputSignal<boolean>;
+    /**
+     * Selected items
+     * Organized by key, containing each an array of selected items of same type
+     */
+    readonly selected: i0.InputSignal<OrganizedModelSelection>;
+    /**
+     * Whether selectable elements can be unselected
+     */
+    readonly allowUnselect: i0.InputSignal<boolean>;
+    /**
+     * Filters that apply to each query
+     */
+    readonly filters: i0.InputSignal<HierarchicFiltersConfiguration$1 | null | undefined>;
+    /**
+     * Search facets
+     */
+    readonly searchFacets: i0.InputSignal<NaturalSearchFacets>;
+    /**
+     * Selections to apply on natural-search on component initialisation
+     */
+    readonly searchSelections: i0.InputSignal<NaturalSearchSelections>;
+    /**
+     * Select all fetched items of the current search result
+     *
+     * Use very carefully as recursivity is ignored. The selection includes children (if any) even if the child list has been closed
+     *
+     * Should be used __only__ for non-recursive use cases. Avoid with recursive because it's not intuitive for end user
+     */
+    readonly allowSelectAll: i0.InputSignal<boolean>;
+    /**
+     * Emits when natural-search selections change
+     */
+    readonly searchSelectionChange: i0.OutputEmitterRef<NaturalSearchSelections>;
+    /**
+     * Inner representation of selected @Input() to allow flat listing as mat-chip.
+     */
+    selectedNodes: HierarchicModelNode[];
+    /**
+     * Emits selection change
+     * Returns a Literal where selected models are organized by key
+     */
+    readonly selectionChange: i0.OutputEmitterRef<OrganizedModelSelection>;
+    /**
+     * Controller for nodes selection
+     */
+    flatNodesSelection: SelectionModel<HierarchicFlatNode>;
+    treeControl: FlatTreeControl<HierarchicFlatNode>;
+    treeFlattener: MatTreeFlattener<HierarchicModelNode, HierarchicFlatNode>;
+    dataSource: MatTreeFlatDataSource<HierarchicModelNode, HierarchicFlatNode>;
+    loading: boolean;
+    /**
+     * Cache for transformed nodes
+     */
+    private readonly flatNodeMap;
+    protected readonly tooBig: i0.Signal<boolean>;
+    /**
+     * Angular OnChange implementation
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Angular OnInit implementation
+     */
+    ngOnInit(): void;
+    /**
+     * Toggle selection of a FlatNode, considering if multiple selection is activated or not
+     */
+    toggleFlatNode(flatNode: HierarchicFlatNode): void;
+    protected selectAll(): void;
+    /**
+     * When unselecting an element from the mat-chips, it can be deep in the hierarchy, and the tree element may not exist...
+     * ... but we still need to remove the element from the mat-chips list.
+     */
+    unselectModelNode(node: HierarchicModelNode): void;
+    isNodeTogglable(flatNode: HierarchicFlatNode): boolean;
+    private getDisplayFn;
+    loadChildren(flatNode: HierarchicFlatNode): void;
+    /**
+     * Created to collapse all children when closing a parent, but not sure it's good.
+     */
+    private getChildren;
+    /**
+     * Transforms a HierarchicModelNode into a FlatNode
+     */
+    private transformer;
+    /**
+     * Return deep of the node in the tree
+     */
+    private getLevel;
+    /**
+     * Is always expandable because we load on demand, we don't know if there are children yet
+     */
+    private isExpandable;
+    private getOrCreateFlatNode;
+    search(selections: NaturalSearchSelections): void;
+    private loadRoots;
+    /**
+     * Sync inner selection (tree and mat-chips) according to selected input attribute
+     */
+    private updateInnerSelection;
+    /**
+     * Unselect a node, keeping the rest of the selected untouched
+     */
+    private unselectFlatNode;
+    /**
+     * Remove a node from chip lists
+     */
+    private removeModelNode;
+    /**
+     * Select a node, keeping th rest of the selected untouched
+     */
+    private selectFlatNode;
+    /**
+     * Clear all selected and select the given node
+     */
+    private selectSingleFlatNode;
+    /**
+     * Clear all selected and select the given node
+     */
+    private unselectSingleFlatNode;
+    /**
+     * Transform the given elements into the organized selection that is emitted to output
+     */
+    private updateSelection;
+    private isNodeSelected;
+    private getFlatNode;
+    private createFlatNode;
+    /**
+     * Returns an identifier key for map cache
+     * As many object types can be used, this function considers typename and ID to return something like document-123
+     */
+    private getMapKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalHierarchicSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalHierarchicSelectorComponent, "natural-hierarchic-selector", never, { "displayWith": { "alias": "displayWith"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "allowUnselect": { "alias": "allowUnselect"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "searchFacets": { "alias": "searchFacets"; "required": false; "isSignal": true; }; "searchSelections": { "alias": "searchSelections"; "required": false; "isSignal": true; }; "allowSelectAll": { "alias": "allowSelectAll"; "required": false; "isSignal": true; }; }, { "searchSelectionChange": "searchSelectionChange"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+type HierarchicDialogResult = {
+    hierarchicSelection?: OrganizedModelSelection;
+    searchSelections?: NaturalSearchSelections | null;
+};
+type HierarchicDialogConfig = {
+    /**
+     * Configuration to setup rules of hierarchy
+     */
+    hierarchicConfig: NaturalHierarchicConfiguration[];
+    /**
+     * Selected items when HierarchicComponent initializes
+     */
+    hierarchicSelection?: OrganizedModelSelection;
+    /**
+     * Filters to apply on queries (when opening new level of hierarchy)
+     */
+    hierarchicFilters?: HierarchicFiltersConfiguration$1 | null;
+    /**
+     * Multiple selection if true or single selection if false
+     */
+    multiple?: boolean;
+    /**
+     * Allow to validate selection with no items checked
+     */
+    allowUnselect?: boolean;
+    /**
+     * Allow to select all items with dedicated button
+     */
+    allowSelectAll?: boolean;
+    /**
+     * Facets for natural-search in HierarchicComponent
+     */
+    searchFacets?: NaturalSearchFacets;
+    /**
+     * Selections of natural search to initialize on HierarchicComponent initialisation
+     */
+    searchSelections?: NaturalSearchSelections | null;
+};
+declare class NaturalHierarchicSelectorDialogComponent {
+    private dialogRef;
+    /**
+     * Set of hierarchic configurations to pass as attribute to HierarchicComponent
+     */
+    config: HierarchicDialogConfig;
+    /**
+     * Natural search selections after initialisation
+     */
+    searchSelectionsOutput: NaturalSearchSelections | undefined | null;
+    constructor();
+    close(selected: OrganizedModelSelection | undefined): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalHierarchicSelectorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalHierarchicSelectorDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class NaturalHierarchicSelectorDialogService {
+    private readonly dialog;
+    open(hierarchicConfig: HierarchicDialogConfig, dialogConfig?: MatDialogConfig): MatDialogRef<NaturalHierarchicSelectorDialogComponent, HierarchicDialogResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalHierarchicSelectorDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalHierarchicSelectorDialogService>;
+}
+
+type NaturalIconType = {
+    name: string;
+    svg?: string;
+    font?: string;
+    class?: 'negative' | 'neutral' | 'positive';
+};
+type NaturalIconConfig = {
+    svg?: string;
+    font?: string;
+    class?: 'negative' | 'neutral' | 'positive';
+};
+type NaturalIconsConfig = Record<string, NaturalIconConfig>;
+declare const NATURAL_ICONS_CONFIG: InjectionToken<NaturalIconsConfig>;
+/**
+ * Allows to use `<mat-icon>` without knowing where an icon comes from (SVG or font) or with aliases for Material font.
+ *
+ * SVG icons and Material font aliases must be configured ahead of time, via `NATURAL_ICONS_CONFIG`.
+ *
+ * It also make it easy to give a specific size to the icon via `[size]`.
+ *
+ * Usage:
+ *
+ * ```html
+ * <mat-icon naturalIcon="search"></mat-icon>
+ * <mat-icon naturalIcon="my-svg-icon-name"></mat-icon>
+ * <mat-icon naturalIcon="my-alias-for-search"></mat-icon>
+ * <mat-icon naturalIcon="search" [size]="150"></mat-icon>
+ * ```
+ */
+declare class NaturalIconDirective {
+    private readonly matIconRegistry;
+    private readonly domSanitizer;
+    private readonly config;
+    private readonly matIconComponent;
+    readonly naturalIcon: i0.InputSignal<string>;
+    readonly size: i0.InputSignal<number | null | undefined>;
+    protected readonly icon: i0.Signal<NaturalIconType>;
+    constructor();
+    private registerIcons;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalIconDirective, "mat-icon[naturalIcon]", never, { "naturalIcon": { "alias": "naturalIcon"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Configure Material Symbols, instead of Material Icons, and configure custom Natural icons.
+ *
+ * This means that `https://fonts.googleapis.com/icon?family=Material+Icons` must be
+ * replaced by `https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:FILL@1`.
+ */
+declare function provideIcons(config: NaturalIconsConfig): (EnvironmentProviders | Provider)[];
+
+declare function providePanels(hooks: NaturalPanelsHooksConfig): Provider[];
+
+declare class NaturalPanelsComponent implements OnDestroy {
+    private readonly panelsService;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalPanelsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalPanelsComponent, "natural-panels", never, {}, {}, never, never, true, never>;
+}
+
+declare const naturalPanelsUrlMatcher: UrlMatcher;
+
+/**
+ * Url fallback matcher to be used instead of `path: '**'` when Panel system
+ * is used in the project.
+ */
+declare const fallbackIfNoOpenedPanels: UrlMatcher;
+
+/**
+ * Custom template usage :
+ *
+ * ```html
+ * <natural-relations [main]="owner" [service]="svc" [filter]="{}" placeholder="Select an item">
+ *     <ng-template let-item="item">
+ *         <span>{{ item.xxx }}</span>
+ *     </ng-template>
+ * </natural-relations>
+ * ```
+ */
+declare class NaturalRelationsComponent<TService extends NaturalAbstractModelService<unknown, any, PaginatedData<LinkableObject>, QueryVariables, unknown, any, unknown, any, unknown, any>> implements OnInit, OnChanges {
+    private readonly destroyRef;
+    private readonly linkMutationService;
+    private readonly hierarchicSelectorDialog;
+    private readonly select;
+    readonly itemTemplate: i0.Signal<TemplateRef<unknown> | undefined>;
+    private _service;
+    get service(): TService;
+    set service(service: TService);
+    /**
+     * The placeholder used in the button to add a new relation
+     */
+    readonly placeholder: i0.InputSignal<string>;
+    /**
+     * Filter for autocomplete selector
+     */
+    readonly autocompleteSelectorFilter: i0.InputSignal<ExtractVall<TService>["filter"] | null | undefined>;
+    /**
+     * Function to customize the rendering of the selected item as text in input
+     */
+    readonly displayWith: i0.InputSignal<((item: ExtractTallOne<TService> | null) => string) | undefined>;
+    /**
+     * Whether the relations can be changed
+     */
+    disabled: boolean;
+    /**
+     * The main object to which all relations belong to
+     */
+    main: LinkableObject & {
+        permissions?: {
+            update: boolean;
+        };
+    };
+    /**
+     * Emits after relations were successfully added on the server
+     */
+    readonly selectionChange: i0.OutputEmitterRef<void>;
+    /**
+     * Filters for hierarchic selector
+     */
+    readonly hierarchicSelectorFilters: i0.InputSignal<HierarchicFiltersConfiguration$1 | null | undefined>;
+    /**
+     * Configuration in case we prefer hierarchic selection over autocomplete selection
+     */
+    readonly hierarchicSelectorConfig: i0.InputSignal<NaturalHierarchicConfiguration[] | undefined>;
+    /**
+     * Link mutation semantic
+     */
+    otherName?: string | null;
+    /**
+     * Listing service instance
+     */
+    dataSource: NaturalDataSource<PaginatedData<LinkableObject>>;
+    loading: boolean;
+    /**
+     * Table columns
+     */
+    displayedColumns: string[];
+    readonly pageSizeOptions: number[];
+    protected readonly defaultPagination: {
+        pageIndex: number;
+        pageSize: number;
+    };
+    /**
+     * Observable variables/options for listing service usage and apollo watchQuery
+     */
+    private variablesManager;
+    readonly removing: Set<LinkableObject>;
+    /**
+     * The filter used to filter relations
+     *
+     * So if the relations are from one action -> to many objectives, then the filter must filter
+     * the objectives that have indeed a relation to the particular action.
+     */
+    set filter(filter: ExtractVall<TService>['filter']);
+    /**
+     * The sorting used to sort relations
+     *
+     * So if the relations are from one action -> to many objectives, then the sorting must sort
+     * the objectives that have indeed a relation to the particular action.
+     */
+    set sorting(sorting: ExtractVall<TService>['sorting']);
+    ngOnChanges(): void;
+    ngOnInit(): void;
+    /**
+     * Unlink action
+     * Refetch result to display it in table
+     */
+    removeRelation(relation: LinkableObject): void;
+    /**
+     * Link action
+     * Refetch result to display it in table
+     * TODO : could maybe use "update" attribute of apollo.mutate function to update table faster (but hard to do it here)
+     */
+    addRelations(relations: (LinkableObject | ExtractTallOne<TService> | string | null)[]): void;
+    pagination(event?: PageEvent): void;
+    getDisplayFn(): (item: ExtractTallOne<TService> | null) => string;
+    openNaturalHierarchicSelector(): void;
+    private getSelectKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalRelationsComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalRelationsComponent<any>, "natural-relations", never, { "service": { "alias": "service"; "required": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "autocompleteSelectorFilter": { "alias": "autocompleteSelectorFilter"; "required": false; "isSignal": true; }; "displayWith": { "alias": "displayWith"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "main": { "alias": "main"; "required": true; }; "hierarchicSelectorFilters": { "alias": "hierarchicSelectorFilters"; "required": false; "isSignal": true; }; "hierarchicSelectorConfig": { "alias": "hierarchicSelectorConfig"; "required": false; "isSignal": true; }; "otherName": { "alias": "otherName"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "sorting": { "alias": "sorting"; "required": false; }; }, { "selectionChange": "selectionChange"; }, ["itemTemplate"], never, true, never>;
+}
+
+declare function toGraphQLDoctrineFilter(facets: NaturalSearchFacets | null, selections: NaturalSearchSelections | null): Filter;
+
+/**
+ * Returns a string representation of the selection that can be used in URL.
+ *
+ * The string can be parsed back with `fromUrl()`
+ */
+declare function toUrl(selections: NaturalSearchSelections | null): string | null;
+/**
+ * Parse a string, probably coming from URL, into a selection
+ */
+declare function fromUrl(selections: string | null): NaturalSearchSelections;
+/**
+ * Transform a search selection to navigation parameters to be used in URL.
+ *
+ * This is typically useful to craft URL to pre-filtered lists.
+ */
+declare function toNavigationParameters(selections: NaturalSearchSelections): Params;
+
+/**
+ * Wrap the searched value by `%` SQL wildcard
+ *
+ * So:
+ *
+ *     {field: 'myFieldName', condition: {like: {value: 'foo'}}}
+ *
+ * will become
+ *
+ *     {field: 'myFieldName', condition: {like: {value: '%foo%'}}}
+ */
+declare function wrapLike(selection: NaturalSearchSelection): NaturalSearchSelection;
+/**
+ * Search by prefix using `%' SQL wildcard
+ *
+ * So:
+ *
+ *     {field: 'myFieldName', condition: {like: {value: 'foo'}}}
+ *
+ * will become
+ *
+ *     {field: 'myFieldName', condition: {like: {value: 'foo%'}}}
+ */
+declare function wrapPrefix(selection: NaturalSearchSelection): NaturalSearchSelection;
+/**
+ * Search by suffix using `%' SQL wildcard
+ *
+ * So:
+ *
+ *     {field: 'myFieldName', condition: {like: {value: 'foo'}}}
+ *
+ * will become
+ *
+ *     {field: 'myFieldName', condition: {like: {value: '%foo'}}}
+ */
+declare function wrapSuffix(selection: NaturalSearchSelection): NaturalSearchSelection;
+/**
+ * Replace the operator name (usually "like", "in" or "between") with the
+ * attribute "field" defined in the configuration
+ *
+ * So:
+ *
+ *     {field: 'myFieldName', condition: {in: {values: [1, 2, 3]}}}
+ *
+ * will become
+ *
+ *     {field: 'myFieldName', condition: {myFieldName: {values: [1, 2, 3]}}}
+ */
+declare function replaceOperatorByField(selection: NaturalSearchSelection): NaturalSearchSelection;
+/**
+ * Replace the operator name (usually "like", "in" or "between") with the
+ * attribute "name" defined in the configuration
+ *
+ * So:
+ *
+ *     {field: 'myFieldName', name:'myConfigName', condition: {in: {values: [1, 2, 3]}}}
+ *
+ * will become
+ *
+ *     {field: 'myFieldName', name:'myConfigName', condition: {myConfigName: {values: [1, 2, 3]}}}
+ */
+declare function replaceOperatorByName(selection: NaturalSearchSelection): NaturalSearchSelection;
+
+declare class NaturalSearchComponent implements OnChanges {
+    #private;
+    private readonly breakpointObserver;
+    /**
+     * Placeholder for last input (the free search input)
+     */
+    readonly placeholder: i0.InputSignal<string>;
+    /**
+     * Exhaustive list of facets to be used in this <natural-search>
+     */
+    facets: NaturalSearchFacets;
+    /**
+     * Whether to allow end-user to create multiple `OR` groups
+     */
+    readonly multipleGroups: i0.InputSignal<boolean>;
+    /**
+     * Text display in the dropdown to select the facet
+     */
+    readonly dropdownTitle: i0.InputSignal<string>;
+    /**
+     * Emits when some selection has been setted by the user
+     */
+    readonly selectionChange: i0.OutputEmitterRef<NaturalSearchSelections>;
+    /**
+     * Cleaned inputted selections. This public API is useful because `selectionChange` does not emit changes made via `[selections]`
+     */
+    readonly innerSelections: i0.Signal<NaturalSearchSelections>;
+    /**
+     * Input to display at component initialisation
+     */
+    set selections(selections: NaturalSearchSelections);
+    readonly isMobile: rxjs.Observable<boolean>;
+    ngOnChanges(): void;
+    updateGroup(groupSelections: GroupSelections, groupIndex: number): void;
+    addGroup(): void;
+    removeGroup(index: number): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalSearchComponent, "natural-search", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "facets": { "alias": "facets"; "required": false; }; "multipleGroups": { "alias": "multipleGroups"; "required": false; "isSignal": true; }; "dropdownTitle": { "alias": "dropdownTitle"; "required": false; "isSignal": true; }; "selections": { "alias": "selections"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+/**
+ * This will completely ignore internal formControl and instead use the one from the component
+ * which comes from outside of this component. This basically allows us to **not** depend on
+ * touched status propagation between outside and inside world, and thus get rid of our legacy
+ * custom FormControl class ("NaturalFormControl").
+ */
+declare class ExternalFormControlMatcher<TValue, TInput> extends ErrorStateMatcher {
+    private readonly component;
+    constructor(component: AbstractSelect<TValue, TInput>);
+    isErrorState(): boolean;
+}
+declare abstract class AbstractSelect<TValue, TInput> implements OnInit, ControlValueAccessor, DoCheck {
+    readonly placeholder: i0.InputSignal<string | undefined>;
+    /**
+     * Mat-hint, if given, and it is non-empty, then `subscriptSizing` will
+     * automatically be set to `dynamic` to allow for long, wrapping text.
+     */
+    readonly hint: i0.InputSignal<string | null | undefined>;
+    protected readonly subscriptSizing: i0.Signal<"dynamic" | "fixed">;
+    /**
+     * If given an error message, it will be displayed in a `<mat-error>`, but only if the control
+     * is actually in an error state via one of its validators.
+     *
+     * This is not needed for the special case of the required validator, because the message is hardcoded.
+     */
+    error: string | null;
+    /**
+     * If the field is required
+     */
+    set required(value: boolean);
+    get required(): boolean;
+    private _required;
+    /**
+     * Add a suffix button that is a link to given destination
+     */
+    navigateTo?: any[] | string | null;
+    /**
+     * If provided cause a new clear button to appear
+     */
+    readonly clearLabel: i0.InputSignal<string | undefined>;
+    /**
+     * Whether to show the search icon
+     */
+    readonly showIcon: i0.InputSignal<boolean>;
+    /**
+     * Icon name
+     */
+    readonly icon: i0.InputSignal<string>;
+    /**
+     * Function to customize the rendering of the selected item as text in input
+     */
+    readonly displayWith: i0.InputSignal<((item: TValue | null) => string) | undefined>;
+    /**
+     * Emit the selected value whenever it changes
+     */
+    readonly selectionChange: i0.OutputEmitterRef<TValue | null>;
+    /**
+     * Emits when internal input is blurred
+     */
+    readonly blur: i0.OutputEmitterRef<void>;
+    /**
+     * Contains internal representation for current selection AND searched text (for autocomplete)
+     *
+     * It is **not** necessarily `TValue | null`.
+     *
+     * - NaturalSelectComponent: `string | TValue | null`. We allow `string`
+     *   only when `optionRequired` is false, so most of the time it is `TValue | null`.
+     * - NaturalSelectHierarchicComponent: `string | null`.
+     * - NaturalSelectEnumComponent: `TValue | null`.
+     *
+     * In natural-select context, we use pristine and dirty to identify if the displayed value is search or committed model :
+     *  - Pristine status (unchanged value) means the model is displayed and propagated = the selection is committed
+     *  - Dirty status (changed value) means we are in search/autocomplete mode
+     */
+    readonly internalCtrl: FormControl<TInput | null>;
+    /**
+     * Interface with ControlValueAccessor
+     * Notifies parent model / form controller
+     */
+    onChange?: (item: TValue | null) => void;
+    /**
+     * Interface with ControlValueAccessor
+     * Notifies parent model / form controller
+     */
+    onTouched?: () => void;
+    readonly matcher: ExternalFormControlMatcher<TValue, TInput>;
+    readonly ngControl: NgControl | null;
+    constructor();
+    ngDoCheck(): void;
+    writeValue(value: TInput | null): void;
+    ngOnInit(): void;
+    /**
+     * Whether the value can be changed
+     */
+    set disabled(disabled: boolean);
+    registerOnChange(fn: (item: TValue | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    abstract getDisplayFn(): (item: TValue | null) => string;
+    /**
+     * Commit the model to null
+     * Emit and event to update the model
+     */
+    clear(): void;
+    /**
+     * If input is dirty (search running) restore to model value
+     */
+    onBlur(): void;
+    /**
+     * Commit the model change
+     */
+    propagateValue(value: TValue | null): void;
+    setDisabledState(isDisabled: boolean): void;
+    showClearButton(): boolean;
+    touch(): void;
+    hasRequiredError(): boolean;
+    /**
+     * Apply Validators.required on the internal form, based on ngControl or [required] attribute, giving priority to attribute.
+     */
+    private applyRequired;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSelect<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractSelect<any, any>, never, never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; }; "required": { "alias": "required"; "required": false; }; "navigateTo": { "alias": "navigateTo"; "required": false; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "displayWith": { "alias": "displayWith"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "selectionChange": "selectionChange"; "blur": "blur"; }, never, never, true, never>;
+}
+
+type Value = IEnum['value'] | IEnum['value'][];
+declare class NaturalSelectEnumComponent extends AbstractSelect<Value, Value> implements OnInit, ControlValueAccessor {
+    private readonly enumService;
+    /**
+     * The name of the enum type, eg: `"ActionStatus"`
+     */
+    readonly enumName: i0.InputSignal<string>;
+    /**
+     * If given an extra option is added to select `null` with given label
+     */
+    nullLabel?: string;
+    /**
+     * Functions that receives an enum value and returns whether that value is disabled
+     */
+    optionDisabled?: (item: IEnum) => boolean;
+    /**
+     * Whether the user should be allowed to select multiple options
+     */
+    readonly multiple: i0.InputSignal<boolean>;
+    items?: Observable<IEnum[]>;
+    ngOnInit(): void;
+    getDisplayFn(): (item: Value | null) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSelectEnumComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalSelectEnumComponent, "natural-select-enum", never, { "enumName": { "alias": "enumName"; "required": true; "isSignal": true; }; "nullLabel": { "alias": "nullLabel"; "required": false; }; "optionDisabled": { "alias": "optionDisabled"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Default usage:
+ *
+ * ```html
+ * <natural-select
+ *     [config]="myConfig"
+ *     [(ngModel)]="amazingModel"
+ *     (ngModelChange)=amazingChangeFn($event)
+ * />
+ * ```
+ *
+ * `[(ngModel)]` and `(ngModelChange)` are optional.
+ *
+ * Placeholder :
+ *
+ * ```html
+ * <natural-select placeholder="amazing placeholder" />
+ * ```
+ */
+declare class NaturalSelectHierarchicComponent extends AbstractSelect<Literal, string> implements OnInit, ControlValueAccessor {
+    private readonly hierarchicSelectorDialogService;
+    /**
+     * If provided cause a new select button to appear
+     */
+    selectLabel?: string;
+    /**
+     * Configuration for hierarchic relations
+     *
+     * It should be an array with at least one element with `selectableAtKey` configured, otherwise the selector will never open.
+     */
+    config: NaturalHierarchicConfiguration[] | null;
+    /**
+     * Filters formatted for hierarchic selector
+     */
+    readonly filters: i0.InputSignal<HierarchicFiltersConfiguration$1 | undefined>;
+    /**
+     * The selected value as an object. The internal value is `internalCtrl.value`, and that is a string.
+     */
+    private value;
+    /**
+     * On Firefox, the combination of <input (focus)> event and dialog opening cause some strange bug where focus event is called multiple
+     * times This prevents it.
+     */
+    private lockOpenDialog;
+    /**
+     * Very important to return something, above all if [select]='displayedValue' attribute value is used
+     */
+    getDisplayFn(): (item: Literal | null) => string;
+    /**
+     * Override parent because our internalCtrl store the textual representation as string instead of raw Literal
+     */
+    writeValue(value: Literal | string | null): void;
+    openDialog(): void;
+    showSelectButton(): boolean;
+    private getSelectKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSelectHierarchicComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalSelectHierarchicComponent, "natural-select-hierarchic", never, { "selectLabel": { "alias": "selectLabel"; "required": false; }; "config": { "alias": "config"; "required": false; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type ValueTypeFor<TService> = string | ExtractTallOne<TService>;
+/**
+ * Default usage:
+ * ```html
+ * <natural-select [service]="myServiceInstance" [(model)]="myModel" (modelChange)=myChangeFn($event) />
+ * ```
+ *
+ * Custom template usage :
+ * ```html
+ * <natural-select [service]="svc" [(ngModel)]="model">
+ *     <ng-template let-item="item">
+ *         <span>{{ item.xxx }}</span>
+ *     </ng-template>
+ * </natural-select>
+ * ```
+ *
+ * `[(ngModel)]` and `(ngModelChange)` are optional.
+ *
+ * Placeholder :
+ * ```html
+ * <natural-select placeholder="my placeholder" />
+ * ```
+ *
+ * Search with like %xxx% on specified field `name` instead of custom filter on whole object
+ * ```html
+ * <natural-select searchField="name" />
+ * ```
+ *
+ * Allows to input free string without selecting an option from autocomplete suggestions
+ * ```html
+ * <natural-select [optionRequired]="false" />
+ * ```
+ */
+declare class NaturalSelectComponent<TService extends NaturalAbstractModelService<any, any, PaginatedData<Literal>, QueryVariables, any, any, any, any, any, any>> extends AbstractSelect<ValueTypeFor<TService>, ValueTypeFor<TService>> implements OnInit, ControlValueAccessor, AfterViewInit {
+    private readonly destroyRef;
+    readonly autoTrigger: i0.Signal<MatAutocompleteTrigger>;
+    readonly itemTemplate: i0.Signal<TemplateRef<any> | undefined>;
+    /**
+     * Service with watchAll function that accepts queryVariables.
+     */
+    readonly service: i0.InputSignal<TService>;
+    /**
+     * If false, allows to input free string without selecting an option from autocomplete suggestions
+     */
+    readonly optionRequired: i0.InputSignal<boolean>;
+    /**
+     * The field on which to search for, default to 'custom'.
+     */
+    searchField: 'custom' | string;
+    /**
+     * The operator with which to search for, default to 'search' if `searchField` is 'custom', else 'like'.
+     */
+    searchOperator: 'search' | string | null;
+    /**
+     * Cache the committed value during search mode.
+     * It's used to be restored in case we cancel the selection
+     */
+    private lastValidValue;
+    /**
+     * Additional filter for query
+     */
+    set filter(filter: ExtractVall<TService>['filter'] | null | undefined);
+    /**
+     * Items returned by server to show in listing
+     */
+    items: null | Observable<readonly any[]>;
+    /**
+     * Whether we are searching something
+     */
+    loading: boolean;
+    /**
+     * If some items are not shown in result list
+     * Shows a message after list if true
+     */
+    hasMoreItems: boolean;
+    nbTotal: number;
+    /**
+     * Default page size
+     */
+    readonly pageSize: i0.InputSignal<number>;
+    /**
+     * Init search options
+     */
+    private readonly variablesManager;
+    /**
+     * Whether the value can be changed
+     */
+    set disabled(disabled: boolean);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onInternalFormChange(): void;
+    onBlur(): void;
+    /**
+     * Reset form to it's initial value
+     * Discard searched text (in autocomplete use case)
+     * Doest not commit the change to the model (no change event is emitted)
+     */
+    reset(): void;
+    /**
+     * Enter semantic means we want to validate something.
+     * If we hit ENTER while typing a text, the stroke is ignored because the value is invalid (it's accepted in free text mode)
+     * If we hit ENTER while the input field is empty, we validate the unselection (empty is a valid value)
+     */
+    onKeyEnter(): void;
+    writeValue(value: ValueTypeFor<TService> | null): void;
+    private initService;
+    startSearch(): void;
+    /**
+     * Commit the model change
+     * Set internal form as pristine to reflect that the visible value match the model
+     */
+    propagateValue(value: ValueTypeFor<TService> | null): void;
+    /**
+     * Very important to return something, above all if [select]='displayedValue' attribute value is used
+     */
+    getDisplayFn(): (item: ValueTypeFor<TService> | null) => string;
+    clear(): void;
+    search(term: ValueTypeFor<TService> | null): void;
+    showClearButton(): boolean;
+    private getSearchFilter;
+    getVariablesForDebug(): Readonly<QueryVariables> | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalSelectComponent<any>, "natural-select", never, { "service": { "alias": "service"; "required": true; "isSignal": true; }; "optionRequired": { "alias": "optionRequired"; "required": false; "isSignal": true; }; "searchField": { "alias": "searchField"; "required": false; }; "searchOperator": { "alias": "searchOperator"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["itemTemplate"], never, true, never>;
+}
+
+declare class NaturalSidenavContainerComponent implements OnInit, OnDestroy {
+    readonly sidenavService: NaturalSidenavService;
+    /**
+     * Unique identifier used for the local storage
+     */
+    readonly name: i0.InputSignal<string>;
+    /**
+     * The side that the drawer is attached to
+     */
+    readonly position: i0.InputSignal<"start" | "end">;
+    /**
+     * If true listens to route changes to close side nav after a route change if mobile view is active
+     * Actually a navigation to current route does not emit a route change, and the sidenav don't close.
+     */
+    readonly mobileAutoClose: i0.InputSignal<boolean>;
+    /**
+     * Width of the minimized menu
+     */
+    readonly minimizedWidth: i0.InputSignal<number>;
+    /**
+     * If true, prevents "native" material sidenav to scroll at container level and delegates the scroll responsability to the transcluded
+     * content
+     */
+    noScroll: boolean;
+    /**
+     * Inner "native" material sidenav
+     */
+    readonly menuSidenav: i0.Signal<MatSidenav>;
+    get isMinimized(): boolean;
+    get isMobileView(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    toggle(): void;
+    close(): void;
+    open(): void;
+    minimize(): void;
+    expand(): void;
+    toggleMinimized(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSidenavContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalSidenavContainerComponent, "natural-sidenav-container", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "mobileAutoClose": { "alias": "mobileAutoClose"; "required": false; "isSignal": true; }; "minimizedWidth": { "alias": "minimizedWidth"; "required": false; "isSignal": true; }; "noScroll": { "alias": "noScroll"; "required": false; }; }, {}, never, ["natural-sidenav", "natural-sidenav-content"], true, never>;
+}
+
+/**
+ * TODO: Fix nav minimize and maximize resize
+ * Since Material 2 beta 10, when nav is resized the body is not resized
+ * https://github.com/angular/material2/issues/6743
+ * Maybe the better is to wait next release
+ */
+declare class NaturalSidenavService {
+    private readonly destroyRef;
+    private readonly breakpointObserver;
+    private readonly router;
+    private readonly sessionStorage;
+    private readonly naturalSidenavStackService;
+    /**
+     * Navigation modes
+     * First is for desktop view
+     * Second is for mobile view
+     */
+    private modes;
+    /**
+     * Activated mode
+     * Default to desktop view
+     */
+    private mode;
+    /**
+     * Whether nav is opened or not
+     */
+    private opened;
+    /**
+     * Stores the opened status during mobile view, to restore if we come back to desktop view
+     */
+    private tmpOpened;
+    /**
+     * Whether nav is minimized or not
+     */
+    private minimized;
+    /**
+     * LocalStorage key that stores the minimized status
+     */
+    private readonly minimizedStorageKey;
+    /**
+     * LocalStorage key that stores the opened status
+     */
+    private readonly openedStorageKey;
+    private minimizedStorageKeyWithName;
+    private openedStorageKeyWithName;
+    private _isMobileView;
+    get activeMode(): MatDrawerMode;
+    get isOpened(): boolean;
+    get isMinimized(): boolean;
+    destroy(component: NaturalSidenavContainerComponent): void;
+    init(name: string, component: NaturalSidenavContainerComponent, autoClose?: boolean): void;
+    isMobileView(): boolean;
+    /**
+     * Close nav on mobile view after a click
+     */
+    navItemClicked(): void;
+    /**
+     * Change minimized status and stores the new value
+     */
+    setMinimized(value: boolean): void;
+    minimize(): void;
+    expand(): void;
+    toggleMinimized(): void;
+    /**
+     * Get the stored minimized status
+     */
+    getMinimizedStatus(): boolean;
+    /**
+     * Get the stored opened status
+     * Default on an opened status if nothing is stored
+     */
+    getMenuOpenedStatus(): boolean;
+    /**
+     * Toggle menu but expand it if mobile mode is activated
+     * Stores the status in local storage
+     */
+    toggle(): void;
+    close(): void;
+    open(): void;
+    setOpened(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSidenavService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalSidenavService>;
+}
+
+declare class NaturalSidenavStackService {
+    /**
+     * The stack of all currently living sidenavs
+     */
+    private readonly sidenavs;
+    /**
+     * Emits the most recent living SidenavContainer whenever it changes. So it's
+     * either the SidenavContainer that was just added, or the one "before" the
+     * SidenavContainer that was just removed
+     */
+    readonly currentSidenav: Subject<NaturalSidenavContainerComponent | undefined>;
+    /**
+     * For internal use only
+     * @internal
+     */
+    register(sidenav: NaturalSidenavContainerComponent): void;
+    /**
+     * For internal use only
+     * @internal
+     */
+    unregister(sidenav: NaturalSidenavContainerComponent): void;
+    private next;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSidenavStackService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalSidenavStackService>;
+}
+
+declare class NaturalSidenavComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSidenavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalSidenavComponent, "natural-sidenav", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class NaturalSidenavContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalSidenavContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalSidenavContentComponent, "natural-sidenav-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+type Stamped = {
+    creator: NameOrFullName | null;
+    updater: NameOrFullName | null;
+    creationDate: string | null;
+    updateDate: string | null;
+};
+declare class NaturalStampComponent {
+    readonly item: i0.InputSignal<Stamped>;
+    protected readonly showUpdate: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalStampComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalStampComponent, "natural-stamp", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Button that fits well in a `<mat-table>` and support either
+ * route navigation via `navigate`, or external URL via `href`,
+ * or callback via `buttonClick`.
+ *
+ * If neither `navigate` nor `href` nor `buttonClick` have a meaningful value, then
+ * it will show the icon and/or label in a `<span>` instead of a button.
+ *
+ * External URL will always be opened in new tab.
+ */
+declare class NaturalTableButtonComponent {
+    readonly queryParams: i0.InputSignal<Params>;
+    readonly queryParamsHandling: i0.InputSignal<QueryParamsHandling>;
+    readonly label: i0.InputSignal<string | null | undefined>;
+    readonly icon: i0.InputSignal<string | null | undefined>;
+    readonly href: i0.InputSignal<string | null | undefined>;
+    readonly navigate: i0.InputSignal<string | readonly any[] | UrlTree | null | undefined>;
+    readonly fragment: i0.InputSignal<string | undefined>;
+    readonly preserveFragment: i0.InputSignal<boolean>;
+    readonly disabled: i0.InputSignal<boolean>;
+    readonly raised: i0.InputSignal<boolean>;
+    protected readonly appearance: i0.Signal<MatButtonAppearance>;
+    protected readonly iconClass: i0.Signal<"" | "mat-elevation-z4">;
+    readonly color: i0.InputSignal<ThemePalette>;
+    protected readonly buttonClick$: Subject<MouseEvent>;
+    readonly buttonClick: i0.OutputRef<MouseEvent>;
+    protected readonly type: i0.Signal<"none" | "href" | "routerLinkOrClick">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalTableButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalTableButtonComponent, "natural-table-button", never, { "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "navigate": { "alias": "navigate"; "required": false; "isSignal": true; }; "fragment": { "alias": "fragment"; "required": false; "isSignal": true; }; "preserveFragment": { "alias": "preserveFragment"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "raised": { "alias": "raised"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
+}
+
+type NaturalDialogTriggerRoutingData<T, D> = {
+    component: ComponentType<T>;
+    afterClosedRoute?: RouterLink['routerLink'];
+    dialogConfig: MatDialogConfig<D>;
+};
+type NaturalDialogTriggerProvidedData<D> = {
+    data?: Readonly<D> | null;
+    activatedRoute: ActivatedRoute;
+};
+type NaturalDialogTriggerRedirectionValues = RouterLink['routerLink'] | null | undefined | '' | -1;
+declare class NaturalDialogTriggerComponent<T, D> implements OnDestroy {
+    private readonly dialog;
+    private readonly route;
+    private readonly router;
+    private readonly dialogRef;
+    private readonly triggerConfig;
+    constructor();
+    /**
+     * Called when router leaves route, and so on, closes the modal with undefined value to prevent a new redirection
+     */
+    ngOnDestroy(): void;
+    /**
+     * Redirects on modal closing under following rules/conditions
+     *
+     * If -1 : no redirection
+     * If undefined, null or empty string : uses the router provided redirection route or fallbacks on parent route if router don't provide
+     * If a value is provided, should be of type any[] and it's used for redirection.
+     */
+    redirect(exitValue: NaturalDialogTriggerRedirectionValues): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalDialogTriggerComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalDialogTriggerComponent<any, any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A creator interface used to instantiate source implementation
+ */
+type SourceCreator = new (sourceValue: string) => Source;
+/**
+ * Contract of all Sources.
+ * Every source must implements the fetch method
+ * in order to provide the avatar source.
+ */
+declare abstract class Source {
+    private readonly value;
+    constructor(value: string);
+    getValue(): string;
+    /**
+     * Gets the avatar that usually is a URL, but,
+     * for example it can also be a string of initials from the name.
+     */
+    abstract getAvatar(size: number): Promise<string>;
+    /**
+     * Whether the avatar is purely textual or an URL for an image
+     */
+    abstract isTextual(): boolean;
+}
+
+/**
+ * Show an avatar from different sources
+ */
+declare class NaturalAvatarComponent {
+    private readonly avatarService;
+    readonly image: i0.InputSignal<string | null | undefined>;
+    readonly initials: i0.InputSignal<string | null | undefined>;
+    readonly gravatar: i0.InputSignal<string | null | undefined>;
+    readonly size: i0.InputSignal<number>;
+    readonly decorated: i0.InputSignal<boolean>;
+    readonly textSizeRatio: i0.InputSignal<number>;
+    readonly bgColor: i0.InputSignal<string | undefined>;
+    readonly fgColor: i0.InputSignal<string>;
+    readonly borderRadius: i0.InputSignal<string>;
+    readonly textMaximumLength: i0.InputSignal<number>;
+    private readonly sources;
+    protected readonly currentSource: i0.Signal<Source | undefined>;
+    protected readonly imageAvatar: i0.Signal<Promise<string> | undefined>;
+    protected readonly textAvatar: i0.Signal<Promise<string> | undefined>;
+    /**
+     * Try to use the next available avatar source that has not already failed in the past
+     */
+    tryNextSource(): void;
+    private findNextNonFailingIndex;
+    /**
+     * Returns initials style
+     */
+    protected readonly textualStyle: i0.Signal<Partial<CSSStyleDeclaration>>;
+    /**
+     * Returns image style
+     */
+    protected readonly imageStyle: i0.Signal<Partial<CSSStyleDeclaration>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NaturalAvatarComponent, "natural-avatar", never, { "image": { "alias": "image"; "required": false; "isSignal": true; }; "initials": { "alias": "initials"; "required": false; "isSignal": true; }; "gravatar": { "alias": "gravatar"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "decorated": { "alias": "decorated"; "required": false; "isSignal": true; }; "textSizeRatio": { "alias": "textSizeRatio"; "required": false; "isSignal": true; }; "bgColor": { "alias": "bgColor"; "required": false; "isSignal": true; }; "fgColor": { "alias": "fgColor"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "textMaximumLength": { "alias": "textMaximumLength"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SourceType = 'gravatar' | 'image' | 'initials';
+/**
+ * Provides utilities methods related to Avatar component
+ */
+declare class AvatarService {
+    /**
+     * Ordered pairs of possible sources. First in the list is the highest priority.
+     * And key must match one the input of AvatarComponent.
+     */
+    private readonly sourceCreators;
+    private readonly avatarColors;
+    private readonly failedSources;
+    getRandomColor(avatarText: string): string;
+    getCreators(): IterableIterator<[SourceType, SourceCreator]>;
+    private getSourceKey;
+    sourceHasFailedBefore(source: Source): boolean;
+    markSourceAsFailed(source: Source): void;
+    private calculateAsciiCode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AvatarService>;
+}
+
+/**
+ * Incomplete list of Matomo functions. But it should be enough
+ * for our basic needs.
+ *
+ * To complete this list, maybe see https://developer.matomo.org/guides/tracking-javascript-guide
+ */
+type MatomoFunction = 'setCustomUrl' | 'setCustomDimension' | 'setDocumentTitle' | 'setReferrerUrl' | 'setSiteId' | 'setTrackerUrl' | 'trackPageView';
+type PaqItem = [MatomoFunction, ...(number | string | null)[]];
+/**
+ * Service to track visitors via Matomo.
+ *
+ * @dynamic
+ */
+declare class NaturalMatomoService {
+    private readonly router;
+    private readonly document;
+    private readonly titleService;
+    private readonly isBrowser;
+    private readonly window;
+    private subscription;
+    private referrerUrl;
+    constructor();
+    /**
+     * Inject Matomo script and start tracking all page navigation
+     */
+    startTracking(url: string | null, site: number | null): void;
+    stopTracking(): void;
+    /**
+     * Push a Matomo command on the stack
+     *
+     * It can be called at any time, including before Matomo is even loaded.
+     *
+     * Also see https://developer.matomo.org/guides/tracking-javascript-guide
+     */
+    push(functionName: PaqItem[0], ...args: PaqItem[1][]): void;
+    private injectTrackingCode;
+    private listenForRouteChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalMatomoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalMatomoService>;
+}
+
+type NaturalLoggerType = {
+    message: string;
+    stacktrace?: string;
+    href?: string;
+    host?: string;
+    path?: string;
+    agent?: string;
+    status?: number;
+    referrer?: string;
+    url?: string;
+    userId?: string;
+    user?: string;
+    [key: string]: any;
+};
+type NaturalLoggerExtra = {
+    /**
+     * Return an observable of extra data that will be logged. Those data will be merged into
+     * the original data, and so it can override things.
+     *
+     * Only the first emitted value will be used.
+     */
+    getExtras(error: unknown): Observable<Partial<NaturalLoggerType>>;
+};
+declare const NaturalLoggerConfigUrl: InjectionToken<string>;
+declare const NaturalLoggerConfigExtra: InjectionToken<NaturalLoggerExtra>;
+/**
+ * Replace Angular's error handler to also send the log to a remote server via HTTP POST.
+ *
+ * Usage is automatic as soon as we provide it via:
+ *
+ * ```ts
+ * provideErrorHandler('http://example.com', ExtraService),
+ * ```
+ */
+declare class NaturalErrorHandler extends ErrorHandler {
+    private readonly http;
+    private readonly document;
+    private readonly url;
+    private readonly loggerExtra;
+    constructor();
+    handleError(error: any): void;
+    private toMessage;
+    /**
+     * Send parameters to remote log
+     */
+    private postLog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NaturalErrorHandler>;
+}
+
+declare function provideErrorHandler(url: string | null, extraService?: Type<NaturalLoggerExtra>): Provider[];
+
+/**
+ * Need to add http:// prefix if we don't have prefix already AND we don't have part of it
+ */
+declare function ensureHttpPrefix(value: string | null): string | null;
+/**
+ * This directive only supports ReactiveForms due to ngModel/ngControl encapsulation and changes emissions.
+ */
+declare class NaturalHttpPrefixDirective {
+    readonly naturalHttpPrefix: i0.InputSignal<AbstractControl<any, any, any> | null>;
+    httpize($event: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NaturalHttpPrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NaturalHttpPrefixDirective, "[naturalHttpPrefix]", never, { "naturalHttpPrefix": { "alias": "naturalHttpPrefix"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Minimal, global providers for Natural to work
+ */
+declare const naturalProviders: ApplicationConfig['providers'];
+
+/**
+ * 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;
+
+export { AvatarService, InvalidWithValueStateMatcher$1 as InvalidWithValueStateMatcher, LOCAL_STORAGE, NATURAL_DROPDOWN_DATA, NATURAL_ICONS_CONFIG, NATURAL_PERSISTENCE_VALIDATOR, NATURAL_SEO_CONFIG, NaturalAbstractDetail, NaturalAbstractEditableList, NaturalAbstractList, NaturalAbstractModelService, NaturalAbstractNavigableList, NaturalAbstractPanel, NaturalAlertService, NaturalAvatarComponent, NaturalBackgroundDensityDirective, NaturalCapitalizePipe, NaturalColumnsPickerComponent, NaturalConfirmComponent, NaturalDataSource, NaturalDebounceService, NaturalDetailHeaderComponent, NaturalDialogTriggerComponent, NaturalDropdownRef, NaturalEllipsisPipe, NaturalEnumPipe, NaturalEnumService, NaturalErrorHandler, NaturalFileComponent, NaturalFileDropDirective, NaturalFileSelectDirective, NaturalFileService, NaturalFixedButtonComponent, NaturalFixedButtonDetailComponent, NaturalHierarchicSelectorComponent, NaturalHierarchicSelectorDialogComponent, NaturalHierarchicSelectorDialogService, NaturalHierarchicSelectorService, NaturalHttpPrefixDirective, NaturalIconDirective, NaturalLinkMutationService, NaturalLinkableTabDirective, NaturalLoggerConfigExtra, NaturalLoggerConfigUrl, NaturalMatomoService, NaturalMemoryStorage, NaturalPanelsComponent, NaturalPanelsService, NaturalPersistenceService, NaturalQueryVariablesManager, NaturalRelationsComponent, NaturalSearchComponent, NaturalSelectComponent, NaturalSelectEnumComponent, NaturalSelectHierarchicComponent, NaturalSeoService, NaturalSidenavComponent, NaturalSidenavContainerComponent, NaturalSidenavContentComponent, NaturalSidenavService, NaturalSidenavStackService, NaturalSrcDensityDirective, NaturalStampComponent, NaturalSwissParsingDateAdapter, NaturalTableButtonComponent, NaturalTimeAgoPipe, NetworkActivityService, PanelsHooksConfig, SESSION_STORAGE, SortingOrder, TypeBooleanComponent, TypeDateComponent, TypeDateRangeComponent, TypeHierarchicSelectorComponent, TypeNaturalSelectComponent, TypeNumberComponent, TypeOptionsComponent, TypeSelectComponent, TypeTextComponent, activityInterceptor, available, cancellableTimeout, cloneDeepButSkipFile, collectErrors, copyToClipboard, createHttpLink, debug, decimal, deepFreeze, deliverableEmail, ensureHttpPrefix, fallbackIfNoOpenedPanels, formatIsoDate, formatIsoDateTime, fromUrl, getForegroundColor, graphqlQuerySigner, hasFilesAndProcessDate, ifValid, integer, isFile, localStorageFactory, localStorageProvider, makePlural, memoryLocalStorageProvider, memorySessionStorageProvider, mergeOverrideArray, money, naturalPanelsUrlMatcher, naturalProviders, onHistoryEvent, possibleComparableOperators, provideErrorHandler, provideIcons, providePanels, provideSeo, relationsToIds, replaceObjectKeepingReference, replaceOperatorByField, replaceOperatorByName, rgbToHex, sessionStorageFactory, sessionStorageProvider, toGraphQLDoctrineFilter, toNavigationParameters, toUrl, unique, upperCaseFirstLetter, urlValidator, validTlds, validateAllFormControls, validateColumns, validatePagination, validateSorting, wrapLike, wrapPrefix, wrapSuffix };
+export type { AvailableColumn, Button, DropdownComponent, DropdownFacet, ExtractResolve, ExtractTall, ExtractTallOne, ExtractTcreate, ExtractTdelete, ExtractTone, ExtractTupdate, ExtractVall, ExtractVcreate, ExtractVdelete, ExtractVone, ExtractVupdate, Facet, FileModel, FileSelection, Filter, FilterGroupConditionField, FlagFacet, FormAsyncValidators, FormControls, FormValidators, HierarchicDialogConfig, HierarchicDialogResult, HierarchicFilterConfiguration$1 as HierarchicFilterConfiguration, HierarchicFiltersConfiguration$1 as HierarchicFiltersConfiguration, IEnum, InvalidFile, LinkableObject, Literal, NameOrFullName, NaturalConfirmData, NaturalDialogTriggerProvidedData, NaturalDialogTriggerRedirectionValues, NaturalDialogTriggerRoutingData, NaturalDropdownData, NaturalHierarchicConfiguration, NaturalIconConfig, NaturalIconsConfig, NaturalLoggerExtra, NaturalLoggerType, NaturalPanelConfig, NaturalPanelData, NaturalPanelResolves, NaturalPanelsBeforeOpenPanel, NaturalPanelsHooksConfig, NaturalPanelsRouteConfig, NaturalPanelsRouterRule, NaturalPanelsRoutesConfig, NaturalSearchFacets, NaturalSearchSelection, NaturalSearchSelections, NaturalSeo, NaturalSeoBasic, NaturalSeoCallback, NaturalSeoConfig, NaturalSeoResolve, NaturalSeoResolveData, NaturalStorage, NavigableItem, OrganizedModelSelection, PaginatedData, PaginationInput, PersistenceValidator, PossibleComparableOpertorKeys, QueryVariables, ResolvedData, Sorting, SubButton, TypeBooleanConfiguration, TypeDateConfiguration, TypeDateRangeConfiguration, TypeHierarchicSelectorConfiguration, TypeNumberConfiguration, TypeOption, TypeOptionsConfiguration, TypeSelectConfiguration, TypeSelectItem, TypeSelectNaturalConfiguration, VariablesWithInput, WithId };