@solidev/data 0.5.1 → 0.6.0

package/index.d.ts

@@ -1,5 +1,2149 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, TransferState, NgZone, OnInit, ElementRef, EventEmitter, OnChanges, PipeTransform, SimpleChanges, OnDestroy, ApplicationRef } from '@angular/core';
+import { ValidatorFn, FormControl, ValidationErrors, FormGroup, UntypedFormControl, UntypedFormGroup, ControlValueAccessor } from '@angular/forms';
+import * as _angular_common_http from '@angular/common/http';
+import { HttpClient, HttpInterceptor, HttpRequest, HttpHandler } from '@angular/common/http';
+import * as rxjs from 'rxjs';
+import { Observable, ReplaySubject, Subject, Subscription } from 'rxjs';
+import { ActivatedRoute, Router, Route, RouterState, UrlSegment } from '@angular/router';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { NgbOffcanvas, NgbDropdown } from '@ng-bootstrap/ng-bootstrap';
+import { Toolbar, Editor } from 'ngx-editor';
+import { SwUpdate } from '@angular/service-worker';
+
 /**
- * Generated bundle index. Do not edit.
+ * DATA_API_URL: stores data api base url
  */
-/// <amd-module name="@solidev/data" />
-export * from './public-api';
+declare const DATA_API_URL: InjectionToken<string>;
+/**
+ * DATA_MAX_TRANSFERSTATE_TIME: max duration to use transferstate time
+ * If DATA_MAX_TRANSFERSTATE_TIME is zero, TransferState is not used
+ */
+declare const DATA_MAX_TRANSFERSTATE_TIME: InjectionToken<number>;
+/**
+ * DataDisplayConfig interface provides default values for display classes
+ */
+interface DataDisplayConfig {
+    dispEdit: {
+        defaultMode: "inline" | "dd";
+        inputClasses: {
+            [index: string]: string;
+        };
+    };
+}
+declare const BootstrapDataDisplayConfig: DataDisplayConfig;
+/**
+ * DATA_DISPLAY_CONFIG: display config & default classes injection token
+ */
+declare const DATA_DISPLAY_CONFIG: InjectionToken<DataDisplayConfig>;
+
+interface IDispEditChoice {
+    desc: string;
+    value: any;
+}
+type DISPEDIT_EDITOR_TYPES = 'input.text' | 'input.email' | 'input.number' | 'input.decimal' | 'input.datetime' | 'input.date' | 'input.checkbox' | 'input.password' | 'textarea' | 'select' | 'quill' | 'fkselect' | 'm2mselect';
+type DISPEDIT_DISPLAY_TYPES = 'text' | 'choice' | 'boolean' | 'decimal' | 'fkdetails' | 'm2mdetails' | 'datetime' | 'date' | 'quill';
+
+/**
+ * Descriptive info for all fields.
+ * All are optional.
+ */
+interface IFieldMetadata<FT> {
+    /** Field name (for display, column title, etc..) */
+    name?: string;
+    /** Field help text (for input) */
+    help?: string;
+    /** Field description (for details on hover etc..) */
+    description?: string;
+    /** Field required : no undefined allowed on save ? */
+    required?: boolean;
+    /** Field cannot be updated */
+    readonly?: boolean;
+    /** Default value */
+    defaultValue?: FT | ((args: any) => FT) | null;
+    /** Priority : first fields = higher priority */
+    priority?: number;
+}
+/**
+ * Base field manager, stores metadata and provides common field utilities
+ *
+ * - name : field name, should be the same in data structure and model
+ * - help : field help text, blank by default
+ * - description : field name for humans
+ * - readonly : field is readonly (cannot be changed / pushed to api)
+ * - default : default value for field
+ *
+ * - editor_type : editor type
+ * - display_type : display type
+ *
+ * - fromJson(data) : deserializer
+ * - toJson(data) : serialiser
+ * - toString(data,format) : to string, for display
+ *
+ * - formControl : returns field form control
+ * - validators : returns field validator
+ */
+declare class BaseFieldManager<FT> implements IFieldMetadata<FT> {
+    /** Name is mandatory in a field manager. It is given by
+     * field decorator if not directly given in field manager. */
+    name: string;
+    description: string;
+    help: string;
+    required: boolean;
+    readonly: boolean;
+    computed: boolean;
+    priority: number;
+    defaultValue?: FT | ((args: any) => FT);
+    editorType: DISPEDIT_EDITOR_TYPES;
+    displayType: DISPEDIT_DISPLAY_TYPES;
+    constructor(params: IFieldMetadata<FT>);
+    /** Return field validators */
+    get validators(): ValidatorFn[];
+    /** Returns current field name */
+    get fname(): string;
+    /** Create a new typed formControl for this field. */
+    formControl(instance: DataModel): FormControl<FT | null>;
+    /** JSON deserializer base method. */
+    fromJson(data: any): FT;
+    /** JSON serializer base method. */
+    toJson(data: FT): any;
+    /**
+     * Display value (as string)
+     * @param data
+     * @param format (not used)
+     */
+    toString(data: FT, format?: string): string;
+    /**
+     * Returns default value for model, using args if needed.
+     * @param args
+     */
+    default(args?: any): FT | undefined;
+    /** Return validators
+     *
+     * @protected
+     */
+    protected getValidators(): ValidatorFn[];
+    /**
+     * Returns default value for model, using args if needed.
+     * @param args
+     * @protected
+     */
+    protected getDefaultValue(args?: any): FT | undefined;
+}
+/**
+ * Field data stored on reflected metadata.
+ */
+interface IFieldStoredMetadata<FT> extends IFieldMetadata<FT> {
+    self: string;
+    name: string;
+    type: string;
+    manager: BaseFieldManager<FT>;
+}
+/**
+ * Field decorator function
+ */
+type FieldDecoratorFn = (target: any, propertyKey: string | symbol) => void;
+
+/**
+ * DataBackend provides CRUD operations to a REST api.
+ * TransferState can be used if DATA_MAX_TRANSFERSTATE_TIME is set and > 0
+ */
+declare class DataBackend {
+    private _http;
+    private _transferState;
+    private _platform;
+    private _apiUrl;
+    private _maxTransferstateTime;
+    private _created;
+    constructor(_http: HttpClient, _transferState: TransferState, _platform: any, _apiUrl: string, _maxTransferstateTime?: number);
+    /**
+     * Return api url for this backend.
+     */
+    get apiUrl(): string;
+    /**
+     * Launch an action on collection.
+     * If method is GET and collection.useTranserState & transferState are enabled,
+     * result is stored / retrieved from transferState.
+     *
+     * @param collection Collection reference
+     * @param method HTTP method
+     * @param url full URL for action
+     * @param body JSON body
+     * @param params query parameters
+     * @param headers query headers
+     * @param responseType response type
+     *
+     * @return an observable of response body
+     */
+    action<T extends DataModel, RT>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<RT>;
+    /**
+     * Launch an action on collection, receiving a blob.
+     *
+     * @param collection Collection reference
+     * @param method HTTP method
+     * @param url full URL for action
+     * @param body JSON body
+     * @param params query parameters
+     * @param headers query headers
+     * @param responseType response type
+     *
+     * @return an observable of response body
+     */
+    blob<T extends DataModel>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<Blob>;
+    put<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<T>;
+    post<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
+    patch<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
+    delete<T extends DataModel, R>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<R>;
+    _cachedGet<T extends DataModel, RT>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<RT>;
+    get<T extends DataModel>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<Partial<T>>;
+    list<T extends DataModel>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<any>;
+    /**
+     * Return headers for this backend.
+     * Provided headers are copied and returned.
+     * Can be overriden by subclasses for specific headers (e.g. auth token).
+     */
+    protected headers(headers: {
+        [key: string]: string;
+    }): {
+        [key: string]: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataBackend, [null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataBackend>;
+}
+
+interface FilterData {
+    [index: string]: string | number | boolean | undefined | null;
+}
+interface OutFilterData {
+    [index: string]: string;
+}
+type SortData = string;
+/**
+ * Queryset parameters
+ */
+interface IQuerysetOptions {
+    /** Emit fields list */
+    emitFields?: boolean;
+    /** Queryset name */
+    name?: string;
+    /** TODO: see usage */
+    route?: ActivatedRoute;
+    /** TODO: see usage */
+    router?: Router;
+    /** TODO: see usage */
+    hash?: string;
+}
+interface IQueryNav {
+    page: number;
+    page_size: number;
+}
+interface IQueryMetaNav {
+    count: number;
+    next: number | null;
+    page: number;
+    pages: number;
+    prev: number | null;
+    size: number;
+}
+interface IQueryMetaNavParams {
+    page: string;
+    page_size: string;
+}
+interface IQueryMeta {
+    nav: IQueryMetaNav;
+    parameters: IQueryMetaNavParams;
+}
+interface IQueryFullResponse<T> extends IQueryMeta {
+    results: T[];
+}
+declare class Queryset<T extends DataModel> {
+    protected _coll: Collection<T>;
+    /** Current filter data */
+    filterData: FilterData;
+    /** Current sorter data */
+    sortData: SortData[];
+    /** Current fields */
+    fields: string[];
+    /** Current page size */
+    pageSize: number;
+    /** Current page number */
+    page: number;
+    options: IQuerysetOptions;
+    private _loading;
+    /** Loading status (true if currently fetching data) */
+    loading: Observable<boolean>;
+    private _meta;
+    /** Results meta part observable */
+    meta: Observable<IQueryMeta>;
+    private _results;
+    /** Results data part observable */
+    results: Observable<T[]>;
+    private _full;
+    /** Full results observable (results, loading, meta) */
+    full: Observable<[T[], boolean, IQueryMeta]>;
+    constructor(_coll: Collection<T>, options?: IQuerysetOptions);
+    private _pristine;
+    /** Pristine status (true if it has not collected results yet) */
+    get pristine(): boolean;
+    /**
+     * Update current filter data. Null or undefined values are removed from filter data.
+     * @param params filter data
+     * @param update boolean to update filter data instead of recreating it from scratch
+     */
+    filter(params?: FilterData, update?: boolean): Queryset<T>;
+    /**
+     * Update sorting parameters, list of strings giving sort parameters e.g. sort("+name", "-id").
+     * @param sorting strings of sort parameters
+     */
+    sort(...sorting: string[]): Queryset<T>;
+    /**
+     * Update page size.
+     * @param pageSize required page size
+     */
+    paginateBy(pageSize?: number): Queryset<T>;
+    /**
+     * Update current page number.
+     * @param page required pqge
+     * @param fragment TODO: fragment usage for router usage
+     */
+    setPage(page?: number, fragment?: string): Queryset<T>;
+    setFields(fields: string[]): Queryset<T>;
+    getQueryParams(): OutFilterData;
+    get(refresh?: boolean, sync?: boolean): Observable<T[]>;
+}
+
+type IHttpMethod = 'POST' | 'GET' | 'DELETE' | 'PUT' | 'PATCH';
+interface IActionParams {
+    body?: any;
+    headers?: {
+        [index: string]: string;
+    };
+    params?: {
+        [index: string]: string;
+    };
+    responseType?: 'json' | 'blob';
+}
+interface ICollectionCacheParams {
+    transferState?: {
+        enabled: boolean;
+        maxTime: number;
+        maxCount: number;
+    };
+}
+type DataModelType<T extends DataModel> = new (_coll?: Collection<T>) => T;
+declare class Collection<T extends DataModel> {
+    protected backend: DataBackend;
+    protected path: string;
+    model: DataModelType<T>;
+    useTransferState: boolean;
+    constructor(backend: DataBackend, path: string, model: DataModelType<T>);
+    create(data?: Partial<T>): T;
+    fromJson(data: Partial<T>): T;
+    fromJson(data: Partial<T>[]): T[];
+    queryset(options?: IQuerysetOptions): Queryset<T>;
+    fetch(id: number, { prefix, suffix, params, headers, }?: {
+        prefix?: string;
+        suffix?: string;
+        params?: {
+            [_index: string]: string;
+        };
+        headers?: {
+            [_index: string]: string;
+        };
+    }): Observable<T>;
+    action<RT>(model: T | null, method: IHttpMethod, action: string, { body, params, headers }?: IActionParams): Observable<RT>;
+    save(model: T, { updateModel }?: {
+        updateModel?: boolean;
+    }): Observable<T>;
+    update(model: T, fields?: string[], { updateModel }?: {
+        updateModel?: boolean;
+    }): Observable<T>;
+    delete(model: T, { params, headers }?: IActionParams): Observable<any>;
+    list(query?: FilterData, { prefix, suffix, params, headers, }?: {
+        prefix?: string;
+        suffix?: string;
+        params?: {
+            [_index: string]: string;
+        };
+        headers?: {
+            [_index: string]: string;
+        };
+    }): Observable<T[]>;
+    /**
+     * Calls *method* endpoint for this collection and returns raw results.
+     *
+     * @param method GET/POST/...
+     * @param prefix collection_urlPREFIXSUFFIX
+     * @param suffix collection_urlPREFIXSUFFIX
+     * @param params query paremeters
+     * @param body body as json
+     * @param headers headers
+     */
+    raw<RT>({ method, prefix, suffix, params, body, headers, }?: {
+        method?: IHttpMethod;
+        prefix?: string;
+        suffix?: string;
+        body?: any;
+        params?: {
+            [_index: string]: string;
+        };
+        headers?: {
+            [_index: string]: string;
+        };
+    }): Observable<RT>;
+    /**
+     * Calls *method* endpoint for this collection and returns raw results.
+     *
+     * @param method GET/POST/...
+     * @param prefix collection_urlPREFIXSUFFIX
+     * @param suffix collection_urlPREFIXSUFFIX
+     * @param params query paremeters
+     * @param body body as json
+     * @param headers headers
+     */
+    blob<RT>({ method, prefix, suffix, params, body, headers, }?: {
+        method?: IHttpMethod;
+        prefix?: string;
+        suffix?: string;
+        body?: any;
+        params?: {
+            [_index: string]: string;
+        };
+        headers?: {
+            [_index: string]: string;
+        };
+    }): Observable<Blob>;
+    getUrl(id?: number | null, { prefix, suffix }?: {
+        prefix?: string;
+        suffix?: string;
+    }): string;
+}
+
+type DataModelFields = Readonly<Map<string, IFieldStoredMetadata<any>>>;
+/**
+ * Base class for data model.
+ *
+ * Each class must have a static __name
+ * primary field is given with id field.
+ *
+ * Some methods are provided to be used with a collection, mostly for CRUD operations.
+ *
+ */
+declare class DataModel {
+    protected _coll?: Collection<any> | undefined;
+    /**
+     * data model name
+     * this need to be given because class name is not fully available because of minification.
+     */
+    protected static readonly __name: string;
+    /**
+     * Primary field; readonly; must be created and auto incremented on db side.
+     */
+    id: number;
+    private readonly _F;
+    /**
+     * Constructor for data model instance.
+     * A matching collection can be provided.
+     * ___fields readonly property is also populated from Reflected metadata
+     *
+     * @param _coll collection used for CRUD, etc..
+     */
+    constructor(_coll?: Collection<any> | undefined);
+    get _collection(): Collection<any>;
+    set _collection(coll: Collection<any>);
+    /**
+     *  HashMap of fields metadata (type, name, manager, etc...)
+     */
+    get F(): DataModelFields;
+    get FN(): IterableIterator<string>;
+    /**
+     * Loads model data from json.
+     * If partial is true, only fields with matching data keys will be loaded
+     * @param data
+     * @param options
+     */
+    fromJson(data: {
+        [index: string]: any;
+    }, { partial, check }?: {
+        partial?: boolean;
+        check?: boolean;
+    }): null | ValidationErrors;
+    toJson(fields?: string | string[]): any;
+    action<T, RT extends {
+        [index: string]: any;
+    }>(method: 'POST' | 'PATCH' | 'GET' | 'DELETE' | 'PUT', name: string, { body, update, updatePartial, updateCheck, params, headers, }?: {
+        body?: {
+            [_index: string]: any;
+        };
+        update?: boolean;
+        updatePartial?: boolean;
+        updateCheck?: boolean;
+        params?: {
+            [_index: string]: string;
+        };
+        headers?: {
+            [_index: string]: string;
+        };
+    }): Observable<RT>;
+    FM<FT>(field: string): BaseFieldManager<FT>;
+    FV<FT>(field: string): FT;
+    /**
+     * Set field value. If check is true, only set value if all validators pass.
+     * Skip setting field value if manager computed flag is true.
+     *
+     * The validation result is returned.
+     *
+     * @param field field name
+     * @param value field valued
+     * @param check default false
+     * @return null or ValidationError
+     */
+    setFV<FT>(field: string, value: FT, check?: boolean): null | ValidationErrors;
+    FC(): FormGroup;
+    FC(field: string): FormControl;
+    FC(field: string[]): FormGroup;
+    save({ updateModel }?: {
+        updateModel?: boolean;
+    }): Observable<this>;
+    update(fields?: string[], { updateModel }?: {
+        updateModel?: boolean;
+    }): Observable<this>;
+}
+
+interface ModelListField {
+    name: string;
+    label: string;
+    enabled: boolean;
+    allowed: boolean;
+    field: any;
+    position: number;
+    priority: number;
+}
+declare class ModelListFields<T extends DataModel> {
+    private readonly __fields;
+    constructor(collection: Collection<T>, params?: FieldsParams);
+    private _fields;
+    get fields(): Observable<ModelListField[]>;
+    private _enabled;
+    get enabled(): string[];
+    private _output;
+    get output(): Observable<string[]>;
+    /**
+     * Enable a field by name. Position is optional.
+     *
+     * @param fname : name of field to be enabled
+     * @param  position : position (optional)
+     * @returns current enabled fields
+     */
+    enable(fname: string, position?: number): string[];
+    /**
+     * Disable a field by name.
+     *
+     * @param fname : name of field to be disabled
+     * @returns  current enabled fields
+     */
+    disable(fname: string): string[];
+    /**
+     * Move field `fname` before or after (depending on `position`) field `dest`.
+     *
+     * @param fname field to move
+     * @param position ("before" or "after")
+     * @param dest reference field
+     * @returns current enabled fields
+     */
+    move(fname: string, position: 'before' | 'after', dest?: string): string[];
+    /**
+     * Check if field with name `fname` is enabled.
+     *
+     * @param fname : name of field
+     * @returns  enabled (true) or disabled (false)
+     */
+    isEnabled(fname: string): boolean;
+    /**
+     * Get field by name
+     * @param fname : name of field
+     * @returns Model list field or null if not found
+     */
+    get(fname: string): ModelListField | null;
+    /**
+     * Get field by position
+     * @param pos : position of field
+     * @returns Model list field or null if not found
+     */
+    getAtPos(pos: number): ModelListField | null;
+    setPosition(fname: any, position: number): string[];
+    private _update;
+}
+
+declare class ModelListPaginator {
+    private _page_size;
+    private _page;
+    constructor(defaults?: IQueryNav);
+    private _output;
+    get output(): Observable<IQueryNav>;
+    setPage(page: number): void;
+    updatePage(page: number): void;
+    setPageSize(size: number): void;
+    updatePageSize(size: number): void;
+    getPageSize(): number;
+    getPage(): number;
+    private _updateOutput;
+}
+
+type SortDirection = 'asc' | 'desc';
+interface FieldSortData {
+    field: string;
+    direction: SortDirection;
+}
+type SorterData = FieldSortData[];
+declare class ModelListSorter {
+    private readonly _values;
+    /**
+     * Create ModelListSorter instance, using defaults.
+     * @param defaults defaults sort values, as a list of strings (+field, -field, field)
+     */
+    constructor(defaults?: SorterDefaults);
+    private _output;
+    /**
+     * Returns a list of "+/-field" sort strings observable.
+     * @returns sort strings observable
+     */
+    get output(): Observable<string[]>;
+    /**
+     * Set sorting for `name` key, in direction `direction`.
+     * If sorting is already set for `name` key, updates direction without changing order.
+     * If sorting isn't set for `name` key, adds it at the end of sorting directions.
+     *
+     * @param name field name
+     * @param direction sort direction
+     * @returns model list sorter
+     */
+    set(name: string, direction: SortDirection): ModelListSorter;
+    /**
+     * Removes `name` sorting key from current keys.
+     *
+     * @param  name sort key to be removed
+     * @returns model list sorter
+     */
+    unset(name: string): ModelListSorter;
+    /**
+     * Get sorting status for `field` argument.
+     * If `field` is not found, returns null.
+     *
+     * @param  field field name
+     * @returns ordering direction / null
+     */
+    get(field: string): FieldSortData | null;
+    /**
+     * Return all sorter data values.
+     *
+     * @returns all sorter data values.
+     */
+    getAll(): SorterData;
+    /**
+     * Get the ordering position for `field` argument. If not found, returns -1.
+     *
+     * @param  field field name
+     * @returns ordering position for field
+     */
+    getOrder(field: string): number;
+    private _updateOutput;
+}
+
+type FILTER_TYPE = 'autocomplete' | 'autocompletemulti' | 'datetime' | 'date' | 'datetimerange' | 'flags' | 'geodistance' | 'number' | 'select' | 'selectmulti' | 'text' | 'tree';
+
+declare class ModelListFilterGroup {
+    name: string;
+    label: string;
+    desc: string;
+    position: number;
+    allowed: boolean;
+    enabled: boolean;
+    filters: ModelListFilter[];
+    constructor(params: Partial<ModelListFilterGroup>);
+}
+
+interface ModelListFilterParams {
+    name: string;
+    field: string;
+    label?: string;
+    help?: string;
+    value?: any;
+    desc?: any;
+    default?: any;
+    displayClasses?: string[] | string;
+    group?: ModelListFilterGroup;
+}
+declare class ModelListFilter implements ModelListFilterParams {
+    name: string;
+    field: string;
+    label: string;
+    help: string;
+    desc?: any;
+    default?: any;
+    type: FILTER_TYPE;
+    allowed: boolean;
+    enabled: boolean;
+    displayClasses?: string[] | string;
+    pristine: boolean;
+    multi: boolean;
+    group?: ModelListFilterGroup;
+    /** Single current value */
+    protected _value: IDispEditChoice | null;
+    /** Multiple current value */
+    protected _mvalue: Map<string, string>;
+    /** Single current value observable */
+    protected _current: ReplaySubject<IDispEditChoice | null>;
+    /** Multiple current value observable */
+    protected _mcurrent: ReplaySubject<IDispEditChoice[]>;
+    constructor(params: ModelListFilterParams);
+    get mcurrent$(): Observable<IDispEditChoice[]>;
+    get current$(): Observable<IDispEditChoice | null>;
+    get valueChanges(): Observable<IDispEditChoice | IDispEditChoice[] | null>;
+    get summary(): string;
+    updateFilter(filter: FilterData): void;
+    clear(notify?: boolean): void;
+    set(value: any, desc: string, notify?: boolean): boolean;
+    unset(value: any, desc: string, notify?: boolean): boolean;
+    toggle(value: any, desc: string, notify?: boolean): boolean;
+    getValue(): string | number;
+    get(): IDispEditChoice | null;
+    private mtoggle;
+    private mset;
+    private munset;
+    private stoggle;
+    private sset;
+    private sunset;
+    private getMultiValue;
+    private notify;
+}
+
+declare class ModelListFilters {
+    private _enabled$;
+    private _filters;
+    private _output$;
+    private _available$;
+    private _groups$;
+    constructor(params?: FiltersParams);
+    private _groups;
+    get groups(): Observable<ModelListFilterGroup[]>;
+    private _enabled;
+    get enabled(): Observable<ModelListFilter[]>;
+    private _available;
+    get available(): Observable<ModelListFilter[]>;
+    get output(): Observable<FilterData>;
+    update(): void;
+}
+
+interface IFieldHeaderMessage {
+    dest: 'header';
+    show?: boolean;
+    menu?: 'hide' | 'side' | 'click' | 'default';
+    sort?: 'hide' | 'side' | 'click' | 'default';
+}
+
+interface IJwtResponseJson {
+    access: string;
+    refresh: string;
+}
+interface IJwtRefreshResponseJson {
+    access: string;
+}
+interface IJwtBaseData {
+    token_type: 'access' | 'refresh';
+    user_id: number;
+}
+declare class Jwt<UserJwtData extends IJwtBaseData> {
+    readonly access?: string;
+    readonly refresh?: string;
+    private readonly _data;
+    constructor(response?: IJwtResponseJson);
+    get data(): UserJwtData | null;
+    toJson(): {
+        access: string | undefined;
+        refresh: string | undefined;
+    };
+}
+
+declare const enum TYPE {
+    SUCCESS = 0,
+    INFO = 1,
+    WARNING = 2,
+    DANGER = 3
+}
+declare enum DEFAULT_TIMEOUTS {
+    SUCCESS = 3000,
+    INFO = 4000,
+    WARNING = 10000,
+    DANGER = 30000
+}
+declare enum STATUS {
+    UNDISP = 0,
+    DISP = 1,
+    ACK = 2
+}
+interface ISoundTypes {
+    [index: string]: string;
+}
+declare const DATA_MESSAGE_SOUNDS: InjectionToken<ISoundTypes>;
+declare class Message {
+    title: string;
+    type: TYPE;
+    message: string;
+    trace: any;
+    ttl: number;
+    status: string;
+    showTrace: boolean;
+    constructor(title: string, type?: TYPE, message?: string, trace?: any, ttl?: number);
+    get style(): string;
+    ack(): void;
+}
+declare class DataMessageService {
+    ngZone: NgZone;
+    sounds: ISoundTypes;
+    _messages$: ReplaySubject<Message[]>;
+    private _messages;
+    private _timer;
+    private _subscription;
+    constructor(ngZone: NgZone, sounds: ISoundTypes);
+    get current(): Observable<Message[]>;
+    init(): void;
+    close(): void;
+    success(title: string, message?: string, trace?: any, timeout?: number): void;
+    info(title: string, message?: string, trace?: any, timeout?: number): void;
+    warning(title: string, message?: string, trace?: any, timeout?: number): void;
+    danger(title: string, message?: string, trace?: any, timeout?: number): void;
+    error(title: string, message?: string, trace?: any): void;
+    debug(title: string, message?: string, trace?: any): void;
+    ack(message: Message): void;
+    play(type?: string): void;
+    private _notify;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataMessageService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataMessageService>;
+}
+
+interface AuthParams {
+    tokenUrl: string;
+    tokenRefreshUrl: string;
+    requestReactivateUrl?: string;
+    processReactivateUrl?: string;
+    requestPwResetUrl?: string;
+    processPwResetUrl?: string;
+    loginField: string;
+    passwordField: string;
+    tokenField: string;
+    loginRoute: string[];
+    logoutRoute: string[];
+    pwresetRoute?: string[];
+    reactivateRoute?: string[];
+    userFetchFields?: string[];
+    userFetchValiditySeconds?: number;
+}
+/**
+ * DATA_API_URL: stores data api base url
+ */
+declare const DATA_AUTH_PARAMS: InjectionToken<AuthParams>;
+declare const DATA_AUTH_USER_SERVICE: InjectionToken<Collection<any>>;
+declare class AuthServiceBase<User extends DataModel, UserService extends Collection<User>, UserData extends IJwtBaseData> {
+    userService: UserService;
+    private _params;
+    private _router;
+    private _http;
+    private _msgs;
+    logout$: Subject<void>;
+    private _user;
+    private _user$;
+    private _token;
+    private _fetched?;
+    constructor(userService: UserService, _params: AuthParams, _router: Router, _http: HttpClient, _msgs: DataMessageService);
+    get isAnonymous(): boolean;
+    get accessToken(): string | null;
+    get refreshToken(): string | null;
+    get currentUser(): User | null;
+    get currentUser$(): Observable<User | null>;
+    get refreshUrl(): string;
+    get loginUrl(): string;
+    get loginRoute(): string[];
+    get logoutRoute(): string[];
+    get pwresetRoute(): string[] | undefined;
+    get reactivateRoute(): string[] | undefined;
+    logout(): void;
+    autoLogin(): void;
+    login(username: string, password: string): Observable<'success' | 'error' | 'invalid_token' | string>;
+    requestReactivate(username: string): Observable<boolean>;
+    requestPwReset(username: string): Observable<boolean>;
+    processReactivate(username: string, token: string): Observable<boolean>;
+    processPwReset(username: string, password: string, token: string): Observable<boolean>;
+    saveAuth(): void;
+    refresh(): Observable<IJwtRefreshResponseJson | null>;
+    private _fetchUser;
+}
+
+interface CustomField {
+    name: string;
+    label: string;
+    priority?: number;
+}
+interface FilterDefaults {
+    [index: string]: string | number | undefined;
+}
+type SorterDefaults = string[];
+/**
+ * Fields parameters.
+ */
+interface FieldsParams {
+    /** Allowed fields, all model fields are allowed if empty */
+    allowed?: string[];
+    /** Default enabled fields */
+    defaults?: string[];
+    /** Excluded fields */
+    excluded?: string[];
+    /** Custom fields */
+    custom?: CustomField[];
+}
+/**
+ * Filters parameters.
+ */
+interface FiltersParams {
+    /** Allowed filter names */
+    allowed?: string[];
+    /** Default active filter names */
+    defaults?: string[];
+    /** Excluded filter names */
+    excluded?: string[];
+    /** Filters definitions */
+    filters?: (ModelListFilter | ModelListFilterGroup)[];
+}
+type PaginationParams = IQueryMetaNavParams;
+type IModelListMessage = IFieldHeaderMessage;
+interface ModelListParams {
+    fields?: FieldsParams;
+    filters?: FiltersParams;
+    filter?: FilterDefaults | Observable<FilterDefaults>;
+    sorter?: SorterDefaults;
+    paginator?: IQueryNav;
+    keep?: boolean;
+    reload?: Subject<void | boolean>;
+    unsubscribe?: Subject<void>;
+}
+declare class ModelList<T extends DataModel> {
+    name: string;
+    filters: ModelListFilters;
+    sorter: ModelListSorter;
+    paginator: ModelListPaginator;
+    queryset: Queryset<T>;
+    fields: ModelListFields<T>;
+    reload: Subject<void | boolean>;
+    unsubscribe: Subject<void>;
+    messages$: ReplaySubject<IFieldHeaderMessage>;
+    started: boolean;
+    constructor(name: string, collection: Collection<T>);
+    private _collection;
+    get collection(): Collection<T>;
+    private _count;
+    /**
+     * Get current results count (from last meta received).
+     */
+    get count(): number | null;
+    private _results?;
+    get results(): Observable<T[]>;
+    private _meta?;
+    get meta(): Observable<IQueryMeta>;
+    private _loading?;
+    get loading(): Observable<boolean>;
+    private _full?;
+    get full(): Observable<[T[], boolean, IQueryMeta]>;
+    start(params: ModelListParams): void;
+}
+declare class ModelListService {
+    private _auth;
+    private _instances;
+    constructor(_auth: AuthServiceBase<any, any, any>);
+    reset(): void;
+    get<T extends DataModel>(name: string, collection: Collection<T>, defaults: ModelListParams): ModelList<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModelListService>;
+}
+
+declare class ModelListFieldsSelectorComponent<T extends DataModel> implements OnInit {
+    private _ofc;
+    list: ModelList<T>;
+    ofctpl: ElementRef<HTMLDivElement>;
+    seeMore: boolean;
+    constructor(_ofc: NgbOffcanvas);
+    ngOnInit(): void;
+    open(): void;
+    drop($event: CdkDragDrop<T, any>): void;
+    toggle(f: ModelListField): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListFieldsSelectorComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListFieldsSelectorComponent<any>, "data-model-list-fields-selector", never, { "list": { "alias": "list"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ModelListFieldHeaderComponent<T extends DataModel> implements OnInit {
+    list: ModelList<T>;
+    field: string;
+    sort?: boolean;
+    sortField?: string;
+    menuMode: 'hide' | 'side' | 'click';
+    sortMode: 'hide' | 'side' | 'click';
+    display?: boolean;
+    mnu?: NgbDropdown;
+    dispMenuMode: "hide" | "side" | "click";
+    dispSortMode: "hide" | "side" | "click";
+    private destroy$;
+    constructor();
+    ngOnInit(): void;
+    disable(): void;
+    enable(f: ModelListField): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListFieldHeaderComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListFieldHeaderComponent<any>, "data-model-list-field-header", never, { "list": { "alias": "list"; "required": false; }; "field": { "alias": "field"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "sortField": { "alias": "sortField"; "required": false; }; "menuMode": { "alias": "menuMode"; "required": false; }; "sortMode": { "alias": "sortMode"; "required": false; }; "display": { "alias": "display"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ModelListSorterComponent {
+    /**
+     * ModelList reference.
+     */
+    list: ModelList<any>;
+    /**
+     * Sort field name.
+     */
+    field: string;
+    constructor();
+    isUp(): boolean;
+    isDown(): boolean;
+    setUp(): void;
+    setDown(): void;
+    getCount(): number;
+    getOrder(): number;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListSorterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListSorterComponent, "data-model-list-sorter", never, { "list": { "alias": "list"; "required": false; }; "field": { "alias": "field"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ModelListFiltersSelectComponent implements OnInit {
+    list: ModelList<any>;
+    containerClasses: string[] | string;
+    itemActiveClasses: string[] | string;
+    itemInactiveClasses: string[] | string;
+    mode: 'select' | 'badge' | 'badge_summary';
+    selectForm: FormControl<ModelListFilter | null>;
+    private destroy$;
+    constructor();
+    toggle(f: ModelListFilter): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListFiltersSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListFiltersSelectComponent, "data-model-list-filters-select", never, { "list": { "alias": "list"; "required": false; }; "containerClasses": { "alias": "containerClasses"; "required": false; }; "itemActiveClasses": { "alias": "itemActiveClasses"; "required": false; }; "itemInactiveClasses": { "alias": "itemInactiveClasses"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ModelListFiltersComponent {
+    list: ModelList<any>;
+    containerClasses: string[] | string;
+    itemClasses: string[] | string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListFiltersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListFiltersComponent, "data-model-list-filters", never, { "list": { "alias": "list"; "required": false; }; "containerClasses": { "alias": "containerClasses"; "required": false; }; "itemClasses": { "alias": "itemClasses"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TplFun<T extends DataModel> = (data: T) => string;
+declare class FkselectComponent<T extends DataModel, R extends DataModel> implements OnInit {
+    model?: T;
+    field?: string;
+    edit: boolean;
+    value?: R;
+    queryset?: Queryset<R>;
+    collection?: Collection<R>;
+    update: boolean;
+    filter: FilterData;
+    mode: 'autocomplete' | 'select' | 'auto';
+    display?: string | TplFun<R>;
+    search: string;
+    label: string;
+    placeholder: string;
+    inputClasses: string[] | string;
+    selected: EventEmitter<T>;
+    cancelled: EventEmitter<void>;
+    cleared: EventEmitter<void>;
+    fc: UntypedFormControl;
+    searchFn: (text$: Observable<string>) => Observable<any>;
+    displayFn: (x: any) => any;
+    private _tpl;
+    private destroy$;
+    constructor();
+    ngOnInit(): void;
+    clearAction(): void;
+    /**
+     * Display function. Uses descfield or desc tpl (lodash template using model fields).
+     */
+    private _display;
+    private _search;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FkselectComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FkselectComponent<any, any>, "data-fkselect", never, { "model": { "alias": "model"; "required": false; }; "field": { "alias": "field"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "value": { "alias": "value"; "required": false; }; "queryset": { "alias": "queryset"; "required": false; }; "collection": { "alias": "collection"; "required": false; }; "update": { "alias": "update"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "display": { "alias": "display"; "required": false; }; "search": { "alias": "search"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "inputClasses": { "alias": "inputClasses"; "required": false; }; }, { "selected": "selected"; "cancelled": "cancelled"; "cleared": "cleared"; }, never, never, true, never>;
+}
+
+interface ModelListAutocompleteParams<T extends DataModel> extends ModelListFilterParams {
+    collection?: Collection<T>;
+    queryset?: Queryset<T>;
+    searchparam?: string;
+    display?: string | TplFun<T>;
+    filter?: FilterData;
+    scroll?: boolean;
+}
+declare class ModelListAutocompleteFilter<T extends DataModel> extends ModelListFilter implements ModelListAutocompleteParams<T> {
+    display?: string | TplFun<T>;
+    searchparam: string;
+    queryset: Queryset<T>;
+    collection?: Collection<T>;
+    filter: FilterData;
+    scroll: boolean;
+    constructor(params: ModelListAutocompleteParams<T>);
+}
+
+interface ModelListAutocompleteMultiParams<T extends DataModel> extends ModelListAutocompleteParams<T> {
+}
+declare class ModelListAutocompleteMultiFilter<T extends DataModel> extends ModelListAutocompleteFilter<T> {
+    multi: boolean;
+    constructor(params: ModelListAutocompleteMultiParams<T>);
+}
+
+declare class ModelListDatetimeFilter extends ModelListFilter {
+    constructor(params: ModelListFilterParams);
+}
+
+declare class ModelListDateFilter extends ModelListFilter {
+    constructor(params: ModelListFilterParams);
+}
+
+declare class ModelListDatetimerangeFilter extends ModelListFilter {
+    constructor(params: ModelListFilterParams);
+}
+
+interface ModelListFlagsFilterParams<T extends DataModel> extends ModelListFilterParams {
+    collection?: Collection<T>;
+    action?: string;
+}
+type GetFlagsResult = {
+    flag: string;
+    count: number;
+}[];
+declare class ModelListFlagsFilter<T extends DataModel> extends ModelListFilter {
+    collection: Collection<T>;
+    action: string;
+    multi: boolean;
+    constructor(params: ModelListFlagsFilterParams<T>);
+}
+
+interface GeoSearchResult {
+    score: number;
+    label: string;
+    lat: number;
+    lng: number;
+}
+interface ModelListGeodistanceFilterParams extends ModelListFilterParams {
+    geolocator: (pos: string) => Observable<GeoSearchResult[]>;
+    geomap?: (pos: [number, number], dist: number) => string;
+    scroll?: boolean;
+}
+declare class ModelListGeodistanceFilter extends ModelListFilter implements ModelListGeodistanceFilterParams {
+    geolocator: (pos: string) => Observable<GeoSearchResult[]>;
+    scroll: boolean;
+    constructor(params: ModelListGeodistanceFilterParams);
+}
+
+interface OperationDescriptor {
+    name: string;
+    label: string;
+    operator: string;
+}
+declare const ModelListNumberOperations: OperationDescriptor[];
+interface ModelListNumberFilterParams extends ModelListFilterParams {
+    operations?: string[];
+}
+declare class ModelListNumberFilter extends ModelListFilter {
+    operator: OperationDescriptor;
+    operations: OperationDescriptor[];
+    constructor(params: ModelListNumberFilterParams);
+    setOperator(op: string): void;
+    updateFilter(filter: FilterData): void;
+}
+
+interface ModelListSelectFilterParams<T extends DataModel> extends ModelListFilterParams {
+    choices?: IDispEditChoice[] | Observable<IDispEditChoice[]>;
+    model?: DataModelType<T>;
+    mfield?: string;
+}
+declare class ModelListSelectFilter<T extends DataModel> extends ModelListFilter implements ModelListSelectFilterParams<T> {
+    choices: Observable<IDispEditChoice[]>;
+    model?: DataModelType<T>;
+    mfield?: string;
+    constructor(params: ModelListSelectFilterParams<T>);
+    setDefault(): void;
+}
+
+interface ModelListMultiSelectFilterParams<T extends DataModel> extends ModelListSelectFilterParams<T> {
+    default?: IDispEditChoice[];
+}
+declare class ModelListSelectMultiFilter<T extends DataModel> extends ModelListSelectFilter<T> {
+    multi: boolean;
+    default?: IDispEditChoice[];
+    constructor(params: ModelListMultiSelectFilterParams<T>);
+}
+
+declare class ModelListTextFilter extends ModelListFilter {
+    constructor(params: ModelListFilterParams);
+}
+
+interface ModelListTreeParams<T extends DataModel> extends ModelListAutocompleteParams<T> {
+    maxLevel?: number;
+}
+declare class ModelListTreeFilter<T extends DataModel> extends ModelListAutocompleteFilter<T> implements ModelListTreeParams<T> {
+    maxLevel: number;
+    constructor(params: ModelListTreeParams<T>);
+}
+
+interface BanResults {
+    type: 'FeatureCollection';
+    version: string;
+    features: {
+        type: 'Feature';
+        geometry: {
+            type: 'Point';
+            coordinates: [number, number];
+        };
+        properties: {
+            label: string;
+            score: number;
+            id: string;
+            type: string;
+            name: string;
+            postcode: string;
+            citycode: string;
+            x: number;
+            y: number;
+            population: number;
+            city: string;
+            context: string;
+            importance: number;
+        };
+    }[];
+}
+declare class BanAdapter {
+    private _http;
+    private _baseUrl;
+    constructor(_http: HttpClient, _baseUrl: string);
+    search(text: string): Observable<GeoSearchResult[]>;
+}
+
+declare class ModelListPaginatorComponent<T extends DataModel> implements OnChanges {
+    list: ModelList<T>;
+    maxPages: number;
+    hide: boolean;
+    perPageControl: FormControl;
+    showDirectAccess: boolean;
+    directAccess: FormControl;
+    curPage: number;
+    curCount: number;
+    pageSize: number;
+    private destroy$;
+    onPageChange(page: number): void;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListPaginatorComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListPaginatorComponent<any>, "data-model-list-paginator", never, { "list": { "alias": "list"; "required": false; }; "maxPages": { "alias": "maxPages"; "required": false; }; "hide": { "alias": "hide"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ChoicePipe<T extends DataModel> implements PipeTransform {
+    transform(value: T, field: string, mode?: 'code' | 'desc' | 'both'): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChoicePipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ChoicePipe<any>, "choice", true>;
+}
+declare class PChoicePipe<T extends DataModel> implements PipeTransform {
+    transform(value: any, model: T, field: string, mode?: 'code' | 'desc' | 'both'): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PChoicePipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PChoicePipe<any>, "pchoice", true>;
+}
+
+declare function isValue(value: number | string | null | undefined): value is number | string;
+declare function strToNumber(value: number | string): number;
+declare class FactorPipe<T extends DataModel> implements PipeTransform {
+    private _locale;
+    constructor(_locale: string);
+    transform(value: T | null, field: string, digitsInfo?: string, locale?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FactorPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FactorPipe<any>, "factor", true>;
+}
+declare class PFactorPipe<T extends DataModel> implements PipeTransform {
+    private _locale;
+    constructor(_locale: string);
+    transform(value: number | string | null | undefined, model: T | null, field: string, digitsInfo?: string, locale?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PFactorPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PFactorPipe<any>, "pfactor", true>;
+}
+
+declare class FactorcPipe<T extends DataModel> implements PipeTransform {
+    private _locale;
+    private _defaultCurrencyCode;
+    constructor(_locale: string, _defaultCurrencyCode?: string);
+    transform(value: T | null, field: string, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string, digitsInfo?: string, locale?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FactorcPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FactorcPipe<any>, "factorc", true>;
+}
+declare class PFactorcPipe<T extends DataModel> implements PipeTransform {
+    private _locale;
+    private _defaultCurrencyCode;
+    constructor(_locale: string, _defaultCurrencyCode?: string);
+    transform(value: number | string | undefined | null, model: T | null, field: string, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string, digitsInfo?: string, locale?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PFactorcPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PFactorcPipe<any>, "pfactorc", true>;
+}
+
+declare class DispeditComponent<FT, T extends DataModel, R extends DataModel> implements OnInit, OnChanges {
+    dconf: DataDisplayConfig;
+    private _msgs;
+    /** Model (mandatory) */
+    model: T;
+    /** Field (mandatory) */
+    field: string;
+    /** External form */
+    form?: UntypedFormGroup;
+    /**
+     * Starting edit mode
+     * If mode is inline, edit is always true.
+     */
+    edit: boolean;
+    /**
+     * Can be switched to edit mode?
+     * default : true
+     */
+    editable: boolean;
+    /**
+     * Save updated values ?
+     * If not given, default value depends on mode :
+     * - save if mode is dd
+     * - don't save if mode is inline
+     */
+    save?: boolean;
+    /**
+     * Display mode
+     * - dd provides display / edit within a dt/dd block
+     * - inline (to be renamed to form) provides a (label? and) form control
+     * */
+    mode: 'dd' | 'inline' | 'form';
+    /**
+     * Custom choices
+     * If provided, a select form control will be used instead of base editor
+     */
+    choices: IDispEditChoice[];
+    /** Custom input classes */
+    inputClasses: string[] | string;
+    /** Override editor, if provided */
+    editor?: DISPEDIT_EDITOR_TYPES;
+    /** Override viewer, if provided */
+    viewer?: DISPEDIT_DISPLAY_TYPES;
+    /** Override default value */
+    default?: any;
+    /**
+     * Override placeholder, if provided.
+     * By default, manager.description is used
+     */
+    placeholder: string;
+    /**
+     * Override help, if provided.
+     * By default, manager.help is used.
+     */
+    help: string;
+    /**
+     *  Hide label (for inline forms)
+     */
+    hideLabel: boolean;
+    /** Fk queryset */
+    queryset?: Queryset<R>;
+    /** Fk collection */
+    collection?: Collection<R>;
+    /** Fk display */
+    display?: string | TplFun<R>;
+    /** Fk filter */
+    filter: FilterData;
+    /** Output emitter, output model on every change */
+    changed: EventEmitter<T>;
+    /** Field manager */
+    manager?: BaseFieldManager<FT>;
+    /** Text value used for display */
+    txtValue?: string;
+    /** Text values used for many displays */
+    txtValues?: string[];
+    /** Computed editor type */
+    realEditor: DISPEDIT_EDITOR_TYPES;
+    /** Computed display type */
+    realDisplay: DISPEDIT_DISPLAY_TYPES;
+    /** Current disp raw value */
+    dispValue?: any;
+    /** Computed chocies type */
+    realChoices?: IDispEditChoice[];
+    /** Computed help */
+    realHelp: string;
+    /** Computed placeholder */
+    realPlaceholder: string;
+    /** Computed required */
+    required: boolean;
+    /** Computed default value */
+    realDefault: any;
+    m2mValues?: any[];
+    fg?: UntypedFormGroup;
+    private _tpl;
+    /**
+     * Constructor, can be given DATA_DISPLAY_CONFIG injection token to override display classes.
+     * By default, bs5 config is used
+     * @param dconf DataDisplayConfig item
+     * @param _msgs messages service
+     */
+    constructor(dconf: DataDisplayConfig, _msgs: DataMessageService);
+    /**
+     * Init sequence.
+     * - Sets mode
+     * - Sets display function
+     * - Loads manager
+     * - Run misc checks on special values
+     * - Get help, placeholder strings
+     */
+    ngOnInit(): void;
+    /**
+     * Upgrade all values on any change.
+     * @param changes
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Set up display mode.
+     * - get choices if available
+     * - get display type
+     * - process current value for display
+     * - set display classes
+     */
+    enableDisplayMode(): void;
+    /**
+     * Set up edit mode :
+     * - get choices if available
+     * - get editor type
+     * - prepare form controle
+     * - set form control value
+     * - update form control classes
+     */
+    enableEditMode(): void;
+    /**
+     * Update model field from form control value (if value is valid).
+     * If save boolean is true, save values to API.
+     */
+    update(): Promise<void>;
+    unsetEdit(): void;
+    toggleEdit(): void;
+    /**
+     * Reset field to default value
+     * TODO: check if edit mode needs to be changed / saved
+     */
+    setDefault(): Promise<void>;
+    selectedRefItem($event: T | null): Promise<void>;
+    onM2MValuesChanges(v: any[]): void;
+    private _checks;
+    /**
+     * Save value to database, only if model have an id.
+     * If mode is dd, toggle edit / display mode.
+     * @private
+     */
+    private _save;
+    private _display;
+    /**
+     * Set display mode based on current display config
+     * @private
+     */
+    private _setMode;
+    private _setDisplayFn;
+    private _getChoices;
+    private _getRealDisplay;
+    private _getRealEditor;
+    private _setFormControl;
+    private _setFormControlValue;
+    private _setEditorClasses;
+    private _getDisplayValue;
+    private _setDisplayClasses;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DispeditComponent<any, any, any>, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DispeditComponent<any, any, any>, "data-dispedit", never, { "model": { "alias": "model"; "required": false; }; "field": { "alias": "field"; "required": false; }; "form": { "alias": "form"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "choices": { "alias": "choices"; "required": false; }; "inputClasses": { "alias": "inputClasses"; "required": false; }; "editor": { "alias": "editor"; "required": false; }; "viewer": { "alias": "viewer"; "required": false; }; "default": { "alias": "default"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "help": { "alias": "help"; "required": false; }; "hideLabel": { "alias": "hideLabel"; "required": false; }; "queryset": { "alias": "queryset"; "required": false; }; "collection": { "alias": "collection"; "required": false; }; "display": { "alias": "display"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; }, { "changed": "changed"; }, never, ["*"], true, never>;
+}
+
+declare class M2mselectComponent<T extends DataModel, R extends DataModel> implements OnInit, ControlValueAccessor {
+    model?: T;
+    field?: string;
+    edit: boolean;
+    values: R[];
+    pks: number[];
+    disabled: boolean;
+    queryset?: Queryset<R>;
+    collection?: Collection<R>;
+    filter: FilterData;
+    mode: 'autocomplete' | 'select' | 'auto';
+    display?: string | TplFun<R>;
+    search: string;
+    label: string;
+    placeholder: string;
+    emptyLabel: string;
+    inputClasses: string[] | string;
+    added: EventEmitter<R>;
+    removed: EventEmitter<R>;
+    cancelled: EventEmitter<void>;
+    cleared: EventEmitter<void>;
+    detailsChanged: EventEmitter<R[]>;
+    changed: EventEmitter<number[]>;
+    fc: UntypedFormControl;
+    searchFn: (text$: Observable<string>) => Observable<any>;
+    displayFn: (x: any) => any;
+    private touched;
+    private _tpl;
+    private destroy$;
+    /**
+     * Control value accessor onChange dummy callback;
+     * @param fks
+     */
+    onChange: (fks: number[]) => void;
+    /**
+     * Control value accessor onTouched dummy callback;
+     */
+    onTouched: () => void;
+    /**
+     * OnChange register from controlValueAccessor
+     * @param onChange callback
+     */
+    registerOnChange(onChange: any): void;
+    /**
+     * OnTouched register from controlValueAccessor
+     * @param onTouched callback
+     */
+    registerOnTouched(onTouched: any): void;
+    /**
+     * OnInit :
+     * - ensures queryset is available
+     * - creates form control for input
+     * - creates display function
+     * - ensure values are set from any source
+     */
+    ngOnInit(): void;
+    /**
+     * Remove a value.
+     * Emits detailsChanged, changed and removed signals.
+     * @param i instance to be removed
+     */
+    onRemove(i: R): void;
+    /**
+     * Add a value.
+     * Emits detailsChanged, changed and added signals.
+     * @param i instance to be added.
+     */
+    onAdd(i: R): void;
+    /**
+     * Clear all values.
+     * Emits detailsChanged, changed and cleared signals.
+     */
+    onClear(): void;
+    /**
+     * Write value from controlValueAccessor.
+     * @param pks
+     */
+    writeValue(pks: number[]): Promise<void>;
+    /**
+     * Mark as touched.
+     */
+    markAsTouched(): void;
+    /**
+     * Mark as disabled.
+     * @param disabled
+     */
+    setDisabledState(disabled: boolean): void;
+    /**
+     * Retrieve display values for current set of pks.
+     * Eventually fetches items from collection.
+     * Emits detailsChanged signal.
+     * @param pks list of current pks.
+     * @private
+     */
+    private _getDisplayValues;
+    /**
+     * Display function. Uses descfield or desc tpl (lodash template using model fields).
+     */
+    private _display;
+    /**
+     * Search function.
+     * @param text$
+     * @private
+     */
+    private _search;
+    static ɵfac: i0.ɵɵFactoryDeclaration<M2mselectComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<M2mselectComponent<any, any>, "data-m2mselect", never, { "model": { "alias": "model"; "required": false; }; "field": { "alias": "field"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "values": { "alias": "values"; "required": false; }; "queryset": { "alias": "queryset"; "required": false; }; "collection": { "alias": "collection"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "display": { "alias": "display"; "required": false; }; "search": { "alias": "search"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; }; "inputClasses": { "alias": "inputClasses"; "required": false; }; }, { "added": "added"; "removed": "removed"; "cancelled": "cancelled"; "cleared": "cleared"; "detailsChanged": "detailsChanged"; "changed": "changed"; }, never, never, true, never>;
+}
+
+interface IFlagItem {
+    flag: string;
+    count: number;
+}
+declare class FlagsComponent<T extends DataModel> implements OnInit {
+    private _msg;
+    model: T;
+    field: string;
+    get_flags_endpoint: string;
+    edit: boolean;
+    editable: boolean;
+    flags: Observable<IFlagItem[]>;
+    free: boolean;
+    create: boolean;
+    action: boolean;
+    ft: FormControl;
+    fs: FormControl;
+    curflags: string[];
+    txtflag: string;
+    selflag: string;
+    flaglist: IFlagItem[];
+    private destroy$;
+    constructor(_msg: DataMessageService);
+    ngOnInit(): Promise<any>;
+    addFreeFlag(): Promise<any>;
+    addFlag(flag: string): Promise<any>;
+    update(): Promise<any>;
+    flagPresent(flag: string): boolean;
+    removeFlag(flag: string): Promise<any>;
+    toggleEdit(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlagsComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FlagsComponent<any>, "data-flags", never, { "model": { "alias": "model"; "required": false; }; "field": { "alias": "field"; "required": false; }; "get_flags_endpoint": { "alias": "get_flags_endpoint"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "flags": { "alias": "flags"; "required": false; }; "free": { "alias": "free"; "required": false; }; "create": { "alias": "create"; "required": false; }; "action": { "alias": "action"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const RichEditToolbars: {
+    [index: string]: Toolbar;
+};
+declare class RicheditComponent<FT, T extends DataModel> implements OnInit, OnDestroy {
+    model?: T;
+    field?: string;
+    editable: boolean;
+    edit: boolean;
+    mode: 'dd' | 'inline' | 'form';
+    /** Hide label (for inline forms) */
+    hideLabel: boolean;
+    /** Hide button (for changed usage) */
+    hideButton: boolean;
+    /** Form control, from outside or created */
+    fc: FormControl<string | null>;
+    /** Toolbar mode */
+    toolbar: 'none' | 'default' | 'light' | Toolbar;
+    changed: EventEmitter<string | null>;
+    /** Field manager */
+    manager?: BaseFieldManager<FT>;
+    /** Computed required */
+    required: boolean;
+    editor: Editor;
+    html: string;
+    realToolbar: Toolbar;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    toggleEdit(): void;
+    save(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RicheditComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RicheditComponent<any, any>, "data-richedit", never, { "model": { "alias": "model"; "required": false; }; "field": { "alias": "field"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "hideLabel": { "alias": "hideLabel"; "required": false; }; "hideButton": { "alias": "hideButton"; "required": false; }; "fc": { "alias": "fc"; "required": false; }; "toolbar": { "alias": "toolbar"; "required": false; }; }, { "changed": "changed"; }, never, ["*"], true, never>;
+}
+
+interface FakeDeleteResult {
+    count: number;
+    details: [string, number][];
+}
+declare class SafeDeleteComponent<T extends DataModel> {
+    private _ofc;
+    private _msgs;
+    /** Model instance to be deleted */
+    model: T;
+    /** Service to be used for deletion, taken from model if not provided */
+    service?: Collection<T>;
+    /** Function to be called for deletion, overrides service deletion */
+    actionFn?: (model: T) => Promise<{
+        success: boolean;
+    }>;
+    /** Translations of database objects names to human names */
+    checks: {
+        [index: string]: string;
+    };
+    /** Messages to be displayed on success or error, default messages are used if not provided */
+    messages: {
+        success?: string;
+        error?: string;
+    };
+    /** Event emitted on successful deletion */
+    deleted: EventEmitter<FakeDeleteResult>;
+    /** Display mode, default is button.
+     *
+     * - `fbutton`: floating button (small)
+     * - `button`: button (small), with text taken from ng-content (no space around icon to allow empty buttons)
+     * - `icon`: icon
+     * - `custom`: custom : ng-content is surrounded by a clickable div
+     * */
+    display: 'fbutton' | 'button' | 'icon' | 'custom';
+    result?: FakeDeleteResult;
+    private _dialogRef?;
+    private ofc?;
+    constructor(_ofc: NgbOffcanvas, _msgs: DataMessageService);
+    checkDelete(model: DataModel): Promise<void>;
+    reallyDelete(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeDeleteComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SafeDeleteComponent<any>, "data-safe-delete", never, { "model": { "alias": "model"; "required": false; }; "service": { "alias": "service"; "required": false; }; "actionFn": { "alias": "actionFn"; "required": false; }; "checks": { "alias": "checks"; "required": false; }; "messages": { "alias": "messages"; "required": false; }; "display": { "alias": "display"; "required": false; }; }, { "deleted": "deleted"; }, never, ["*"], true, never>;
+}
+
+interface ICharFieldDescChoice {
+    value: string;
+    desc: string;
+}
+type ICharFieldChoice = ICharFieldDescChoice | string;
+interface ICharFieldMetadata extends IFieldMetadata<string> {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp | string;
+    choices?: ICharFieldChoice[];
+}
+interface IEmailFieldMetadata extends ICharFieldMetadata {
+    validate?: boolean;
+}
+interface IPasswordFieldMetadata extends ICharFieldMetadata {
+    validate?: boolean;
+}
+interface ITextFieldMetadata extends ICharFieldMetadata {
+    syntax?: string;
+}
+declare const charField: (updates?: ICharFieldMetadata) => FieldDecoratorFn;
+declare const emailField: (updates?: IEmailFieldMetadata) => FieldDecoratorFn;
+declare const textField: (updates?: ITextFieldMetadata) => FieldDecoratorFn;
+declare const passwordField: (updates?: IPasswordFieldMetadata) => FieldDecoratorFn;
+
+interface IPrimaryFieldMetadata extends IFieldMetadata<number> {
+    step?: number;
+}
+declare const primaryField: (updates?: IPrimaryFieldMetadata) => FieldDecoratorFn;
+
+interface IDateFieldMetadata extends IFieldMetadata<Date | null> {
+    autoNow?: boolean;
+    autoNowAdd?: boolean;
+    min?: Date;
+    max?: Date;
+}
+interface IDatetimeFieldMetadata extends IDateFieldMetadata {
+    timezone?: string | null;
+}
+declare const dateField: (updates?: IDateFieldMetadata) => FieldDecoratorFn;
+declare const datetimeField: (updates?: IDatetimeFieldMetadata) => FieldDecoratorFn;
+
+interface IForeignKeyFieldMetadata extends IFieldMetadata<number> {
+    related?: string;
+}
+interface IReverseForeignKeyFieldMetadata extends IFieldMetadata<number> {
+    related: string;
+}
+interface IDetailsFieldMetadata<T> extends IFieldMetadata<T> {
+    field?: string;
+    many?: boolean;
+    model?: T;
+    deserialize?: (data: any) => T;
+}
+interface IManyToManyFieldMetadata extends IFieldMetadata<number[]> {
+    related: string;
+}
+declare const foreignKeyField: (updates: IForeignKeyFieldMetadata) => FieldDecoratorFn;
+declare const reverseForeignKeyField: (updates: IReverseForeignKeyFieldMetadata) => FieldDecoratorFn;
+declare const detailsField: (meta?: IDetailsFieldMetadata<any>) => FieldDecoratorFn;
+declare const manyToManyField: (meta: IManyToManyFieldMetadata) => FieldDecoratorFn;
+
+type IBooleanFieldMetadata = IFieldMetadata<boolean | null>;
+declare const booleanField: (updates?: IBooleanFieldMetadata) => FieldDecoratorFn;
+
+interface IIntegerFieldMetadata extends IFieldMetadata<number> {
+    min?: number;
+    max?: number;
+}
+interface IFloatFieldMetadata extends IFieldMetadata<number> {
+    min?: number;
+    max?: number;
+}
+interface IDecimalFieldMetadata extends IFieldMetadata<number> {
+    min?: number;
+    max?: number;
+    factor?: number;
+}
+declare const integerField: (updates?: IIntegerFieldMetadata) => FieldDecoratorFn;
+declare const floatField: (updates?: IFloatFieldMetadata) => FieldDecoratorFn;
+declare const decimalField: (updates?: IDecimalFieldMetadata) => FieldDecoratorFn;
+
+interface IComputedFieldMetadata<T> extends IFieldMetadata<T> {
+    field?: string;
+    factor?: number;
+    choices?: ICharFieldChoice[];
+}
+declare const computedField: (meta?: IComputedFieldMetadata<any>) => FieldDecoratorFn;
+
+declare class MessageZoneComponent implements OnInit {
+    messages: DataMessageService;
+    filter?: string;
+    current: Message[];
+    private destroy$;
+    constructor(messages: DataMessageService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageZoneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageZoneComponent, "data-message-zone", never, { "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class QuerysetMock<T extends DataModel> {
+    protected _coll: CollectionMock<T>;
+    options: IQuerysetOptions;
+    mockData: T[];
+    filterData: FilterData;
+    sortData: SortData[];
+    pageSize: number;
+    page: number;
+    pristine: boolean;
+    loading: Observable<boolean>;
+    constructor(_coll: CollectionMock<T>, options?: IQuerysetOptions);
+    get results(): Observable<T[]>;
+    get meta(): Observable<IQueryMeta>;
+    get full(): Observable<[T[], boolean, IQueryMeta]>;
+    filter(params?: FilterData): QuerysetMock<T>;
+    sort(...sorting: string[]): QuerysetMock<T>;
+    paginateBy(pageSize?: number): QuerysetMock<T>;
+    setPage(page: number): QuerysetMock<T>;
+    getQueryParams(): FilterData;
+    get(): Observable<T[]>;
+}
+
+declare class CollectionMock<T extends DataModel> {
+    protected model: new (coll: Collection<T>) => T;
+    mockValue?: T;
+    mockValues?: T[];
+    actionValue: any;
+    constructor(model: new (coll: Collection<T>) => T);
+    fetch(id: number, suffix?: string): Observable<T>;
+    action(model: T | null, method: IHttpMethod, action: string, params: IActionParams): Observable<any>;
+    queryset(options?: IQuerysetOptions): QuerysetMock<T>;
+    list(query?: {
+        [index: string]: string;
+    }, suffix?: string): Observable<any>;
+    fromJson(data: any, many?: boolean): T | any;
+}
+
+interface UploaderOptions {
+    concurrency: number;
+    allowedContentTypes?: string[];
+    maxUploads?: number;
+    maxFileSize?: number;
+}
+interface BlobFile extends Blob {
+    name: string;
+}
+declare enum UploadStatus {
+    Queue = 0,
+    Uploading = 1,
+    Done = 2,
+    Cancelled = 3
+}
+interface UploadProgress {
+    status: UploadStatus;
+    data?: {
+        percentage: number;
+        speed: number;
+        speedHuman: string;
+        startTime: number | null;
+        endTime: number | null;
+        eta: number | null;
+        etaHuman: string | null;
+    };
+}
+interface UploadFile {
+    id: string;
+    fileIndex: number;
+    lastModifiedDate: Date;
+    name: string;
+    size: number;
+    type: string;
+    form: FormData;
+    progress: UploadProgress;
+    response?: any;
+    responseStatus?: number;
+    sub?: Subscription | any;
+    nativeFile?: File;
+    responseHeaders?: {
+        [key: string]: string;
+    };
+}
+interface UploadOutput {
+    type: "addedToQueue" | "allAddedToQueue" | "uploading" | "done" | "start" | "cancelled" | "dragOver" | "dragOut" | "drop" | "removed" | "removedAll" | "rejected";
+    file?: UploadFile;
+    nativeFile?: File;
+}
+interface UploadInput {
+    type: "uploadAll" | "uploadFile" | "cancel" | "cancelAll" | "remove" | "removeAll";
+    url?: string;
+    method?: string;
+    id?: string;
+    fieldName?: string;
+    fileIndex?: number;
+    file?: UploadFile;
+    data?: {
+        [key: string]: string | Blob;
+    };
+    headers?: {
+        [key: string]: string;
+    };
+    includeWebKitFormBoundary?: boolean;
+    withCredentials?: boolean;
+}
+
+declare function humanizeBytes(bytes: number): string;
+declare class DataUploaderService {
+    queue: UploadFile[];
+    serviceEvents: EventEmitter<UploadOutput>;
+    uploadScheduler: Subject<{
+        file: UploadFile;
+        event: UploadInput;
+    }>;
+    subs: {
+        id: string;
+        sub: Subscription;
+    }[];
+    contentTypes: string[];
+    maxUploads: number;
+    maxFileSize: number;
+    constructor(concurrency?: number, contentTypes?: string[], maxUploads?: number, maxFileSize?: number);
+    handleFiles(incomingFiles: FileList): void;
+    initInputEvents(input: EventEmitter<UploadInput>): Subscription;
+    startUpload(upload: {
+        file: UploadFile;
+        event: UploadInput;
+    }): Observable<UploadOutput>;
+    uploadFile(file: UploadFile, event: UploadInput): Observable<UploadOutput>;
+    secondsToHuman(sec: number): string;
+    generateId(): string;
+    setContentTypes(contentTypes: string[]): void;
+    allContentTypesAllowed(): boolean;
+    isContentTypeAllowed(mimetype: string): boolean;
+    isFileSizeAllowed(fileSize: number): boolean;
+    makeUploadFile(file: File, index: number): UploadFile;
+    private parseResponseHeaders;
+}
+
+declare class NgFileDropDirective implements OnInit, OnDestroy {
+    elementRef: ElementRef;
+    options: UploaderOptions;
+    uploadInput: EventEmitter<UploadInput>;
+    uploadOutput: EventEmitter<UploadOutput>;
+    upload: DataUploaderService;
+    el: HTMLInputElement;
+    private _sub;
+    constructor(elementRef: ElementRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    stopEvent: (e: Event) => void;
+    onDrop(e: any): void;
+    onDragOver(e: Event): void;
+    onDragLeave(e: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgFileDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgFileDropDirective, "[dataFileDrop]", never, { "options": { "alias": "options"; "required": false; }; "uploadInput": { "alias": "uploadInput"; "required": false; }; }, { "uploadOutput": "uploadOutput"; }, never, never, false, never>;
+}
+
+declare class NgFileSelectDirective implements OnInit, OnDestroy {
+    elementRef: ElementRef;
+    options: UploaderOptions;
+    uploadInput: EventEmitter<any>;
+    uploadOutput: EventEmitter<UploadOutput>;
+    upload: DataUploaderService;
+    el: HTMLInputElement;
+    private _sub;
+    constructor(elementRef: ElementRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    fileListener: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgFileSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgFileSelectDirective, "[dataFileSelect]", never, { "options": { "alias": "options"; "required": false; }; "uploadInput": { "alias": "uploadInput"; "required": false; }; }, { "uploadOutput": "uploadOutput"; }, never, never, false, never>;
+}
+
+declare class NgxUploaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxUploaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxUploaderModule, [typeof NgFileDropDirective, typeof NgFileSelectDirective], never, [typeof NgFileDropDirective, typeof NgFileSelectDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxUploaderModule>;
+}
+
+declare const DATA_AUTH_SERVICE: InjectionToken<AuthServiceBase<any, any, any>>;
+/**
+ * List of urls that should be intercepted by the auth interceptor, thus receiving the auth token
+ * Default : empty list
+ */
+declare const DATA_AUTH_URLS: InjectionToken<string[]>;
+declare class AuthInterceptor implements HttpInterceptor {
+    private _auth;
+    private _apiUrl;
+    private _urls;
+    private _isRefreshing;
+    private _refreshTokenSubject;
+    constructor(_auth: AuthServiceBase<any, any, any>, _apiUrl: string, _urls: string[] | null);
+    /**
+     * The auth token in added to the request if :
+     * - the request is not anonymous
+     * - the request is for the api url, but not for the refresh or login urls
+     * - the request is for one of the urls specified in the DATA_AUTH_URLS injection token
+     * @param req
+     * @param next
+     */
+    intercept(req: HttpRequest<any>, next: HttpHandler): rxjs.Observable<_angular_common_http.HttpEvent<any>>;
+    private _handle401Error;
+    private _addToken;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthInterceptor, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthInterceptor>;
+}
+
+/**
+ * Template function type.
+ * Used for page title or other data to string operations.
+ *
+ * @param data: object
+ * @param path: optional path (see: usage)
+ */
+type TplFn<T> = (data: T, path?: string) => string;
+/**
+ * Base route parameters interface.
+ */
+interface BaseRouteParams {
+    /** Skip route in breadcrumbs */
+    skip?: boolean;
+    /** Route title or title template */
+    title?: string | TplFn<any>;
+    /** Route icon string */
+    icon?: string;
+    /** Route config item */
+    route: RouteConfigItem;
+    /** This route is a tree route */
+    tree?: boolean;
+}
+/**
+ * Route function type.
+ * Takes parameters, return a route.
+ */
+type RouteFn = (...args: any[]) => (string | number)[];
+/**
+ * Route config item.
+ * Stores route named parameters, route function and route name.
+ */
+interface RouteConfigItem {
+    params: string[];
+    route: RouteFn;
+    name: string;
+}
+declare function RData<T extends BaseRouteParams>(value: T): T;
+type RoutesConfig<T extends string> = {
+    readonly [Property in T]: RouteConfigItem;
+};
+interface StrictRoutes extends Route {
+    data: BaseRouteParams;
+}
+type RoutesDefinition = StrictRoutes[];
+interface RouteArg<T> {
+    [index: string]: T;
+}
+declare class Link<T> {
+    private _cargs;
+    private _params;
+    private _route;
+    private _router?;
+    constructor(config: RouteConfigItem, context: any, router?: Router);
+    private _name;
+    get name(): string;
+    context(ctx: any): void;
+    route(params?: Required<RouteArg<T>>): (string | number)[];
+    navigate(params?: {
+        [index: string]: T;
+    }, router?: Router): Promise<boolean>;
+}
+
+interface IPathTreeItem {
+    path: string;
+    title: string;
+    icon: string;
+    current: boolean;
+}
+/**
+ * Use data from route config to create a breadcrumb for current route.
+ *
+ * Route config data is :
+ * - title : route fragment title or lodash template to build title
+ *   (provided arguments for template processing : route (current segment route snapshot)
+ *   and data (input argument)
+ * - icon: icon classes. Example fa fa-home for home & font awesome
+ */
+declare class BreadcrumbComponent implements OnChanges, OnInit {
+    router: Router;
+    route: ActivatedRoute;
+    /**
+     * Additional data to be used in titleTemplate
+     */
+    data: any;
+    /**
+     * Do we display icons ?
+     */
+    icons: boolean;
+    tree: IPathTreeItem[];
+    private destroy$;
+    constructor(router: Router, route: ActivatedRoute);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getRouteTree(current: RouterState): void;
+    getTitle(rdata: Partial<BaseRouteParams>, data: BaseRouteParams, u?: UrlSegment): string;
+    getIcon(rdata: Partial<BaseRouteParams>, data: BaseRouteParams): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "data-breadcrumb", never, { "data": { "alias": "data"; "required": false; }; "icons": { "alias": "icons"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface ITabStoredMem {
+    name: string;
+    value: string;
+}
+declare class NavDriver {
+    private _parent;
+    name: string;
+    defaults: string;
+    private save;
+    private lastActive;
+    constructor(_parent: TabMemoryService, name: string, defaults: string, save: boolean);
+    private _current;
+    get current(): string;
+    set current(value: string);
+    get value(): ITabStoredMem;
+}
+declare class TabMemoryService {
+    private _route;
+    private tabMem;
+    constructor(_route: ActivatedRoute);
+    private static targetToString;
+    memFor(target: (string | number | UrlSegment)[], defaults: string, save?: boolean, fragment?: string | null): NavDriver;
+    save(): void;
+    load(name: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabMemoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TabMemoryService>;
+}
+
+declare const slugify: (str: string) => string;
+
+declare const tmpl: (text: string, data?: any, objectName?: string) => any;
+
+declare class UpdateService {
+    private appRef;
+    private swUpdate;
+    private stable;
+    constructor(appRef: ApplicationRef, swUpdate: SwUpdate);
+    private _available$;
+    get available$(): Observable<boolean>;
+    activate(): void;
+    dismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateService>;
+}
+
+declare class UpdateComponent {
+    update: UpdateService;
+    constructor(update: UpdateService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UpdateComponent, "data-update", never, {}, {}, never, never, true, never>;
+}
+
+export { AuthInterceptor, AuthServiceBase, BanAdapter, BootstrapDataDisplayConfig, BreadcrumbComponent, ChoicePipe, Collection, CollectionMock, DATA_API_URL, DATA_AUTH_PARAMS, DATA_AUTH_SERVICE, DATA_AUTH_URLS, DATA_AUTH_USER_SERVICE, DATA_DISPLAY_CONFIG, DATA_MAX_TRANSFERSTATE_TIME, DATA_MESSAGE_SOUNDS, DEFAULT_TIMEOUTS, DataBackend, DataMessageService, DataModel, DataUploaderService, DispeditComponent, FactorPipe, FactorcPipe, FkselectComponent, FlagsComponent, Jwt, Link, M2mselectComponent, Message, MessageZoneComponent, ModelList, ModelListAutocompleteFilter, ModelListAutocompleteMultiFilter, ModelListDateFilter, ModelListDatetimeFilter, ModelListDatetimerangeFilter, ModelListFieldHeaderComponent, ModelListFieldsSelectorComponent, ModelListFilter, ModelListFilterGroup, ModelListFilters, ModelListFiltersComponent, ModelListFiltersSelectComponent, ModelListFlagsFilter, ModelListGeodistanceFilter, ModelListNumberFilter, ModelListNumberOperations, ModelListPaginatorComponent, ModelListSelectFilter, ModelListSelectMultiFilter, ModelListService, ModelListSorterComponent, ModelListTextFilter, ModelListTreeFilter, NavDriver, NgFileDropDirective, NgFileSelectDirective, NgxUploaderModule, PChoicePipe, PFactorPipe, PFactorcPipe, Queryset, RData, RichEditToolbars, RicheditComponent, STATUS, SafeDeleteComponent, TYPE, TabMemoryService, UpdateComponent, UpdateService, UploadStatus, booleanField, charField, computedField, dateField, datetimeField, decimalField, detailsField, emailField, floatField, foreignKeyField, humanizeBytes, integerField, isValue, manyToManyField, passwordField, primaryField, reverseForeignKeyField, slugify, strToNumber, textField, tmpl };
+export type { AuthParams, BanResults, BaseRouteParams, BlobFile, CustomField, DataDisplayConfig, DataModelFields, DataModelType, FakeDeleteResult, FieldsParams, FilterData, FilterDefaults, FiltersParams, GeoSearchResult, GetFlagsResult, IActionParams, ICollectionCacheParams, IFlagItem, IHttpMethod, IJwtBaseData, IJwtRefreshResponseJson, IJwtResponseJson, IModelListMessage, IPathTreeItem, IQueryFullResponse, IQueryMeta, IQueryMetaNav, IQueryMetaNavParams, IQueryNav, IQuerysetOptions, ISoundTypes, ModelListAutocompleteMultiParams, ModelListAutocompleteParams, ModelListFilterParams, ModelListFlagsFilterParams, ModelListGeodistanceFilterParams, ModelListMultiSelectFilterParams, ModelListNumberFilterParams, ModelListParams, ModelListSelectFilterParams, ModelListTreeParams, OutFilterData, PaginationParams, RouteConfigItem, RouteFn, RoutesConfig, RoutesDefinition, SortData, SorterDefaults, StrictRoutes, TplFn, TplFun, UploadFile, UploadInput, UploadOutput, UploadProgress, UploaderOptions };